Exception filters શું છે?

Question

Accepted Answer

**Exception filters** તમને **errors કેવી રીતે catch કરવા અને responses માં રૂપાંતરિત કરવા** તે પર સંપૂર્ણ નિયંત્રણ આપે છે. તેઓ request lifecycle ના અંતે બેસે છે, request ની કોઈ પણ જગ્યાએથી ફેંકવામાં આવેલ exceptions catch કરે છે અને તમને error response ફોર્મેટ, 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 types સંભાળે છે તે સ્પષ્ટ કરે છે, અને `catch()` method exception અને context બંને મેળવે છે — તમને કોઈ પણ response બનાવવાની મંજૂરી આપે છે.

## બધા exceptions catch કરો (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()` (કોઈ argument વિના) સાથેનો filter દરેક exception સંભાળે છે — આશ્ચર્યજનક errors log કરવા અને non-HTTP errors પણ સ્વચ્છ, સુરક્ષિત response પરત કરવાની જગ્યા (stack traces clients ને leak કર્યા વિના).

## Filters લાગુ કરો

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

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

Filters સામાન્યતઃ **વૈશ્વિક** રીતે લાગુ કરવામાં આવે છે સમગ્ર API માં સુસંગત error ફોર્મેટ લાગુ કરવા માટે.

## 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 વિ 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 એ NestJS ની એક મહત્વપૂર્ણ વૈશિષ્ટ્ય છે **સુસંગત, નિયંત્રિત error handling** સાથે મજબૂત, પ્રોફેશનલ APIs બનાવવા માટે.

જ્યારે NestJS ની built-in exception layer પહેલાથી ફેંકવામાં આવેલ exceptions ને HTTP responses માં ફેરવે છે, exception filters તમને તે વર્તન કસ્ટમાઇઝ કરવા માટે સંપૂર્ણ નિયંત્રણ આપે છે — જે ઘણી વાસ્તવિક ચિંતા માટે મહત્વપૂર્ણ છે: દરેક endpoint અંગે **સુસંગત error-response shape** લાગુ કરવો (જેથી clients હંમેશા એક જ ફોર્મેટમાં errors મેળવે), **error logging કેન્દ્રીય બનાવવો** (દરેક error એક જગ્યાએ capture કરવો વધુ try/catch વિખેરવા કરતાં), સુરક્ષિતપણે **અપ્રત્યાશિત non-HTTP errors સંભાળવો** (તેમને સ્વચ્છ 500s માં રૂપાંતરિત કરવો એટલે crash કરવો અથવા વિગતો leak કરવો), અને **સુરક્ષા** (clients ને internal stack traces અને સંવેદનશીલ વિગતો છુપાવવી જ્યારે તેમને આંતરિક રીતે log કરવો).

گ્લોબલ "catch-all" filter સાથે તમારા code માં specific HTTP exceptions ફેંકવા એ production-grade error handling માટે પ્રમાણભૂત પેટર્ન છે.

Filters કેટલી વાર અને કેવી રીતે વાપરવું (simply throwing exceptions કરતાં), અને consistency માટે તેમને ગ્લોબલ રીતે લાગુ કરવું, તે સારી રીતે built NestJS applications ની ખાનગી અને error handling આસપાસ ઘણીવાર overlooked પણ critical ચિંતા પ્રતિ પરિપક્વ back-end પ્રયોગ પ્રતિબિંબિત કરે છે.