Ce sunt furnizorii personalizați și tokenurile de injecție?

Question

Accepted Answer

Dincolo de clasele simple `@Injectable()`, NestJS suportă **furnizorii personalizați** — modalități flexibile de a defini ce se injectează — folosind **tokenurile de injecție**. Aceasta vă permite să injectați valori, să configurați modul în care sunt create instanțele, să schimbați implementările și să injectați dependențe non-class.

## Cele patru tipuri de furnizorii personalizați

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

## Tokenurile de injecție — pentru dependențele non-class

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

Din moment ce nu puteți injecta o interfață sau o valoare simplă după tip (acestea nu există la runtime), utilizați un **token** (un șir de caractere sau un `Symbol`) cu `@Inject(token)` pentru a-l injecta. Aceasta este modul în care injectați obiecte de configurare, clienți terților sau dependențe tipizate cu interfață.

## useFactory — cel mai puternic (setup dinamic, asincron)

```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` execută o funcție (cu dependințe injectate) pentru a produce furnizorul — esențial pentru conexiuni, clienți sau orice ce necesită configurare la runtime sau setup asincron.

## Schimbarea implementărilor (useClass) — flexibilitate și testare

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

Deoarece consumatorii depind de token (`PaymentService`), puteți schimba clasa concretă — un serviciu Stripe real în producție, un mock în teste — fără a schimba codul consumator.

## De ce conteaza

Furnizorii personalizați și tokenurile de injecție extind injecția de dependență a NestJS dincolo de clasele simple, oferindu-vă flexibilitatea necesară pentru aplicațiile din lumea reală.

Înțelegerea lor este importantă pentru mai multe scenarii frecvente: **injectarea valorilor non-class** (obiecte de configurare, constante) prin `useValue` și tokenuri șir/Symbol (deoarece nu puteți injecta interfețe sau valori simple după tip); **crearea furnizorului dinamic/asincron** prin `useFactory` (cea mai puternică formă — crearea conexiunilor la baze de date, clienți Redis sau instanțe SDK terților configurate din valori la runtime, cu propriile lor dependințe injectate); și **schimbarea implementărilor** prin `useClass` în spatele unui token (permiții implementări bazate pe mediu și, crucialmente, **mocking ușor în teste** — furnizați o clasă mock pentru un token fără a atinge consumatorii).

Această flexibilitate este ceea ce face injecția de dependență a NestJS puternică pentru arhitectura de producție și excelentă testabilitate.

Cunoașterea celor patru tipuri de furnizorii (`useClass`, `useValue`, `useFactory`, `useExisting`), modul în care funcționează tokenurile de injecție pentru dependențele non-class și când să recurgeți la fiecare este un pas important dincolo de injecția de dependență de bază — aceasta este modul în care conectați baze de date, servicii externe, configurare și dependențe schimbabile/mockable în modul idiomativ al NestJS, făcând-o o temă frecvent necesară și semnificativă din punct de vedere arhitectural în aplicațiile reale.