Kaj so izjemni filtri?

Question

Accepted Answer

**Izjemni filtri** vam dajo popoln nadzor nad tem, kako se napake **ujamejo in pretvorijo v odgovore**. Nahajajo se na koncu životnega cikla zahteve, ujamejo izjeme, vrnjene kjerkoli v zahtevi, in vam omogočajo prilagajanje oblike, statusa in beleženja odgovora napake.

## Osnovni izjemni filter

```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, katere vrste izjem ta filter obravnava, metoda `catch()` pa prejme izjemo in kontekst — kar vam omogoča oblikovanje poljubnega odgovora.

## Ujemanje VSEH izjem (vključno z ne-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 z `@Catch()` (brez argumenta) obravnava vse izjeme — to je mesto za beleženje nepričakovanih napak in zagotavljanje, da celo ne-HTTP napake vrnejo čist, varen odgovor (brez puščanja sledi napak klientom).

## Uporaba filtrov

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

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

Filtri so običajno uporabljeni **globalno** za uveljavljanje dosledne oblike napak v celotnem API-ju.

## Zakaj uporabljati izjemne filtre?

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

## Filtri proti metanju izjem

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

## Zakaj je to pomembno

Izjemni filtri so pomembna funkcionalnost NestJS za izgradnjo robustnih, profesionalnih API-jev s **doslednim, kontroliranim obravnavanjem napak**.

Ceprav že vgrajena NestJS izjemna plast vrnjene izjeme pretvori v HTTP odgovore, vam izjemni filtri dajo popoln nadzor za prilagajanje tega vedenja — kar je pomembno za več resničnih skrbi: uveljavljanja **dosledne oblike odgovora napake** v vseh končnih točkah (tako da klienti vedno dobijo napake v isti obliki), **centralizacije beleženja napak** (zajemanje vsake napake na enem mestu namesto raztresenih try/catch), varnega **obravnavanja nepričakovanih ne-HTTP napak** (njihova pretvorba v čiste 500 namesto padca ali puščanja podrobnosti), in **varnosti** (skrivanje notranjih sledi napak in občutljivih podrobnosti pred klienti, medtem ko jih beležimo interno).

Globalni "ujemanje vsega" filter skupaj z metanjem specifičnih HTTP izjem v vašem kodu je standardni vzorec za obravnavanje napak v produkciji.

Razumevanje, kdaj in kako uporabljati filtre (v primerjavi s preprostim metanjem izjem), in njihova globalna uporaba za doslednost je značilnost dobro zgrajenih NestJS aplikacij in odraža zrelo back-end prakso glede pogosto zanemarjenega, vendar kritičnega vidika obravnavanja napak.