Apa urutan siklus hidup permintaan NestJS?

Question

Accepted Answer

**Siklus hidup permintaan** adalah urutan yang tepat dari komponen-komponen yang dilalui oleh permintaan di NestJS — middleware, guard, interceptor, pipe, handler, kemudian interceptor lagi, dan exception filter pada kesalahan. Mengetahui urutan yang tepat sangat penting untuk memahami *kapan* setiap bagian logika dijalankan.

## Urutan lengkap

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

## Mengapa urutan itu penting (konsekuensi praktis)

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

## Dalam setiap kategori, urutan scope berlaku

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

## Contoh konkret

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

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

Urutan ini memiliki signifikansi yang nyata dan praktis: **guard berjalan sebelum pipe**, jadi otorisasi diperiksa dengan benar sebelum repot-repot memvalidasi input (permintaan yang tidak diotorisasi ditolak sebelum validasi); **pipe berjalan tepat sebelum handler**, menjamin handler selalu menerima argumen yang divalidasi dan ditransformasi; **interceptor membungkus handler** (berjalan sebelum *dan* sesudah), yang justru memungkinkan mereka mengukur waktu eksekusi dan mentransformasi respons; dan **exception filter menangkap kesalahan dari tahap apa pun**, memungkinkan penanganan kesalahan terpusat.

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

Ini mengikat semua bagian penanganan-permintaan framework (middleware, guard, interceptor, pipe, filter) ke dalam model mental yang koheren, menjadikannya topik yang penting dan sering diuji yang mencerminkan pemahaman sejati tentang bagaimana NestJS memproses permintaan.