Kakšen je vrstni red življenjskega cikla zahtevka v NestJS?

Question

Accepted Answer

**Življenjski cikel zahtevka** je natančno zaporedje komponent, skozi katere zahtevek potuje v NestJS — middleware, guards, interceptors, pipes, handler, nato spet interceptors, in exception filters pri napakah. Poznavanje natančnega vrstnega reda je ključno za razumevanje *kdaj* se izvršuje vsaka logika.

## Polni vrstni red

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

## Zakaj je vrstni red pomemben (praktične posledice)

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

## Znotraj vsake kategorije se uporablja urejanje po obsegu

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

## Konkreten primer

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

## Zakaj je to pomembno

Razumevanje vrstnega reda življenjskega cikla zahtevka je temeljno za pravilno gradnjo NestJS aplikacij — določa natančno *kdaj* se izvršuje vsaka cross-cutting logika, kar neposredno vpliva na odločitve pri načrtovanju in odpravljanju napak.

Vrstni red ima pravo, praktično pomen: **guards se izvršijo pred pipes**, zato je avtorizacija pravilno preverjena preden se sploh lotimo validacije vhoda (nepooblaščena zahtevka se zavrne preden validacija); **pipes se izvršijo tik pred handlerjem**, kar zagotavlja, da handler vedno prejme validirane, transformirane argumente; **interceptors obdajajo handler** (izvršujejo se pred *in* po), kar je natanko tisto, kar jim omogoča merjenje časa izvršitve in transformacijo odgovorov; in **exception filters lovijo napake iz kateregakoli stopnje**, kar omogoča centralizirano obravnavo napak.

Poznavanje tega vrstnega reda — skupaj z urejanjem po obsegu znotraj kategorije (global → controller → method) — vam omogoči, da logiko postavite v pravo komponento, napovedate tok izvršitve, odpravljate napake zakaj se nešto izvršuje (ali se ne izvršuje) kadar je pričakovano, in pravilno arhitektirate funkcionalnosti.

To povezuje vse okvira za obdelavo zahtevkov (middleware, guards, interceptors, pipes, filters) v koherentni miselni model, kar ga naredi pomembno, pogosto preverjano temo, ki odraža pravo razumevanje kako NestJS obdeluje zahtevke.