Cad iad gréasánaithe (Interceptors)?

Question

Accepted Answer

**Gréasánaithe** aran an fhorghníomhaithe conair, agus deis a bhíonn agat loighic a rith **roimh agus tar éis** — agus an iarratas nó an freagra a athrú. Inspíonn siad dul chun cinn gealadh-dhírithe, ar dhóigh i bhfeidhm dóibh do impleachtaí trasnearrach cosúil le logadh, trasfhoirmiú freagra, taiscéadh, agus am a thomhas.

## An struchtúr: roimh + tar éis trí RxJS

```ts
@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    console.log("Before handler");          // runs BEFORE the route handler
    const now = Date.now();

return next.handle().pipe(               // next.handle() = invoke the handler
      tap(() => console.log(`After: ${Date.now() - now}ms`)),   // runs AFTER
    );
  }
}
```

Cuireann gréasánaí an fheidhm `intercept()` i bhfeidhm. Rithíonn cód roimh `next.handle()` **roimh** an fhorghníomhaithe; tuigeann `next.handle()` ar ais RxJS `Observable` an fhreagra, agus tugann oibreoirí cosúil le `tap`/`map` deis duit gníomh a dhéanamh ar an fhreagra **tar éis** don fhorghníomhaithe a bheith críochnaithe.

## An freagra a athrú (úsáid choiteann)

```ts
@Injectable()
export class TransformInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler) {
    return next.handle().pipe(
      map(data => ({ success: true, data, timestamp: new Date().toISOString() })),
      // wraps EVERY response in a consistent envelope: { success, data, timestamp }
    );
  }
}
```

An `map` á úsáid, is féidir le gréasánaí gach freagra a athrú — m.sh. na freagraí go léir a fholuain i gcúrsainn chaighdeánach, patrún an-choiteann do fhreagraí API comhsheasmhach.

## Úsáidí cumhachtacha eile

```ts
// caching — return a cached response, skipping the handler entirely
// timeout — fail requests taking too long
return next.handle().pipe(timeout(5000));

// error mapping — transform exceptions
return next.handle().pipe(catchError(err => throwError(() => new BadGatewayException())));

// excluding fields (serialization) — ClassSerializerInterceptor strips @Exclude() fields
```

```text
Common interceptor uses:
  ✓ Logging / timing requests (before + after)
  ✓ Transforming responses (consistent envelopes, field exclusion)
  ✓ Caching responses
  ✓ Adding timeouts
  ✓ Mapping/handling errors
```

## Gréasánaithe a chur i bhfeidhm

```ts
@UseInterceptors(LoggingInterceptor)   // method or controller level
app.useGlobalInterceptors(new TransformInterceptor());   // global
```

## Gréasánaithe in aghaidh idirmheáin in aghaidh gardaí

```text
Middleware  → runs BEFORE everything, with raw req/res (can't easily touch the response)
Guard       → AUTHORIZATION decision (allow/block) before the handler
Interceptor → wraps the handler — runs BEFORE and AFTER, can TRANSFORM the response
```

An gné shainiúil: is féidir le gréasánaithe loighic a rith **tar éis** an fhorghníomhaithe agus **an freagra a athrú** — rud nach féidir le idirmheáin agus gardaí a dhéanamh go geal.

## Cad a chiallaíonn sé

Is gné cumhachtach NestJS iad gréasánaithe chun impleachtaí **trasnearrach** a láimhseáil go deascartha, agus an cumas sainiúil acu — loighic a rith ar dhá thaobh an fhorghníomhaithe, agus an freagra a athrú — a dhéanann an uirlis cheart dóibh do dhíthreabhair nach féidir le idirmheáin agus gardaí a thackáil.

Tá sé tábhachtach tuiscint a bheith agat orthu toisc go mapáilítear go leor riachtanais choiteanna go nádúrtha ar gréasánaithe: formáidiú freagra comhsheasmhach (na freagraí go léir a fholuain i gcúrsainn caighdeánach `{ success, data }`), logadh/am a thomhas (fad an fhorghníomhaithe a thomhas), taiscéadh (freagraí taiscéadh a dhíol ar ais), fití, claochlú earráide, agus srithiú (réimsí mothúchánach a dhíchur).

Bheith ar eolas ar an struchtúr (an `next.handle()` Observable, le `tap`/`map`/`catchError` gníomh a dhéanamh roimh/tar éis), na cásanna úsáide coiteanna, agus go háirithe **conas a bhíonn gréasánaithe difriúil ó idirmheáin agus gardaí** (an cumas an freagra a bhailiú agus a athrú) is príomhchuid de inchomhthéacs ailtireachta NestJS.

Coimeádann gréasánaithe loighic impleachtaí trasnearrach geal agus lárnach seachas a bhheith déanta ar fud na bhforghníomhaithe, agus déanann siad iad a scríobh, uirlis thábhachtach agus in-úsáide do thógáil glan, so-chaomhnaithe NestJS feidhmchlár.