Co jsou interceptory?

Question

Accepted Answer

**Interceptory** obalují spuštění handler route, což umožňuje spustit logiku **před a po** něm — a transformovat request nebo response. Jsou inspirovány aspect-oriented programmingem a ideální jsou pro cross-cutting concerns, jako je logování, transformace response, caching a měření času.

## Struktura: before + after přes 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
    );
  }
}
```

Interceptor implementuje `intercept()`. Kód před `next.handle()` se spustí **před** handlerem; `next.handle()` vrací RxJS `Observable` response a operátory jako `tap`/`map` vám umožňují pracovat s response **poté**, co se handler dokončí.

## Transformace response (časté použití)

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

Pomocí `map` může interceptor přetvořit každý response — např. zabalení všech responsů do standardního obálky, velmi běžný vzor pro konzistentní API responses.

## Další výkonné použití

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

## Použití interceptorů

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

## Interceptory vs middleware vs 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
```

Definiční vlastnost: interceptory mohou spustit logiku **po** handleru a **transformovat response** — což middleware a guards čistě nemohou.

## Proč na tom záleží

Interceptory jsou výkonnou NestJS vlastností pro elegantní zpracování **cross-cutting concerns** a jejich rozlišující schopnost — spouštění logiky před *i po* handleru a transformace response — z nich dělá správný nástroj pro potřeby, které middleware a guards nemohou řešit čistě.

Rozdělání jejich důležitosti je důležité, protože mnoho běžných požadavků se přirozeně mapuje na interceptory: konzistentní formatování response (zabalení všech responsů do standardního `{ success, data }` obálku), logování/měření času (měření doby trvání handleru), caching (vrácení cachovaných responsů), timeouty, transformace chyb a serializace (vyloučení citlivých polí).

Znalost struktury (RxJS `Observable` `next.handle()`, s `tap`/`map`/`catchError` pro práci před/po), běžných případů použití a zejména **jak se interceptory liší od middleware a guards** (schopnost zabalit a transformovat response) je klíčovou součástí NestJS architektonické způsobilosti.

Interceptory udržují cross-cutting logiku DRY a centralizovanou místo duplikování across handlery, což z nich dělá často používaný, důležitý nástroj pro vytváření čistých, udržovatelných NestJS aplikací.