Wat is middleware in NestJS en hoe verschilt het van guards/interceptors?

Question

Accepted Answer

**Middleware** is een functie die **vóór de route handler** wordt uitgevoerd, met toegang tot de request en response objecten — hetzelfde concept als Express middleware. NestJS heeft ook guards, interceptors, pipes en filters, die elk op een specifiek moment in de request lifecycle worden uitgevoerd met een duidelijk doel. Weten welke je moet gebruiken is essentieel.

## Middleware — wordt eerst uitgevoerd, heeft 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 wordt het eerst uitgevoerd, vóór guards/interceptors/pipes, en werkt met raw `req`/`res` — goed voor logging, request aanpassingen, CORS en Express-compatibele concerns.

## De volledige request lifecycle volgorde

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

## Wat elk is VOOR (het juiste gereedschap kiezen)

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

De kernverschillen: middleware is generieke Express-stijl pre-processing; **guards** behandelen specifiek autorisatie (een schone, dedicated plek voor auth, in tegenstelling tot het in middleware proppen); **interceptors** omwikkelen de handler om responses te transformeren of cross-cutting behavior toe te voegen; **pipes** valideren invoer; **filters** behandelen fouten.

## Wanneer middleware vs guards vs interceptors gebruiken

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

## Waarom het belangrijk is

Inzicht in middleware en hoe het verschilt van guards, interceptors, pipes en filters is essentieel voor het correct structureren van NestJS applicaties — elk heeft een specifieke rol en wordt op een specifiek moment in de request lifecycle uitgevoerd, en het juiste gereedschap gebruiken leidt tot schone, idiomatische code.

Middleware behandelt algemene Express-stijl pre-processing met raw req/res.

De cruciale onderscheidingen zijn dat **guards** de dedicated, juiste plek zijn voor autorisatie (auth/roles) — veel schoner dan middleware voor dat doel — en **interceptors** omwikkelen de handler om responses te transformeren en cross-cutting concerns toe te voegen (logging, caching, timing) die middleware niet gemakkelijk kan doen (omdat het vóór de handler wordt uitgevoerd en niet natuurlijk de response ziet).

Weten van de volledige lifecycle volgorde (middleware → guards → interceptors → pipes → handler → interceptors → filters) en welk gereedschap bij elk concern past (auth → guard, response transformatie → interceptor, validatie → pipe, fouten → filter) is een kenmerk van NestJS competentie en voorkomt de veelgemaakte fout van middleware voor alles misbruiken.

Dit is een frequently-tested, architecturaal-belangrijk onderwerp in het framework.