Kako rukovaš iznimkama u NestJS-u?

Question

Accepted Answer

NestJS ima **ugrađeni sloj rukovanja iznimkama** koji automatski hvata neobrađene greške i pretvara ih u ispravne HTTP odgovore. Greške signaliziraš **bacanjem iznimki** (često ugrađenih klasa za HTTP iznimke), a Nest ih formatira u strukturirane JSON odgovore s ispravnim statusnim kodom.

## Bacanje ugrađenih HTTP iznimki

```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 pruža klase iznimki koje se mapiraju na HTTP statusne kodove, a bacanje neke od njih automatski proizvodi ispravan, strukturirani odgovor:

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

## Česte ugrađene HTTP iznimke

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

Postoji klasa za svaku čestu HTTP grešku — koristi odgovarajuću da komuniciraš ispravan status.

## Prilagođene poruke i generička HttpException

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

## Prilagođene klase iznimki

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

## Neobrađene greške postaju 500-ice

```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 iznimki za globalno prilagođavanje

```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 konzistentno formatiranje grešaka, logiranje ili rukovanje greškama koje nisu HTTP, koriste se **filtri iznimki** (povezana, naprednija značajka).

## Zašto je važno

Ispravan rukovanje iznimkama je bitan za izgradnju pouzdanih API-ja, a ugrađeni sloj iznimki u NestJS-u to čini čistim i dosljednim.

Razumijevanje kako **baciti HTTP iznimke** (`NotFoundException`, `BadRequestException` itd.) je svakodnevno znanje — to je idiomatski način signaliziranja grešaka s ispravnim statusnim kodovima i strukturiranim, klijentski-prihvatljivim JSON odgovorima, bez ručne konstrukcije odgovora na greške u svakom handleru.

Framework automatski hvata te iznimke i formatira ih, te sigurno pretvara neočekivane greške u generičke 500-ice bez curenja internih detalja (važno za sigurnost).

Znanje čestih klasa iznimki, kako baciti prilagođene poruke/iznimke, i da **filtri iznimki** postoje za globalno prilagođavanje (konzistentno formatiranje, logiranje) je temeljno za izgradnju robusnih, profesionalnih NestJS API-ja.

Čisto, dosljedno rukovanje greškama je znamenka kvalitete backend koda, čineći ovo fundamentalnim, često korištenim aspektom frameworka.