Hvordan fungerer dependency injection i NestJS?

Question

Accepted Answer

**Dependency Injection (DI)** er et kernekoncept i NestJS, hvor frameworket **automatisk opretter og leverer** de afhængigheder, en klasse har brug for, i stedet for at klassen selv konstruerer dem. Du erklærer, hvad du har brug for, i konstruktøren, og NestJS leverer det — hvilket fører til løst koblet, testbar kode.

## Hvordan det fungerer: erklær 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 læser konstruktørens parametertyper, slår de tilsvarende registrerede providere op, opretter dem (hvis ikke allerede oprettet) og sender dem ind — og løser automatisk hele afhængighedsgrafen.

## DI-flowet

```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 oplø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 værdifuldt

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

## Testability — det afgørende fordelag

```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 afhængigheder, kan du erstatte dem med mocks til test — DI gør NestJS-applikationer meget testbare.

## Injicering af værdier, der ikke er klasser

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

## Hvorfor det betyder noget

Dependency injection er det grundlæggende mønster, der understøtter hele NestJS' arkitektur — det er sådan, controllers får services, services får repositories og andre services, og hele applikationen bliver forbundet.

At forstå det er væsentligt, fordi næsten hver NestJS-klasse deltager i DI: du erklærer afhængigheder i konstruktøren, og frameworkets IoC-container løser og leverer dem automatisk, hvilket eliminerer manuel instantiering og stram koblingen.

Fordelene er betydelige og centrale for, hvorfor NestJS værdsættes: **løs kobbling** (afhænge af abstraktion), **testability** (injicér mocks i stedet for rigtige afhængigheder — gør grundig unit test nem), gjenbrugbarhed (delte singletons) og vedligeholdbarhed.

DI er lånt fra frameworks som Angular og Spring, og at mestre det — hvordan man erklærer, registrerer, injicerer og mock'er afhængigheder — er nødvendigt for at bygge velstrukturerede, testbare NestJS-applikationer og er et af de vigtigste koncepter at forstå grundigt i frameworket.