Što su prilagođeni pružatelji i tokeni za injekciju?

Question

Accepted Answer

Izvan jednostavnih `@Injectable()` klasa, NestJS podržava **prilagođene pružatelje** — fleksibilne načine za definiranje što se injecira — koristeći **tokene za injekciju**. To vam omogućava injekciju vrijednosti, konfiguraciju kako se instance kreiraju, zamjenu implementacija, i injekciju ovisnosti koje nisu klase.

## Četiri tipa prilagođenih pružatelja

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

## Tokeni za injekciju — za ovisnosti koje nisu klase

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

Budući da ne možete injecirati sučelje ili običnu vrijednost po tipu (ne postoje u runtime-u), koristite **token** (string ili `Symbol`) s `@Inject(token)` da biste ga injecirali. Na ovaj način injecirate objekte konfiguracije, klijente treće strane, ili ovisnosti tipizirane sučeljem.

## useFactory — najmoćnija (dinamička, asinkrona postavka)

```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` pokreće funkciju (s injeciranim ovisnostima) da bi proizveo pružatelja — neophodno za konekcije, klijente, ili bilo što što trebate runtime konfiguraciju ili asinkronu postavku.

## Zamjena implementacija (useClass) — fleksibilnost & testiranje

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

Budući da konzumenti ovise o tokenu (`PaymentService`), možete zamijeniti konkretnu klasu — prava Stripe usluga u produkciji, mock u testovima — bez promjene bilo kojeg konzumnog koda.

## Zašto je važno

Prilagođeni pružatelji i tokeni za injekciju proširuju NestJS-ovu injekciju ovisnosti izvan jednostavnih klasa, dajući vam fleksibilnost potrebnu za aplikacije u stvarnom svijetu.

Razumijevanje ih je važno za nekoliko čestih scenarija: **injekcija vrijednosti koje nisu klase** (objekti konfiguracije, konstante) preko `useValue` i string/Symbol tokena (jer ne možete injecirati sučelja ili obične vrijednosti po tipu); **dinamička/asinkrona kreiranja pružatelja** preko `useFactory` (najmoćniji oblik — kreiranje konekcija baze podataka, Redis klijenta, ili instanci SDK-a treće strane konfigurirane iz runtime vrijednosti, s vlastitim injeciranim ovisnostima); i **zamjena implementacija** preko `useClass` iza tokena (omogućavanje implementacija ovisnih o okruženju i, ključno, lako **mockiranje u testovima** — pružanje mock klase za token bez dodira sa konzumentima).

Ova fleksibilnost je ono što čini NestJS-ovu injekciju ovisnosti moćnom za produkcijsku arhitekturu i odličnom testabilnošću.

Znanje četiri tipa pružatelja (`useClass`, `useValue`, `useFactory`, `useExisting`), kako tokeni za injekciju rade za ovisnosti koje nisu klase, i kada dosegnuti za svaki je važan korak izvan osnovne injekcije ovisnosti — to je način na koji povezujete baze podataka, vanjske usluge, konfiguraciju, i ovisnosti koje je moguće zamijeniti/mockirati idiomatic NestJS način, čineći to često potrebnom, arhitekturalno značajnom temom u stvarnim aplikacijama.