Cad é ord an chúrsaí dhul chun cinn ar iarratas i NestJS?

Question

Accepted Answer

Is é an **cúrsa dhul chun cinn ar iarratas** an t-ord beacht den seicheamh de chomhpháirteanna a théann iarratas tríd i NestJS — middleware, guards, interceptors, pipes, an handler, ansin na h-interceptors arís, agus exception filters ar earráidí. Tá sé ríthábhachtach an t-ord beacht a thuiscint chun a fhios a bheith agat *cathain* a ritheann gach píosa loighic.

## The full order

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

## Why the order matters (practical consequences)

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

## Within each category, scope ordering applies

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

## A concrete example

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

## Cén fáth a bhfuil tábhacht ann

Tá tuiscint ar ord an chúrsa dhul chun cinn ar iarratas bunúsach d'fheidhmchlár NestJS a thógáil i gceart — socraíonn sé an tAm cruinn *cathain* a ritheann gach píosa loighic thrasnaschuiditheach, a dhéanann difear go díreach do bhailí deartha agus dífhabhraíochta.

Tá brí praiticiúil dhílis ag an ord: **ritheannn guards roimh pipes**, mar sin déantar an údarú a sheiceáil i gceart sula dtugtar géill go bhailí ionchuir a fhailí (dhíthacar iarratas neamhumdaithe sula bailíonn sé); **ritheannn pipes díreach roimh an handler**, rud a thugann dea-bharúil go bhfaigheann an handler argóintí bailíochtaithe, claochluithe i gcónaí; **spréachann interceptors an handler** (ag rith roimh *agus* tar éis), ar an rud go díreach is féidir leo fad agus claochlúcháin a infhilleadh; agus **baileann exception filters earráidí ó aon chéim**, rud a chumasóidh láimhseáil earráidí lárnaigh.

Tríd an t-ord seo a thuiscint — móide an ord raon laistigh de gach catagóir (domhanda → controller → modh) — bíonn tú ábalta loighic a chur san fhíorcomhpháirt cheart, sreabh forghníomhaithe a thuar, dífhabhraíochta a dhéanamh ar an bhfáth go rithíonn rud (nó nach rithíonn sé) ag an am iontaofa, agus gné a ailtireachta i gceart.

Tá sé i dteangbháil na bhfeidhmchláranna ar fad an fhraim (middleware, guards, interceptors, pipes, filters) i samhail intinne comhéifeachtúil, rud a dhéanann ábhar tábhachtach agus thástéilte go minic de é a léiríonn tuiscint fhíor ar an mbealach ar a ritheann NestJS iarratas.