Hur hanterar du exceptions i NestJS?

Question

Accepted Answer

NestJS har ett **inbyggt exceptionlager** som automatiskt fångar ohanterade fel och omvandlar dem till korrekta HTTP-svar. Du signalerar fel genom att **kasta exceptions** (ofta inbyggda HTTP-exceptionklasser), och Nest formaterar dem till strukturerade JSON-svar med rätt statuskod.

## Throwing built-in HTTP exceptions

```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 tillhandahåller exceptionklasser mappade till HTTP-statuskoder, och att kasta en producerar ett korrekt, strukturerat svar automatiskt:

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

## Common built-in HTTP exceptions

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

Det finns en klass för varje vanligt HTTP-fel — använd den lämpliga för att kommunicera rätt status.

## Custom messages and the generic HttpException

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

## Custom exception classes

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

## Unhandled errors become 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 for global customization

```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 konsistent felformatering, loggning eller hantering av icke-HTTP-fel använder du **exception filters** (en relaterad, mer avancerad funktion).

## Varför det spelar roll

Korrekt exceptionhantering är väsentlig för att bygga pålitliga API:er, och NestJS:s inbyggda exceptionlager gör det rent och konsekvent.

Att förstå hur man **kastar HTTP-exceptions** (`NotFoundException`, `BadRequestException`, osv.) är vardagskunskap — det är det idiomatiska sättet att signalera fel med rätt statuskoder och strukturerade, klientvänliga JSON-svar, utan att manuellt konstruera felsvar i varje handler.

Frameworket fångar automatiskt dessa och formaterar dem, och det konverterar säkert oväntade fel till generiska 500-tal utan att läcka interna detaljer (viktigt för säkerhet).

Att veta de vanliga exceptionklasserna, hur man kastar anpassade meddelanden/exceptions, och att **exception filters** existerar för global anpassning (konsistent formatering, loggning) är grundläggande för att bygga robusta, professionella NestJS-API:er.

Ren, konsistent felhantering är en kännetecken på högkvalitativ back-end-kod, vilket gör detta till en central, ofta använd aspekt av frameworket.