NestJS request lifecycle order ਕੀ ਹੈ?

Question

Accepted Answer

**Request lifecycle** NestJS ਵਿਚ ਭਦੀਆਂ ਦੀ ਸਟੀਕ ਲੜੀ ਹੈ ਜਿਸ ਵਿਚੋਂ ਇਕ request ਲੰਘਦا ਹੈ — 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)
```

## ਇਹ ਕਿਓਂ ਮਹੱਤਵਪੂਰਨ ਹੈ

Request lifecycle ਕ੍ਰਮ ਨੂੰ ਸਮਝਣਾ NestJS ਐਪਲੀਕੇਸਨ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਬਣਾਉਣ ਲਈ ਮੁੱਢਲਾ ਹੈ — ਇਹ ਸਟੀਕ ਤੌਰ ਉੱਤੇ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ *ਕਦੋਂ* ਹਰ ਇਕ ਪਾਰ-ਕਾਟ ਤਰਕ ਵਾਹੇ ਹੁੰਦਾ ਹੈ, ਜੋ ਸਿੱਧੇ ਡਿਜ਼ਾਇਨ ਫੈਸਲਿਆਂ ਅਤੇ debugging ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ।

ਕ੍ਰਮ ਦਾ ਅਸਲ, ਵਿਹਾਰਕ ਮਹੱਤਵ ਹੈ: **guards pipes ਤੋਂ ਪਹਿਲਾ ਚਲਦੇ ਹਨ**, ਤਾਂ authorization ਸਹੀ ਢੰਗ ਨਾਲ input ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਤੋਂ ਪਹਿਲਾ ਜਾਂਚਿਆ ਜਾਂਦਾ ਹੈ (ਇੱਕ unauthorized request validation ਤੋਂ ਪਹਿਲਾ ਰੱਦ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ); **pipes handler ਤੋਂ ਬਿਲਕੁਲ ਪਹਿਲਾ ਚਲਦੇ ਹਨ**, handler ਨੂੰ ਹਮੇਸ਼ਾ validated, transformed arguments ਮਿਲਦੀਆਂ ਹਨ ਇਸ ਦੀ ਗ੍ਰੈਂਟੀ ਦਿੰਦੇ ਹਨ; **interceptors handler ਨੂੰ wrap ਕਰਦੇ ਹਨ** (handler ਤੋਂ *ਪਹਿਲਾ ਅਤੇ ਬਾਅਦ* ਵਿਚ ਚਲਦੇ ਹਨ), ਜੋ ਬਿਲਕੁਲ ਸੰਭਵ ਬਣਾਉਂਦਾ ਹੈ execution ਨੂੰ ਸਮਾ ਅਤੇ responses ਨੂੰ ਵਾਹੇ ਕਰਨ ਲਈ; ਅਤੇ **exception filters ਕਿਸੇ ਵੀ ਸਮੋਂ ਤੋਂ errors ਨੂੰ ਫੜਦੇ ਹਨ**, ਕੇਂਦਰੀ error ਹੈਂਡਲਿੰਗ ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦੇ ਹਨ।

ਇਹ ਕ੍ਰਮ ਜਾਣਨਾ — ਅਤੇ within-category scope ਕ੍ਰਮ (global → controller → method) — ਤੁਹਾਨੂੰ ਸਹੀ ਸ਼੍ਰੇਣੀ ਵਿਚ ਤਰਕ ਰੱਖਣ, execution flow ਦਾ ਮਤਲਬ ਲਗਾਉਣ, debug ਕਰਨ ਕਿ ਕਿਉਂ ਕੁਝ ਚਲਦਾ ਹੈ (ਜਾਂ ਨਹੀਂ ਚਲਦਾ) ਜਦੋਂ ਅਪੇਖਿਤ ਹੋ, ਅਤੇ features ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ architect ਕਰਨ ਦੀ ਮੰਜ਼ੂਰੀ ਦਿੰਦਾ ਹੈ।

ਇਹ ਸਾਰੇ framework ਦੇ request-handling pieces (middleware, guards, interceptors, pipes, filters) ਨੂੰ ਇੱਕ cohesive mental ਮਾਡਲ ਵਿਚ ਮਿਲਾਉਂਦਾ ਹੈ, ਇਸਨੂੰ ਇੱਕ ਮਹੱਤਵਪੂਰਨ, frequently-tested ਟਿਪਿਕ ਬਣਾ ਕੇ ਜੋ genuine ਸਮਝ ਨੂੰ ਪ੍ਰਤਿਬਿੰਬਿਤ ਕਰਦਾ ਹੈ ਕਿ NestJS ਕਿਵੇਂ requests ਨੂੰ ਪ੍ਰਸੇਸ ਕਰਦਾ ਹੈ।