Vad är anpassade providers och injektionstoken?

Question

Accepted Answer

Bortom enkla `@Injectable()`-klasser stöder NestJS **anpassade providers** — flexibla sätt att definiera vad som ska injiceras — med hjälp av **injektionstoken**. Detta låter dig injicera värden, konfigurera hur instanser skapas, byta implementeringar och injicera icke-klassberoenden.

## De fyra typerna av anpassade providers

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

## Injektionstoken — för icke-klassberoenden

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

Eftersom du inte kan injicera ett interface eller ett enkelt värde efter typ (de finns inte vid körtid) använder du en **token** (en sträng eller `Symbol`) med `@Inject(token)` för att injicera det. Det är så du injicerar konfigurationsobjekt, tredjepartsklienter eller interface-typade beroenden.

## useFactory — den mest kraftfulla (dynamisk, asynk konfiguration)

```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` kör en funktion (med injicerade beroenden) för att producera providern — väsentlig för anslutningar, klienter eller vad som helst som behöver körtidskonfiguration eller asynk konfiguration.

## Att byta implementeringar (useClass) — flexibilitet och testning

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

Eftersom konsumenter är beroende av token (`PaymentService`) kan du byta den konkreta klassen — en verklig Stripe-tjänst i produktion, en mock i tester — utan att ändra någon konsumerande kod.

## Varför det spelar roll

Anpassade providers och injektionstoken utökar NestJS:s beroendeinjektion bortom enkla klasser, vilket ger dig den flexibilitet som behövs för verkliga applikationer.

Det är viktigt att förstå dem för flera vanliga scenarier: **injicering av icke-klassvärden** (konfigurationsobjekt, konstanter) via `useValue` och sträng-/Symbol-token (eftersom du inte kan injicera interface eller enkla värden efter typ); **dynamisk/asynk providerskapande** via `useFactory` (den mest kraftfulla formen — att skapa databasanslutningar, Redis-klienter eller instanser av tredjepartens SDK-er konfigurerade från körtidsvärden, med sina egna injicerade beroenden); och **att byta implementeringar** via `useClass` bakom en token (möjliggörande av miljöberoende implementeringar och, avgörande, enkelt **mockning i tester** — tillhandahålla en mock-klass för en token utan att röra konsumenter).

Den här flexibiliteten är det som gör NestJS:s DI kraftfull för produktionsarkitektur och utmärkt testbarhet.

Att känna till de fyra providertypen (`useClass`, `useValue`, `useFactory`, `useExisting`), hur injektionstoken fungerar för icke-klassberoenden, och när man ska använda var och en är ett viktigt steg bortom grundläggande DI — det är hur du kopplar ihop databaser, externa tjänster, konfiguration och utbytbara/mockbara beroenden på det idiomatiska NestJS-sättet, vilket gör det till ett ofta behövt, arkitektoniskt betydelsefullt ämne i verkliga applikationer.