¿Cuál es el orden del ciclo de vida del request en NestJS?

Question

Accepted Answer

El **Request Lifecycle** es la secuencia precisa de componentes por los que pasa una solicitud a través de NestJS — middleware, guards, interceptors, pipes, handler, luego interceptors de nuevo, y exception filters en caso de errores. Conocer el orden exacto es crucial para entender *cuándo* se ejecuta cada pieza de la lógica.

## El orden completo

```text
Incoming Request
   │
   ▼
1. MIDDLEWARE            (Express-style; raw req/res; runs first)
   │
   ▼
2. GUARDS                (authorization — return true to continue, false/throw to block)
   │
   ▼
3. INTERCEPTORS (pre)    (logic BEFORE the handler — start timing, etc.)
   │
   ▼
4. PIPES                 (validate/transform the handler's arguments — DTO validation)
   │
   ▼
5. ROUTE HANDLER         (your controller method runs)
   │
   ▼
6. INTERCEPTORS (post)   (logic AFTER the handler — transform the response)
   │
   ▼
Response

✗ If an exception is thrown ANYWHERE above →
7. EXCEPTION FILTERS     (catch it and format the error response)
```

## Por qué el orden es importante (consecuencias prácticas)

```text
• Guards run BEFORE pipes → authorization is checked before input validation
  (no point validating a body for an unauthorized request)
• Pipes run JUST BEFORE the handler → the handler always gets validated/transformed args
• Interceptors straddle the handler → they can measure its duration and transform output
• Filters catch errors from any stage → centralized, consistent error handling
```

## Dentro de cada categoría, se aplica scope ordering

```text
For each type (guards, interceptors, pipes), they run in this scope order:
  Global → Controller → Method (route)
So a global guard runs before a controller-level guard, before a route-level guard.
```

## Un ejemplo concreto

```ts
@Controller("users")
@UseGuards(AuthGuard)                    // 2. checks authorization
@UseInterceptors(LoggingInterceptor)     // 3 (pre) + 6 (post)
export class UsersController {
  @Post()
  create(@Body() dto: CreateUserDto) {    // 4. ValidationPipe validates dto, 5. handler runs
    return this.usersService.create(dto);
  }
}
// Flow: middleware → AuthGuard → LoggingInterceptor(before) → ValidationPipe →
//       create() → LoggingInterceptor(after) → response (or → filter on error)
```

## Por qué es importante

Comprender el orden del ciclo de vida del request es fundamental para construir aplicaciones NestJS correctamente — determina exactamente *cuándo* se ejecuta cada pieza de lógica transversal, lo que afecta directamente las decisiones de diseño y la depuración.

El orden tiene una importancia real y práctica: **los guards se ejecutan antes que los pipes**, por lo que la autorización se verifica correctamente antes de molestarse en validar la entrada (una solicitud no autorizada se rechaza antes de la validación); **los pipes se ejecutan justo antes del handler**, garantizando que el handler siempre reciba argumentos validados y transformados; **los interceptors envuelven el handler** (ejecutándose antes *y* después), que es precisamente lo que les permite cronometrar la ejecución y transformar respuestas; y **los exception filters capturan errores de cualquier etapa**, permitiendo manejo centralizado de errores.

Conocer este orden — más el scope ordering dentro de categorías (global → controller → method) — te permite colocar lógica en el componente correcto, predecir el flujo de ejecución, depurar por qué algo se ejecuta (o no) cuando se espera, y arquitectar características correctamente.

Une todas las piezas de manejo de solicitudes del framework (middleware, guards, interceptors, pipes, filters) en un modelo mental coherente, convirtiéndolo en un tema importante y frecuentemente probado que refleja una comprensión genuina de cómo NestJS procesa las solicitudes.