Jak działa dependency injection w NestJS?

Question

Accepted Answer

**Dependency Injection (DI)** to podstawowy wzorzec NestJS, w którym framework **automatycznie tworzy i dostarcza** zależności, których klasa potrzebuje, zamiast aby klasa sama je konstruowała. Deklarujesz, co potrzebujesz w konstruktorze, a NestJS to dostarcza — co prowadzi do luźno powiązanego, testowanego kodu.

## Jak to działa: zadeklaruj w konstruktorze

```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 odczytuje typy parametrów konstruktora, wyszukuje odpowiadające zarejestrowane providery, je tworzy (jeśli jeszcze nie istnieją) i je przekazuje — automatycznie rozwiązując cały graf zależności.

## Przepływ 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
```

## Rejestracja i rozwiązywanie

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

## Dlaczego to ważne

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

## Testowalnośćl — największa zaleta

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

Ponieważ klasa nie konstruuje swoich zależności, możesz podstawić mocki do testowania — DI czyni aplikacje NestJS wysoce testowalne.

## Wstrzykiwanie nieklasmowych wartości

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

## Dlaczego to ważne

Dependency injection to podstawowy wzorzec leżący u podstaw całej architektury NestJS — to sposób, w jaki kontrolery otrzymują serwisy, serwisy otrzymują repozytoria i inne serwisy, i cała aplikacja jest ze sobą powiązana.

Zrozumienie tego jest niezbędne, ponieważ prawie każda klasa w NestJS uczestniczy w DI: deklarujesz zależności w konstruktorze, a kontener IoC frameworka automatycznie je rozwiązuje i dostarcza, eliminując ręczną instancjację i ścisłe powiązanie.

Korzyści są znaczące i centralne dla tego, dlaczego NestJS jest ceniony: **luźne powiązanie** (zależy od abstrakcji), **testowalnośćl** (wstrzykiwanie mocków zamiast rzeczywistych zależności — ułatwiające gruntowne testowanie jednostkowe), możliwość ponownego użycia (wspólne singletony) i łatwe utrzymanie.

DI jest zapożyczone z frameworków takich jak Angular i Spring, a opanowanie tego — jak deklarować, rejestrować, wstrzykiwać i mockować zależności — jest niezbędne do budowania dobrze ustrukturyzowanych, testowanych aplikacji NestJS i jest jednym z najważniejszych koncepcji do głębokoiego zrozumienia w frameworku.