Apakah itu custom providers dan injection tokens?

Question

Accepted Answer

Selain kelas `@Injectable()` yang ringkas, NestJS menyokong **custom providers** — cara yang fleksibel untuk mentakrifkan apa yang disuntik — menggunakan **injection tokens**. Ini membolehkan anda menyuntik nilai, mengkonfigurasi cara instance dicipta, menukar implementasi, dan menyuntik dependencies bukan-kelas.

## Empat jenis 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 tokens — untuk dependencies bukan-kelas

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

Memandangkan anda tidak boleh menyuntik satu interface atau nilai biasa mengikut jenis (ia tidak wujud pada masa runtime), anda menggunakan satu **token** (satu string atau `Symbol`) dengan `@Inject(token)` untuk menyuntiknya. Inilah cara anda menyuntik objek configuration, client pihak ketiga, atau dependencies yang bertaip interface.

## useFactory — yang paling berkuasa (penyediaan dinamik, 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` menjalankan satu fungsi (dengan dependencies yang disuntik) untuk menghasilkan provider tersebut — penting untuk sambungan, client, atau apa-apa yang memerlukan configuration masa runtime atau penyediaan async.

## Menukar implementasi (useClass) — fleksibiliti & testing

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

Kerana pengguna bergantung pada token (`PaymentService`), anda boleh menukar kelas konkrit — satu Stripe service sebenar dalam production, satu mock dalam tests — tanpa mengubah sebarang kod pengguna.

## Mengapa ia penting

Custom providers dan injection tokens melanjutkan dependency injection NestJS melangkaui kelas ringkas, memberi anda fleksibiliti yang diperlukan untuk aplikasi dunia sebenar.

Memahaminya adalah penting untuk beberapa senario biasa: **menyuntik nilai bukan-kelas** (objek configuration, pemalar) melalui `useValue` dan token string/Symbol (kerana anda tidak boleh menyuntik interface atau nilai biasa mengikut jenis); **penciptaan provider secara dinamik/async** melalui `useFactory` (bentuk yang paling berkuasa — mencipta sambungan database, client Redis, atau instance SDK pihak ketiga yang dikonfigurasi daripada nilai masa runtime, dengan dependencies tersuntiknya sendiri); dan **menukar implementasi** melalui `useClass` di sebalik satu token (membolehkan implementasi berasaskan persekitaran dan, yang terpenting, **mocking yang mudah dalam tests** — menyediakan satu kelas mock untuk satu token tanpa menyentuh pengguna).

Fleksibiliti ini ialah yang menjadikan DI NestJS berkuasa untuk seni bina production dan kebolehujian yang sangat baik.

Mengetahui empat jenis provider (`useClass`, `useValue`, `useFactory`, `useExisting`), cara injection tokens berfungsi untuk dependencies bukan-kelas, dan bila perlu mencapai setiap satu ialah satu langkah penting melangkaui DI asas — itulah cara anda mengaitkan database, perkhidmatan luaran, configuration, dan dependencies yang boleh ditukar/dimock mengikut cara NestJS yang idiomatik, menjadikannya satu topik yang kerap diperlukan dan penting dari segi seni bina dalam aplikasi sebenar.