ਇੰਟਰਸੈਪਟਰ ਕੀ ਹੁੰਦੇ ਹਨ?

Question

Accepted Answer

**ਇੰਟਰਸੈਪਟਰ** ਇੱਕ ਰੂਟ ਹ੍ਵੈਂਡਲਰ ਦੀ ਐਕਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਲਪੇਟਦੇ ਹਨ, ਤੁਹਾਨੂੰ ਇਸ ਤੋਂ **ਪਹਿਲਾਂ ਅਤੇ ਬਾਅਦ ਵਿੱਚ** ਲਾਜਿਕ ਚਲਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ — ਅਤੇ ਰਿਕੁਅਸਟ ਜਾਂ ਰਿਸਪਾਂਸ ਨੂੰ ਟਰਾਂਸਫ਼ਾਰਮ ਕਰ ਸਕਦੇ ਹਨ। ਉਹ ਆਸਪੈਕਟ-ਓਰਿਏਂਟਡ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਤੋਂ ਪ੍ਰੇਰਿਤ ਹਨ, ਲਾਗਿੰਗ, ਰਿਸਪਾਂਸ ਟਰਾਂਸਫ਼ਰਮੇਸ਼ਨ, ਕੈਸ਼ਿੰਗ, ਅਤੇ ਟਾਇਮਿੰਗ ਵਰਗੀਆਂ ਕ੍ਰਾਸ-ਕਟਿੰਗ ਚਿੰਤਾਵਾਂ ਲਈ ਆਦਰਸ਼।

## ਬਣਤਰ: 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` ਵਰਗੇ ਆਪਰੇਟਰ ਤੁਹਾਨੂੰ ਹ੍ਵੈਂਡਲਰ ਦੀ ਪੂਰਤੀ ਤੋਂ **ਬਾਅਦ** ਰਿਸਪਾਂਸ ਤੇ ਕੰਮ ਕਰਨ ਦਿੰਦੇ ਹਨ।

## ਰਿਸਪਾਂਸ ਨੂੰ ਟਰਾਂਸਫ਼ਾਰਮ ਕਰਨਾ (ਇੱਕ ਆਮ ਵਰਤੋਂ)

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

## ਇੰਟਰਸੈਪਟਰ ਬਨਾਮ ਮਿਡਲਵੇਅਰ ਬਨਾਮ ਗਾਰਡ

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

ਪਰਿਭਾਸ਼ਿਤ ਖਾਸੀਅਤ: ਇੰਟਰਸੈਪਟਰ ਹ੍ਵੈਂਡਲਰ ਤੋਂ **ਬਾਅਦ** ਲਾਜਿਕ ਚਲਾ ਸਕਦੇ ਹਨ ਅਤੇ **ਰਿਸਪਾਂਸ ਨੂੰ ਟਰਾਂਸਫ਼ਾਰਮ** ਕਰ ਸਕਦੇ ਹਨ — ਜਿਸਨੂੰ ਮਿਡਲਵੇਅਰ ਅਤੇ ਗਾਰਡ ਸਾਫ਼-ਸੁਥਰੇ ਢੰਗ ਨਾਲ ਨਹੀਂ ਕਰ ਸਕਦੇ।

## ਇਹ ਕਿਉਂ ਮਹੱਤਵਪੂਰਨ ਹੈ

ਇੰਟਰਸੈਪਟਰ **ਕ੍ਰਾਸ-ਕਟਿੰਗ ਚਿੰਤਾਵਾਂ** ਨੂੰ ਸੁੰਦਰਤਾ ਨਾਲ ਸੰਭਾਲਣ ਲਈ NestJS ਦੀ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਸੁਵਿਧਾ ਹੈ, ਅਤੇ ਇਹਨਾਂ ਦੀ ਵਿਸ਼ੇਸ਼ ਸਮਰੱਥਾ — ਹ੍ਵੈਂਡਲਰ ਤੋਂ ਪਹਿਲਾਂ *ਅਤੇ ਬਾਅਦ ਵਿੱਚ* ਲਾਜਿਕ ਚਲਾਉਣਾ, ਅਤੇ ਰਿਸਪਾਂਸ ਨੂੰ ਟਰਾਂਸਫ਼ਾਰਮ ਕਰਨਾ — ਉਹਨਾਂ ਨੂੰ ਉਹਨਾਂ ਲੋੜਾਂ ਲਈ ਸਹੀ ਸਾਧਨ ਬਣਾਉਂਦੀ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਮਿਡਲਵੇਅਰ ਅਤੇ ਗਾਰਡ ਨਿਭਾ ਨਹੀਂ ਸਕਦੇ।

