Custom providers और injection tokens क्या होते हैं?

Question

Accepted Answer

सरल `@Injectable()` classes से परे, NestJS **custom providers** का समर्थन करता है — यह परिभाषित करने के लचीले तरीके कि क्या inject किया जाए — **injection tokens** का उपयोग करके। यह आपको values inject करने, instances कैसे बनाए जाएँ इसे configure करने, implementations को swap करने, और गैर-class dependencies को inject करने देता है।

## चार 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 — गैर-class dependencies के लिए

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

चूँकि आप किसी interface या सादे value को type के आधार पर inject नहीं कर सकते (वे runtime पर मौजूद नहीं होते), आप उसे inject करने के लिए `@Inject(token)` के साथ एक **token** (एक string या `Symbol`) का उपयोग करते हैं। यही तरीका है जिससे आप configuration objects, third-party clients, या interface-typed dependencies को inject करते हैं।

## useFactory — सबसे शक्तिशाली (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` एक function चलाता है (injected dependencies के साथ) ताकि provider उत्पन्न हो — connections, clients, या किसी भी ऐसी चीज़ के लिए आवश्यक जिसे runtime configuration या async setup की ज़रूरत हो।

## Implementations को swap करना (useClass) — लचीलापन और testing

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

चूँकि consumers token (`PaymentService`) पर निर्भर करते हैं, आप ठोस class को swap कर सकते हैं — production में एक असली Stripe service, tests में एक mock — बिना किसी उपभोग करने वाले code को बदले।

## यह क्यों महत्वपूर्ण है

Custom providers और injection tokens NestJS के dependency injection को सरल classes से परे विस्तारित करते हैं, जिससे आपको असली दुनिया की applications के लिए आवश्यक लचीलापन मिलता है।

इन्हें समझना कई आम परिदृश्यों के लिए महत्वपूर्ण है: `useValue` और string/Symbol tokens के माध्यम से **गैर-class values inject करना** (configuration objects, constants) (क्योंकि आप interfaces या सादे values को type के आधार पर inject नहीं कर सकते); `useFactory` के माध्यम से **dynamic/async provider निर्माण** (सबसे शक्तिशाली रूप — runtime values से configured database connections, Redis clients, या third-party SDK instances बनाना, उनकी अपनी injected dependencies के साथ); और एक token के पीछे `useClass` के माध्यम से **implementations को swap करना** (environment-आधारित implementations को सक्षम करना और, महत्वपूर्ण रूप से, tests में आसान **mocking** — किसी token के लिए एक mock class प्रदान करना, बिना consumers को छुए)।

यह लचीलापन ही NestJS के DI को production architecture और उत्कृष्ट testability के लिए शक्तिशाली बनाता है।

चार provider प्रकारों (`useClass`, `useValue`, `useFactory`, `useExisting`) को जानना, injection tokens गैर-class dependencies के लिए कैसे काम करते हैं, और प्रत्येक का उपयोग कब करना है — यह बुनियादी DI से आगे एक महत्वपूर्ण कदम है — यही वह तरीका है जिससे आप databases, external services, configuration, और swappable/mockable dependencies को आदर्श NestJS तरीके से जोड़ते हैं, जिससे यह असली applications में एक बार-बार आवश्यक, architectural रूप से महत्वपूर्ण विषय बन जाता है।