რა არის ინტერსეპტორები?

Question

Accepted Answer

**ინტერსეპტორები** მოაქავთ მარშრუტის ხელმძღვანელის შესრულებას, რაც საშუალებას გაძლევთ გაშვებოთ ლოგიკა **მის წინ და შემდეგ** — და გარდაიცვალოთ მოთხოვნა ან პასუხი. ისინი ნიშნავან ასპექტზე ორიენტირებული პროგრამირებით, იდეალური ჯვარედინი საკითხებისთვის, როგორიცაა ლოგირება, პასუხის ტრანსფორმაცია, კეშირება და დროის გაზომვა.

## სტრუქტურა: წინ + შემდეგ RxJS-ის მეშვეობით

```ts
@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    console.log("Before handler");          // runs BEFORE the route handler
    const now = Date.now();

return next.handle().pipe(               // next.handle() = invoke the handler
      tap(() => console.log(`After: ${Date.now() - now}ms`)),   // runs AFTER
    );
  }
}
```

ინტერსეპტორი ახორციელებს `intercept()`. კოდი `next.handle()`-მდე გაშვება ხდება **მის წინ**; `next.handle()` აბრუნებს RxJS `Observable`-ს პასუხზე, და ოპერატორები, როგორიცაა `tap`/`map`, გაძლევთ საქმეს გაკეთების საშუალებას პასუხზე **მის შემდეგ**, როდესაც ხელმძღვანელი დასრულდება.

## პასუხის ტრანსფორმაცია (ჩვეულებრივი გამოყენება)

```ts
@Injectable()
export class TransformInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler) {
    return next.handle().pipe(
      map(data => ({ success: true, data, timestamp: new Date().toISOString() })),
      // wraps EVERY response in a consistent envelope: { success, data, timestamp }
    );
  }
}
```

`map`-ის გამოყენებით, ინტერსეპტორი შეიძლება გადახაზოს ყველა პასუხი — მაგ. ყველა პასუხის შეფუთვა სტანდარტული კონვერტში, ეს ძალიან ჩვეულებრივი შაბლონია თანმიმდევრული API პასუხებისთვის.

## სხვა ძლიერი გამოყენებები

```ts
// caching — return a cached response, skipping the handler entirely
// timeout — fail requests taking too long
return next.handle().pipe(timeout(5000));

// error mapping — transform exceptions
return next.handle().pipe(catchError(err => throwError(() => new BadGatewayException())));

// excluding fields (serialization) — ClassSerializerInterceptor strips @Exclude() fields
```

```text
Common interceptor uses:
  ✓ Logging / timing requests (before + after)
  ✓ Transforming responses (consistent envelopes, field exclusion)
  ✓ Caching responses
  ✓ Adding timeouts
  ✓ Mapping/handling errors
```

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

```ts
@UseInterceptors(LoggingInterceptor)   // method or controller level
app.useGlobalInterceptors(new TransformInterceptor());   // global
```

## ინტერსეპტორები წინააღმდეგ middleware-სა და guards-ის

```text
Middleware  → runs BEFORE everything, with raw req/res (can't easily touch the response)
Guard       → AUTHORIZATION decision (allow/block) before the handler
Interceptor → wraps the handler — runs BEFORE and AFTER, can TRANSFORM the response
```

მომიჯნავე მახასიათებელი: ინტერსეპტორები შეიძლება გაშვებოთ ლოგიკა **მის შემდეგ** ხელმძღვანელმა და **გარდაიცვალოთ პასუხი** — რაც middleware და guards არ შეუძლიათ깔끔하게.

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

ინტერსეპტორები არის NestJS-ის ძლიერი ფუნქცია **ჯვარედინი საკითხების** ელეგანტური გამკლავებისთვის, და მათი განმასხვავებელი შესაძლებლობა — ლოგიკის გაშვება ხელმძღვანელის წინ *და შემდეგ*, და პასუხის ტრანსფორმაცია — მათ კარგი ხელსაწყო ხდის საჭიროებებისთვის, რომლებსაც middleware და guards არ შეუძლიათ მოგვარება.

მათი გაგება მნიშვნელოვანია, რადგან ბევრი ჩვეულებრივი მოთხოვნა ბუნებრივად ემთხვევა ინტერსეპტორებს: თანმიმდევრული პასუხის ფორმატირება (ყველა პასუხის შეფუთვა სტანდარტული `{ success, data }` კონვერტში), ლოგირება/დროის გაზომვა (ხელმძღვანელის ხანგრძლივობის გაზომვა), კეშირება (კეშირებული პასუხების დაბრუნება), ტიმაუტები, შეცდომის ტრანსფორმაცია, და სერიალიზაცია (მგრძნობიარე ველების გამორიცხვა).

სტრუქტურის ცოდნა (`next.handle()` Observable, `tap`/`map`/`catchError`-თან საქმეს გაკეთების წინ/შემდეგ), ჩვეულებრივი გამოყენების შემთხვევები, და განსაკუთრებით **როგორ განსხვავდება ინტერსეპტორები middleware-დან და guards-დან** (პასუხის შეფუთვა და ტრანსფორმაცია) არის NestJS არქიტექტურული კომპეტენტნობის ძირითადი ნაწილი.

ინტერსეპტორები ინარჩუნებენ ჯვარედინი ლოგიკას DRY-ს და ცენტრალიზებულად, ვიდრე დუპლიკატურად ხელმძღვანელებში, რაც მათ ხშირად გამოყენებულ, მნიშვნელოვან ხელსაწყოდ აკეთებს სუფთა, მდგრადი NestJS აპლიკაციების სამშენებლოდ.