Kaj je middleware v NestJS in kako se razlikuje od guards/interceptors?

Question

Accepted Answer

**Middleware** je funkcija, ki se izvede **pred route handlerjem**, z dostopom do request in response objektov — isti koncept kot Express middleware. NestJS ima tudi guards, interceptors, pipes in filters, vsak se izvede na specifični točki v request lifecycle z različnim namenjem. Poznavanje tega, katero orodje uporabiti, je ključno.

## Middleware — se izvede 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 izvede najhitrej, pred guards/interceptors/pipes, in dela z surimi `req`/`res` — primeren za logging, modifikacijo zahtevka, CORS in Express-kompatibilne zadeve.

## Celoten vrstni red request lifecycle

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

## Za kaj je vsak namenjen (izbira pravilnega orodja)

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

Klučne razlike: middleware je generičen Express-slog pre-processing; **guards** posebej rokovajo s privzgajanjem (čisto, namenske mesto za avtentifikacijo, drugače kot da bi jo vtiskali v middleware); **interceptors** obdajo handler, da transformiirajo response ali dodajo cross-cutting obnašanje; **pipes** validirajo vnos; **filters** rokovajo s programskimi napakami.

## Kdaj uporabiti 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
```

## Zakaj je to pomembno

Razumevanje middleware in kako se razlikuje od guards, interceptors, pipes in filters je nujno za pravilno strukturiranje NestJS aplikacij — vsak ima specifično vlogo in se izvede na specifični točki v request lifecycle, in uporaba pravilnega orodja vodi do čistega, idiomatskega koda.

Middleware obravnava splošni Express-slog pre-processing s surimi req/res.

Osnovne razlike so, da so **guards** namensko, primerno mesto za avtentifikacijo (auth/roles) — daleč čisteje kot middleware za ta namen — in **interceptors** obdajo handler, da transformirajo response in dodajajo cross-cutting zadeve (logging, caching, timing), ki jih middleware ne more enostavno storiti (ker se izvede pred handlerjem in naravno ne vidi response).

Poznavanje polnega vrstnega reda lifecycle (middleware → guards → interceptors → pipes → handler → interceptors → filters) in katero orodje se ujema z vsako zadevo (auth → guard, response transformacija → interceptor, validacija → pipe, napake → filter) je značilnost NestJS kompetentnosti in preprečuje pogosto napako napačne uporabe middleware za vse.