Çfarë janë ofruesit të personalizuar dhe çelësat e injektimit?

Question

Accepted Answer

Përtej klasave të thjeshta `@Injectable()`, NestJS suporton **ofruesit të personalizuar** — mënyra fleksibël për të përcaktuar se çfarë injektohet — duke përdorur **çelësat e injektimit**. Kjo ju lejon të injektoni vlera, të konfiguroni se si krijohen instancat, të ndërroni implementimet, dhe të injektoni varësitë jo-klasë.

## Katër llojet e ofruesve të personalizuar

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

## Çelësat e injektimit — për varësitë jo-klasë

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

Meqenëse nuk mund të injektoni një ndërfaqe ose një vlerë të thjeshtë sipas llojit (ato nuk ekzistojnë në kohën e ekzekutimit), përdorni një **çelës** (një varg ose `Symbol`) me `@Inject(çelësi)` për ta injektuar atë. Kështu injektoni objektet e konfigurimit, klientët e palëve të treta, ose varësitë e tipizuara me ndërfaqe.

## useFactory — më i fuqishmi (setup dinamik, 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` ekzekuton një funksion (me varësi të injektuara) për të prodhuar ofruesi — thelbësor për lidhjet, klientët, ose çdo gjë që kërkon konfigurimin në kohën e ekzekutimit ose setup asinkron.

## Ndërrimi i implementimeve (useClass) — fleksibilitet & testim

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

Meqenëse konsumatorët varen nga çelësi (`PaymentService`), mund të ndërroni klasën konkrete — një shërbim real Stripe në prodhim, një mock në teste — pa ndryshuar asnjë kod konsumator.

## Pse ka rëndësi

Ofruesit të personalizuar dhe çelësat e injektimit zgjerosin injektimin e varësive të NestJS përtej klasave të thjeshta, duke ju dhënë fleksibilitetin e nevojshëm për aplikacione të botës reale.

Përmendja e tyre është e rëndësishme për disa skenare të zakonshme: **injektimi i vlerave jo-klasë** (objektet e konfigurimit, konstantet) përmes `useValue` dhe çelësave string/Symbol (pasi nuk mund të injektoni ndërfaqet ose vlerat e thjeshtë sipas llojit); **krijimi dinamik/asinkron i ofruesit** përmes `useFactory` (forma më e fuqishme — krijimi i lidhjeve të bazës së të dhënave, klientëve Redis, ose instancave të SDK-ve të palëve të treta të konfiguruar nga vlerat në kohën e ekzekutimit, me varësitë e tyre të injektuara); dhe **ndërrimi i implementimeve** përmes `useClass` pas një çelësi (duke mundësuar implementimet e bazuara në mjedis dhe, në mënyrë kritike, **mockimin e lehtë në teste** — siguroni një klasë mock për një çelës pa prekur konsumatorët).

Ky fleksibilitet është ajo që e bën DI të NestJS të fuqishëm për arkitekturën e prodhimit dhe testueshmëri të shkëlqyer.

Përfaqja e katër llojeve të ofruesve (`useClass`, `useValue`, `useFactory`, `useExisting`), se si funksionojnë çelësat e injektimit për varësitë jo-klasë, dhe kur të përdorni secilën është një hap i rëndësishëm përtej DI bazik — është ajo se si lidhni bazat e të dhënave, shërbimeve të jashtme, konfigurimin, dhe varësitë e zëvendësueshme/mockable mënyrën idiomatike të NestJS, duke e bërë atë një temë shpesh e nevojshme, arkitekturisht e rëndësishme në aplikacionet reale.