Interceptor คืออะไร?

Question

Accepted Answer

**Interceptor** ห่อหุ้มการทำงานของ route handler ทำให้คุณรัน logic ได้ **ทั้งก่อนและหลัง** มัน — และแปลง request หรือ response ได้ มันได้แรงบันดาลใจจาก aspect-oriented programming เหมาะสำหรับเรื่องแบบ cross-cutting เช่น logging, การแปลง response, caching และ timing

## โครงสร้าง: before + after ผ่าน 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 implement `intercept()` โค้ดก่อน `next.handle()` ทำงาน **ก่อน** handler; `next.handle()` ส่งคืน RxJS `Observable` ของ response และ operator อย่าง `tap`/`map` ทำให้คุณกระทำกับ response **หลัง** handler ทำงานเสร็จได้

## การแปลง response (การใช้งานที่พบบ่อย)

```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` ทำให้ interceptor สามารถปรับรูปร่าง response ทุกตัวได้ — เช่น ห่อ response ทั้งหมดใน envelope มาตรฐาน ซึ่งเป็นรูปแบบที่พบบ่อยมากสำหรับ response 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
```

## การใช้ interceptor

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

## Interceptor เทียบกับ middleware เทียบกับ guard

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

คุณสมบัติที่บ่งบอกตัวตน: interceptor สามารถรัน logic **หลัง** handler และ **แปลง response** ได้ — ซึ่ง middleware และ guard ทำไม่ได้อย่างสะอาด

## ทำไมจึงสำคัญ

Interceptor เป็นฟีเจอร์ทรงพลังของ NestJS สำหรับจัดการเรื่อง **cross-cutting** อย่างสง่างาม และความสามารถที่แตกต่าง — การรัน logic ทั้งก่อน *และหลัง* handler และการแปลง response — ทำให้มันเป็นเครื่องมือที่ถูกต้องสำหรับความต้องการที่ middleware และ guard จัดการไม่ได้

การเข้าใจมันเป็นเรื่องสำคัญเพราะความต้องการที่พบบ่อยหลายอย่างแมปเข้ากับ interceptor ได้อย่างเป็นธรรมชาติ: การจัดรูปแบบ response ที่สม่ำเสมอ (ห่อ response ทั้งหมดใน envelope มาตรฐาน `{ success, data }`), logging/timing (วัดระยะเวลาของ handler), caching (ส่งคืน response ที่ cache ไว้), timeout, การแปลง error และ serialization (ตัด field ที่อ่อนไหวออก)

การรู้โครงสร้าง (Observable ของ `next.handle()` พร้อม `tap`/`map`/`catchError` เพื่อกระทำก่อน/หลัง), กรณีการใช้งานที่พบบ่อย และโดยเฉพาะ **ว่า interceptor ต่างจาก middleware และ guard อย่างไร** (ความสามารถในการห่อหุ้มและแปลง response) เป็นส่วนสำคัญของความสามารถทางสถาปัตยกรรมของ NestJS

Interceptor ทำให้ logic แบบ cross-cutting เป็น DRY และรวมศูนย์แทนที่จะซ้ำซ้อนข้าม handler ทำให้มันเป็นเครื่องมือสำคัญที่ใช้บ่อยในการสร้างแอปพลิเคชัน NestJS ที่สะอาดและดูแลรักษาง่าย