Mikä on middleware NestJS:ssä ja miten se eroaa guard/interceptor-komponenteista?

Question

Accepted Answer

**Middleware** on funktio, joka suoritetaan **ennen route-handleria**, ja sillä on pääsy request- ja response-objekteihin — sama käsite kuin Express middlewaressa. NestJS:ssä on myös guardit, interceptorit, putkistot ja suodattimet, joista jokainen suoritetaan request-elinkaaren tietyssä pisteessä omalla tarkoituksellaan. Sen tietäminen, mitä käyttää, on avainasemassa.

## Middleware — suoritetaan ensimmäisenä, sillä on 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 suoritetaan aikaisimmin, ennen guardeja/interceptoreita/putkistoja, ja toimii raa'illa `req`/`res`-objekteilla — hyvä loggaukselle, request-muokaukselle, CORS:ille ja Express-yhteensopivuusasioille.

## Koko request-elinkaaren järjestys

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

## Mihin kutakin käytetään (oikean työkalun valinta)

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

Avainasiat: middleware on yleinen Express-tyylinen esikäsittely; **guardit** käsittelevät erityisesti valtuutusta (selkeä, omistettu paikka autentikoinnille, toisin kuin sen ujuttaminen middlewareen); **interceptorit** käärivät handlerin vastausten muuntamiseen tai poikkisuuntaisen käyttäytymisen lisäämiseen; **putkistot** vahvistavat syötettä; **suodattimet** käsittelevät virheitä.

## Milloin käyttää middlewarea vs guardeja vs interceptoreita

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

## Miksi se on tärkeää

Middlewaren ja sen erojen ymmärtäminen guardeista, interceptoreista, putkistoista ja suodattimista on olennaista NestJS-sovellusten oikealle rakenteelle — jokaisella on erityinen rooli ja se suoritetaan request-elinkaaren tietyssä pisteessä, ja oikean valinta johtaa puhtaaseen, idiomatiikkaa noudattavaan koodiin.

Middleware käsittelee yleistä Express-tyylisen esikäsittelyä raa'illa req/res-objekteilla.

Ratkaisevia eroja ovat, että **guardit** ovat omistettu, sopiva paikka valtuutukselle (auth/roolit) — paljon siistimpi kuin middleware tähän tarkoitukseen — ja **interceptorit** käärivät handlerin vastausten muuntamiseen ja poikkisuuntaisen huolimisen lisäämiseen (loggaus, välimuisti, ajoitus), jota middleware ei voi helposti tehdä (koska se suoritetaan ennen handleria eikä luonnollisesti näe vastausta).

Koko elinkaaren järjestyksen (middleware → guardit → interceptorit → putkistot → handler → interceptorit → suodattimet) tietäminen ja sen tietäminen, mikä työkalu sopii kuhunkin huoleen (auth → guard, vastauksen muuntaminen → interceptor, validointi → putkisto, virheet → suodatin), on NestJS-osaamisen merkki ja estää yleisen virheen, jossa middlewarea käytetään kaikkeen.

Tämä on usein testattu, arkkitehtuurisesti tärkeä aihe kehyksessä.