Hvordan håndterer du undtagelser i NestJS?

Question

Accepted Answer

NestJS har et **built-in exception layer**, der automatisk fanger uhåndterede fejl og omdanner dem til korrekte HTTP-svar. Du signalerer fejl ved at **kaste undtagelser** (ofte built-in HTTP exception-klasser), og Nest formaterer dem til strukturerede JSON-svar med den rigtige statuskode.

## Kaste built-in HTTP-undtagelser

```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 leverer exception-klasser, der mapper til HTTP-statuskoder, og at kaste én producerer automatisk et korrekt, struktureret svar:

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

## Almindelige built-in HTTP-undtagelser

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

Der er en klasse for hver almindelig HTTP-fejl — brug den passende til at kommunikere den rigtige status.

## Brugerdefinerede meddelelser og den generiske HttpException

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

## Brugerdefinerede exception-klasser

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

## Uhåndterede fejl bliver til 500'ere

```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 filters til global tilpasning

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

For konsistent fejlformatering, logging eller håndtering af ikke-HTTP-fejl bruger du **exception filters** (en relateret, mere avanceret funktion).

## Hvorfor det betyder noget

Korrekt exception-håndtering er vigtig for at bygge pålidelige API'er, og NestJS's built-in exception layer gør det rent og konsistent.

At vide, hvordan man **kaster HTTP-undtagelser** (`NotFoundException`, `BadRequestException` osv.) er daglig viden — det er den idiomatiske måde at signalere fejl med de korrekte statuskoder og strukturerede, klientvenlige JSON-svar uden manuelt at konstruere fejlsvar i hvert handler.

Frameworket fanger disse automatisk og formaterer dem, og det konverterer sikkert uventede fejl til generiske 500'ere uden at lække interne detaljer (vigtig for sikkerhed).

At kende de almindelige exception-klasser, hvordan man kaster brugerdefinerede meddelelser/undtagelser, og at **exception filters** eksisterer til global tilpasning (konsistent formatering, logging) er grundlæggende for at bygge robuste, professionelle NestJS API'er.

Ren, konsistent fejlhåndtering er et kendetegn på kvalitetskode på back-end, hvilket gør dette til et centralt, hyppigt brugt aspekt af frameworket.