Što su filtri iznimki?

Question

Accepted Answer

**Filtri iznimki** vam daju potpunu kontrolu nad načinom kako se greške **hvataju i pretvaraju u odgovore**. Nalaze se na kraju životnog cikla zahtjeva, hvatajući iznimke izbačene bilo gdje tijekom zahtjeva i omogućavajući vam prilagođavanje formata, statusa i logiranja odgovora greške.

## Osnovni filter iznimki

```ts
import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from "@nestjs/common";

@Catch(HttpException)                    // catch HttpExceptions specifically
export class HttpExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const request = ctx.getRequest();
    const status = exception.getStatus();

// build a CUSTOM error response shape
    response.status(status).json({
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
      message: exception.message,
    });
  }
}
```

Dekorator `@Catch()` specificira koje vrste iznimki ovaj filter obrađuje, a metoda `catch()` prima iznimku plus kontekst — omogućavajući vam oblikovanje bilo kojeg odgovora koji želite.

## Hvatanje SVIH iznimki (uključujući one koje nisu HTTP)

```ts
@Catch()                                 // no argument = catch EVERYTHING
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const status = exception instanceof HttpException
      ? exception.getStatus()
      : 500;                              // unknown errors → 500
    // log the full error internally, return a safe message to the client
    this.logger.error(exception);
    ctx.getResponse().status(status).json({ statusCode: status, message: "..." });
  }
}
```

Filter s `@Catch()` (bez argumenta) obrađuje svaku iznimku — mjesto je za logiranje neočekivanih grešaka i osiguravanje da čak i greške koje nisu HTTP vraćaju čist, siguran odgovor (bez curenja stack trace-eva klijentima).

## Primjena filtara

```ts
@UseFilters(HttpExceptionFilter)         // method or controller level
export class UsersController {}

app.useGlobalFilters(new AllExceptionsFilter());   // GLOBAL — app-wide, most common
```

Filtari se obično primjenjuju **globalno** kako bi se osigurala konzistentna format greške kroz čitav API.

## Zašto koristiti filtere iznimki?

```text
✓ Consistent error response format across ALL endpoints (a standard shape)
✓ Centralized error LOGGING (log every error in one place)
✓ Handle non-HTTP errors safely (turn unexpected errors into clean 500s)
✓ Hide internal details from clients (no leaked stack traces — security)
✓ Add context (request path, timestamp, correlation IDs) to error responses
```

## Filtari nasuprot bacanju iznimki

```text
Throwing exceptions (NotFoundException, etc.) → SIGNALS an error with a status
Exception filters → control HOW those errors are FORMATTED/logged into responses
→ You throw exceptions in your code; filters customize the resulting response globally.
```

## Zašto je to važno

Filtri iznimki su važna NestJS značajka za gradnju robusnih, profesionalnih API-ja s **konzistentnom, kontroliranom obradom grešaka**.

Ali NestJS-ova ugrađena sloj iznimki već pretvara izbačene iznimke u HTTP odgovore, filtri iznimki vam daju potpunu kontrolu za prilagođavanje tog ponašanja — što je važno za nekoliko stvarnih briga: forsiranje **konzistentnog oblika odgovora greške** kroz svaki endpoint (tako da klijenti uvijek dobivaju greške u istom formatu), **centraliziranje logiranja grešaka** (hvatanje svake greške na jednom mjestu umjesto raspršenih try/catch), sigurna **obrada neočekivanih grešaka koje nisu HTTP** (pretvaranje u čiste 500-e umjesto pucanja ili curenja detalja), i **sigurnost** (skrivanje unutarnjih stack trace-eva i osjetljivih detalja od klijenata dok ih interno logirate).

Globalni "catch-all" filter kombiniran s bacanjem specifičnih HTTP iznimki u vašem kodu je standardni obrazac za rukovanje greškama na razini produkcije.

Razumijevanje kada i kako koristiti filtare (nasuprot jednostavnom bacanju iznimki), i njihova primjena globalno za konzistentnost, je značajka dobro izgrađenih NestJS aplikacija i odražava zrelu praksu back-enda oko često zanemarene, ali kritične brige rukovanja greškama.