Exception filters என்றால் என்ன?

Question

Accepted Answer

**Exception filters** ஆனது பிழைகள் எப்படி **பிடிக்கப்பட்டு responses ஆக மாற்றப்படுகின்றன** என்பதன் மீது உங்களுக்கு முழுக் கட்டுப்பாட்டை வழங்குகின்றன. அவை request lifecycle-இன் இறுதியில் அமர்ந்து, request-இல் எங்கேனும் வீசப்படும் exceptions-ஐ பிடித்து, error response format, status மற்றும் logging-ஐ தனிப்பயனாக்க உங்களை அனுமதிக்கின்றன.

## ஒரு அடிப்படை exception filter

```ts
import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from "@nestjs/common";

@Catch(HttpException)                    // catch HttpExceptions specifically
export class HttpExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const request = ctx.getRequest();
    const status = exception.getStatus();

// build a CUSTOM error response shape
    response.status(status).json({
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
      message: exception.message,
    });
  }
}
```

`@Catch()` decorator இந்த filter எந்த exception வகைகளை கையாளுகிறது என்பதைக் குறிப்பிடுகிறது, மேலும் `catch()` method ஆனது exception உடன் context-ஐயும் பெறுகிறது — இது நீங்கள் விரும்பும் எந்த response-ஐயும் உருவாக்க அனுமதிக்கிறது.

## அனைத்து exceptions-ஐயும் பிடித்தல் (HTTP அல்லாதவை உட்பட)

```ts
@Catch()                                 // no argument = catch EVERYTHING
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const status = exception instanceof HttpException
      ? exception.getStatus()
      : 500;                              // unknown errors → 500
    // log the full error internally, return a safe message to the client
    this.logger.error(exception);
    ctx.getResponse().status(status).json({ statusCode: status, message: "..." });
  }
}
```

`@Catch()` (argument இல்லாமல்) கொண்ட filter ஒவ்வொரு exception-ஐயும் கையாளுகிறது — எதிர்பாராத பிழைகளை log செய்து, HTTP அல்லாத பிழைகள் கூட clients-க்கு stack traces கசியவிடாமல், சுத்தமான, பாதுகாப்பான response-ஐத் திருப்பித் தருவதை உறுதிசெய்ய இதுவே இடம்.

## Filters-ஐ பயன்படுத்துதல்

```ts
@UseFilters(HttpExceptionFilter)         // method or controller level
export class UsersController {}

app.useGlobalFilters(new AllExceptionsFilter());   // GLOBAL — app-wide, most common
```

Filters பொதுவாக முழு API முழுவதும் ஒரு நிலையான error format-ஐ அமல்படுத்த **globally** பயன்படுத்தப்படுகின்றன.

## Exception filters ஏன் பயன்படுத்த வேண்டும்?

```text
✓ Consistent error response format across ALL endpoints (a standard shape)
✓ Centralized error LOGGING (log every error in one place)
✓ Handle non-HTTP errors safely (turn unexpected errors into clean 500s)
✓ Hide internal details from clients (no leaked stack traces — security)
✓ Add context (request path, timestamp, correlation IDs) to error responses
```

## Filters vs exceptions வீசுதல்

```text
Throwing exceptions (NotFoundException, etc.) → SIGNALS an error with a status
Exception filters → control HOW those errors are FORMATTED/logged into responses
→ You throw exceptions in your code; filters customize the resulting response globally.
```

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

**நிலையான, கட்டுப்படுத்தப்பட்ட error handling** கொண்ட வலுவான, தொழில்முறை APIs-ஐ உருவாக்குவதற்கு exception filters ஒரு முக்கியமான NestJS அம்சமாகும்.

NestJS-இன் உள்ளமைந்த exception layer ஏற்கனவே வீசப்பட்ட exceptions-ஐ HTTP responses ஆக மாற்றினாலும், exception filters அந்த நடத்தையைத் தனிப்பயனாக்க முழுக் கட்டுப்பாட்டை வழங்குகின்றன — இது பல உண்மையான கவலைகளுக்கு முக்கியம்: ஒவ்வொரு endpoint முழுவதும் **நிலையான error-response shape**-ஐ அமல்படுத்துதல் (இதனால் clients எப்போதும் ஒரே format-இல் பிழைகளைப் பெறுகின்றன), **error logging-ஐ மையப்படுத்துதல்** (சிதறிய try/catch-க்கு பதிலாக ஒரே இடத்தில் ஒவ்வொரு பிழையையும் பிடித்தல்), எதிர்பாராத HTTP அல்லாத பிழைகளை பாதுகாப்பாக **கையாளுதல்** (அவற்றை crash செய்வதற்கோ விவரங்களைக் கசியவிடுவதற்கோ பதிலாக சுத்தமான 500s ஆக மாற்றுதல்), மற்றும் **security** (உள் stack traces மற்றும் முக்கியமான விவரங்களை clients-இடமிருந்து மறைத்து, அவற்றை உள்நாட்டில் log செய்தல்).

உங்கள் code-இல் குறிப்பிட்ட HTTP exceptions-ஐ வீசுவதுடன் இணைந்த ஒரு global "catch-all" filter ஆனது production-grade error handling-க்கான நிலையான pattern ஆகும்.

Filters-ஐ எப்போது, எப்படி பயன்படுத்துவது (வெறுமனே exceptions வீசுவதற்கு எதிராக) என்பதைப் புரிந்துகொள்வதும், நிலைத்தன்மைக்காக அவற்றை globally பயன்படுத்துவதும் நன்கு கட்டமைக்கப்பட்ட NestJS applications-இன் அடையாளமாகும், மேலும் பெரும்பாலும் கவனிக்கப்படாத ஆனால் முக்கியமான error handling கவலையைச் சுற்றிய முதிர்ந்த back-end நடைமுறையைப் பிரதிபலிக்கிறது.