Exception filters లు ఏమిటి?

Question

Accepted Answer

**Exception filters** లు మీకు errors ఎలా **caught and transformed into responses** అవుతాయో పూర్తి నియంత్రణ ఇస్తాయి. అవి request lifecycle చివరలో కూర్చుండి, request లో ఎక్కడైనా thrown చేయిన exceptions ను catch చేస్తాయి మరియు error response format, status, మరియు logging ను customize చేయడానికి మిమ్మల్ని అనుమతిస్తాయి.

## ఒక basic 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 handle చేసే exception types ను specify చేస్తుంది, మరియు `catch()` method exception ప్లస్ context ను receives చేస్తుంది — ఇది మీరు ఏదైనా response craft చేయడానికి అనుమతిస్తుంది.

## ALL exceptions catching చేయడం (non-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()` (no argument) ఉన్న filter ప్రతి exception ను handle చేస్తుంది — unexpected errors logging చేయడానికి మరియు non-HTTP errors కూడా clean, safe response return చేస్తుందని ensure చేయడానికి ఖచ్చితమైన స్థానం (clients కు stack traces leak కాకుండా).

## Filters ను apply చేయడం

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

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

Filters సాధారణంగా **globally** apply చేయబడతాయి మొత్తం API across ఒక consistent error format enforce చేయడానికి.

## 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 throwing 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.
```

## ఇది ఎందుకు ముఖ్యమైనది

Exception filters అనేది **consistent, controlled error handling** ఉన్న robust, professional APIs building చేయడానికి ఒక ముఖ్యమైన NestJS feature.

NestJS యొక్క built-in exception layer ఇప్పటికే thrown exceptions ను HTTP responses లోకి turn చేస్తుంది, exception filters మీకు ఆ behavior customize చేయడానికి పూర్తి నియంత్రణ ఇస్తాయి — ఇది అనేక real concerns కోసం ముఖ్యమైనది: ప్రతి endpoint across ఒక **consistent error-response shape** enforce చేయడం (కాబట్టి clients ఎల్లప్పుడూ errors ను same format లో get చేస్తారు), **centralizing error logging** (scattered try/catch కు బదులుగా ఒక స్థానంలో ప్రతి error ను capturing), safely **handling unexpected non-HTTP errors** (వాటిని clean 500s లోకి convert చేయడం crashing లేదా details leak చేయటానికి బదులుగా), మరియు **security** (clients కు internal stack traces మరియు sensitive details hide చేయడం internal logging లోకి log చేసేటప్పుడు).

A global "catch-all" filter combined with throwing specific HTTP exceptions మీ code లో production-grade error handling కోసం ప్రామాణిక pattern.

Filters ఎప్పుడు మరియు ఎలా use చేయాలి అని అర్థం చేసుకోవడం (simply throwing exceptions కు బదులుగా), మరియు consistency కోసం globally apply చేయడం, well-built NestJS applications ఒక hallmark మరియు maturity reflection around often-overlooked కానీ critical concern ఆ error handling.