ఇంటర్సెప్టర్లు అంటే ఏమిటి?

Question

Accepted Answer

**ఇంటర్సెప్టర్లు** రూట్ హ్యాండ్లర్ యొక్క అమలును చుట్టుముట్టాయి, ఇది **ఎముందు మరియు తరువాత** లాజిక్ నడపడానికి అనుమతిస్తుంది — మరియు అభ్యర్థన లేదా ప్రతిస్పందనను రూపాంతరం చేయండి. అవి aspect-oriented programming ద్వారా ప్రేరణ పొందాయి, logging, response transformation, caching, మరియు timing వంటి cross-cutting concerns కోసం ఆదర్శ.

## నిర్మాణం: 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
    );
  }
}
```

ఇంటర్సెప్టర్ `intercept()` ను నిర్వహిస్తుంది. `next.handle()` ముందు కోడ్ హ్యాండ్లర్ కు **ఎముందు** నడుస్తుంది; `next.handle()` ప్రతిస్పందన యొక్క RxJS `Observable` ను తిరిగి ఇస్తుంది, మరియు `tap`/`map` వంటి operators హ్యాండ్లర్ సంపూర్ణ చేసిన **తరువాత** ప్రతిస్పందన పై అभిनయం చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.

## ప్రతిస్పందనను రూపాంతరం చేయడం (ఒక సాధారణ ఉపయోగం)

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

`map` ఉపయోగించి, ఇంటర్సెప్టర్ ప్రతిটి ప్రతిస్పందనను పునర్నిర్మాణం చేయవచ్చు — ఉదా అన్ని ప్రతిస్పందనలను ప్రామాణిక ఎన్వెలప్‌లో చుట్టడం, స్థిరమైన API ప్రతిస్పందనల కోసం చాలా సాధారణ నమూనా.

## ఇతర శక్తివంతమైన ఉపయోగాలు

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

## ఇంటర్సెప్టర్లను వర్తింపజేయడం

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

## ఇంటర్సెప్టర్లు vs middleware vs guards

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

నిర్వచించే లక్షణం: ఇంటర్సెప్టర్లు హ్యాండ్లర్ **తరువాత** లాజిక్ నడుస్తాయి మరియు **ప్రతిస్పందనను రూపాంతరం** చేయవచ్చు — ఇది middleware మరియు guards చేయలేవు.

## ఇది ఎందుకు ముఖ్యమైనది

ఇంటర్సెప్టర్లు **cross-cutting concerns** ను సొగసుగా నిర్వహించడానికి ఒక శక్తివంతమైన NestJS లక్షణం, మరియు వాటి విశిష్టమైన సామర్థ్యం — హ్యాండ్లర్ కు ఎముందు మరియు తరువాత లాజిక్ నడుపడం, మరియు ప్రతిస్పందనను రూపాంతరం చేయడం — అవి middleware మరియు guards పరిష్కరించలేని అవసరాల కోసం సరైన సాధనం.

తెలుసుకోవడం ముఖ్యమైనది ఎందుకంటే అనేక సాధారణ అవసరాలు ఇంటర్సెప్టర్లకు సహజంగా మ్యాప్ చేస్తాయి: స్థిరమైన ప్రతిస్పందన ఫార్మాట్ (అన్ని ప్రతిస్పందనలను ప్రామాణిక `{ success, data }` ఎన్వెలప్‌లో చుట్టడం), logging/timing (హ్యాండ్లర్ వ్యవధిని కొలవడం), caching (కాష్ చేసిన ప్రతిస్పందనలను తిరిగి ఇవ్వడం), timeouts, error transformation, మరియు serialization (సంవేదనశీల ఫీల్డ్‌లను మినహాయించడం).

నిర్మాణం తెలుసుకోవడం (the `next.handle()` Observable, `tap`/`map`/`catchError` ఎముందు/తరువాత అభినయం చేయడానికి), సాధారణ ఉపయోగ సందర్భాలు, మరియు ప్రత్యేకించి **ఇంటర్సెప్టర్లు middleware మరియు guards నుండి ఎలా భిన్నంగా ఉన్నాయి** (ప్రతిస్పందనను చుట్టుముట్టడం మరియు రూపాంతరం చేయడానికి సామర్థ్యం) NestJS ఆర్కిటెక్చరల సామర్థ్యం యొక్క ముఖ్య భాగం.

ఇంటర్సెప్టర్లు cross-cutting లాజిక్ను DRY మరియు కేంద్రీకృతంగా ఉంచుతాయి బదులుగా హ్యాండ్లర్‌ల ఎక్కడ నకిలీ చేయబడటం, వాటిని ఆకర్షక-ఉపయోగించిన, ముఖ్యమైన సాధనం చేస్తుంది పరిశుభ్రమైన, నిర్వహించదగిన NestJS అనువర్తనాలను నిర్మిణించడానికి.