X'inhu l-ordni taċ-ċiklu ta' ħajja tar-richiesta f'NestJS?

Question

Accepted Answer

Il-**ċiklu ta' ħajja tar-richiesta** huwa s-sekwenza eżatta ta' komponenti li għaliha tgħaddi richiesta f'NestJS — middleware, guard, interceptor, pipe, handler, imbagħad interceptor mill-ġdid, u exception filter fuq żbalji. Jikkun kruċjali li tkun taf is-sekwenza eżatta biex tifhem *meta* kull biċċa loġika taħdem.

## L-ordni sħiħ

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

## Għaliex l-ordni huwa importanti (konsegwenzi prattiċi)

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

## Ġewwa kull kategorija, l-ordni ta' scope tapplika

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

## Eżempju konkretu

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

## Għaliex Dan Importanti

Fhem l-ordni taċ-ċiklu ta' ħajja tar-richiesta huwa fundamentali għad-disinn ta' applikazzjonijiet NestJS korretti — huwa jiddetermina eżattament *meta* kull biċċa loġika cross-cutting taħdem, li taffettwa direttament id-deċizzjonijiet tal-disinn u d-debugging.

L-ordni għandu sinifikat reali u pratiku: **guard jaħdem qabel pipe**, għalhekk l-awtorizzazzjoni tiċċekkja korrettament qabel ma jkollok tħassib tal-validazzjoni tal-input (richiesta li mhix awtorizzata tiġi miċħuda qabel il-validazzjoni); **pipe jaħdem eżattament qabel il-handler**, jiżgura li l-handler dejjem jirċievi argumenti validati u trasformati; **interceptor iħoll l-handler** (jaħdem qabel *u* wara), li huwa eżattament dak li jippermettilhom jimexxu l-ħin ta' eseċuzzjoni u jitrasformaw ir-risposta; u **exception filter jinqabdu żbalji minn kwalunkwe stadju**, li jippermetti għall-maniguldazzjoni ċentralizzata ta' żbalji.

Jaf din l-ordni — bla jippettu l-ordni ta' scope ġewwa-kategorija (globali → controller → method) — jippermettillik tpoġġi l-loġika fil-komponenti t-tajjeb, tbassar il-fluss tal-eseċuzzjoni, tid-debug għaliex xi ħaġa taħdem (jew ma taħdemx) meta mistenni, u tandizza l-features korretti.

Dan jgħaqqad il-pezzi kollu tal-għoti tal-framework tar-richiesta (middleware, guard, interceptor, pipe, filter) f'mudell mentali koerenti, li jagħmlu suġġett importanti u spiss-ttestet li jirrifletti l-fehim genuinu ta' kif NestJS jipproċessa r-riċhjedot.