ਕਸਟਮ ਪ੍ਰੋਵਾਈਡਰ ਅਤੇ ਇਨਜੈਕਸ਼ਨ ਟੋਕਨ ਕੀ ਹਨ?

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

ਕਿਉਂਕਿ ਤੁਸੀਂ ਇੱਕ ਇੰਟਰਫੇਸ ਜਾਂ ਸਾਧਾਰਨ ਮੁੱਲ ਨੂੰ ਟਾਈਪ ਦੁਆਰਾ ਇਨਜੈਕਟ ਨਹੀਂ ਕਰ ਸਕਦੇ (ਉਹ ਰੂਨਟਾਈਮ ਤੇ ਮੌਜੂਦ ਨਹੀਂ ਹਨ), ਤੁਸੀਂ `@Inject(token)` ਨਾਲ **ਟੋਕਨ** (ਇੱਕ ਸਤਰ ਜਾਂ `Symbol`) ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ ਇਸ ਨੂੰ ਇਨਜੈਕਟ ਕਰਨ ਲਈ। ਇਹ ਉਹ ਹੈ ਕਿ ਕਿਸ ਤਰਾਂ ਤੁਸੀਂ ਕੌਂਫਿਗਰੇਸ਼ਨ ਆਬਜੈਕਟ, ਤੀਜੇ-ਪੱਖ ਕਲਾਇੰਟ, ਜਾਂ ਇੰਟਰਫੇਸ-ਟਾਈਪ ਡਿਪੈਂਡੈਂਸੀ ਇਨਜੈਕਟ ਕਰਦੇ ਹੋ।

## useFactory — ਸਭ ਤੋਂ ਸ਼ਕਤੀਸ਼ਾਲੀ (ਗਤੀਸ਼ੀਲ, ਅਸਿੰਕ ਸੈਟਅਪ)

```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` ਇੱਕ ਫੰਕਸ਼ਨ (ਇਨਜੈਕਟ ਕੀਤੀ ਡਿਪੈਂਡੈਂਸੀ ਨਾਲ) ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ ਪ੍ਰੋਵਾਈਡਰ ਪੈਦਾ ਕਰਨ ਲਈ — ਸੰਪਰਕ, ਕਲਾਇੰਟ, ਜਾਂ ਰਨਟਾਈਮ ਕੌਂਫਿਗਰੇਸ਼ਨ ਜਾਂ ਅਸਿੰਕ ਸੈਟਅਪ ਦੀ ਲੋੜ ਹਨ ਉਸ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

## ਲਾਗੂ ਕਰਨਾਂ ਨੂੰ ਬਦਲਨਾ (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 ਟੋਕਨ ਦੁਆਰਾ (ਕਿਉਂਕਿ ਤੁਸੀਂ ਇੰਟਰਫੇਸ ਜਾਂ ਸਾਧਾਰਨ ਮੁੱਲਾਂ ਨੂੰ ਟਾਈਪ ਦੁਆਰਾ ਇਨਜੈਕਟ ਨਹੀਂ ਕਰ ਸਕਦੇ); **ਗਤੀਸ਼ੀਲ/ਅਸਿੰਕ ਪ੍ਰੋਵਾਈਡਰ ਨਿਰਮਾਣ** `useFactory` ਦੁਆਰਾ (ਸਭ ਤੋਂ ਸ਼ਕਤੀਸ਼ਾਲੀ ਫਾਰਮ — ਡਾਟਾਬੇਸ ਸੰਪਰਕ, Redis ਕਲਾਇੰਟ, ਜਾਂ ਤੀਜੇ-ਪੱਖ SDK ਇਨਸਟੈਂਸ ਬਣਾਉਣਾ ਰਨਟਾਈਮ ਮੁੱਲਾਂ ਤੋਂ ਕੌਂਫਿਗਰ ਕੀਤੇ, ਆਪਣੀ ਇਨਜੈਕਟ ਕੀਤੀ ਡਿਪੈਂਡੈਂਸੀ ਨਾਲ); ਅਤੇ **ਲਾਗੂ ਕਰਨਾਂ ਨੂੰ ਬਦਲਨਾ** `useClass` ਦੁਆਰਾ ਇੱਕ ਟੋਕਨ ਦੇ ਪਿੱਛੇ (ਵਾਤਾਵਰਣ-ਆਧਾਰਿਤ ਲਾਗੂ ਕਰਨਾਂ ਨੂੰ ਸਮਰਥ ਬਣਾਉਣਾ ਅਤੇ, ਖਾਸ ਤੌਰ ਤੇ, ਟੈਸਟਾਂ ਵਿੱਚ **ਆਸਾਨ ਮੌਕਿੰਗ** — ਇੱਕ ਟੋਕਨ ਲਈ ਇੱਕ ਮੌਕ ਕਲਾਸ ਫਰਾਹਮ ਕਰੋ ਬਿਨਾਂ ਖਪਤਕਾਰਾਂ ਨੂੰ ਛੂਹੇ)।

ਇਹ ਲਚਕ ਉਹ ਹੈ ਜੋ NestJS ਦੀ DI ਨੂੰ ਪ੍ਰੋਡਕਸ਼ਨ ਆਰਕੀਟੈਕਚਰ ਲਈ ਸ਼ਕਤੀਸ਼ਾਲੀ ਅਤੇ ਛਾਤ ਕਰਨ ਯੋਗ ਬਣਾਉਂਦਾ ਹੈ।

ਚਾਰ ਪ੍ਰੋਵਾਈਡਰ ਕਿਸਮਾਂ (`useClass`, `useValue`, `useFactory`, `useExisting`) ਨੂੰ ਜਾਣਨਾ, ਕਿ ਗੈਰ-ਕਲਾਸ ਡਿਪੈਂਡੈਂਸੀ ਲਈ ਇਨਜੈਕਸ਼ਨ ਟੋਕਨ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ, ਅਤੇ ਹਰੇਕ ਕਦੋਂ ਪਹੁੰਚਨਾ ਹੈ, ਮੂਲ DI ਤੋਂ ਪਰੇ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਕਦਮ ਹੈ — ਇਹ ਉਹ ਹੈ ਕਿ ਤੁਸੀਂ ਡਾਟਾਬੇਸ, ਬਾਹਰੀ ਸੇਵਾਂ, ਕੌਂਫਿਗਰੇਸ਼ਨ, ਅਤੇ ਸਵਈ-ਪ੍ਰਮੋਲ ਬਦਲੀ/ਮੌਕਬਲ ਡਿਪੈਂਡੈਂਸੀ ਨੂੰ ਸਦਚੇ NestJS ਤਰੀਕੇ ਨਾਲ ਤਿਆਰ ਕਰਦੇ ਹੋ, ਇਸ ਨੂੰ ਅਸਲੀ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਅਕਸਰ-ਲੋੜੀਂਦਾ, ਆਰਕੀਟੈਕਚਰ-ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਵਿਸ਼ਾ ਬਣਾਉਂਦੇ ਹੋ।