इंटरसेप्टर्स म्हणजे काय?

Question

Accepted Answer

**इंटरसेप्टर्स** route handler च्या execution ला wrap करतात, ज्यामुळे तुम्ही logic **before आणि after** चलवू शकता — आणि request किंवा response ला transform करू शकता. ते aspect-oriented programming वरून प्रेरित आहेत, logging, response transformation, caching, आणि timing सारख्या cross-cutting concerns साठी आदर्श आहेत.

## रचना: before + after via 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()` ला implement करतो. `next.handle()` आधी कोड **before** handler चलतो; `next.handle()` response चा RxJS `Observable` return करतो, आणि `tap`/`map` सारख्या operators तुम्हाला handler पूर्ण झाल्यानंतर response वर कार्य करू देतात **after**.

## 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` वापरून, एक इंटरसेप्टर प्रत्येक response ला reshape करू शकतो — उदाहरणार्थ सर्व responses ला एक standard envelope मध्ये wrap करणे, consistent 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
```

## इंटरसेप्टर्स लागू करणे

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

व्यतिरिक्त वैशिष्ट्य: इंटरसेप्टर्स handler **after** logic चलवू शकतात आणि **response transform** करू शकतात — जे middleware आणि guards cleanly करू शकत नाहीत.

## महत्व का आहे

इंटरसेप्टर्स **cross-cutting concerns** साधारणपणे हाताळण्यासाठी NestJS ची एक शक्तिशाली feature आहेत, आणि त्यांची विशिष्ट क्षमता — handler **before आणि after** दोन्ही logic चलवणे, आणि response transform करणे — हे middleware आणि guards ला address करू शकत नाहीत अशा गरजांसाठी योग्य साधन बनवते.

त्यांना समजून घेणे महत्वाचे आहे कारण अनेक सामान्य आवश्यकता इंटरसेप्टर्समध्ये नैसर्गिकरित्या map होतात: consistent response formatting (सर्व responses ला standard `{ success, data }` envelope मध्ये wrap करणे), logging/timing (handler duration मापन करणे), caching (cached responses return करणे), timeouts, error transformation, आणि serialization (sensitive fields exclude करणे).

रचना (the `next.handle()` Observable, `tap`/`map`/`catchError` सह before/after साठी कार्य करणे), सामान्य use cases, आणि विशेषत: **इंटरसेप्टर्स middleware आणि guards पासून कसे वेगळे आहेत** (response wrap आणि transform करण्याची क्षमता) हे जाणून घेणे NestJS architectural competence चा एक मुख्य भाग आहे.

इंटरसेप्टर्स cross-cutting logic DRY आणि centralized ठेवतात handlers मध्ये duplicated होण्याऐवजी, त्यांना एक frequently-used, महत्वाचे साधन बनवतात clean, maintainable NestJS applications बांधण्यासाठी.