X'inhuma exception filters?

Question

Accepted Answer

**Exception filters** jagħtuk kontroll sħiħ fuq kif l-iżbalji huma **miksuba u trasformati f'responses**. Jinsabu fit-tmiem tal-lifecycle tar-request, miksuba exceptions imqadhda kullimkien fir-request u jigħtuk tħaffif biex tippersonalizza l-format, status, u logging tar-response tal-iżball.

## A 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,
    });
  }
}
```

Id-decorator `@Catch()` jispeċifika liema types ta' exceptions dan il-filter jittratta, u l-metodu `catch()` jirċievi l-exception flimkien mal-context — u jigħtik il-possibbiltà biex tikkera kwalunkwe response trid.

## Miksuba ALL exceptions (inkluż 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: "..." });
  }
}
```

Filter b' `@Catch()` (mingħajr argument) jittratta kull exception — il-post biex tlogg errors mhux mistwieqa u biex tiżgura li anke errors non-HTTP jirritornaw response nadif u sikur (mingħajr li tixraq stack traces lill-clients).

## L-applikazzjoni tal-filters

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

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

Filters ħaċċ huma applikati **globally** biex jenfurzaw format ta' iżball konsistenti matul l-API kollu.

## Għalfejn tuża 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.
```

## Għalfejn dan importanti

Exception filters huma feature importanti ta' NestJS għall-bini ta' APIs robust u professjonali b' **error handling konsistenti u kontrollat**.

Minkejja l-fact li l-exception layer integrat ta' NestJS diġà jissottometti exceptions imqadhda f'HTTP responses, exception filters jagħtuk kontroll sħiħ biex tikkustomizza dak il-komportament — u dan importanti għal ħafna concerns reali: l-enfurzament ta' **error-response shape konsistenti** fuq kull endpoint (sabiex il-clients dejjem jiksbu errors fl-istess format), **centralized error logging** (miksuba kull error f'post wieħed minflok imixtuqa f'try/catch disseminati), safe **handling ta' unexpected non-HTTP errors** (konvertihom lil clean 500s minflok crash jew xiexqa ta' details), u **security** (moħbija ta' internal stack traces u sensitive details mill-clients filwaqt li tiloggja internament).

Global "catch-all" filter flimkien mal-throwing ta' specific HTTP exceptions fil-code tiegħek huma l-pattern standard għal production-grade error handling.

L-faham ta' meta u kif tuża filters (versus sempliċiment throwing exceptions), u l-applikazzjoni tiegħom globally għall-konsistenza, hija sinjal tal-well-built NestJS applications u tirrifletti mature back-end practice dwar l-often-overlooked pero critical concern ta' error handling.