Apa iku interceptors?

Question

Accepted Answer

**Interceptors** mbungkus eksekusi saka route handler, ndadekake sampeyan bisa mbukak logic **sadurunge lan sakwise** — lan ngarubah request utawa response. Iku inspirasi saka aspect-oriented programming, ideal kanggo cross-cutting concerns kaya logging, transformasi response, caching, lan timing.

## Struktur: sadurunge + sakwise 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
    );
  }
}
```

Siji interceptor implement `intercept()`. Code sadurunge `next.handle()` mlaku **sadurunge** handler; `next.handle()` mulih RxJS `Observable` saka response, lan operators kaya `tap`/`map` ndadekake sampeyan bisa action ing response **sakwise** handler rampung.

## Ngarubah response (panganggo umum)

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

Nganggo `map`, interceptor bisa reshape saben response — contone mbungkus kabeh responses ing standard envelope, pola sing umum banget kanggo consistent API responses.

## Panganggo liyane sing kuat

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

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

Fitur khas: interceptors bisa mbukak logic **sakwise** handler lan **ngarubah response** — apa middleware lan guards ora bisa nindakake kanthi bersih.

## Apa gunane

Interceptors minangka fitur NestJS sing kuat kanggo nangani **cross-cutting concerns** kanthi elegan, lan kapabilitas khassane — mbukak logic sadurunge *lan* sakwise handler, lan ngarubah response — ndadekake iku alat sing tepat kanggo kabutuhan apa middleware lan guards ora bisa ngatasi.
". Mangerteni iku penting amarga akeh kabutuhan umum map kanthi natural menyang interceptors: consistent response formatting (mbungkus kabeh responses ing standard `{ success, data }` envelope), logging/timing (ukur durasi handler), caching (mulih cached responses), timeouts, transformasi error, lan serialization (ngasingake sensitive fields).

Nandani struktur (the `next.handle()` Observable, karo `tap`/`map`/`catchError` kanggo action sadurunge/sakwise), kabutuhan use cases umum, lan utamane **apa interceptors beda saka middleware lan guards** (kemampuan kanggo mbungkus lan ngarubah response) minangka bagian kunci saka NestJS architectural competence.

Interceptors tetap cross-cutting logic DRY lan centralized tinimbang diduplikat ing sakabehane handlers, ndadekake iku alat sing asring dienggo, penting kanggo nulis NestJS applications sing bersih lan mudah dirawat.