Kas yra interceptoriai?

Question

Accepted Answer

**Interceptoriai** apima maršruto tvarkytojo vykdymą, leidžiant jums paleisti logiką **prieš ir po jo** — ir transformuoti užklausą arba atsakymą. Jie įkvėpti aspektinio programavimo, idealūs skersainiams rūpesčiams, tokiems kaip registravimas, atsakymo transformacija, talpinimas ir laikas.

## Struktūra: prieš + po per 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
    );
  }
}
```

Interceptorius įgyvendina `intercept()`. Kodas prieš `next.handle()` veikia **prieš** tvarkytoją; `next.handle()` grąžina RxJS `Observable` atsakymą, ir operatoriai, tokie kaip `tap`/`map`, leidžia jums veikti atsakymą **po** to, kai tvarkytoja yra baigta.

## Atsakymo transformavimas (dažnas naudojimas)

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

Naudojant `map`, interceptorius gali perrūpintis kiekvieno atsakymo — pvz., sumaišant visus atsakymus standartiniame vokelyje, labai dažnas modelis nuoseklūs API atsakymai.

## Kiti galingi naudojimai

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

## Interceptorių taikymas

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

## Interceptoriai vs middleware vs saugai

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

Apibrėžianti savybė: interceptoriai gali paleisti logiką **po** tvarkytojo ir **transformuoti atsakymą** — ko middleware ir saugai negali daryti švariai.

## Kodėl tai svarbu

Interceptoriai yra galinga NestJS savybė, skirta **skersainiams rūpesčiams** tvarkyti elegantiškai, ir jų skiriamoji savybė — paleidimas logiką tiek prieš *ir po* tvarkytojo, ir transformavimas atsakymą — daro juos tinkama priemone poreikiams, kuriuos middleware ir saugai negali išspręsti.

Supratimas yra svarbus, nes daugelis bendrų reikalavimų natūraliai susiję su interceptoriais: nuoseklus atsakymo formatavimas (visos atsakymai sumaišyti standartiniame `{ success, data }` vokelyje), registravimas/laikas (tvarkytojo trukmės matavimas), talpinimas (grąžinimas sualpintos atsakymai), timeoutai, klaidų transformacija ir serijalizacija (išskyrus jautrius laukus).

Žinoti struktūrą (the `next.handle()` Observable, su `tap`/`map`/`catchError` veikti prieš/po), bendri naudojimo atvejai, ir ypač **kaip interceptoriai skiriasi nuo middleware ir saugų** (galimybė apgaubti ir transformuoti atsakymą) yra svarbi NestJS architektūrinės kompetencijos dalis.

Interceptoriai išlaiko skersainio logiką DRY ir centralizuotą, o ne pakartotą per tvarkytojas, todėl jie yra dažnai naudojama, svarbi priemonė švaraus, prižiūrimo NestJS programų statymui.