¿Qué son los interceptores?

Question

Accepted Answer

**Interceptores** envuelven la ejecución de un manejador de ruta, permitiéndote ejecutar lógica **antes y después** del mismo — y transformar la solicitud o respuesta. Están inspirados en programación orientada a aspectos, ideales para preocupaciones transversales como logging, transformación de respuestas, caché y medición de tiempo.

## Por qué es importante: antes + después vía 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
    );
  }
}
```

Un interceptor implementa `intercept()`. El código antes de `next.handle()` se ejecuta **antes** del manejador; `next.handle()` devuelve un `Observable` de RxJS de la respuesta, y operadores como `tap`/`map` te permiten actuar sobre la respuesta **después** de que el manejador se complete.

## Transformando la respuesta (un uso común)

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

Usando `map`, un interceptor puede remodelar cada respuesta — por ejemplo, envolviendo todas las respuestas en un sobre estándar, un patrón muy común para respuestas API consistentes.

## Otros usos poderosos

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

## Aplicando interceptores

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

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

La característica definitoria: los interceptores pueden ejecutar lógica **después** del manejador y **transformar la respuesta** — lo que middleware y guards no pueden hacer limpiamente.

## Por qué es importante

Los interceptores son una característica poderosa de NestJS para manejar **preocupaciones transversales** elegantemente, y su capacidad distintiva — ejecutar lógica tanto antes *como después* del manejador, y transformar la respuesta — los convierte en la herramienta correcta para necesidades que middleware y guards no pueden abordar.

Entenderlos es importante porque muchos requisitos comunes se mapean naturalmente a interceptores: formato de respuesta consistente (envolviendo todas las respuestas en un sobre estándar `{ success, data }`), logging/medición (midiendo la duración del manejador), caché (devolviendo respuestas en caché), timeouts, transformación de errores y serialización (excluyendo campos sensibles).

Conocer la estructura (`next.handle()` Observable, con `tap`/`map`/`catchError` para actuar antes/después), los casos de uso comunes, y especialmente **cómo los interceptores difieren de middleware y guards** (la capacidad de envolver y transformar la respuesta) es una parte clave de la competencia arquitectónica de NestJS.

Los interceptores mantienen la lógica transversal DRY y centralizada en lugar de duplicada en los manejadores, convirtiéndolos en una herramienta frecuentemente utilizada e importante para construir aplicaciones NestJS limpias y mantenibles.