Mitä ovat mukautetut tarjoajat ja injektointitokenit?

Question

Accepted Answer

`@Injectable()` -luokkien lisäksi NestJS tukee **mukautettuja tarjoajia** — joustavia tapoja määritellä, mitä injektoidaan — käyttäen **injektointitokeneita**. Tämä mahdollistaa arvojen injektoinnin, instanssien luomisen konfiguroinnin, toteutuksien vaihtamisen ja ei-luokkatyyppiisten riippuvuuksien injektoinnin.

## Neljä mukautetun tarjoajan tyyppiä

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

## Injektointitokenit — ei-luokkaryyppisille riippuvuuksille

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

Koska et voi injektoida rajapintaa tai tavallista arvoa tyypin perusteella (niitä ei ole olemassa ajon aikana), käytät **tokenia** (merkkijonoa tai `Symbol`) yhdessä `@Inject(token)` kanssa injektoimiseen. Näin injektoit konfiguraatioobjekteja, kolmannen osapuolen asiakkaita tai rajapintaa käyttäviä riippuvuuksia.

## useFactory — tehokkain (dynaaminen, asynkroninen asetus)

```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` suorittaa funktion (injektoiduilla riippuvuuksilla) tarjoajan tuottamiseksi — välttämätöntä yhteyksille, asiakkaille tai millekään, joka tarvitsee ajon aikaista konfigurointia tai asynkronista asettamista.

## Toteutuksien vaihtaminen (useClass) — joustavuus ja testaaminen

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

Koska kuluttajat riippuvat tokenista (`PaymentService`), voit vaihtaa konkreettisen luokan — todellisen Stripe-palvelun tuotannossa, näyttelyn testeissä — muuttamatta mitään kuluttavaa koodia.

## Miksi se on tärkeää

Mukautteet tarjoajat ja injektointitokenit laajentavat NestJS:n riippuvuuksien injektointia yksinkertaisten luokkien ulkopuolelle, antaen sinulle joustavuuden, joka vaaditaan todellisissa sovelluksissa.

Niiden ymmärtäminen on tärkeää useissa tavallisissa tilanteissa: **ei-luokkaarvojen injektointi** (konfiguraatioobjektit, vakiot) `useValue`-tavalla ja merkkijono/Symbol-tokeneja käyttäen (koska et voi injektoida rajapintoja tai tavallisia arvoja tyypin perusteella); **dynaaminen/asynkroninen tarjoajan luominen** `useFactory`-tavalla (tehokkain muoto — tietokannan yhteyksien, Redis-asiakkaiden tai kolmannen osapuolen SDK-instanssien luominen, jotka konfiguroituvat ajon aikaisten arvojen perusteella, omilla injektoiduilla riippuvuuksilla); ja **toteutuksien vaihtaminen** `useClass`-tavalla tokenin takana (mahdollistaa ympäristöön perustuvia toteutuksia ja ratkaisevan tärkeää, **testien helpompaa mockaamista** — tarjoa token-mockluokka muuttamatta kuluttajia).

Tämä joustavuus on se, mikä tekee NestJS:n riippuvuuksien injektoinista tehokkaan tuotantoarkkitehtuurille ja erinomaisesti testattavaksi.

Neljän tarjoajatyypin (`useClass`, `useValue`, `useFactory`, `useExisting`) tunteminen, injektointitokeneiden toiminta ei-luokkaryyppisille riippuvuuksille ja kunkin käyttöhetki on tärkeä askel perus-riippuvuuksien injektoinnin jälkeen — näin kytket tietokantoja, ulkoisia palveluita, konfigurointia ja vaihdettavia/mockattavia riippuvuuksia idiomiaattisuudella NestJS-tavalla, mikä tekee siitä usein tarvitun, arkkitehtuurisesti merkittävän aiheen todellisissa sovelluksissa.