Kas yra pasirinktiniai teikėjai ir injekcijos ženklai?

Question

Accepted Answer

Už paprastas `@Injectable()` klases NestJS palaiko **pasirinktinių teikėjų** — lankstūs būdai apibrėžti, kas įinjektuojama — naudojant **injekcijos ženklus**. Tai leidžia jums injektuoti reikšmes, konfigūruoti, kaip kuriamos egzemplioriai, keisti implementacijas ir injektuoti ne klasės priklausomybes.

## Keturi pasirinktinių teikėjų tipai

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

## Injekcijos ženklai — ne klasės priklausomybėms

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

Kadangi negalite injektuoti sąsajos arba paprastos reikšmės pagal tipą (jie nepavaldūs vykdymo metu), naudojate **ženklą** (eilutę arba `Symbol`) su `@Inject(ženklas)` jai injektuoti. Tai yra būdas injektuoti konfigūracijos objektus, trečiųjų šalių klientus arba sąsajos tipo priklausomybes.

## useFactory — galingiausias (dinaminis, asinchroninis sąranka)

```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` vykdo funkciją (su injektuotomis priklausomybėmis), kad gautų teikėją — esminiai ryšiams, klientams arba visam, reikalingam vykdymo laiko konfigūracijai arba asinchroninei sąrankiai.

## Implementacijų keitimas (useClass) — lankstunas ir bandymai

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

Kadangi vartotojai priklauso nuo ženklo (`PaymentService`), galite keisti konkretią klasę — tikrąjį Stripe paslaugą produkcijoje, modelį bandymuose — nekeisdami jokio vartotojų kodo.

## Kodėl tai svarbu

Pasirinktiniai teikėjai ir injekcijos ženklai išplečia NestJS priklausomybių injekciją už paprastas klases, suteikdami lankstumo, reikalingo realaus pasaulio programoms.

Suprasti juos yra svarbu keliais dažnais scenarijais: **injektuojant ne klasės reikšmes** (konfigūracijos objektus, konstantas) per `useValue` ir eilučių/Symbol ženklus (kadangi negalite injektuoti sąsajų arba paprastų reikšmių pagal tipą); **dinaminiu/asinchroniu teikėjo kūrimu** per `useFactory` (galingiausias ženklas — kurti duomenų bazės ryšius, Redis klientus arba trečiųjų šalių SDK egzempliorius, sukonfigūruotus iš vykdymo laiko reikšmių, su jų pačių injektuotomis priklausomybėmis); ir **implementacijų keitimu** per `useClass` už ženklo (suteikiant aplinkos pagrįstas implementacijas ir, labai svarbu, lengvą **modeliavimą bandymuose** — teikti modelio klasę ženklui nekeičiant vartotojų).

Šis lankstunas yra tai, kas daro NestJS DI galingą gamybos architektūrai ir išskirtinai gerai testinimui.

Supratimas apie keturis teikėjo tipus (`useClass`, `useValue`, `useFactory`, `useExisting`), kaip injekcijos ženklai veikia ne klasės priklausomybėms ir kada siekti kiekvieno, yra svarbus žingsnis už pagrindinį DI — tai yra būdas sukabelyti duomenų bazės, išorines paslaugas, konfigūraciją ir keičiamas/modeliavimui skirtas priklausomybes idiomine NestJS maniera, dėl to tai yra dažnai reikalinga, architektūriškai reikšminga tema realaus pasaulio programose.