NestJS request lifecycle క్రమం ఏమిటి?

Question

Accepted Answer

The **request lifecycle** అనేది NestJS లో request ఖచ్చితమైన క్రమం — middleware, guards, interceptors, pipes, handler, ఆపై interceptors మళ్లీ, మరియు errors వద్ద exception filters. ప్రతి piece of logic ఎప్పుడు నడుస్తుంది అని అర్థం చేసుకోవడం కోసం సరిగ్గా ఏ క్రమంలో ఉందో తెలుసుకోవడం చాలా ముఖ్యమైనది.

## పూర్తి క్రమం

```text
Incoming Request
   │
   ▼
1. MIDDLEWARE            (Express-style; raw req/res; runs first)
   │
   ▼
2. GUARDS                (authorization — return true to continue, false/throw to block)
   │
   ▼
3. INTERCEPTORS (pre)    (logic BEFORE the handler — start timing, etc.)
   │
   ▼
4. PIPES                 (validate/transform the handler's arguments — DTO validation)
   │
   ▼
5. ROUTE HANDLER         (your controller method runs)
   │
   ▼
6. INTERCEPTORS (post)   (logic AFTER the handler — transform the response)
   │
   ▼
Response

✗ If an exception is thrown ANYWHERE above →
7. EXCEPTION FILTERS     (catch it and format the error response)
```

## క్రమం ఎందుకు ముఖ్యమైనది (ఆచరణాత్మక పర్యవసానాలు)

```text
• Guards run BEFORE pipes → authorization is checked before input validation
  (no point validating a body for an unauthorized request)
• Pipes run JUST BEFORE the handler → the handler always gets validated/transformed args
• Interceptors straddle the handler → they can measure its duration and transform output
• Filters catch errors from any stage → centralized, consistent error handling
```

## ప్రతి వర్గం లోపల, scope ordering వర్తిస్తుంది

```text
For each type (guards, interceptors, pipes), they run in this scope order:
  Global → Controller → Method (route)
So a global guard runs before a controller-level guard, before a route-level guard.
```

## కాంక్రీట్ ఉదాహరణ

```ts
@Controller("users")
@UseGuards(AuthGuard)                    // 2. checks authorization
@UseInterceptors(LoggingInterceptor)     // 3 (pre) + 6 (post)
export class UsersController {
  @Post()
  create(@Body() dto: CreateUserDto) {    // 4. ValidationPipe validates dto, 5. handler runs
    return this.usersService.create(dto);
  }
}
// Flow: middleware → AuthGuard → LoggingInterceptor(before) → ValidationPipe →
//       create() → LoggingInterceptor(after) → response (or → filter on error)
```

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

Request lifecycle క్రమాన్ని అర్థం చేసుకోవడం NestJS అనువర్తనాలను సరిగ్గా నిర్మించడానికి ప్రాథమికమైనది — ప్రతి piece of cross-cutting logic ఎప్పుడు execute అవుతుంది అని ఖచ్చితంగా నిర్ణయిస్తుంది, ఇది నేరుగా design decisions మరియు debugging ను ప్రభావితం చేస్తుంది.

ఈ ordering సరిపడి వాస్తవ, ఆచరణాత్మక ప్రాముఖ్యతను కలిగి ఉంది: **guards pipes కంటే ముందు నడుస్తాయి**, కాబట్టి authorization input validation చేయకముందే సరిగ్గా తనిఖీ చేయబడుతుంది (అనుమతిలేని request validation నుండి ముందే తిరస్కరించబడుతుంది); **pipes handler కు సరిగ్గా ముందు నడుస్తాయి**, handler ఎల్లప్పుడూ validated, transformed arguments పొందుతుందని నిర్ధారిస్తుంది; **interceptors handler ను చుట్టుముట్టుతాయి** (handler కు ముందు *మరియు* తరువాత నడుస్తాయి), ఇది ఖచ్చితంగా execution సమయం చేసుకుని responses transform చేయడానికి వారిని అనుమతిస్తుంది; మరియు **exception filters ఏదైనా stage నుండి errors ను catch చేస్తాయి**, centralized error handling ను సక్షమ చేస్తాయి.

ఈ క్రమాన్ని తెలుసుకోవడం — ప్లస్ within-category scope ordering (global → controller → method) — ఎక్కడ logic ఉంచాలో, execution flow ను predict చేయకుండా, ఎందుకు something నడుస్తుంది (లేదా నడదు) expected సమయానికి, మరియు features సరిగ్గా ఆర్కిటెక్చర చేయడానికి నిర్ణయించుకోవడానికి మీకు అనుమతిస్తుంది.

ఇది framework యొక్క అన్ని request-handling pieces (middleware, guards, interceptors, pipes, filters) ను coherent mental model లో కలపుతుంది, ఇది ఒక ముఖ్యమైన, frequently-tested topic చేస్తుంది ఇది NestJS request ను ఎలా process చేస్తుందో genuine understanding ను ప్రతిబింబిస్తుంది.