Was sind Exception Filter?

Question

Accepted Answer

**Exception Filter** geben dir volle Kontrolle darüber, wie Fehler **abgefangen und in Responses umgewandelt werden**. Sie sitzen am Ende des Request-Lifecycles, fangen Exceptions auf, die überall im Request geworfen werden, und ermöglichen dir, das Fehler-Response-Format, den Status und das Logging anzupassen.

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

Der `@Catch()` Decorator gibt an, welche Exception-Typen dieses Filter behandelt, und die `catch()` Methode erhält die Exception plus den Kontext — was dir ermöglicht, jede beliebige Response zu erstellen.

## Alle Exceptions abfangen (inklusive 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: "..." });
  }
}
```

Ein Filter mit `@Catch()` (ohne Argument) behandelt jede Exception — der Ort, um unerwartete Fehler zu protokollieren und sicherzustellen, dass auch Non-HTTP-Fehler eine saubere, sichere Response zurückgeben (ohne Stack Traces an Clients zu leaken).

## Filter anwenden

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

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

Filter werden normalerweise **global** angewendet, um ein konsistentes Fehlerformat über die ganze API hinweg durchzusetzen.

## Warum Exception Filter verwenden?

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

## Filter vs. Exceptions werfen

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

## Warum es wichtig ist

Exception Filter sind eine wichtige NestJS-Funktion zum Aufbau robuster, professioneller APIs mit **konsistenter, kontrollierter Fehlerbehandlung**.

Obwohl die eingebaute Exception-Schicht von NestJS bereits geworfene Exceptions in HTTP-Responses umwandelt, geben dir Exception Filter volle Kontrolle, um dieses Verhalten anzupassen — was mehrere praktische Belange betrifft: Durchsetzung einer **konsistenten Error-Response-Form** über jeden Endpoint hinweg (damit Clients Fehler immer im gleichen Format erhalten), **Zentralisierung von Error-Logging** (Erfassung jedes Fehlers an einer Stelle statt verstreut in try/catch), sichere **Behandlung unerwarteter Non-HTTP-Fehler** (Umwandlung zu sauberen 500ern statt Abstürze oder Leaking von Details), und **Sicherheit** (Verstecken von internen Stack Traces und sensiblen Details vor Clients, während sie intern protokolliert werden).

Ein globales "Catch-All"-Filter kombiniert mit dem Werfen spezifischer HTTP-Exceptions in deinem Code ist das Standard-Pattern für produktionsreife Fehlerbehandlung.

Zu verstehen, wann und wie man Filter verwendet (versus einfach Exceptions zu werfen) und sie global für Konsistenz anzuwenden, ist ein Merkmal gut strukturierter NestJS-Anwendungen und spiegelt reife Backend-Praktiken rund um die oft übersehene, aber kritische Frage der Fehlerbehandlung wider.