Jak funguje dependency injection v NestJS?

Question

Accepted Answer

**Dependency Injection (DI)** je základní NestJS pattern, kde framework **automaticky vytváří a poskytuje** závislosti, které třída potřebuje, místo aby si je třída vytvářela sama. Deklarujete, co potřebujete v konstruktoru, a NestJS to dodá — výsledkem je volně vázaný, testovatelný kód.

## Jak to funguje: deklarace v konstruktoru

```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 přečte typy parametrů konstruktoru, vyhledá odpovídající registrované poskytovatele, vytvoří je (pokud ještě neexistují), a předá je — automaticky vyřeší celý graf závislostí.

## Tok DI

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

## Registrace a rozlišení

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

## Proč je DI cenné

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

## Testovatelnost — největší výhoda

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

Protože třída nevytváří své závislosti, můžete pro testování dosadit mock objekty — DI činí NestJS aplikace vysoce testovatelné.

## Injektování non-class hodnot

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

## Proč je to důležité

Dependency injection je základní pattern, na kterém spočívá celá architektura NestJS — je to způsob, jak se služby dostávají do kontrolérů, jak se do služeb dostávají repozitáře a ostatní služby, a jak je celá aplikace propojena.

Porozumění mu je nezbytné, protože se do DI zapojuje téměř každá NestJS třída: deklarujete závislosti v konstruktoru a IoC kontejner frameworku je automaticky vyřeší a poskytne, čímž se eliminuje ruční vytváření instancí a těsná vazba.

Výhody jsou značné a ústřední na to, proč je NestJS cenné: **volná vazba** (závislost na abstrakcích), **testovatelnost** (injektování mock objektů místo skutečných závislostí — usnadnění důkladného testování jednotek), opětovná použitelnost (sdílené singletony) a udržovatelnost.

DI je převzaté z frameworků jako Angular a Spring, a zvládnutí ho — jak deklarovat, registrovat, injektovat a mockovat závislosti — je nezbytné pro budování dobře strukturovaných, testovatelných NestJS aplikací a je jedním z nejdůležitějších konceptů k hlubokému pochopení v rámci frameworku.