NestJS లో middleware అంటే ఏమిటి మరియు ఇది guards/interceptors నుండి ఎలా విభిన్నమైనది?

Question

IT Interview Practice · Accepted Answer

**Middleware** అనేది **route handler నుండి ముందు** నడిచే ఫంక్షన్, request మరియు response objects లకు యాక్సెస్ ఉంటుంది — 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 సంబంధిత విషయాల కోసం మంచిది.

## సంపూర్ణ 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 ముందస్తు ప్రాసెసింగ్; **guards** ప్రత్యేకంగా authorization ను నిర్వహిస్తుంది (middleware లో చిక్కుకోలేని, సరిగ్గా రూపొందించిన ప్రత్యేక స్థానం); **interceptors** handler ను wrapping చేయడానికి responses మార్చడానికి లేదా cross-cutting behavior జోడించడానికి; **pipes** input validate చేస్తాయి; **filters** errors నిర్వహిస్తాయి.

## 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 అనువర్తనాలను సరిగ్గా నిర్మించడానికి అవసరం — ప్రతిదానికి ఒక నిర్దిష్ట పాత్ర ఉంది మరియు request lifecycle లో ఒక నిర్దిష్ట పాయింట్ వద్ద నడుస్తుంది, మరియు సరైనది ఉపయోగించడం స్వచ్ఛమైన, idiomatic కోడ్‌కు దారితీస్తుంది.

Middleware raw req/res సాధారణ Express-style ముందస్తు ప్రాసెసింగ్ నిర్వహిస్తుంది.

నిర్ణయాత్మక వ్యత్యాసాలు ఏమిటంటే **guards** authorization (auth/roles) కోసం ఆపాదితమైన, సరైన స్థానం — ఆ ఉద్దేశ్యానికి middleware కంటే చాలా స్వచ్ఛమైనది — మరియు **interceptors** response ను రూపాంతరం చేయడానికి మరియు cross-cutting concerns (logging, caching, timing) జోడించడానికి handler ను wrap చేస్తాయి, middleware తేలికగా చేయలేనిది (handler నుండి ముందు నడిచినందున మరియు సహజంగా response చూడదు).

సంపూర్ణ lifecycle క్రమం (middleware → guards → interceptors → pipes → handler → interceptors → filters) మరియు ప్రతిదానికి ఏ టూల్ సరిపోతుందో (auth → guard, response transformation → interceptor, validation → pipe, errors → filter) తెలుసుకోవడం NestJS పరిజ్ఞానం యొక్క లక్షణం మరియు ప్రతిదానికి middleware ను దుర్వినియోగం చేసే సాధారణ తప్పును నిరోధిస్తుంది.

ఇది framework లో తరచుగా పరీక్ష చేయబడిన, నిర్మాణాత్మకంగా ముఖ్యమైన విషయం.

Middleware — మొదట నడుస్తుంది, req/res యాక్సెస్ ఉంటుంది

సంపూర్ణ request lifecycle క్రమం

ప్రతిదానికి ఎటువంటి ఉద్దేశ్యం ఉంది (సరైన టూల్ ఎంచుకోవడం)

Middleware vs guards vs interceptors ఎప్పుడు ఉపయోగించాలి

ఇది ఎందుకు ముఖ్యమైనది

సంబంధిత ప్రశ్నలు