Wat zijn exception filters?

Question

Accepted Answer

**Exception filters** geven je volledige controle over hoe fouten **worden afgevangen en in responses worden omgezet**. Ze bevinden zich aan het einde van de request lifecycle, vangen exceptions af die overal in de request worden gegooid en laten je het error response format, status en logging aanpassen.

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

De `@Catch()` decorator specificeert welke exception types deze filter afhandelt, en de `catch()` methode ontvangt de exception plus de context — wat je in staat stelt om elke response die je wilt in te stellen.

## Alle exceptions afvangen (inclusief niet-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: "..." });
  }
}
```

Een filter met `@Catch()` (zonder argument) handelt elke exception af — de plek om onverwachte fouten op te loggen en ervoor te zorgen dat zelfs niet-HTTP fouten een schone, veilige response opleveren (zonder stack traces aan clients prijs te geven).

## Filters toepassen

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

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

Filters worden meestal **globaal** toegepast om een consistent error format in de hele API af te dwingen.

## Waarom exception filters gebruiken?

```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 versus exceptions gooien

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

## Waarom het belangrijk is

Exception filters zijn een belangrijk NestJS feature voor het bouwen van robuuste, professionele APIs met **consistente, gecontroleerde error handling**.

Alhoewel NestJS's ingebouwde exception layer reeds gegoide exceptions in HTTP responses omzet, geven exception filters je volledige controle om dat gedrag aan te passen — wat belangrijk is voor verschillende praktische overwegingen: het afdwingen van een **consistente error-response vorm** in elk endpoint (zodat clients altijd fouten in hetzelfde format krijgen), **error logging centraliseren** (elke fout op één plek vastleggen in plaats van verspreid over try/catch blokken), veilig **onverwachte niet-HTTP fouten afhandelen** (ze converteren naar schone 500s in plaats van crashes of het prijs geven van details), en **security** (interne stack traces en gevoelige details verbergen voor clients terwijl je ze intern logt).

Een globale "catch-all" filter gecombineerd met het gooien van specifieke HTTP exceptions in je code is het standaard patroon voor error handling op production-level.

Begrijpen wanneer en hoe je filters gebruikt (versus eenvoudig exceptions gooien), en ze globaal toepassen voor consistentie, is een kenmerk van goed gebouwde NestJS applicaties en weerspiegelt volwassen back-end praktijk rond het vaak over het hoofd geziene maar kritieke punt van error handling.