Qual è l'ordine del ciclo di vita della richiesta in NestJS?

Question

Accepted Answer

Il **ciclo di vita della richiesta** è la sequenza precisa di componenti attraverso cui una richiesta passa in NestJS — middleware, guard, interceptor, pipe, handler, poi di nuovo interceptor, e exception filter in caso di errori. Conoscere l'ordine esatto è cruciale per capire *quando* ogni pezzo di logica viene eseguito.

## L'ordine 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)
```

## Perché l'ordine è importante (conseguenze pratiche)

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

## All'interno di ogni categoria, vale l'ordinamento per scope

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

## Perché è importante

Comprendere l'ordine del ciclo di vita della richiesta è fondamentale per costruire correttamente le applicazioni NestJS — determina esattamente *quando* ogni pezzo di logica trasversale viene eseguito, il che influisce direttamente sulle decisioni di progettazione e sul debug.

L'ordinamento ha un significato reale e pratico: **i guard vengono eseguiti prima delle pipe**, quindi l'autorizzazione viene controllata correttamente prima di preoccuparsi di validare l'input (una richiesta non autorizzata viene rifiutata prima della validazione); **le pipe vengono eseguite subito prima dell'handler**, garantendo che l'handler riceva sempre argomenti validati e trasformati; **gli interceptor avvolgono l'handler** (eseguendosi prima *e* dopo), il che è esattamente quello che permette loro di cronometrare l'esecuzione e trasformare le risposte; e **gli exception filter catturano errori da qualsiasi fase**, abilitando la gestione centralizzata degli errori.

Conoscere questo ordine — più l'ordinamento per scope all'interno di ogni categoria (globale → controller → metodo) — ti permette di posizionare la logica nel componente giusto, prevedere il flusso di esecuzione, eseguire il debug di perché qualcosa viene eseguito (o non viene eseguito) quando previsto, e progettare le funzionalità correttamente.

Lega insieme tutti i pezzi della gestione delle richieste del framework (middleware, guard, interceptor, pipe, filter) in un modello mentale coerente, il che lo rende un argomento importante e frequentemente testato che riflette una vera comprensione di come NestJS elabora le richieste.