Apakah itu middleware dalam NestJS dan bagaimanakah ia berbeza daripada guards/interceptors?

Question

Accepted Answer

**Middleware** ialah satu fungsi yang berjalan **sebelum route handler**, dengan akses kepada objek request dan response — konsep yang sama seperti middleware Express. NestJS juga mempunyai guards, interceptors, pipes, dan filters, masing-masing berjalan pada titik tertentu dalam kitar hayat request dengan tujuan yang berbeza. Mengetahui yang mana untuk digunakan adalah kunci.

## Middleware — berjalan dahulu, mempunyai 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 — sesuai untuk logging, pengubahsuaian request, CORS, dan urusan yang serasi dengan Express.

## Susunan penuh kitar hayat request

```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 fungsi setiap satu (memilih alat yang betul)

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

Perbezaan utama: middleware ialah pra-pemprosesan gaya Express yang umum; **guards** secara khusus mengendalikan authorization (satu tempat yang bersih dan khusus untuk auth, tidak seperti memaksakannya ke dalam middleware); **interceptors** membalut handler untuk mengubah response atau menambah kelakuan rentas-keratan; **pipes** mengesahkan input; **filters** mengendalikan ralat.

## Bila menggunakan middleware lwn guards lwn 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 ia penting

Memahami middleware dan bagaimana ia berbeza daripada guards, interceptors, pipes, dan filters adalah penting untuk menstruktur aplikasi NestJS dengan betul — setiap satu mempunyai peranan khusus dan berjalan pada titik tertentu dalam kitar hayat request, dan menggunakan yang betul menghasilkan kod yang bersih dan idiomatik.

Middleware mengendalikan pra-pemprosesan gaya Express yang umum dengan req/res mentah.

Perbezaan penting ialah bahawa **guards** ialah tempat yang khusus dan wajar untuk authorization (auth/roles) — jauh lebih bersih daripada middleware untuk tujuan itu — dan **interceptors** membalut handler untuk mengubah response serta menambah urusan rentas-keratan (logging, caching, timing) yang tidak mudah dilakukan oleh middleware (kerana ia berjalan sebelum handler dan tidak secara semula jadi nampak response).

Mengetahui susunan kitar hayat penuh (middleware → guards → interceptors → pipes → handler → interceptors → filters) dan alat mana yang sesuai untuk setiap urusan (auth → guard, pengubahan response → interceptor, validation → pipe, ralat → filter) ialah tanda kecekapan NestJS dan mengelakkan kesilapan biasa iaitu menyalahgunakan middleware untuk segala-galanya.

Ini ialah topik yang kerap diuji dan penting dari segi seni bina dalam framework ini.