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

Question

Accepted Answer

**अनुरोध जीवनचक्र** NestJS मा अनुरोध गुजरने घटकहरूको सटीक क्रम हो — middleware, guards, interceptors, pipes, handler, त्यसपछि interceptors फेरि, र त्रुटिमा exception filters। सटीक क्रम जान्नु प्रत्येक तर्कको *कहिले* चल्छ भन्ने बुझ्नको लागि महत्वपूर्ण छ।

## पूर्ण क्रम

```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 क्रम लागू हुन्छ

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

## किन यो महत्वपूर्ण छ

अनुरोध जीवनचक्र क्रम बुझ्नु NestJS अनुप्रयोग सही तरिकामा निर्माण गर्नको लागि मौलिक छ — यो सटीकको निर्धारण गर्दछ *कहिले* प्रत्येक cross-cutting तर्क कार्यान्वयन हुन्छ, जो सीधा डिजाइन निर्णय र डिबगिंगलाई असर गर्दछ।

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

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

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