Apa itu custom providers dan injection tokens?

Question

Accepted Answer

Di luar kelas `@Injectable()` sederhana, NestJS mendukung **custom providers** — cara fleksibel untuk mendefinisikan apa yang disuntikkan — menggunakan **injection tokens**. Ini memungkinkan Anda menyuntikkan nilai, mengonfigurasi cara instance dibuat, menukar implementasi, dan menyuntikkan dependensi non-kelas.

## Empat tipe 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 dependensi non-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
}
```

Karena Anda tidak dapat menyuntikkan interface atau nilai biasa berdasarkan tipe (mereka tidak ada pada runtime), Anda menggunakan **token** (string atau `Symbol`) dengan `@Inject(token)` untuk menyuntikkannya. Ini adalah cara Anda menyuntikkan objek konfigurasi, klien pihak ketiga, atau dependensi bertipe interface.

## useFactory — yang paling powerful (setup dinamis, 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 fungsi (dengan dependensi yang disuntikkan) untuk menghasilkan provider — penting untuk koneksi, klien, atau apa pun yang memerlukan konfigurasi runtime atau setup async.

## Menukar implementasi (useClass) — fleksibilitas & testing

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

Karena konsumen bergantung pada token (`PaymentService`), Anda dapat menukar kelas konkret — layanan Stripe asli di production, mock dalam test — tanpa mengubah kode konsumen apa pun.

## Mengapa ini penting

Custom providers dan injection tokens memperluas dependency injection NestJS di luar kelas sederhana, memberikan Anda fleksibilitas yang dibutuhkan untuk aplikasi dunia nyata.

Memahaminya penting untuk beberapa skenario umum: **menyuntikkan nilai non-kelas** (objek konfigurasi, konstanta) via `useValue` dan token string/Symbol (karena Anda tidak dapat menyuntikkan interface atau nilai biasa berdasarkan tipe); **pembuatan provider dinamis/async** via `useFactory` (bentuk paling powerful — membuat koneksi database, klien Redis, atau instansi SDK pihak ketiga dikonfigurasi dari nilai runtime, dengan dependensi yang disuntikkan mereka sendiri); dan **menukar implementasi** via `useClass` di balik token (mengaktifkan implementasi berbasis lingkungan dan, yang sangat penting, **mocking mudah dalam test** — sediakan kelas mock untuk token tanpa menyentuh konsumen).

Fleksibilitas ini adalah yang membuat DI NestJS powerful untuk arsitektur production dan testability yang sangat baik.

Mengetahui empat tipe provider (`useClass`, `useValue`, `useFactory`, `useExisting`), cara injection tokens bekerja untuk dependensi non-kelas, dan kapan menggunakan masing-masing adalah langkah penting melampaui DI dasar — ini adalah cara Anda mewirakan database, layanan eksternal, konfigurasi, dan dependensi yang dapat ditukar/dimock dengan cara idiomatik NestJS, menjadikannya topik yang sering dibutuhkan dan signifikan secara arsitektural dalam aplikasi nyata.