X'inhu custom providers u injection tokens?

Question

Accepted Answer

Lil hinn minn sempliċi klassijiet `@Injectable()`, NestJS jappoġġja **custom providers** — modi flessibli biex tiddefinixxi x'inhu li jiddaħħal — billi tuża **injection tokens**. Dan jippermettilek tiddaħħal valuri, tikonfigura kif jinħolqu l-istanzi, tibdel l-implimentazzjonijiet, u tiddaħħal dipendenzi li mhumiex klassijiet.

## L-erba' tipi ta' 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 — għal dipendenzi li mhumiex klassijiet

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

Billi ma tistax tiddaħħal interface jew valur sempliċi skond it-tip (ma jeżistux waqt il-ħin tal-esekuzzjoni), tuża **token** (string jew `Symbol`) ma' `@Inject(token)` biex tiddaħħal. Hawn kif tiddaħħal objekti ta' konfigurazzjoni, klijenti minn partijiet terzi, jew dipendenzi b'tip interface.

## useFactory — l-aktar qawwi (setup dinamiku u asinkron)

```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` teħdem funzjoni (b'dipendenzi ddaħħala) biex tipproduċi l-provider — essenzjali għal konnessjonijiet, klijenti, jew xi ħaġa li teħtieġ konfigurazzjoni waqt il-ħin tal-esekuzzjoni jew setup asinkron.

## Tibdil tal-implimentazzjonijiet (useClass) — flessibilità u ttestjar

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

Billi l-konsumers jiddependu fuq it-token (`PaymentService`), tista' tbeddel il-klassi konkreta — servizz real Stripe fil-produzzjoni, mock fit-testijiet — mingħajr ma tbiddel xi kodiċi konsument.

## Għala importanti

Custom providers u injection tokens jestindu l-dipendenza-injezzjoni ta' NestJS lil hinn minn klassijiet sempliċi, u jagħtuk il-flessibilità meħtieġa għal applikazzjonijiet tal-dinja reali.

L-għarfien tiegħhom huwa importanti għal diversi xenarji komuni: **tiddaħħil ta' valuri li mhumiex klassijiet** (objekti ta' konfigurazzjoni, kostanti) permezz ta' `useValue` u tokens ta' string/Symbol (billi ma tistax tiddaħħal interfaces jew valuri sempliċi skond it-tip); **ħolq dinamiku/asinkron ta' provider** permezz ta' `useFactory` (il-forma l-aktar qawwija — għad-dħul tal-konnessjonijiet tad-database, klijenti Redis, jew istanzi SDK minn partiji terzi kkonfigurati minn valuri waqt il-ħin tal-esekuzzjoni, b'dipendenzji iddaħħla tagħhom); u **tibdil tal-implimentazzjonijiet** permezz ta' `useClass` wara token (biex tippermetti implimentazzjonijiet bbazati fuq l-ambjent u, kruċjalment, **mock faċli fit-testijiet** — iprovdi klassi mock għal token mingħajr ma taffetwa l-konsumers).

Il-flessibilità din hija dik li tagħmel l-DI ta' NestJS qawwi għal arkitettura ta' produzzjoni u eċċellenti għat-testabbilità.

L-għarfien tal-erba' tipi ta' provider (`useClass`, `useValue`, `useFactory`, `useExisting`), kif jaħdem l-injection tokens għal dipendenzi li mhumiex klassijiet, u meta jintgħażel kull wieħed huwa pass importanti lil hinn minn DI bażiku — hawn kif tikkabla d-databases, servizzi esterni, konfigurazzjoni, u dipendenzi swappable/mockable il-mod idiomatiku ta' NestJS, u jagħmilha tema ta' ħtieġa frekwenti, sinifikanti mir-raħħ tal-arkitettura f'applikazzjonijiet reali.