NestJS ਵਿਚ middleware ਕੀ ਹੈ ਅਤੇ ਇਹ guards/interceptors ਤੋਂ ਕਿਵੇਂ ਵੱਖਰਾ ਹੈ?

Question

Accepted Answer

**Middleware** ਇਕ ਫੰਕਸ਼ਨ ਹੈ ਜੋ **route handler ਤੋਂ ਪਹਿਲਾਂ** ਚਲਦਾ ਹੈ, request ਅਤੇ response objects ਨੂੰ access ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਦੇ ਨਾਲ — ਇਹ Express middleware ਦੇ ਸਮਾਨ ਹੈ। NestJS ਵਿਚ guards, interceptors, pipes, ਅਤੇ filters ਵੀ ਹਨ, ਜਿਹੜੇ request lifecycle ਦੇ ਇਕ ਖਾਸ ਬਿੰਦੂ ਤੇ ਚਲਦੇ ਹਨ ਤੇ ਹਰ ਇਕ ਦੀ ਵੱਖਰੀ ਉਦੇਸ਼ ਹੁੰਦੀ ਹੈ। ਜਾਣਨਾ ਕਿ ਕੌਣ ਵਰਤਣਾ ਹੈ, ਇਹ ਮੁੱਖ ਹੈ।

## Middleware — ਪਹਿਲਾਂ ਚਲਦਾ ਹੈ, 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 ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਚਲਦਾ ਹੈ, guards/interceptors/pipes ਤੋਂ ਪਹਿਲਾਂ, ਅਤੇ raw `req`/`res` ਨਾਲ ਕਾਮ ਕਰਦਾ ਹੈ — logging, request modification, CORS, ਅਤੇ Express-compatible concerns ਲਈ ਚੰਗਾ ਹੈ।

## ਪੂਰੀ 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
```

## ਹਰ ਇਕ ਕਿਸ ਲਈ ਹੈ (ਸਹੀ ਟੂਲ ਚੁਣਨਾ)

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

ਮੁੱਖ ਫਰਕ: middleware ਇਕ ਆਮ Express-style pre-processing ਹੈ; **guards** ਵਿਸ਼ੇਸ਼ ਤੌਰ ਤੇ authorization ਨੂੰ handle ਕਰਦੇ ਹਨ (auth ਲਈ ਇਕ ਸਾਫ, ਖਾਸ ਜਗ੍ਹਾ, middleware ਵਿਚ ਭੱਜਣ ਤੋਂ ਉਲਟ); **interceptors** handler ਨੂੰ wrap ਕਰਦੇ ਹਨ responses ਨੂੰ transform ਕਰਨ ਜਾਂ cross-cutting behavior ਨੂੰ add ਕਰਨ ਲਈ; **pipes** input ਨੂੰ validate ਕਰਦੇ ਹਨ; **filters** errors ਨੂੰ handle ਕਰਦੇ ਹਨ।

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

## ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

Middleware ਨੂੰ ਸਮਝਣਾ ਅਤੇ ਜਾਣਨਾ ਕਿ ਇਹ guards, interceptors, pipes, ਅਤੇ filters ਤੋਂ ਕਿਵੇਂ ਵੱਖਰਾ ਹੈ, NestJS applications ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ structure ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ — ਹਰ ਇਕ ਦੀ ਇਕ ਖਾਸ ਭੂਮਿਕਾ ਹੈ ਅਤੇ request lifecycle ਦੇ ਇਕ ਖਾਸ ਬਿੰਦੂ ਤੇ ਚਲਦਾ ਹੈ, ਅਤੇ ਸਹੀ ਇਕ ਵਰਤਣ ਨਾਲ clean, idiomatic code ਮਿਲਦਾ ਹੈ।

Middleware ਆਮ Express-style pre-processing ਨੂੰ handle ਕਰਦਾ ਹੈ raw req/res ਦੇ ਨਾਲ।

ਮਹੱਤਵਪੂਰਨ ਫਰਕ ਇਹ ਹਨ ਕਿ **guards** authorization ਲਈ ਖਾਸ, ਸਹੀ ਜਗ੍ਹਾ ਹਨ (auth/roles) — middleware ਦੀ ਤੁਲਨਾ ਵਿਚ ਬਹੁਤ ਸਾਫ — ਅਤੇ **interceptors** handler ਨੂੰ wrap ਕਰਦੇ ਹਨ responses ਨੂੰ transform ਕਰਨ ਅਤੇ cross-cutting concerns ਨੂੰ add ਕਰਨ ਲਈ (logging, caching, timing) ਜੋ middleware ਆਸਾਨੀ ਨਾਲ ਨਹੀਂ ਕਰ ਸਕਦਾ (ਕਿਉਂਕਿ ਇਹ handler ਤੋਂ ਪਹਿਲਾਂ ਚਲਦਾ ਹੈ ਅਤੇ naturally response ਨੂੰ ਨਹੀਂ ਦੇਖਦਾ)।

ਪੂਰੀ lifecycle order (middleware → guards → interceptors → pipes → handler → interceptors → filters) ਅਤੇ ਜਾਣਨਾ ਕਿ ਹਰ ਸਤਿਕਾਰ ਲਈ ਕਿਹੜਾ ਟੂਲ ਫਿੱਟ ਹੈ (auth → guard, response transformation → interceptor, validation → pipe, errors → filter) ਨੂੰ ਸਮਝਣਾ NestJS competence ਦਾ ਇਕ ਨਿਸ਼ਾਨ ਹੈ ਅਤੇ middleware ਨੂੰ ਸਭ ਲਈ misusing ਕਰਨ ਦੀ ਆਮ ਗਲਤੀ ਨੂੰ ਰੋਕਦਾ ਹੈ।

ਇਹ frequently-tested, architecturally-important topic ਹੈ framework ਵਿਚ।