Mpangilio wa request lifecycle wa NestJS ni upi?

Question

Accepted Answer

**Request lifecycle** ni mfuatano kamili wa vipengele ambavyo request hupita ndani yake katika NestJS — middleware, guards, interceptors, pipes, handler, kisha interceptors tena, na exception filters pale makosa yanapotokea. Kujua mpangilio kamili ni muhimu kwa kuelewa *lini* kila kipande cha logic huendeshwa.

## Mpangilio kamili

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

## Kwa nini mpangilio ni muhimu (matokeo ya kivitendo)

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

## Ndani ya kila kundi, mpangilio wa scope hutumika

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

## Mfano halisi

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

## Kwa nini ni muhimu

Kuelewa mpangilio wa request lifecycle ni msingi kwa kujenga programu za NestJS ipasavyo — huamua hasa *lini* kila kipande cha logic ya kupita pande mbalimbali huendeshwa, jambo linaloathiri moja kwa moja maamuzi ya usanifu na utatuzi (debugging).

Mpangilio una umuhimu halisi wa kivitendo: **guards huendeshwa kabla ya pipes**, hivyo authorization hukaguliwa ipasavyo kabla ya kujishughulisha kuthibitisha input (request isiyoidhinishwa hukataliwa kabla ya validation); **pipes huendeshwa muda mfupi kabla ya handler**, ikihakikisha handler daima hupokea arguments zilizothibitishwa na kubadilishwa; **interceptors huzungushia handler** (zikiendeshwa kabla *na* baada), jambo ambalo ndilo hasa linalowezesha kupima muda wa utekelezaji na kubadilisha responses; na **exception filters hunasa makosa kutoka hatua yoyote**, ikiwezesha ushughulikiaji wa makosa wa kati.

Kujua mpangilio huu — pamoja na mpangilio wa scope ndani ya kundi (global → controller → method) — kunakuwezesha kuweka logic katika kipengele sahihi, kutabiri mtiririko wa utekelezaji, kutatua kwa nini kitu huendeshwa (au hakiendeshwi) wakati inavyotarajiwa, na kupanga features ipasavyo.

Huunganisha vipande vyote vya kushughulikia request vya framework (middleware, guards, interceptors, pipes, filters) katika mfano thabiti wa kiakili, jambo linalolifanya kuwa eneo muhimu, linalopimwa mara kwa mara linaloonyesha uelewa wa kweli wa jinsi NestJS inavyoshughulikia requests.