Hur fungerar dependency injection i NestJS?

Question

Accepted Answer

**Dependency Injection (DI)** är ett kärnmönster i NestJS där ramverket **automatiskt skapar och tillhandahåller** de beroenden som en klass behöver, snarare än att klassen själv konstruerar dem. Du deklarerar vad du behöver i konstruktorn, och NestJS levererar det — vilket leder till löst kopplad, testbar kod.

## Så fungerar det: deklarera i konstruktorn

```ts
@Injectable()
export class UsersService {
  // declare dependencies as constructor parameters — Nest injects them
  constructor(
    private readonly db: DatabaseService,
    private readonly logger: LoggerService,
  ) {}
  // you NEVER write `new DatabaseService()` — Nest creates and provides it
}
```

Nest läser konstruktorns parametertyper, söker upp motsvarande registrerade providers, skapar dem (om de inte redan finns) och skickar dem in — automatiskt löser den hela beroendegrafen.

## DI-flödet

```text
1. A class is marked @Injectable() → it's a provider
2. The provider is registered in a module's `providers` array
3. Another class declares it as a constructor parameter
4. NestJS's IoC container resolves and INJECTS the instance automatically
```

## Registrering och resolution

```ts
@Module({
  providers: [UsersService, DatabaseService, LoggerService],  // register all providers
  controllers: [UsersController],
})
export class UsersModule {}
// Nest's container now knows how to construct each and inject them where needed
```

## Varför DI är värdefullt

```text
✓ Loose coupling — classes depend on ABSTRACTIONS, not on constructing concrete deps
✓ Testability — inject MOCK dependencies in tests easily (no real DB needed)
✓ Reusability — one shared instance (singleton) used across the app
✓ Maintainability — change an implementation in one place (the module registration)
```

## Testbarhet — superkraften

```ts
// in a test, provide a fake DatabaseService — no real database required
const module = await Test.createTestingModule({
  providers: [
    UsersService,
    { provide: DatabaseService, useValue: mockDatabase },  // inject a mock
  ],
}).compile();
```

Eftersom klassen inte konstruerar sina beroenden kan du byta ut dem mot mocks för testning — DI gör NestJS-applikationer mycket testbara.

## Injicera icke-klassvärden

```ts
// use injection tokens for config/values, not just classes
constructor(@Inject("CONFIG") private config: AppConfig) {}
```

## Varför det spelar roll

Dependency injection är det grundläggande mönster som ligger till grund för NestJS hela arkitektur — det är hur kontroller får tjänster, tjänster får arkiv och andra tjänster, och hela applikationen kopplas samman.

Att förstå det är väsentligt eftersom nästan varje NestJS-klass deltar i DI: du deklarerar beroenden i konstruktorn och ramverkets IoC-container löser och tillhandahåller dem automatiskt, vilket eliminerar manuell instansiering och tight coupling.

Förmånerna är betydande och centrala till varför NestJS är värderat: **löst koppling** (beroende på abstraktioner), **testbarhet** (injicera mocks istället för riktiga beroenden — vilket gör grundlig enhetstestning enkel), återanvändbarhet (delade singeltons) och underhållbarhet.

DI är lånat från ramverk som Angular och Spring, och att bemästra det — hur man deklarerar, registrerar, injicerar och mockar beroenden — är nödvändigt för att bygga väl strukturerade, testbara NestJS-applikationer och är ett av de viktigaste begreppen att förstå djupt i ramverket.