Kako obvladujete izjeme v NestJS-u?

Question

Accepted Answer

NestJS ima **vgrajeni sloj za obravnavo izjem**, ki avtomatično ujame neobdelane napake in jih pretvori v ustrezne HTTP-odzive. Napake signalizirate z **metanjem izjem** (pogosto vgrajenih razredov za HTTP-izjeme), Nest pa jih oblikuje v strukturirane JSON-odzive z ustrezno kodo stanja.

## Metanje vgrajenih HTTP-izjem

```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 ponuja razrede izjem, ki se preslikujejo v HTTP-kode stanja. Metanje enega od njih avtomatično ustvari pravilen, strukturiran odziv:

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

## Pogosto uporabljene vgrajene HTTP-izjeme

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

Za vsako pogosto HTTP-napako obstaja razred — uporabite ustreznega, da sporočite pravilno stanje.

## Povratne sporočila po meri in generična HttpException

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

## Razredi izjem po meri

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

## Neobdelane napake postanejo 500

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

## Filtri izjem za globalno prilagoditev

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

Za dosljedno oblikovanje napak, beleženje ali obravnavo ne-HTTP-napak uporabite **filtre izjem** (povezana, naprednejša funkcionalnost).

## Zakaj je to pomembno

Pravilna obravnava izjem je bistvena za gradnjo zanesljivih API-jev, in vgrajeni sloj NestJS-a za obravnavo izjem to naredi čisto in doslednost.

Razumevanje, kako **metati HTTP-izjeme** (`NotFoundException`, `BadRequestException` itd.), je vsakodnevno znanje — to je idiomatski način signaliziranja napak z ustreznimi kodami stanja in strukturiranimi, odjemalcu prijaznimi JSON-odzivi, brez ročne gradnje odzivov napak v vsakem rukovalniku.

Okvirni program te avtomatično ujame in oblikuje, in varno pretvori nepričakovane napake v generične 500-ke, ne da bi razkril notranje podrobnosti (важно za varnost).

Znanje pogostih razredov izjem, kako metati po meri oblikovana sporočila/izjeme, in da **filtri izjem** obstajajo za globalno prilagoditev (dosljedno oblikovanje, beleženje), je temeljno za gradnjo robustnih, profesionalnih NestJS-API-jev.

Čista, dosledna obravnava napak je značilnost kakovostne back-end-kode, zato je to osnovna, pogosto uporabljena značilnost ogrodja.