Interceptors क्या होते हैं?

Question

Accepted Answer

**Interceptors** किसी route handler के निष्पादन को लपेटते (wrap) हैं, जिससे आप उसके **पहले और बाद में** logic चला सकते हैं — और request या response को transform कर सकते हैं। वे aspect-oriented programming से प्रेरित हैं, और logging, response transformation, caching, और timing जैसी क्रॉस-कटिंग चिंताओं के लिए आदर्श हैं।

## संरचना: 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
    );
  }
}
```

एक interceptor `intercept()` को implement करता है। `next.handle()` से पहले का code handler से **पहले** चलता है; `next.handle()` response का एक RxJS `Observable` लौटाता है, और `tap`/`map` जैसे operators आपको handler के पूरा होने के **बाद** response पर कार्य करने देते हैं।

## Response को transform करना (एक आम उपयोग)

```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` का उपयोग करके, एक interceptor हर response को पुनः आकार दे सकता है — जैसे सभी responses को एक मानक envelope में लपेटना, जो सुसंगत API responses के लिए एक बहुत आम pattern है।

## अन्य शक्तिशाली उपयोग

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

## Interceptors लागू करना

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

## Interceptors बनाम middleware बनाम 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
```

परिभाषित करने वाली विशेषता: interceptors handler के **बाद** logic चला सकते हैं और **response को transform** कर सकते हैं — जो middleware और guards स्वच्छ ढंग से नहीं कर सकते।

## यह क्यों महत्वपूर्ण है

Interceptors **क्रॉस-कटिंग चिंताओं** को सुरुचिपूर्ण ढंग से संभालने के लिए एक शक्तिशाली NestJS feature हैं, और उनकी विशिष्ट क्षमता — handler के पहले *और बाद* दोनों में logic चलाना, और response को transform करना — उन्हें उन आवश्यकताओं के लिए सही उपकरण बनाती है जिन्हें middleware और guards संबोधित नहीं कर सकते।

इन्हें समझना महत्वपूर्ण है क्योंकि कई आम आवश्यकताएँ स्वाभाविक रूप से interceptors से मेल खाती हैं: सुसंगत response formatting (सभी responses को एक मानक `{ success, data }` envelope में लपेटना), logging/timing (handler अवधि मापना), caching (cached responses लौटाना), timeouts, error transformation, और serialization (संवेदनशील fields को बाहर रखना)।

संरचना (`next.handle()` Observable, जिसमें पहले/बाद में कार्य करने के लिए `tap`/`map`/`catchError`), आम उपयोग के मामलों, और विशेष रूप से **interceptors middleware और guards से कैसे भिन्न हैं** (response को लपेटने और transform करने की क्षमता) को जानना NestJS architectural दक्षता का एक प्रमुख भाग है।

Interceptors क्रॉस-कटिंग logic को handlers में दोहराने के बजाय DRY और केंद्रीकृत रखते हैं, जिससे वे स्वच्छ, अनुरक्षणीय NestJS applications बनाने के लिए बार-बार उपयोग होने वाला, महत्वपूर्ण उपकरण बन जाते हैं।