Custom providers na injection tokens ni nini?

Question

Accepted Answer

Zaidi ya class rahisi za `@Injectable()`, NestJS inaunga mkono **custom providers** — njia zinazonyumbulika za kufafanua kile kinachoingizwa (injected) — kwa kutumia **injection tokens**. Hii inakuruhusu kuingiza values, kusanidi jinsi instances zinavyoundwa, kubadilishana implementations, na kuingiza dependencies zisizo za class.

## Aina nne za 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 — kwa dependencies zisizo za class

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

Kwa kuwa huwezi kuingiza interface au value ya kawaida kwa type (hazipo wakati wa runtime), unatumia **token** (string au `Symbol`) pamoja na `@Inject(token)` kuiingiza. Hii ndiyo jinsi unavyoingiza configuration objects, third-party clients, au dependencies zenye type ya interface.

## useFactory — yenye nguvu zaidi (dynamic, async setup)

```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` inaendesha function (yenye dependencies zilizoingizwa) ili kuzalisha provider — muhimu kwa connections, clients, au chochote kinachohitaji configuration ya runtime au async setup.

## Kubadilishana implementations (useClass) — unyumbulifu na upimaji

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

Kwa kuwa consumers wanategemea token (`PaymentService`), unaweza kubadilishana class halisi — Stripe service halisi katika production, mock katika tests — bila kubadilisha code yoyote inayotumia.

## Kwa nini ni muhimu

Custom providers na injection tokens zinapanua dependency injection ya NestJS zaidi ya class rahisi, zikikupa unyumbulifu unaohitajika kwa programu za ulimwengu halisi.

Kuzielewa ni muhimu kwa hali kadhaa za kawaida: **kuingiza values zisizo za class** (configuration objects, constants) kupitia `useValue` na string/Symbol tokens (kwa kuwa huwezi kuingiza interfaces au values za kawaida kwa type); **uundaji wa provider wa dynamic/async** kupitia `useFactory` (muundo wenye nguvu zaidi — kuunda database connections, Redis clients, au third-party SDK instances zilizosanidiwa kutoka kwa runtime values, zenye dependencies zao zilizoingizwa); na **kubadilishana implementations** kupitia `useClass` nyuma ya token (kuwezesha implementations zinazotegemea environment na, muhimu zaidi, **mocking** rahisi katika tests — toa mock class kwa token bila kugusa consumers).

Unyumbulifu huu ndio unaofanya DI ya NestJS kuwa yenye nguvu kwa ajili ya production architecture na uwezo bora wa kupimwa.

Kujua aina nne za provider (`useClass`, `useValue`, `useFactory`, `useExisting`), jinsi injection tokens zinavyofanya kazi kwa dependencies zisizo za class, na lini kutumia kila moja ni hatua muhimu zaidi ya DI ya msingi — ni jinsi unavyounganisha databases, external services, configuration, na dependencies zinazoweza kubadilishwa/kufanyiwa mock kwa njia ya kawaida ya NestJS, na kuifanya kuwa mada inayohitajika mara kwa mara na yenye umuhimu wa kiarchitectural katika programu halisi.