Interceptors என்றால் என்ன?

Question

Accepted Answer

**Interceptors** ஒரு route handler-இன் execution-ஐ wrap செய்கின்றன, அதற்கு **முன்னும் பின்னும்** logic-ஐ இயக்க அனுமதிக்கின்றன — மற்றும் request அல்லது response-ஐ transform செய்கின்றன. அவை 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
    );
  }
}
```

ஒரு 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-ஐயும் ஒரு standard envelope-இல் wrap செய்தல், ஒத்திசைவான 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 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
```

வரையறுக்கும் feature: interceptors handler-க்கு **பின்** logic-ஐ இயக்கி **response-ஐ transform** செய்ய முடியும் — இதை middleware மற்றும் guards சுத்தமாக செய்ய முடியாது.

## இது ஏன் முக்கியம்

Interceptors என்பது **cross-cutting concerns**-ஐ நேர்த்தியாக கையாள்வதற்கான ஒரு சக்திவாய்ந்த NestJS feature, மற்றும் அவற்றின் தனித்துவமான திறன் — handler-க்கு முன்னும் *பின்னும்* logic-ஐ இயக்குதல், மற்றும் response-ஐ transform செய்தல் — middleware மற்றும் guards தீர்க்க முடியாத தேவைகளுக்கு அவற்றை சரியான கருவியாக ஆக்குகிறது.

அவற்றை புரிந்துகொள்வது முக்கியம், ஏனெனில் பல பொதுவான தேவைகள் இயற்கையாக interceptors-உடன் map செய்கின்றன: ஒத்திசைவான response formatting (அனைத்து responses-ஐயும் ஒரு standard `{ success, data }` envelope-இல் wrap செய்தல்), logging/timing (handler duration-ஐ அளவிடுதல்), caching (cached responses-ஐ திருப்பி அனுப்புதல்), timeouts, error transformation, மற்றும் serialization (sensitive fields-ஐ விலக்குதல்).

கட்டமைப்பை (`next.handle()` Observable, `tap`/`map`/`catchError`-உடன் முன்/பின் செயல்படுதல்), பொதுவான use cases, மற்றும் குறிப்பாக **interceptors middleware மற்றும் guards-இலிருந்து எவ்வாறு வேறுபடுகின்றன** (response-ஐ wrap செய்து transform செய்யும் திறன்) என்பதை அறிவது NestJS architectural திறமையின் ஒரு முக்கிய பகுதி.

Interceptors cross-cutting logic-ஐ handlers முழுவதும் duplicate செய்யாமல் DRY ஆகவும் centralized ஆகவும் வைத்திருக்கின்றன, அவற்றை சுத்தமான, maintainable NestJS applications-ஐ உருவாக்க அடிக்கடி பயன்படுத்தப்படும், முக்கியமான கருவியாக ஆக்குகின்றன.