a ਨੂੰ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਬਹੁਤ ਸਾਰੀਆਂ ਆਮ ਲੋੜਾਂ ਕੁਦਰਤੀ ਤਰੀਕੇ ਨਾਲ ਇੰਟਰਸੈਪਟਰ ਨਾਲ ਮੈਪ ਹੁੰਦੀਆਂ ਹਨ: ਮਸਲ਼ੀਤ ਰਿਸਪਾਂਸ ਫ਼ਾਰਮੈਟਿੰਗ (ਸਾਰੀਆਂ ਰਿਸਪਾਂਸਾਂ ਨੂੰ ਸਟੈਂਡਰਡ `{ success, data }` ਐਨਵੈਲੋਪ ਵਿੱਚ ਲਪੇਟਨਾ), ਲਾਗਿੰਗ/ਟਾਇਮਿੰਗ (ਹ੍ਵੈਂਡਲਰ ਦੁਰਵਸਥਿ ਨੂੰ ਮਾਪਣਾ), ਕੈਸ਼ਿੰਗ (ਕੈਸ਼ ਕੀਤੀ ਰਿਸਪਾਂਸ ਮੁੜ ਕਰਨਾ), ਟਾਈਮਆਉਟ, ਐਰਰ ਰੂਪਾਂਤਰ, ਅਤੇ ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ (ਸੰਵੇਦਨਸ਼ੀਲ ਖੇਤਰ ਨੂੰ ਬਾਹਰ ਕੱਢਣਾ)।

ਬਣਤਰ ਨੂੰ ਜਾਣਨਾ (`next.handle()` Observable, `tap`/`map`/`catchError` ਦੇ ਨਾਲ ਪਹਿਲਾਂ/ਬਾਅਦ ਵਿੱਚ ਕੰਮ ਕਰਨ ਲਈ), ਆਮ ਵਰਤੋਂ ਦੀ ਸਥਿਤੀ, ਅਤੇ ਖ਼ਾਸ ਕਰਕੇ **ਇੰਟਰਸੈਪਟਰ ਮਿਡਲਵੇਅਰ ਅਤੇ ਗਾਰਡ ਤੋਂ ਕਿਵੇਂ ਵੱਖ ਹਨ** (ਰਿਸਪਾਂਸ ਨੂੰ ਲਪੇਟਣ ਅਤੇ ਤਬਦੀਲ ਕਰਨ ਦੀ ਯੋਗਤਾ) NestJS ਆਰਕੀਟੈਕਚਰਲ ਸਮਰੱਥਾ ਦਾ ਇੱਕ ਮੁੱਖ ਹਿੱਸਾ ਹੈ।

ਇੰਟਰਸੈਪਟਰ ਕ੍ਰਾਸ-ਕਟਿੰਗ ਲਾਜਿਕ ਨੂੰ DRY ਅਤੇ ਕੇਂਦ੍ਰਿਤ ਰੱਖਦੇ ਹਨ ਬਜਾਏ ਹ੍ਵੈਂਡਲਰ ਪਾਰ ਨਕਲ ਕੀਤੇ ਹੋਣ ਦੇ, ਉਹਨਾਂ ਨੂੰ ਲਗਾਤਾਰ ਵਰਤਿਆ ਜਾਣ ਵਾਲਾ, ਮਹੱਤਵਪੂਰਨ ਸਾਧਨ ਬਣਾਉਂਦੇ ਹਨ ਜੋ ਸਾਫ਼, ਸਥਿਰ NestJS ਐਪਲੀਕੇਸਨ ਬਣਾਉਣ ਲਈ ਹੈ।