Menene middleware a cikin NestJS kuma ta yaya ya bambanta da guards/interceptors?

Question

Accepted Answer

**Middleware** aiki ne da ke "aiki **kafin jiya route handler", tare da samun damar zuwa bugun ajiya da amsa — kadar kadar da Express middleware. NestJS kuma yana da guards, interceptors, pipes, da filters, kowannensu yana "aiki a musamman wurin kwanar jiya da unguwar musamman. Sanin wanda zai ji "aiki ne mahimmi.

## Middleware — tunanin nan jiya, tare da 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 yana "aiki na farko, kafin guards/interceptors/pipes, kuma yana "aiki tare da raw `req`/`res` — kyau don "aiki, gyarawa bugin, CORS, da Express-matching aliaji.

## Cikakken "umarni na kwanar jiya

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

## Menene kowa don (zaɓa kayan aikin dama)

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

Bambatattun muhimmi: middleware gaba ɗa Express-style aiki; **guards** musamman "uke baudde (jiya wuri da jiya auth, ba da saita shi a middleware ba) ; **interceptors** "uke fullon handler don canzawa amsa ko ƙara jiya-cuta; **pipes** tabbatar da shigarwa; **filters** "uke gudde kuskure.

## Lokaci da zai "amfe 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
```

## Me ya sa haka muhimmi

Sanin middleware kuma ta yaya ta bambanta da guards, interceptors, pipes da filters shine mahimmi don "uke tsarata NestJS aikace-aikacen - kowa yana da musamman "aiki da musamman wuri a "umarni na kwanar jiya, kuma amfani da dama yana "aika ga jiya, idiomatic code.

Middleware "uke kujerun gaba ɗa Express-style aiki tare da raw req/res.

Bambatattun mahimmi sune cewa **guards** jiya wuri da dama don "uke baudde (auth/roles) — a fisiye mai tsani fiye da middleware gida - kuma **interceptors** fullon handler don canzawa amsa kuma ƙara jiya-cuta aliaji ("aiki, adana, "aiki) wanda middleware ba zai iya "aiki ba (tun ya "aika kafin handler kuma ba sidikane ji amsa ba).

Sanin cikakken "umarni na kwanar (middleware → guards → interceptors → pipes → handler → interceptors → filters) kuma wacce kalifa ya dace ga kowa aliaji (auth → guard, amsa canza → interceptor, tabbatar → pipe, kuskure → filter) shine alama na NestJS ilimi kuma ta hana barcin rabana middleware don kome.

Itaje a yau-yau, mahimmancin ginin jiya a cikin fassarar.