Hvordan fungerer avhengighetsinjeksjon i NestJS?

Question

Accepted Answer

**Dependency Injection (DI)** er et kjernemønster i NestJS hvor rammeverket **automatisk oppretter og leverer** avhengighetene en klasse trenger, i stedet for at klassen konstruerer dem selv. Du deklarerer hva du trenger i konstruktøren, og NestJS leverer det — noe som fører til løst koplet, testbar kode.

## Hvordan det fungerer: deklarer i konstruktøren

```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 leser konstruktørens parametertyper, slår opp de tilsvarende registrerte providerne, oppretter dem (hvis de ikke allerede finnes), og sender dem inn — automatisk oppløsning av hele avhengighetsgrafen.

## DI-flyten

```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 og oppløsning

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

## Hvorfor DI er verdifullt

```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 — kjempefordelen

```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();
```

Fordi klassen ikke konstruerer sine avhengigheter, kan du bytte inn mocks for testing — DI gjør NestJS-apper svært testbare.

## Injeksjon av ikke-klasseverdier

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

## Hvorfor det er viktig

Avhengighetsinjeksjon er det grunnleggende mønsteret som ligger til grunn for hele NestJS-arkitekturen — det er hvordan kontrollere får services, services får repositories og andre services, og hele applikasjonen er koblet sammen.

Å forstå det er essensielt fordi nesten hver NestJS-klasse deltar i DI: du deklarerer avhengigheter i konstruktøren og rammeverkets IoC-container løser og leverer dem automatisk, noe som eliminerer manuell instansiering og stram koblingen.

Fordelene er betydelige og sentrale til hvorfor NestJS er verdsatt: **løs koblings** (avheng av abstraksjoner), **testbarhet** (injiser mocks i stedet for ekte avhengigheter — noe som gjør grundig enhetstesting enkel), gjenbrukbarhet (delte singeltons), og vedlikeholdbarhet.

DI er lånt fra rammeverk som Angular og Spring, og å mestre det — hvordan du deklarerer, registrerer, injiserer og mockes avhengigheter — er nødvendig for å bygge velstrukturerte, testbare NestJS-applikasjoner og er ett av de viktigste konseptene å forstå grundig i rammeverket.