Custom providers மற்றும் injection tokens என்றால் என்ன?

Question

Accepted Answer

எளிய `@Injectable()` classes-க்கு அப்பால், NestJS **custom providers**-ஐ ஆதரிக்கிறது — என்ன inject செய்யப்படுகிறது என்பதை வரையறுக்கும் நெகிழ்வான வழிகள் — **injection tokens**-ஐப் பயன்படுத்தி. இது values-ஐ inject செய்யவும், instances எவ்வாறு உருவாக்கப்படுகின்றன என்பதை configure செய்யவும், implementations-ஐ மாற்றவும், 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` ஆனது provider-ஐ உருவாக்க ஒரு function-ஐ (inject செய்யப்பட்ட dependencies உடன்) இயக்குகிறது — connections, clients, அல்லது runtime configuration அல்லது async setup தேவைப்படும் எதற்கும் இது அவசியம்.

## Implementations-ஐ மாற்றுதல் (useClass) — நெகிழ்வுத்தன்மை & testing

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

Consumers token-ஐ (`PaymentService`) சார்ந்திருப்பதால், எந்த consuming code-ஐயும் மாற்றாமல் — production-இல் ஒரு உண்மையான Stripe service, tests-இல் ஒரு mock — concrete class-ஐ நீங்கள் மாற்றலாம்.

## இது ஏன் முக்கியம்

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-இலிருந்து configure செய்யப்பட்ட database connections, Redis clients, அல்லது third-party SDK instances-ஐ அவற்றின் சொந்த inject செய்யப்பட்ட dependencies உடன் உருவாக்குதல்); மற்றும் ஒரு token-க்குப் பின்னால் `useClass` மூலம் **implementations-ஐ மாற்றுதல்** (environment அடிப்படையிலான implementations-ஐ செயல்படுத்துதல் மற்றும், முக்கியமாக, tests-இல் எளிதான **mocking** — consumers-ஐத் தொடாமல் ஒரு token-க்கு ஒரு mock class-ஐ வழங்குதல்).

இந்த நெகிழ்வுத்தன்மையே NestJS-இன் DI-ஐ production architecture-க்கு சக்திவாய்ந்ததாகவும் சிறந்த testability கொண்டதாகவும் ஆக்குகிறது.

நான்கு provider வகைகளையும் (`useClass`, `useValue`, `useFactory`, `useExisting`), injection tokens class அல்லாத dependencies-க்கு எவ்வாறு வேலை செய்கின்றன என்பதையும், ஒவ்வொன்றையும் எப்போது அணுக வேண்டும் என்பதையும் அறிந்திருப்பது அடிப்படை DI-க்கு அப்பால் ஒரு முக்கியமான படியாகும் — databases, external services, configuration, மற்றும் மாற்றக்கூடிய/mock செய்யக்கூடிய dependencies-ஐ idiomatic NestJS வழியில் இணைப்பது இப்படித்தான், இது உண்மையான applications-இல் அடிக்கடி தேவைப்படும், கட்டிடக்கலை ரீதியாக முக்கியமான தலைப்பாக ஆக்குகிறது.