Wie handhabst du Exceptions in NestJS?

Question

Accepted Answer

NestJS hat eine **integrierte Exception-Schicht**, die unbehandelte Fehler automatisch abfängt und sie in ordnungsgemäße HTTP-Antworten umwandelt. Du signalisierst Fehler durch **das Werfen von Exceptions** (oft integrierte HTTP-Exception-Klassen), und Nest formatiert sie in strukturierte JSON-Antworten mit dem richtigen Statuscode.

## Integrierte HTTP-Exceptions werfen

```ts
import { NotFoundException, BadRequestException, UnauthorizedException } from "@nestjs/common";

@Get(":id")
findOne(@Param("id") id: string) {
  const user = this.usersService.findOne(id);
  if (!user) {
    throw new NotFoundException("User not found");   // → 404 with a JSON error body
  }
  return user;
}
```

NestJS bietet Exception-Klassen, die HTTP-Statuscodes zuordnen, und das Werfen einer solchen Klasse erzeugt automatisch eine korrekte, strukturierte Antwort:

```json
{ "statusCode": 404, "message": "User not found", "error": "Not Found" }
```

## Häufige integrierte HTTP-Exceptions

```text
BadRequestException        → 400
UnauthorizedException      → 401
ForbiddenException         → 403
NotFoundException          → 404
ConflictException          → 409
UnprocessableEntityException → 422
InternalServerErrorException → 500
```

Es gibt eine Klasse für jeden häufigen HTTP-Fehler — verwende die passende, um den richtigen Status zu kommunizieren.

## Benutzerdefinierte Meldungen und die generische HttpException

```ts
// custom status + body via the base HttpException
throw new HttpException(
  { status: HttpStatus.FORBIDDEN, error: "custom message" },
  HttpStatus.FORBIDDEN,
);
```

## Benutzerdefinierte Exception-Klassen

```ts
export class UserNotFoundException extends NotFoundException {
  constructor(id: string) {
    super(`User with id ${id} not found`);   // domain-specific, reusable
  }
}
throw new UserNotFoundException(id);
```

## Unbehandelte Fehler werden zu 500ern

```text
If code throws a non-HttpException error (e.g. a plain Error or an unexpected
exception), NestJS's default exception filter catches it and returns a generic
500 Internal Server Error (without leaking internal details to the client).
```

## Exception-Filter für globale Anpassung

```ts
// a custom exception filter customizes how errors are formatted/logged globally
@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    // log, format the response, etc.
  }
}
app.useGlobalFilters(new AllExceptionsFilter());   // apply app-wide
```

Für konsistente Fehlerformatierung, Protokollierung oder Handhabung von Nicht-HTTP-Fehlern verwendest du **Exception-Filter** (eine verwandte, fortgeschrittenere Funktion).

## Warum es wichtig ist

Ordnungsgemäße Exception-Behandlung ist essentiell für den Aufbau zuverlässiger APIs, und die integrierte Exception-Schicht von NestJS macht es sauber und konsistent.
"`Das Verstehen, wie man HTTP-Exceptions wirft (`NotFoundException`, `BadRequestException`, usw.), ist alltägliches Wissen — es ist die idiomatische Weise, Fehler mit den korrekten Statuscodes und strukturierten, client-freundlichen JSON-Antworten zu signalisieren, ohne in jedem Handler Fehlerantworten manuell zu konstruieren.

Das Framework fängt diese automatisch ab und formatiert sie, und es konvertiert sicher unerwartete Fehler in generische 500er, ohne interne Details preiszugeben (wichtig für die Sicherheit).

Das Kennen der häufigen Exception-Klassen, wie man benutzerdefinierte Meldungen/Exceptions wirft, und dass **Exception-Filter** für globale Anpassung (konsistente Formatierung, Protokollierung) vorhanden sind, ist grundlegend für den Aufbau robuster, professioneller NestJS-APIs.

Saubere, konsistente Fehlerbehandlung ist ein Merkmal von qualitativ hochwertigem Backend-Code, was diesen zu einem grundlegenden, häufig genutzten Aspekt des Frameworks macht.