Apa itu middleware di NestJS dan bagaimana perbedaannya dengan guards/interceptors?

Question

Accepted Answer

**Middleware** adalah fungsi yang berjalan **sebelum route handler**, dengan akses ke objek request dan response — konsep yang sama dengan middleware Express. NestJS juga memiliki guards, interceptors, pipes, dan filters, masing-masing berjalan pada titik tertentu dalam siklus hidup permintaan dengan tujuan yang berbeda. Mengetahui mana yang harus digunakan sangat penting.

## Middleware — berjalan terlebih dahulu, memiliki req/res

```ts
@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log(`${req.method} ${req.url}`);   // logging, modifying req
    next();                                      // MUST call next() to continue
  }
}

// register in a module
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(LoggerMiddleware).forRoutes("*");   // apply to routes
  }
}
```

Middleware berjalan paling awal, sebelum guards/interceptors/pipes, dan bekerja dengan `req`/`res` mentah — bagus untuk logging, modifikasi request, CORS, dan masalah yang kompatibel dengan Express.

## Urutan siklus hidup permintaan lengkap

```text
Request →
  1. Middleware     (req/res; runs first, Express-style)
  2. Guards         (return true/false → AUTHORIZE or block the request)
  3. Interceptors   (BEFORE the handler)
  4. Pipes          (validate/transform the handler's arguments)
  5. → Route Handler ←
  6. Interceptors   (AFTER the handler — transform the response)
  7. Exception Filters (if an error was thrown anywhere)
→ Response
```

## Apa tujuan masing-masing (memilih alat yang tepat)

```text
Middleware  → general pre-processing with req/res (logging, CORS, raw request work)
Guards      → AUTHORIZATION — decide if a request may proceed (auth, roles)
              (return true = allow, false/throw = block)
Interceptors→ wrap the handler — transform request/response, add logging/caching/timing
              (can run logic BEFORE and AFTER the handler)
Pipes       → VALIDATE/TRANSFORM the handler's input arguments (DTO validation)
Filters     → catch and format EXCEPTIONS into responses
```

Pembedaan utama: middleware adalah pemrosesan sebelumnya gaya Express generik; **guards** khusus menangani otorisasi (tempat yang bersih dan didedikasikan untuk auth, tidak seperti memasukkannya ke middleware); **interceptors** membungkus handler untuk mengubah respons atau menambahkan perilaku lintas-cutting; **pipes** memvalidasi input; **filters** menangani error.

## Kapan menggunakan middleware vs guards vs interceptors

```text
Auth check?           → Guard (dedicated, has execution context, returns boolean)
Logging requests?     → Middleware OR an interceptor (interceptor sees the response too)
Transform responses?  → Interceptor (runs after the handler)
Validate a DTO?       → Pipe
Modify raw req early?  → Middleware
```

## Mengapa ini penting

Memahami middleware dan bagaimana perbedaannya dengan guards, interceptors, pipes, dan filters sangat penting untuk menstruktur aplikasi NestJS dengan benar — masing-masing memiliki peran spesifik dan berjalan pada titik tertentu dalam siklus hidup permintaan, dan menggunakan yang tepat menghasilkan kode yang bersih dan idiomatik.

Middleware menangani pemrosesan sebelumnya gaya Express generik dengan req/res mentah.

Pembedaan krusial adalah bahwa **guards** adalah tempat yang didedikasikan dan tepat untuk otorisasi (auth/roles) — jauh lebih bersih daripada middleware untuk tujuan itu — dan **interceptors** membungkus handler untuk mengubah respons dan menambahkan kepedulian lintas-cutting (logging, caching, timing) yang tidak dapat dilakukan middleware dengan mudah (karena berjalan sebelum handler dan tidak secara alami melihat respons).

Mengetahui urutan siklus hidup lengkap (middleware → guards → interceptors → pipes → handler → interceptors → filters) dan alat mana yang cocok untuk setiap kepedulian (auth → guard, transformasi respons → interceptor, validasi → pipe, error → filter) adalah tanda kompetensi NestJS dan mencegah kesalahan umum menyalahgunakan middleware untuk segalanya.

Ini adalah topik yang sering diuji dan penting secara arsitektur dalam framework.