Što je middleware u NestJS-u i kako se razlikuje od guards/interceptors?

Question

Accepted Answer

**Middleware** je funkcija koja se izvršava **prije handlera rute**, s pristupom objektima zahtjeva i odgovora — isti koncept kao Express middleware. NestJS također ima guards, interceptors, pipes i filters, od kojih se svaki izvršava na određenoj točki u životnom ciklusu zahtjeva s različitom svrhom. Znati koji koristiti je ključno.

## Middleware — izvršava se prvi, ima 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 izvršava prvi, prije guards/interceptors/pipes, i radi s raw `req`/`res` — dobro za logging, mijenjanje zahtjeva, CORS i probleme kompatibilne s Express-om.

## Redoslijed punog životnog ciklusa zahtjeva

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

## Čemu služi svaki (odabir pravog alata)

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

Kljiučne razlike: middleware je generička obrada prije Express-stila; **guards** specifično rukuju autorizacijom (čisto, namjenjeno mjesto za auth, za razliku od stavljanja u middleware); **interceptors** omotavaju handler za transformaciju odgovora ili dodavanje sveobuhvatnog ponašanja; **pipes** validiraju ulaz; **filters** obrađuju greške.

## Kada koristiti 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
```

## Zašto je to važno

Razumijevanje middleware-a i kako se razlikuje od guards, interceptors, pipes i filters bitno je za pravilnu strukturu NestJS aplikacija — svaki ima specifičnu ulogu i izvršava se na specifičnoj točki u životnom ciklusu zahtjeva, a korištenje pravog dovodi do čistog, idiomatskog koda.

Middleware rukuje generičkom obradom prije Express-stila s raw req/res.

Kritične razlike su što su **guards** namjenjeno, prikladnije mjesto za autorizaciju (auth/roles) — daleko čišće od middleware-a u tu svrhu — i **interceptors** omotavaju handler za transformaciju odgovora i dodavanje sveobuhvatnih problema (logging, cachiranje, timing) što middleware ne može lako učiniti (jer se izvršava prije handlera i ne vidi prirodno odgovor).

Znati redoslijed punog ciklusa (middleware → guards → interceptors → pipes → handler → interceptors → filters) i koji alat odgovara svakom problemu (auth → guard, transformacija odgovora → interceptor, validacija → pipe, greške → filter) je znak NestJS kompetentnosti i sprječava čest grešku korištenja middleware-a za sve.

Ovo je često testirani, arhitekturalno važan topic u okviru.