Çfarë është middleware në NestJS dhe si ndryshon nga guards/interceptors?

Question

Accepted Answer

**Middleware** është një funksion që ekzekutohet **përpara route handler-it**, me akses në objektet e request-it dhe response-it — i njëjti koncept si Express middleware. NestJS gjithashtu ka guards, interceptors, pipes dhe filters, secila që ekzekutohet në një pikë specifike në ciklin e kërkesës me një qëllim të veçantë. Të dija se cilën të përdorësh është kyçe.

## Middleware — ekzekutohet i pari, ka 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 ekzekutohet më i pari, përpara guards/interceptors/pipes, dhe funksionon me raw `req`/`res` — i mirë për logging, modifikimin e kërkesës, CORS dhe çështjet e përputhshme me Express.

## Rendi i plotë i ciklit të kërkesës

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

## Çfarë përfaqëson secila (zgjedhja e mjetit të duhur)

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

Dallimi kryesor: middleware është përpunim i përgjithshëm i stilit Express; **guards** trajtojnë konkretisht autorizimin (një vend i dedikuar dhe i pastër për auth, ndryshe nga fusja e tij në middleware); **interceptors** mbyllin handler-in për të transformuar responses ose shtuar sjellje tërthore; **pipes** validojnë input-in; **filters** trajtojnë gabimet.

## Kur të përdorësh 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
```

## Pse është e rëndësishme

Kuptimi i middleware-it dhe si ndryshon nga guards, interceptors, pipes dhe filters është thelbësor për strukturimin e duhur të aplikacioneve NestJS — secila ka një rol të veçantë dhe ekzekutohet në një pikë të veçantë në ciklin e kërkesës, dhe përdorimi i mjetit të duhur sjell kod të pastër dhe idiomatik.

Middleware trajtojnë përpunimin e përgjithshëm të stilit Express me raw req/res.

Dallimi vendimtar është se **guards** janë vendi i dedikuar dhe i duhur për autorizim (auth/roles) — shumë më i pastër se middleware për këtë qëllim — dhe **interceptors** mbyllin handler-in për të transformuar responses dhe shtuar shqetësimet tërthore (logging, caching, timing) që middleware nuk mund t'i bëjë lehtë (pasi ekzekutohet përpara handler-it dhe nuk sheh natyrisht response-in).

Të njohësh rendin e plotë të ciklit (middleware → guards → interceptors → pipes → handler → interceptors → filters) dhe cilin mjet përshtatet çdo shqetësim (auth → guard, transformim i response-it → interceptor, validim → pipe, gabime → filter) është një shenjë e aftësisë në NestJS dhe parandalon gabimin e zakonshëm të keqpërdorimit të middleware-it për gjithçka.

Kjo është një temë që testohet shpesh dhe është arkitekturisht e rëndësishme në framework-un.