Kas yra išimčių filtrai?

Question

Accepted Answer

**Išimčių filtrai** suteikia jums visą kontrolę over kaip klaidos yra **sudaromos ir transformuojamos į atsakymus**. Jie yra prašymo ciklo pabaigoje, sugaupdami išimtis, išmestas bet kurioje prašymo vietoje, ir leidžia jums pritaikyti klaidos atsakymo formatą, statusą ir registravimą.

## Pagrindinis išimčių filtras

```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,
    });
  }
}
```

Dekoratorius `@Catch()` nurodo, kurias išimčių tipos šis filtras apdoroja, o metodas `catch()` gauna išimtį plus kontekstą — leidžiant jums sukurti bet kokį norimą atsakymą.

## Gaudymas VISŲ išimčių (įskaitant 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: "..." });
  }
}
```

Filtras su `@Catch()` (be argumento) apdoroja kiekvieną išimtį — vieta netikėtoms klaidoms registruoti ir užtikrinti, kad net ne-HTTP klaidos grąžintų švarų, saugų atsakymą (neatskleidžiant stack trace'ų klientams).

## Filtrų taikymas

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

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

Filtrai paprastai taikomi **globaliai**, siekiant užtikrinti nuoseklų klaidos formatą visoje API.

## Kodėl naudoti išimčių filtrus?

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

## Filtrai prieš išimtis metant

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

## Kodėl tai svarbu

Išimčių filtrai yra svarbi NestJS funkcija, skirta staigiai API, turinti **nuoseklų, kontroliuojamą klaidos apdorojimą**.

Nors NestJS integruota išimties sluoksnis jau paverčia išmestas išimtis į HTTP atsakymus, išimčių filtrai suteikia jums visą kontrolę tą elgesį pritaikyti — o tai svarbų keliems tikriems rūpesčiams: **nuoseklios klaidos-atsakymo formos** įgyvendinimai visame kiekviename endpoint'e (kad klientai visada gautų klaidas tuo pačiu formatu), **centralizuotas klaidos registravimas** (kiekvienos klaidos fiksavimas vienoje vietoje, o ne išsklaidytas try/catch), saugus **netikėtų ne-HTTP klaidų apdorojimas** (jų konvertavimas į švarių 500 vietoj kraš arba detalių nutekinimo), ir **saugumas** (slepiamos vidinės stack trace'ai ir jautrios detalės nuo klientų, tuo tarpu jas registruojant viduje).

Globalus "catch-all" filtras, sujungtas su konkrečių HTTP išimčių metavimu jūsų kode, yra standartinis gamybos kokybės klaidos apdorojimo šablonas.

Supratimas, kada ir kaip naudoti filtrus (priešingai nei tiesiog metant išimtis), ir jų taikymas globaliai nuoseklumui, yra gerai pastatytos NestJS programos žymė ir atspindi brandią back-end praktiką apie dažnai nepastebėtą, bet kritinį klaidos apdorojimo klausimą.