X'inhuma l-interceptors?

Question

Accepted Answer

**Interceptors** iħawwdu l-eżekuzzjoni ta' route handler, u jippermettulek li ċċarrej logika **qabel u wara** - u ttrasforma r-request jew ir-response. Huma inspirati minn aspect-oriented programming, ideali għal cross-cutting concerns bħal logging, response transformation, caching, u timing.

## L-istruttura: qabel + wara 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
    );
  }
}
```

Interceptor jimplimenta `intercept()`. Il-kodiċi qabel `next.handle()` jaħdem **qabel** il-handler; `next.handle()` jirritorna RxJS `Observable` tal-response, u operators bħal `tap`/`map` jippermettulek li taġixxxi fuq ir-response **wara** li l-handler jitmiem.

## Trasformazzjoni tal-response (użu komuni)

```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 }
    );
  }
}
```

Billi tuża `map`, interceptor jista' jirriforma kull response - per eżempju, iħawwdu lkoll ir-responses f'envelop standard, mudell komuni ħafna għar-responses tal-API konsistenti.

## Użi oħra qawwija

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

## Applikazzjoni ta' 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
```

L-feature li jiddefinixxi: interceptors jistgħu jaħdmu logika **wara** il-handler u **ttrasforma r-response** - li middleware u guards ma jistgħux jagħmlu b'mod nadif.

## Għaliex huwa importanti

Interceptors huma feature qawwija ta' NestJS għall-ġestjoni ta' **cross-cutting concerns** b'mod eleganti, u l-kapaċità li jiddistingwu - ċarrej logika qabel *u wara* il-handler, u ttrasforma r-response - tagħmilhom l-għodda ġusta għal ħtieġa li middleware u guards ma jistgħux indirizzaw.
//mifhuma huwa importanti għaliex ħafna ħtieġa komuni huma mappjati b'mod naturali għall-interceptors: formatting tal-response konsistenti (iħawwdu lkoll ir-responses f'envelop standard `{ success, data }`), logging/timing (kejl id-durata tal-handler), caching (irritorna r-responses cached), timeouts, error transformation, u serialization (esklużjoni ta' fields sensittivi).

Il-għarfien tal-istruttura (l-`next.handle()` Observable, b'`tap`/`map`/`catchError` biex taġixxxi qabel/wara), il-use cases komuni, u speċjalment **kif interceptors huma differenti minn middleware u guards** (l-abbiltà li iħawwdu u ttrasforma r-response) hija parti ċavi tal-kompetenza arkitettoniċa ta' NestJS.

Interceptors iħallu l-logika ta' cross-cutting DRY u centralized aktar milli dupplikata madwar handlers, għalhekk huma għodda użata ta' spiss, importanti għall-bini ta' NestJS applications nadif u maintainable.