Co jsou vlastní poskytovatelé a injekční tokeny?

Question

Accepted Answer

Mimo jednoduché třídy `@Injectable()` NestJS podporuje **vlastní poskytovatele** — flexibilní způsoby, jak definovat, co se injektuje — pomocí **injekčních tokenů**. To vám umožňuje injektovat hodnoty, konfigurovat vytváření instancí, vyměňovat implementace a injektovat nesamostatné závislosti.

## Čtyři typy vlastních poskytovatelů

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

## Injekční tokeny — pro nesamostatné závislosti

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

Protože nemůžete injektovat rozhraní nebo prostou hodnotu podle typu (v čase běhu neexistují), použijete **token** (řetězec nebo `Symbol`) s `@Inject(token)` k jejímu injektování. Takto injektujete objekty konfigurace, klienty třetích stran nebo závislosti typované rozhraním.

## useFactory — nejsilnější (dynamické, asynchronní nastavení)

```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` spustí funkci (s injektovanými závislostmi) k vytvoření poskytovatele — nezbytné pro připojení, klienty nebo cokoli vyžadující konfiguraci za běhu nebo asynchronní nastavení.

## Výměna implementací (useClass) — flexibilita a testování

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

Protože spotřebitelé závisí na tokenu (`PaymentService`), můžete vyměňovat konkrétní třídu — skutečnou Stripe službu v produkci, mock v testech — bez změny kódu v žádném spotřebiteli.

## Proč to má betydnost

Vlastní poskytovatelé a injekční tokeny rozšiřují závislostní injekci NestJS nad jednoduché třídy a dávají vám flexibilitu potřebnou pro aplikace v reálném světě.

Jejich pochopení je důležité pro několik běžných scénářů: **injektování nesamostatných hodnot** (objekty konfigurace, konstanty) přes `useValue` a řetězcové/Symbol tokeny (protože nemůžete injektovat rozhraní nebo prosté hodnoty podle typu); **dynamické/asynchronní vytváření poskytovatele** přes `useFactory` (nejsilnější forma — vytváření databázových připojení, Redis klientů nebo instancí SDK třetích stran nakonfigurovaných z hodnot za běhu, s vlastními injektovanými závislostmi); a **výměna implementací** přes `useClass` za tokenem (umožňuje implementace založené na prostředí a, zásadně, jednoduché **mockování v testech** — poskytnutí mock třídy pro token bez dotýkání se spotřebitelů).

Tato flexibilita je to, co činí DI v NestJS účinným pro produkční architekturu a vynikající testovatelnost.

Znalost čtyř typů poskytovatelů (`useClass`, `useValue`, `useFactory`, `useExisting`), toho, jak injekční tokeny fungují pro nesamostatné závislosti, a kdy sáhnout po každém z nich je důležitým krokem za základní DI — je to tak, jak zapojujete databáze, externí služby, konfiguraci a vyměnitelné/mockované závislosti idiomatickým způsobem NestJS, což z toho činí často potřebné, architektonicky významné téma v reálných aplikacích.