Što su interceptori?

Question

Accepted Answer

**Interceptori** omotavaju izvršavanje route handlera, omogućavajući vam da pokrenete logiku **prije i nakon** njega — i transformirate zahtjev ili odgovor. Inspirirani su aspect-oriented programiranjem, idealni za cross-cutting concerns poput logiranja, transformacije odgovora, cachiranja i mjerenja vremena.

## Struktura: prije + nakon putem RxJS-a

```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 implementira `intercept()`. Kod prije `next.handle()` se izvršava **prije** handlera; `next.handle()` vraća RxJS `Observable` odgovora, a operatori poput `tap`/`map` vam omogućavaju da djelujete na odgovor **nakon** što se handler završi.

## Transformacija odgovora (česta upotreba)

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

Korištenjem `map`, interceptor može preoblikovati svaki odgovor — npr. omotavajući sve odgovore u standardnu omotnicu, što je vrlo čest obrazac za konzistentne API odgovore.

## Ostale moćne upotrebe

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

## Primjena interceptora

```ts
@UseInterceptors(LoggingInterceptor)   // method or controller level
app.useGlobalInterceptors(new TransformInterceptor());   // global
```

## Interceptori vs middleware vs guardovi

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

Označavajuća značajka: interceptori mogu pokrenuti logiku **nakon** handlera i **transformirati odgovor** — što middleware i guardovi ne mogu učiniti čisto.

## Zašto je važno

Interceptori su moćna NestJS značajka za elegantno rukovanje **cross-cutting concerns**, a njihova razlikovana sposobnost — pokretanje logike i prije i nakon handlera, te transformacija odgovora — čini ih pravim alatom za potrebe koje middleware i guardovi ne mogu adresirati.

Razumijevanje je važno jer se mnogi česti zahtjevi prirodno mapiraju na interceptore: konzistentno formatiranje odgovora (omotavanje svih odgovora u standardnu `{ success, data }` omotnicu), logiranje/mjerenje vremena (mjerenje trajanja handlera), cachiranje (vraćanje cachiranih odgovora), timeout-i, transformacija grešaka i serializacija (isključivanje osjetljivih polja).

Znati strukturu (the `next.handle()` Observable, sa `tap`/`map`/`catchError` za djelovanje prije/nakon), česte use case-eve, i posebno **kako se interceptori razlikuju od middleware i guardova** (sposobnost omotavanja i transformacije odgovora) je ključni dio NestJS arhitekturne kompetencije.

Interceptori čuvaju cross-cutting logiku DRY i centraliziranu umjesto da bude duplikovana kroz handlere, čineći ih često korištenim, važnim alatom za gradnju čistih, održivih NestJS aplikacija.