Hoe gaan je met exceptions in NestJS?

Question

Accepted Answer

NestJS heeft een **ingebouwde exception-laag** die automatisch niet-afgehandelde fouten opvangt en ze omzet in juiste HTTP-responses. Je signaleert fouten door **exceptions te gooien** (vaak ingebouwde HTTP-exceptionklassen), en Nest formatteert ze in gestructureerde JSON-responses met de juiste statuscode.

## Ingebouwde HTTP-exceptions gooien

```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 biedt exceptionklassen die mappen naar HTTP-statuscodes, en het gooien van één ervan produceert automatisch een juiste, gestructureerde response:

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

## Veelgebruikte ingebouwde HTTP-exceptions

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

Er is een klasse voor elke veelgebruikte HTTP-fout — gebruik de passende om de juiste status te communiceren.

## Custom berichten en de generieke HttpException

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

## Custom 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);
```

## Niet-afgehandelde fouten worden 500s

```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 voor globale aanpassing

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

Voor consistente foutformattering, logging of afhandeling van niet-HTTP-fouten, gebruik je **exception filters** (een gerelateerde, meer geavanceerde feature).

## Waarom het belangrijk is

Juiste exception-afhandeling is essentieel voor het bouwen van betrouwbare API's, en de ingebouwde exception-laag van NestJS maakt het schoon en consistent.

weten hoe je **HTTP-exceptions gooit** (`NotFoundException`, `BadRequestException`, enz.) is alledaagse kennis — het is de idiomatische manier om fouten met de juiste statuscodes en gestructureerde, clientvriendelijke JSON-responses te signaleren, zonder handmatig error-responses in elke handler te construeren.

Het framework vangt deze automatisch op en formatteert ze, en zet onverwachte fouten veilig om in generieke 500s zonder interne details bloot te geven (belangrijk voor veiligheid).

De veelgebruikte exception-klassen kennen, weten hoe je custom berichten/exceptions gooit, en dat **exception filters** bestaan voor globale aanpassing (consistente formattering, logging) is fundamenteel voor het bouwen van robuuste, professionele NestJS API's.

Schone, consistente foutafhandeling is een kenmerk van code van hoge kwaliteit, waardoor dit een kernaspect van het framework is dat veel wordt gebruikt.