Miten käsittelet poikkeuksia NestJS:ssä?

Question

Accepted Answer

NestJS:llä on **sisäänrakennettu poikkeuskerros**, joka automaattisesti kaappaa käsittelemättömät virheet ja muuntaa ne asianmukaisiksi HTTP-vastauksiksi. Signaloit virheitä **heittämällä poikkeuksia** (usein sisäänrakennetuilla HTTP-poikkeusluokilla), ja Nest muotoilee ne strukturoiduiksi JSON-vastauksiksi oikealla tilakoodilla.

## Sisäänrakennettujen HTTP-poikkeusten heittäminen

```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 tarjoaa poikkeusluokkia, jotka vastaavat HTTP-tilakoodeita, ja yhden heittäminen tuottaa automaattisesti oikean, strukturoidun vastauksen:

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

## Yleisimmät sisäänrakennetut HTTP-poikkeukset

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

Jokaiselle tavalliselle HTTP-virheelle on luokka — käytä sopivaa ilmaistaksesi oikean tilan.

## Mukautetut viestit ja yleinen HttpException

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

## Mukautetut poikkeusluokat

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

## Käsittelemättömät virheet muuttuvat 500:iksi

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

## Poikkeussuodattimet globaaliin mukauttamiseen

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

Johdonmukaista virhemuotoilua, lokitusta tai ei-HTTP-virheiden käsittelyä varten käytät **poikkeussuodattimia** (liittyvä, edistyneempi ominaisuus).

## Miksi se on tärkeää

Asianmukainen poikkeusten käsittely on välttämätöntä luotettavien sovellusliittymien rakentamiseen, ja NestJS:n sisäänrakennettu poikkeuskerros tekee siitä puhtaan ja johdonmukaisen.

Tietojen ymmärtäminen siitä, **kuinka heität HTTP-poikkeuksia** (`NotFoundException`, `BadRequestException` jne.), on jokapäiväistä tietoa — se on idiomaattinen tapa signaloida virheitä oikeilla tilakoodeilla ja strukturoiduilla, asiakasystävällisillä JSON-vastauksilla ilman, että sinun tarvitsee rakentaa virhevastauksista manuaalisesti jokaisessa käsittelijässä.

Kehys automaattisesti kaappaa nämä ja muotoilee ne, ja se turvallisesti muuntaa odottamattomat virheet yleisiksi 500:iksi ilman, että se vuotaa sisäisiä tietoja (tärkeää turvallisuuden kannalta).

Tietäminen tavallisista poikkeusluokista, kuinka heittää mukautettuja viestejä/poikkeuksia, ja että **poikkeussuodattimet** ovat olemassa globaaliin mukauttamiseen (johdonmukainen muotoilu, lokitus) on perustavanlaatuista vahvojen, ammattimaisten NestJS-sovellusliittymien rakentamiselle.

Puhdas, johdonmukainen virheenkäsittely on korkealaatuisen taustakoodin tunnusmerkki, joten tämä on kehyksen keskeinen, usein käytetty puoli.