ઇન્ટરસેપ્ટર્સ શું છે?

Question

Accepted Answer

**ઇન્ટરસેપ્ટર્સ** રૂટ હ্যાન્ડલરના એક્ઝીક્યુશનને રેપ કરે છે, જે તમને તેના **પહેલા અને પછી** લોજિક ચલાવવાનું દેય છે — અને રિક્વેસ્ટ અથવા રેસ્પોન્સને રૂપાંતરિત કરે છે. તેઓ aspect-oriented programming દ્વારા પ્રેરિત છે, જે લૉગિંગ, રેસ્પોન્સ ટ્રાન્સફોર્મેશન, કેશિંગ, અને ટાઇમિંગ જેવી cross-cutting concerns માટે આદર્શ છે.

## માળખું: RxJS દ્વારા before + after

```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` જેવા ઓપરેટરો તમને હ્यાન્ડલર પૂર્ણ થયા **પછી** રેસ્પોન્સ પર કાર્ય કરવાનું દેય છે.

## રેસ્પોન્સને રૂપાંતરિત કરવું (એક સામાન્ય ઉપયોગ)

```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` નો ઉપયોગ કરીને, ઇન્ટરસેપ્ટર દરેક રેસ્પોન્સને પુનઃરૂપરેખાંકિત કરી શકે છે — દાખલા તરીકે બધા રેસ્પોન્સને સ્ટાન્ડર્ડ envelopeમાં લપેટવું, જે સંગત 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
```

## ઇન્ટરસેપ્ટર્સ વર્ષ 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
```

વ્યાખ્યાયિત વૈશિષ્ટ્ય: ઇન્ટરસેપ્ટર્સ હ્યાન્ડલર **પછી** લોજિક ચલાવી શકે છે અને **રેસ્પોન્સને રૂપાંતરિત** કરી શકે છે — જે middleware અને guards સાફલ્যযથી કરી શકતા નથી.

## તે શા માટે મહત્વનું છે

ઇન્ટરસેપ્ટર્સ **cross-cutting concerns** સુંદરતાથી સંભાળવા માટે NestJS નું શક્તિશાળી ફીચર છે, અને તેમની વ્યાખ્યાયિત ક્ષમતા — હ્યાન્ડલર પહેલા *અને પછી* લોજિક ચલાવવું, અને રેસ્પોન્સને રૂપાંતરિત કરવું — તેમને એમ જરૂરિયાતો માટે યોગ્ય સાધન બનાવે છે જે middleware અને guards સંબોધી શકતા નથી.

તેમને સમજવું મહત્વપૂર્ણ છે કારણ કે ઘણી સામાન્ય જરૂરિયાતો ઇન્ટરસેપ્ટર્સમાં સ્વાભાવિકપણે મેપ થાય છે: સંગત રેસ્પોન્સ ફોર્મેટિંગ (બધા રેસ્પોન્સને સ્ટાન્ડર્ડ `{ success, data }` envelopeમાં લપેટવું), લૉગિંગ/ટાઇમિંગ (હ્યાન્ડલર અવધિ માપવું), કેશિંગ (કેશ કરેલા રેસ્પોન્સ આપવું), ટાઇમઆઉટ્સ, error transformation, અને serialization (સંવેદનશીલ ક્ષેત્રો બાકાત કરવું).

માળખું જાણવું (the `next.handle()` Observable, `tap`/`map`/`catchError` સાથે before/afterમાં કાર્ય કરવા માટે), સામાન્ય ઉપયોગ કેસો, અને ખાસ કરીને **ઇન્ટરસેપ્ટર્સ middleware અને guards થી કેવી રીતે અલગ છે** (રેસ્પોન્સને લપેટવા અને રૂપાંતરિત કરવાની ક્ષમતા) NestJS આર્કિટેક્ચરલ સક્ષમતાનો મુખ્ય ભાગ છે.

ઇન્ટરસેપ્ટર્સ cross-cutting લોજિકને DRY અને કેન્દ્રીકૃત રાખે છે હ્યાન્ડલર્સ દરમિયાન ડુપ્લિકેટ કરવાને બદલે, તેમને વારંવાર ઉપયોગમાં લેવાતું, સ્વચ્છ, જાળવણીયોગ્ય NestJS એપ્લિકેશન્સ બનાવવા માટે મહત્વપૂર્ણ સાધન બનાવે છે.

માળખું: RxJS દ્વારા before + after

રેસ્પોન્સને રૂપાંતરિત કરવું (એક સામાન્ય ઉપયોગ)

અન્ય શક્તિશાળી ઉપયોગો

ઇન્ટરસેપ્ટર્સ લાગુ કરવું

ઇન્ટરસેપ્ટર્સ વર્ષ middleware વર્ષ guards

તે શા માટે મહત્વનું છે

question.related