Kaj so interceptorji?

Question

Accepted Answer

**Interceptorji** ovijejo izvajanje route handler-ja, kar vam omogoča, da zaženete logiko **pred in po** njem — ter transformirate zahtevo ali odgovor. Navdihnjena so z aspect-oriented programiranjem, idealna za cross-cutting concerns kot so logiranje, transformacija odgovora, caching in časovne meritve.

## Struktura: pred + po preko 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 implementira `intercept()`. Koda pred `next.handle()` se zažene **pred** handler-jem; `next.handle()` vrne RxJS `Observable` odgovora, operatorji pa kot `tap`/`map` vam omogočajo, da delujete na odgovoru **potem**, ko se handler zaključi.

## Transformacija odgovora (pogosten primer)

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

Z `map` interceptor lahko preuoblikuje vsak odgovor — npr. zavijanje vseh odgovorov v standardno ovojnico, zelo pogost vzorec za dosledne API odgovore.

## Druge zmogljive uporabe

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

## Uporaba interceptorjev

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

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

Definirajača lastnost: interceptorji lahko zaženejo logiko **po** handler-ju in **transformirajo odgovor** — kar middleware in guards ne moreta narediti čisto.

## Zakaj je to pomembno

Interceptorji so zmogljiva NestJS lastnost za elegantno obravnavo **cross-cutting concerns**, njihova razlikujoča sposobnost — izvajanje logike pred *in po* handler-ju ter transformacija odgovora — pa jih naredi pravo orodje za potrebe, ki jih middleware in guards ne morejo naslavljati čisto.

Razumevanje je pomembno, ker se številne pogosta zahteva naravno preslika na interceptorje: dosledna oblika odgovora (zavijanje vseh odgovorov v standardno `{ success, data }` ovojnico), logiranje/časovanje (merjenje trajanja handler-ja), caching (vrnitev cached odgovorov), timeouts, transformacija napak in serializacija (izključevanje občutljivih polj).

Znanje strukture (Observable `next.handle()`, z `tap`/`map`/`catchError` za delovanje pred/po), pogosti scenariji in posebej **kako se interceptorji razlikujejo od middleware in guards** (sposobnost za ovijanje in transformacijo odgovora) je ključni del NestJS arhitekturne kompetence.

Interceptorji ohranijo cross-cutting logiko DRY in centralizirano namesto da bi bila podvojena v handler-jih, kar jih naredi pogosto uporabljeno, pomembno orodje za gradnjo čistih, vzdrživnih NestJS aplikacij.