რა არის exception ფილტრები?

Question

Accepted Answer

**Exception ფილტრები** სრულად აკონტროლებენ, თუ როგორ იჭერა და გარდაიქმნება **შეცდომები რესპონსებად**. ისინი მოთხოვნის ცხოვრების ციკლის ბოლოში მდებარეობენ, ჭერენ გამონაკლისებს, რომლებიც მოთხოვნის ნებისმიერ ადგილას იფრქვება და საშუალებას გაძლევთ მოთავსოთ შეცდომის რესპონსის ფორმატი, სტატუსი და ლოგირება.

## საბაზო exception ფილტრი

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

`@Catch()` დეკორატორი განსაზღვრავს, რომელი გამონაკლისის ტიპები ამ ფილტრს ამუშავებს, ხოლო `catch()` მეთოდი იღებს გამონაკლისს პლუს კონტექსტს — რაც შეგიძლია შექმნა ნებისმიერი რესპონსი რომელიც გინდა.

## ALL გამონაკლისების ჭერა (მათ შორის non-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: "..." });
  }
}
```

ფილტრი `@Catch()` (არგუმენტის გარეშე) ამუშავებს ყველა გამონაკლისს — ადგილი, სადაც ლოგირება უნელი შეცდომები და დარწმუნება, რომ თუნდაც non-HTTP შეცდომები დააბრუნებენ სუფთა, უსაფრთხო რესპონსს (სტეკის ტრეისი ক්লიენტებისთვის გაზიარებული არ იქნება).

## ფილტრების გამოყენება

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

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

ფილტრები ჩვეულებრივ გამოიყენება **გლობალურად** რომ გამოიმუშაოს თანმიმდევრული შეცდომის ფორმატი მთელი API-ის მიხედვით.

## რატომ გამოვიყენოთ exception ფილტრები?

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

## ფილტრები გამონაკლისის გამოტყენებასთან შედარებით

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

## რატომ აქვს ეს მნიშვნელობა

Exception ფილტრები NestJS-ის მნიშვნელოვანი ფიჩა მძლავრი, პროფესიონალური API-ების აგებისთვის **თანმიმდევრული, კონტროლირებული შეცდომის დამუშავებით**.

მიუხედავად იმისა, რომ NestJS-ის ჩაშენებული გამონაკლის ფენა უკვე გარდააქცევს გამოტყენებულ გამონაკლისებს HTTP რესპონსებად, exception ფილტრები სრულად აკონტროლებენ ამ ქცევის მოთავსებას — რაც მნიშვნელოვანია რამდენიმე რეალური მიზეზის გამო: **თანმიმდევრული შეცდომის-რესპონსის ფორმის** გამოჯამება ყველა endpoint-ის მიხედვით (რათა ক්লიენტები ყოველთვის მივიღოთ შეცდომები იმავე ფორმატში), **შეცდომის ლოგირების ცენტრალიზაცია** (ყველა შეცდომის ჩაბჭიხვა ერთ ადგილში, ვიდრე ფ散된 try/catch), უსაფრთხოდ **მოულოდი non-HTTP შეცდომების დამუშავება** (მათი გარდაქმნა სუფთა 500-ებში სერვერის ხარვეზის ან დეტალების ღიდის ნაცვლად), და **უსაფრთხოება** (შიდა სტეკის ტრეისი და სენსიტიური დეტალების დამალვა ক්লიენტებისთვის, მათ დროს ლოგირება ზეწოდან).

გლობალური "catch-all" ფილტრი, რომელიც უერთდება კონკრეტული HTTP გამონაკლისების გამოტყენებას თქვენს კოდში, სტანდარტული ნიმუში ყოფილიყო production-grade შეცდომის დამუშავებისთვის.

რა დროს და როგორ გამოვიყენოთ ფილტრები (გამონაკლისის უბრალოდ გამოტყენების ნაცვლად), და მათი გამოყენება გლობალურად თანმიმდევრობისთვის, არის კარგად აგებული NestJS აპლიკაციებისა და მოწიფული back-end პრაქტიკის თვისება ხშირად უგულებელმყოფი, მაგრამ კრიტიკული შეცდომის დამუშავების შესახებ.