NestJS में अनुरोध जीवनचक्र क्रम क्या है?

Question

Accepted Answer

**अनुरोध जीवनचक्र** NestJS में एक सटीक अनुक्रम है जो एक अनुरोध के माध्यम से गुजरता है — middleware, guards, interceptors, pipes, handler, फिर interceptors फिर से, और त्रुटियों पर exception filters। सटीक क्रम को जानना आवश्यक है यह समझने के लिए *कब* प्रत्येक तर्क चलता है।

## The full order

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

## Why the order matters (practical consequences)

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

## Within each category, scope ordering applies

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

## A concrete example

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

## यह महत्वपूर्ण क्यों है

अनुरोध जीवनचक्र क्रम को समझना NestJS एप्लिकेशन को सही तरीके से बनाने के लिए मौलिक है — यह सटीक *कब* निर्धारित करता है प्रत्येक क्रॉस-कटिंग लॉजिक निष्पादित होता है, जो सीधे डिज़ाइन निर्णय और डिबगिंग को प्रभावित करता है।

क्रम का वास्तविक, व्यावहारिक महत्व है: **guards pipes से पहले चलते हैं**, इसलिए प्राधिकरण सही तरीके से इनपुट को सत्यापित करने से पहले जांचा जाता है (अनुमोदित अनुरोध सत्यापन से पहले अस्वीकार किए जाते हैं); **pipes handler से ठीक पहले चलते हैं**, यह गारंटी देते हैं कि handler हमेशा सत्यापित, रूपांतरित तर्क प्राप्त करता है; **interceptors handler को लपेटते हैं** (पहले *और* बाद में चलते हैं), जो बिल्कुल उन्हें निष्पादन समय और प्रतिक्रिया रूपांतरण करने देता है; और **exception filters किसी भी चरण से त्रुटियों को पकड़ते हैं**, केंद्रीकृत त्रुटि हैंडलिंग सक्षम करते हैं।

इस क्रम को जानना — साथ ही प्रत्येक श्रेणी के भीतर scope क्रमणन (global → controller → method) — आपको सही घटक में लॉजिक रखने, निष्पादन प्रवाह की भविष्यवाणी करने, यह डिबग करने में सक्षम बनाता है कि कुछ क्यों चलता है (या अपेक्षित समय पर नहीं चलता है), और सुविधाओं को सही तरीके से डिज़ाइन करें।

यह फ्रेमवर्क के सभी अनुरोध-हैंडलिंग टुकड़ों (middleware, guards, interceptors, pipes, filters) को एक सुसंगत मानसिक मॉडल में बांधता है, जो इसे एक महत्वपूर्ण, अक्सर-परीक्षित विषय बनाता है जो यह दर्शाता है कि NestJS अनुरोधों को कैसे संसाधित करता है, इसकी वास्तविक समझ।