Ce este middleware în NestJS și cum diferă de guards/interceptors?

Question

Accepted Answer

**Middleware** este o funcție care se execută **înainte de handler-ul rutei**, cu acces la obiectele request și response — același concept ca middleware-ul Express. NestJS are, de asemenea, guards, interceptors, pipes și filters, fiecare executând la un punct specific în ciclul de viață al request-ului cu un scop distinct. Știind care să folosești este esențial.

## Middleware — se execută mai întâi, are acces la 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 se execută cel mai devreme, înainte de guards/interceptors/pipes, și funcționează cu `req`/`res` brut — bun pentru logging, modificare request, CORS și preocupări compatibile cu Express.

## Ordinea completă a ciclului de viață al request-ului

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

## Pentru ce este fiecare (alegerea instrumentului potrivit)

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

Distincțiile cheie: middleware este pre-procesare generică în stil Express; **guards** gestionează specific autorizarea (un loc dedicat și curat pentru auth, spre deosebire de a o introduce în middleware); **interceptors** înfășoară handler-ul pentru a transforma răspunsurile sau a adăuga comportament transversal; **pipes** validează input; **filters** gestionează erorile.

## Când să folosești 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
```

## De ce contează

Înțelegerea middleware și a diferenței sale de guards, interceptors, pipes și filters este esențială pentru structurarea corectă a aplicațiilor NestJS — fiecare are un rol specific și se execută la un punct specific în ciclul de viață al request-ului, și folosirea celui potrivit conduce la cod curat și idiomatici pentru framework.

Middleware gestionează pre-procesare generică în stil Express cu req/res brut.

Distincțiile cruciale sunt că **guards** sunt locul dedicat și potrivit pentru autorizare (auth/roles) — mult mai curat decât middleware pentru acest scop — și **interceptors** înfășoară handler-ul pentru a transforma răspunsurile și a adăuga preocupări transversale (logging, caching, timing) pe care middleware nu le poate face cu ușurință (deoarece se execută înainte de handler și nu vede natural răspunsul).

Cunoașterea ordinei complete a ciclului de viață (middleware → guards → interceptors → pipes → handler → interceptors → filters) și care instrument se potrivește fiecărei preocupări (auth → guard, transformare răspuns → interceptor, validare → pipe, erori → filter) este o marcă a competenței NestJS și previne greșeala comună de a folosi middleware pentru totul.

Acesta este un subiect testat frecvent și arhitectural important în framework.