કસ્ટમ પ્રોવાઇડર્સ અને ઇનજેક્શન ટોકન્સ શું છે?

Question

Accepted Answer

સાધારણ `@Injectable()` ક્લાસ્સ્ સ્વરૂપથી આગળ, NestJS **કસ્ટમ પ્રોવાઇડર્સ** સપોર્ટ કરે છે — શું ઇનજેક્ટ કરવું તે વ્યાખ્યાયિત કરવાની લવચક રીતો — **ઇનજેક્શન ટોકન્સ** નો ઉપયોગ કરીને. આ તમને મૂલ્યો ઇનજેક્ટ કરવા, ઇન્સ્ટાન્સ્ કેવી રીતે બનાવવામાં આવે તે ગોઠવવા, ઇમ્પ્લીમેન્ટેશન સ્વેપ કરવા, અને નોન-ક્લાસ ડિપેન્ડેન્સીઝ ઇનજેક્ટ કરવા દેય છે..

## ચાર કસ્ટમ પ્રોવાઇડર પ્રકારો

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

## ઇનજેક્શન ટોકન્સ — નોન-ક્લાસ ડિપેન્ડેન્સીઝ માટે

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

તમે ઇન્ટરફેસ અથવા પ્લેઈન વેલ્યુને પ્રકાર દ્વારા ઇનજેક્ટ કરી શકતા નથી (તેઓ રનટાઈમ પર અસ્તિત્વમાં નથી), તો તમે **ટોકન** (સ્ટ્રિંગ અથવા `Symbol`) નો ઉપયોગ કરો છો `@Inject(token)` સાથે તેને ઇનજેક્ટ કરવા માટે. આ તે છે કે તમે કન્ફિગરેશન ઑબ્જેક્ટ્સ, થર્ડ-પાર્ટી ક્લાયન્ટ્સ, અથવા ઇન્ટરફેસ-ટાઈપ ડિપેન્ડેન્સીઝ કેવી રીતે ઇનજેક્ટ કરો છો.

## useFactory — સૌથી શક્તિશાળી (ડાયનામિક, 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` એક ફંક્શન (ઇનજેક્ટેડ ડિપેન્ડેન્સીઝ સાથે) ચલાવે છે પ્રોવાઇડર ઉત્પન્ન કરવા માટે — કનેક્શન્સ, ક્લાયન્ટ્સ, અથવા કોઈપણ જો રનટાઈમ કન્ફિગરેશન અથવા async સેટઅપની જરૂર હોય તો તે આવશ્યક છે.

## ઇમ્પ્લીમેન્ટેશન સ્વેપ કરવું (useClass) — લવચકતા અને ટેસ્ટિંગ

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

કારણ કે કંઝ્યુમર્સ ટોકન (`PaymentService`) પર આધાર રાખે છે, તમે કોન્ક્રીટ ક્લાસ સ્વેપ કરી શકો છો — પ્રોડક્શનમાં વાસ્તવિક Stripe સર્વિસ, ટેસ્ટમાં મોક — કોઈપણ કોન્જ્યુમિંગ કોડ બદલ્યા વિના.

## શા માટે તે મહત્વપૂર્ણ છે

કસ્ટમ પ્રોવાઇડર્સ અને ઇનજેક્શન ટોકન્સ NestJS ના ડિપેન્ડેન્સી ઇનજેક્શનને સાધારણ ક્લાસ્સ્ સ્વરૂપથી આગળ વધારે છે, તમને વાસ્તવિક-વિશ્વ એપ્લીકેશન્સ માટે જરૂરી લવચકતા આપે છે.

તેમને સમજવું કેટલાક સામાન્ય પરિસ્થિતિઓ માટે મહત્વપૂર્ણ છે: **નોન-ક્લાસ મૂલ્યો ઇનજેક્ટ કરવું** (કન્ફિગરેશન ઑબ્જેક્ટ્સ, કોન્સ્ટેંટ્સ) `useValue` અને string/Symbol ટોકન્સ દ્વારા (કારણ કે તમે ઇન્ટરફેસ અથવા પ્લેઈન મૂલ્યો પ્રકાર દ્વારા ઇનજેક્ટ કરી શકતા નથી); **ડાયનામિક/async પ્રોવાઇડર ક્રિએશન** `useFactory` દ્વારા (સૌથી શક્તિશાળી ફોર્મ — ડેટાબેસ કનેક્શન્સ, Redis ક્લાયન્ટ્સ, અથવા થર્ડ-પાર્ટી SDK ઇન્સ્ટાન્સ્ ક્રિએટ કરવું રનટાઈમ મૂલ્યો દ્વારા કન્ફિગર કરવું, તેમના પોતાના ઇનજેક્ટેડ ડિપેન્ડેન્સીઝ સાથે); અને **ઇમ્પ્લીમેન્ટેશન સ્વેપ કરવું** `useClass` દ્વારા ટોકનની પાછળ (પર્યાવરણ-આધારિત ઇમ્પ્લીમેન્ટેશન્સ સક્ષમ કરીને અને, નિર્ણાયક રીતે, ટેસ્ટમાં સરળ **મોકિંગ** — ટોકન માટે મોક ક્લાસ પ્રદાન કરો કોઈપણ કોન્જ્યુમર્સને સ્પર્શ કર્યા વિના).

આ લવચકતા તે છે જે NestJS નું DI પ્રોડક્શન આર્કિટેક્ચર માટે શક્તિશાળી અને ઉત્તમ ટેસ્ટેબિલિટી બનાવે છે.

ચાર પ્રોવાઇડર પ્રકારો (`useClass`, `useValue`, `useFactory`, `useExisting`) જાણવું, કેવી રીતે ઇનજેક્શન ટોકન્સ નોન-ક્લાસ ડિપેન્ડેન્સીઝ માટે કામ કરે છે, અને કોણે દરેક સમયે પહોંચવું તે આધારભૂત DI ની આગળ એક મહત્વપૂર્ણ પગલું છે — તે તે છે કે તમે કેવી રીતે ડેટાબેસ્, બાહ્ય સર્વિસ્, કન્ફિગરેશન, અને સ્વેપેબલ/મોકેબલ ડિપેન્ડેન્સીઝ વાયર અપ કરો છો idiomatic NestJS પદ્ધતિમાં, તે એક વારંવાર-જરૂરી, આર્કિટેક્ચરલી-મહત્વપૂર્ણ વિષય બનાવીને વાસ્તવિક એપ્લીકેશન્સમાં.