Çfarë janë filtrat e përjashtimeve?

Question

Accepted Answer

**Filtrat e përjashtimeve** ju japin kontroll të plotë mbi mënyrën se si gabat janë **kapërcyer dhe transformuar në përgjigje**. Ato ndodhen në fundin e ciklit të kërkesës, duke kapërcyer përjashtimet e hedhura kudo në kërkesë dhe duke ju lejuar të përshtatni formatën e përgjigjes së gabimit, statusin dhe regjistrimin.

## Një filtër themelor përjashtimi

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

Dekoruesi `@Catch()` specifikon cilat lloje përjashtimesh e trajtojnë këtë filtër, dhe metoda `catch()` merr përjashtimin plus kontekstin — duke ju lejuar të krijoni cilëndo përgjigje dëshironi.

## Kapërcimi i TË GJITHË përjashtimeve (përfshirë jo-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: "..." });
  }
}
```

Një filtër me `@Catch()` (pa argument) trajtojnë çdo përjashtim — vendi për të regjistruar gabat e papritur dhe për të siguruar që edhe gabat jo-HTTP kthejnë një përgjigje të pastër dhe të sigurt (pa rrjedhur gjurmët e stack në klientë).

## Aplikimi i filtrave

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

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

Filtrat zakonisht aplikohen **globalisht** për të zbatuar një format gabimi konsistent në të gjithë API-në.

## Pse të përdorni filtrat e përjashtimeve?

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

## Filtrat në krahasim me hedhjen e përjashtimeve

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

## Pse ka rëndësi

Filtrat e përjashtimeve janë një veçori e rëndësishme e NestJS për ndërtimin e API-ve të fuqishëm, profesionale me **trajtimin e gabave konsistent dhe të kontrolluar**.

Ndërsa shtresa e përjashtimeve të integruar të NestJS tashmë e kthen përjashtimet e hedhura në përgjigje HTTP, filtrat e përjashtimeve ju japin kontroll të plotë për të përshtatur këtë sjellje — e cila ka rëndësi për disa shqetësime reale: zbatimin e një **forme përgjigje gabimi konsistente** në çdo pikë përfundimi (në mënyrë që klientët të marrin gjithmonë gabat në të njëjtën formë), **qendrën e regjistrimit të gabave** (duke kapur çdo gabë në një vend në vend që të shpërndahet try/catch), trajtimin e sigurt të **gabave të papritur jo-HTTP** (duke i konvertuar ato në 500 të pastër në vend që të shemben ose të rrjedhin detaje), dhe **sigurinë** (duke fshehur gjurmët e stack të brendshëm dhe detajet e ndjeshme nga klientët ndërsa i regjistroni ato brenda).

Një filtër global "catch-all" i kombinuar me hedhjen e përjashtimeve HTTP specifike në kodin tuaj është modeli standard për trajtimin e gabave në nivel produksioni.

Përtej se kur dhe si të përdorni filtrat (në krahasim me thjesht hedhjen e përjashtimeve), dhe zbatimin e tyre globalisht për konsistencë, është një shenjë e aplikacioneve të ndërtuar mirë të NestJS dhe pasqyron praktikë të pjekur të back-end-it rreth shqetësimit shpesh të neglizhuar por kritik të trajtimit të gabave.