Custom provider และ injection token คืออะไร?

Question

Accepted Answer

นอกเหนือจากคลาส `@Injectable()` แบบธรรมดา NestJS ยังรองรับ **custom provider** ซึ่งเป็นวิธีที่ยืดหยุ่นในการกำหนดว่าจะ inject อะไรเข้าไป โดยใช้ **injection token** สิ่งนี้ทำให้คุณ inject ค่าต่างๆ, กำหนดวิธีสร้าง instance, สลับ implementation และ inject dependency ที่ไม่ใช่คลาสได้

## custom provider สี่ประเภท

```ts
@Module({
  providers: [
    // 1. useClass — standard (or swap the implementation behind a token)
    { provide: PaymentService, useClass: StripePaymentService },

// 2. useValue — inject a constant/object/mock (great for config and testing)
    { provide: "CONFIG", useValue: { apiKey: "abc", timeout: 5000 } },

// 3. useFactory — compute the provider dynamically (can use other deps)
    {
      provide: "DATABASE_CONNECTION",
      useFactory: async (config: ConfigService) => {
        return await createConnection(config.get("DB_URL"));   // async setup
      },
      inject: [ConfigService],        // dependencies for the factory
    },

// 4. useExisting — create an alias for an existing provider
    { provide: "ALIAS", useExisting: PaymentService },
  ],
})
export class AppModule {}
```

## injection token — สำหรับ dependency ที่ไม่ใช่คลาส

```ts
// classes can be tokens directly (by type). For values/interfaces, use a string/Symbol token:
@Injectable()
export class PaymentProcessor {
  constructor(@Inject("CONFIG") private config: AppConfig) {}   // inject by token
}
```

เนื่องจากคุณไม่สามารถ inject interface หรือค่าธรรมดาด้วย type ได้ (เพราะมันไม่มีอยู่ ณ runtime) คุณจึงใช้ **token** (string หรือ `Symbol`) ร่วมกับ `@Inject(token)` เพื่อ inject มัน นี่คือวิธีที่คุณ inject ออบเจ็กต์ configuration, client จากภายนอก หรือ dependency ที่มีชนิดเป็น interface

## useFactory — ทรงพลังที่สุด (การตั้งค่าแบบ dynamic, async)

```ts
// create a provider whose value depends on runtime config / async initialization
{
  provide: "REDIS_CLIENT",
  useFactory: (config: ConfigService) => new Redis(config.get("REDIS_URL")),
  inject: [ConfigService],
}
```

`useFactory` จะรันฟังก์ชัน (พร้อม dependency ที่ inject เข้ามา) เพื่อสร้าง provider ซึ่งจำเป็นอย่างยิ่งสำหรับ connection, client หรืออะไรก็ตามที่ต้องการ configuration ณ runtime หรือการตั้งค่าแบบ async

## การสลับ implementation (useClass) — ความยืดหยุ่นและการทดสอบ

```ts
// inject a different implementation based on environment
{
  provide: PaymentService,
  useClass: process.env.NODE_ENV === "test" ? MockPaymentService : StripePaymentService,
}
```

เพราะตัวที่เรียกใช้ขึ้นอยู่กับ token (`PaymentService`) คุณจึงสามารถสลับคลาสที่เป็นรูปธรรมได้ เช่น service ของ Stripe จริงใน production และ mock ในการทดสอบ โดยไม่ต้องเปลี่ยนโค้ดที่เรียกใช้เลย

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

Custom provider และ injection token ขยาย dependency injection ของ NestJS ให้เกินกว่าคลาสธรรมดา มอบความยืดหยุ่นที่จำเป็นสำหรับแอปพลิเคชันในโลกจริง

การเข้าใจสิ่งเหล่านี้สำคัญสำหรับสถานการณ์ทั่วไปหลายอย่าง ได้แก่ การ **inject ค่าที่ไม่ใช่คลาส** (ออบเจ็กต์ configuration, ค่าคงที่) ผ่าน `useValue` และ token แบบ string/Symbol (เพราะคุณไม่สามารถ inject interface หรือค่าธรรมดาด้วย type ได้); การ **สร้าง provider แบบ dynamic/async** ผ่าน `useFactory` (รูปแบบที่ทรงพลังที่สุด สำหรับสร้าง database connection, Redis client หรือ instance ของ third-party SDK ที่ตั้งค่าจากค่า ณ runtime พร้อม dependency ของตัวเองที่ inject เข้ามา); และการ **สลับ implementation** ผ่าน `useClass` ที่อยู่เบื้องหลัง token (ทำให้ใช้ implementation ตาม environment ได้ และที่สำคัญคือ **mock ในการทดสอบ** ได้ง่าย โดย provide คลาส mock ให้กับ token โดยไม่ต้องแตะตัวที่เรียกใช้)

ความยืดหยุ่นนี้คือสิ่งที่ทำให้ DI ของ NestJS ทรงพลังสำหรับสถาปัตยกรรมระดับ production และทดสอบได้ดีเยี่ยม

การรู้ provider ทั้งสี่ประเภท (`useClass`, `useValue`, `useFactory`, `useExisting`), รู้ว่า injection token ทำงานอย่างไรกับ dependency ที่ไม่ใช่คลาส และรู้ว่าเมื่อใดควรหยิบแต่ละอย่างมาใช้ เป็นก้าวสำคัญที่เกินกว่า DI พื้นฐาน เพราะมันคือวิธีที่คุณเชื่อมต่อ database, external service, configuration และ dependency ที่สลับ/mock ได้ ในแบบฉบับ NestJS ทำให้มันเป็นหัวข้อที่ต้องใช้บ่อยและมีความสำคัญเชิงสถาปัตยกรรมในแอปพลิเคชันจริง