Cili është rendi i ciklit të kërkesës në NestJS?

Question

Accepted Answer

Cikli **i kërkesës** është sekuenca e saktë e komponentëve përmes të cilëve kalon një kërkesë në NestJS — middleware, guards, interceptors, pipes, handler, pastaj interceptors përsëri, dhe exception filters në raste gabimi. Të njohësh rendin e saktë është vendimtar për të kuptuar *kur* ekzekutohet secila pjesë e logjikës.

## Rendi i plotë

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

## Pse rendi është i rëndësishëm (pasoja praktike)

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

## Brenda çdo kategorie, zbatohet renditja e rolit

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

## Një shembull konkret

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

## Pse është i rëndësishëm

Të kuptosh rendin e ciklit të kërkesës është themelor për ndërtimin e saktë të aplikacioneve NestJS — ai përcakton saktësisht *kur* ekzekutohet secila pjesë e logjikës ndërkryq, e cila ndikon drejtpërdrejt në vendimet e projektimit dhe në debugimin.

Renditja ka një rëndësi të vërtetë, praktike: **guards ekzekutohen para pipes**, prandaj autorizimi kontrollohej saktësisht para se të përpiqet të validoj hyrjen (një kërkesë e paautorizuar hidhet poshtë para validimit); **pipes ekzekutohen pikë përpara handler**, garantuese që handler-i gjithmonë merr argumente të validuara, të transformuara; **interceptors mbyllin handler-in** (ekzekutohen para *dhe* pas), e cila është pikërisht ajo që u lejon atyre të matim ekzekutimin dhe të transformoj përgjigjet; dhe **exception filters kapen gabimet nga çdo fazë**, duke mundësuar trajtimin qendror të gabimeve.

Të njohësh këtë rend — plus renditjen e rolit brenda kategorisë (global → controller → method) — të lejon të vendosësh logjikën në komponentin e duhur, të parashikosh rrjedhën e ekzekutimit, të debugosh pse diçka ekzekutohet (ose nuk ekzekutohet) kur pritet, dhe të arkitekturosh karakteristikat saktë.

Ai lidh të gjithë pjesët e kërkesës-trajtimit të framework-ut (middleware, guards, interceptors, pipes, filters) në një model mendor koherent, duke e bërë atë një temë të rëndësishme, të testuar shpesh, që pasqyron të kuptuarit e vërtetë të se si NestJS përpunon kërkesën.