Apa urutan siklus hidup permintaan di NestJS?

Question

Accepted Answer

**Siklus hidup permintaan** adalah urutan yang tepat dari komponen yang dilalui permintaan di NestJS — middleware, guards, interceptors, pipes, handler, kemudian interceptors lagi, dan exception filters pada kesalahan. Mengetahui urutan yang tepat sangat penting untuk memahami *kapan* setiap bagian logika berjalan.

## The full order

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

## Why the order matters (practical consequences)

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

## Within each category, scope ordering applies

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

## A concrete example

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

## Mengapa ini penting

Memahami urutan siklus hidup permintaan adalah fundamental untuk membangun aplikasi NestJS dengan benar — hal ini menentukan dengan tepat *kapan* setiap bagian logika lintas-cutting dijalankan, yang secara langsung mempengaruhi keputusan desain dan debugging.

Urutan memiliki signifikansi praktis yang nyata: **guards berjalan sebelum pipes**, jadi otorisasi diperiksa dengan benar sebelum repot melakukan validasi input (permintaan yang tidak berwenang ditolak sebelum validasi); **pipes berjalan tepat sebelum handler**, menjamin handler selalu menerima argumen yang divalidasi dan ditransformasi; **interceptors membungkus handler** (berjalan sebelum *dan* sesudah), yang merupakan cara yang memungkinkan mereka mengukur waktu eksekusi dan mentransformasi respons; dan **exception filters menangkap kesalahan dari tahap apa pun**, memungkinkan penanganan kesalahan terpusat.

Mengetahui urutan ini — ditambah urutan scope dalam setiap kategori (global → controller → method) — memungkinkan Anda menempatkan logika di komponen yang tepat, memprediksi aliran eksekusi, men-debug mengapa sesuatu berjalan (atau tidak berjalan) saat diharapkan, dan merancang fitur dengan benar.

Ini mengikat semua bagian penanganan permintaan framework (middleware, guards, interceptors, pipes, filters) ke dalam model mental yang kohesif, menjadikannya topik yang penting dan sering diuji yang mencerminkan pemahaman sejati tentang bagaimana NestJS memproses permintaan.