NestJS मध्ये विनंती जीवनचक्र क्रम काय आहे?

Question

Accepted Answer

**विनंती जीवनचक्र** हा NestJS मध्ये विनंती ज्या घटकांमधून जाते त्या क्रम आहे — middleware, guard, interceptor, pipe, handler, नंतर पुन्हा interceptor, आणि त्रुटींसाठी exception filter. अचूक क्रम जाणून घेणे महत्त्वाचे आहे कारण यावरून समजते *केव्हा* प्रत्येक तुकडा तर्कशास्त्र चालू होतो.

## संपूर्ण क्रम

```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 तर्कशास्त्र कार्यान्वित होतो, जो डिজाइन निर्णय आणि डिबगिंगवर थेट परिणाम करते.

क्रमाचे खरे, व्यावहारिक महत्त्व आहे: **guard pipe पूर्वी चालते**, म्हणून अनुमती इनपुट सत्यापित करण्यापूर्वी योग्यरित्या तपासली जाते (अनुपयुक्त विनंती सत्यापनापूर्वी नाकारली जाते); **pipe handler च्या अगदी आधी चालते**, handler नेहमी सत्यापित, रूपांतरित arguments प्राप्त करते हे सुनिश्चित करते; **interceptor handler ला लपेटतात** (आधी *आणि* नंतर चालते), ज्याचा अर्थ तंतुमात्र त्यांना execution वेळ घेऊन प्रतिक्रिया रूपांतरित करायला देते; आणि **exception filter कोणत्याही टप्प्यापासून त्रुटी पकडतात**, केंद्रीकृत त्रुटी हाताळणी सक्षम करते.

हा क्रम जाणून घेणे — तसेच श्रेणी-मध्ये scope क्रम (global → controller → method) — तुम्हाला योग्य घटकात तर्कशास्त्र ठेवता देते, कार्यान्वन प्रवाह अंदाज करता देते, काहीतरी कधी चालते (किंवा न चालते) तेव्हा डिबग करता देते, आणि वैशिष्ट्य योग्यरित्या डिজाइन करता देते.

हे framework च्या सर्व विनंती-हाताळण्याचे तुकडे (middleware, guard, interceptor, pipe, filter) एक सुसंगत मानसिक मॉडेलमध्ये बांधते, हे एक महत्त्वाचा, वारंवार-चाचणीचा विषय करते जो NestJS विनंती कसे प्रक्रिया करतो याबद्दल खरी समज दर्शवितो.