NestJS-இல் exceptions-ஐ எவ்வாறு கையாளுகிறீர்கள்?

Question

Accepted Answer

NestJS-க்கு ஒரு **built-in exception layer** உள்ளது, இது கையாளப்படாத errors-ஐ தானாகவே catch செய்து அவற்றை சரியான HTTP responses ஆக மாற்றுகிறது. நீங்கள் **exceptions-ஐ throw** செய்வதன் மூலம் (பெரும்பாலும் built-in HTTP exception classes) errors-ஐ சமிக்ஞை செய்கிறீர்கள், மற்றும் Nest அவற்றை சரியான status code-உடன் கட்டமைக்கப்பட்ட JSON responses ஆக format செய்கிறது.

## Built-in HTTP exceptions-ஐ throw செய்தல்

```ts
import { NotFoundException, BadRequestException, UnauthorizedException } from "@nestjs/common";

@Get(":id")
findOne(@Param("id") id: string) {
  const user = this.usersService.findOne(id);
  if (!user) {
    throw new NotFoundException("User not found");   // → 404 with a JSON error body
  }
  return user;
}
```

NestJS HTTP status codes-க்கு map செய்யும் exception classes-ஐ வழங்குகிறது, மற்றும் ஒன்றை throw செய்வது தானாகவே சரியான, கட்டமைக்கப்பட்ட response-ஐ உருவாக்குகிறது:

```json
{ "statusCode": 404, "message": "User not found", "error": "Not Found" }
```

## பொதுவான built-in HTTP exceptions

```text
BadRequestException        → 400
UnauthorizedException      → 401
ForbiddenException         → 403
NotFoundException          → 404
ConflictException          → 409
UnprocessableEntityException → 422
InternalServerErrorException → 500
```

ஒவ்வொரு பொதுவான HTTP error-க்கும் ஒரு class உள்ளது — சரியான status-ஐ தெரிவிக்க பொருத்தமானதை பயன்படுத்துங்கள்.

## Custom messages மற்றும் generic HttpException

```ts
// custom status + body via the base HttpException
throw new HttpException(
  { status: HttpStatus.FORBIDDEN, error: "custom message" },
  HttpStatus.FORBIDDEN,
);
```

## Custom exception classes

```ts
export class UserNotFoundException extends NotFoundException {
  constructor(id: string) {
    super(`User with id ${id} not found`);   // domain-specific, reusable
  }
}
throw new UserNotFoundException(id);
```

## கையாளப்படாத errors 500s ஆகின்றன

```text
If code throws a non-HttpException error (e.g. a plain Error or an unexpected
exception), NestJS's default exception filter catches it and returns a generic
500 Internal Server Error (without leaking internal details to the client).
```

## Global customization-க்கான exception filters

```ts
// a custom exception filter customizes how errors are formatted/logged globally
@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    // log, format the response, etc.
  }
}
app.useGlobalFilters(new AllExceptionsFilter());   // apply app-wide
```

ஒத்திசைவான error formatting, logging, அல்லது HTTP அல்லாத errors-ஐ கையாள்வதற்கு, நீங்கள் **exception filters**-ஐ பயன்படுத்துகிறீர்கள் (ஒரு தொடர்புடைய, மேம்பட்ட feature).

## இது ஏன் முக்கியம்

சரியான exception handling நம்பகமான APIs-ஐ உருவாக்க அத்தியாவசியம், மற்றும் NestJS-இன் built-in exception layer அதை சுத்தமாகவும் ஒத்திசைவாகவும் ஆக்குகிறது.

**HTTP exceptions-ஐ throw** செய்வது எவ்வாறு (`NotFoundException`, `BadRequestException`, etc.) என்பதை புரிந்துகொள்வது தினசரி அறிவு — இது ஒவ்வொரு handler-இலும் error responses-ஐ manual ஆக உருவாக்காமல், சரியான status codes மற்றும் கட்டமைக்கப்பட்ட, client-friendly JSON responses-உடன் errors-ஐ சமிக்ஞை செய்யும் idiomatic வழி.

Framework இவற்றை தானாகவே catch செய்து format செய்கிறது, மற்றும் internal details-ஐ வெளியிடாமல் எதிர்பாராத errors-ஐ generic 500s ஆக பாதுகாப்பாக மாற்றுகிறது (security-க்கு முக்கியம்).

பொதுவான exception classes-ஐ அறிவது, custom messages/exceptions-ஐ எவ்வாறு throw செய்வது, மற்றும் global customization-க்கு (ஒத்திசைவான formatting, logging) **exception filters** உள்ளன என்பதை அறிவது robust, professional NestJS APIs-ஐ உருவாக்க அடிப்படை.

சுத்தமான, ஒத்திசைவான error handling தரமான back-end code-இன் ஒரு அடையாளம், இதை framework-இன் ஒரு முக்கிய, அடிக்கடி பயன்படுத்தப்படும் அம்சமாக ஆக்குகிறது.