Mik azok az interceptorok?

Question

Accepted Answer

**Interceptorok** becsomagolják egy route handler végrehajtását, lehetővé téve, hogy logikát futtass **előtte és után** — valamint átalakítsd a kérést vagy a választ. Az aspektusorientált programozásból inspirálódtak, ideálisak a keresztmetszeteket érintő problémák, például naplózás, válasz átalakítása, gyorsítótárazás és időmérés kezelésére.

## A szerkezet: előtte + után az RxJS-en keresztül

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

Az interceptor implementálja az `intercept()` metódust. A `next.handle()` előtt írt kód **előtte** fut le a handler-nek; a `next.handle()` egy RxJS `Observable`-t ad vissza a válaszból, és az operátorok, mint a `tap`/`map`, lehetővé teszik, hogy a handler befejezése **után** cselekedj a válaszon.

## A válasz átalakítása (közös felhasználási eset)

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

A `map` segítségével egy interceptor átformázhat minden választ — például az összes válasz becsomagolása egy szabványos burkolóba, amely nagyon gyakori minta a konzisztens API válaszokhoz.

## Egyéb erőteljes felhasználások

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

## Interceptorok alkalmazása

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

## Interceptorok vs middleware vs guardok

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

A meghatározó jellemző: az interceptorok a handler **után** futtathatnak logikát és **átalakíthatják a választ** — amit a middleware és guardok nem tehetnek meg tisztán.

## Miért fontos

Az interceptorok egy erőteljes NestJS funkció a **keresztmetszeteket érintő problémák** elegáns kezeléséhez, és megkülönböztető képességük — a logika futtatása a handler előtt *és után*, valamint a válasz átalakítása — olyan problémák megoldására teszi őket ideálissá, amelyekkel a middleware és guardok nem tudnak megbirkózni.

Az értékelésük azért fontos, mert sok gyakori követelmény természetesen leképezhető az interceptorokra: konzisztens válaszformázás (az összes válasz becsomagolása egy szabványos `{ success, data }` burkolóba), naplózás/időmérés (a handler időtartamának mérése), gyorsítótárazás (gyorsítótárazott válaszok visszaadása), időkorlátok, hiba átalakítása és szerializáció (érzékeny mezők kizárása).

A szerkezet ismerete (a `next.handle()` Observable, a `tap`/`map`/`catchError` segítségével az előtti/utáni cselekvéshez), a gyakori felhasználási esetek, és különösen az **hogy az interceptorok miben különböznek a middleware-től és guardoktól** (a képesség a válasz becsomagolásához és átalakításához) a NestJS építészeti kompetencia kulcsfontosságú része.

Az interceptorok a keresztmetszeteket érintő logikát DRY-ben és központosítva tartják, ahelyett hogy duplikálnák őket a handlerek között, így a tiszta, karbantartható NestJS alkalmazások építésének gyakran használt, fontos eszköze.