Cad é middleware i NestJS agus conas a bhíonn sé difriúil ó guards/interceptors?

Question

Accepted Answer

**Middleware** is feidhm a rith **roimh an láimhseálaí bealaigh**, le rochtain ar na rudaí iarratas agus freagartas — an choincheap céanna le middleware Express. Tá guards, interceptors, pipes, agus filters ag NestJS freisin, gach ceann ag rith ag pointe ar leith i saolré an iarratais le críoch ar leith. Tá sé ríthábhachtach a fhios a bheith agat cé acu a úsáid.

## Middleware — rith ar dtús, le 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
  }
}
```

Bíonn middleware ag rith ar dtús, roimh guards/interceptors/pipes, agus oibríonn sé le `req`/`res` amh — go maith do thaifead, modhnú iarratas, CORS, agus gnéithe atá comhoiriúnach le Express.

## An t-ord iomlán i saolré an iarratais

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

## Cad atá gach ceann ann (an uirlis cheart a roghnú)

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

Na bearna thábhachtacha: is réamhphróiseáil ghinearálta de stíl Express an middleware; bíonn **guards** i ndiaidh údarú a láimhseáil go sonrach (áit dhedichithe, geal do auth, murab ionann is a chur i middleware) ; **bíonn interceptors** ag clúdach an láimhseálaí chun freagartas a athrú nó iompar trasnaighean a chur leis ; **pipelines** fíordheimhniú ionchuir; **cuireann filters** earráidí in iúl.

## Cathain a úsáid 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
```

## Cad é atá tábhachtach

Tá tuiscint ar middleware agus conas a bhíonn sé difriúil ó guards, interceptors, pipes agus filters riachtanach chun feidhmchláir NestJS a dhéanamh i gceart — tá ról ar leith agus pointe ar leith i saolré an iarratais ag gach ceann, agus is iad an ceann ceart a úsáid go codanna geal agus idiomatic.

Bíonn middleware ag déanamh réamhphróiseálaithe ghinearálta de stíl Express le req/res amh.

Na bearna chriticiúla atá ann ná go bhfuil **guards** an áit dhedichithe agus chuí do údarú (auth/roles) — i bhfad níos geal ná middleware ar an gcuspóir sin — agus **bíonn interceptors** ag clúdach an láimhseálaí chun freagartas a athrú agus gnéithe trasnaighean a chur leis (taifead, taisce, am) nach féidir le middleware a dhéanamh go furasta (toisc go bhfuil sé ag rith roimh an láimhseálaí agus nach bhfuil radharc nádúrtha ar an bhfreagra aige).

An t-ord iomlán i saolré (middleware → guards → interceptors → pipes → láimhseálaí → interceptors → filters) a bheith ar eolas agat agus an uirlis a bhíonn oiriúnach do gach ábhar (auth → guard, athrú freagartas → interceptor, fíordheimhniú → pipe, earráidí → filter) is comhartha de ghairmíochta NestJS agus cuireann sé stop ar an mearachta choiteann middleware a úsáid le haghaidh gach rud.

Is ábhar atá tástáilte go minic agus atá tábhachtach ó thaobh foirgneamh ann sa fhramework.