Hogyan működik a dependency injection a NestJS-ben?

Question

Accepted Answer

**Dependency Injection (DI)** a NestJS alapvető mintája, ahol a keretrendszer **automatikusan létrehozza és biztosítja** azokat a függőségeket, amelyekre az osztálynak szüksége van, ahelyett, hogy az osztály maga hozná létre azokat. Deklarálod a konstruktorban, hogy mire van szükséged, és a NestJS biztosítja — lazán csatolt, tesztelhető kódhoz vezet.

## Hogyan működik: deklaráció a konstruktorban

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

A Nest beolvassa a konstruktor paramétertípusait, megkeresi a megfelelő regisztrált service providereket, létrehozza őket (ha még nem léteznek), és átadja azokat — automatikusan feloldva az egész függőségi gráfot.

## A DI folyamata

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

## Regisztrálás és feloldás

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

## Miért értékes a DI

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

## Tesztelhetőség — a döntő előny

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

Mivel az osztály nem hozza létre a függőségeit, cserélhetsz mock-okat teszteléshez — a DI nagyon tesztelhetővé teszi a NestJS alkalmazásokat.

## Nem osztály értékek injektálása

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

## Miért fontos

A dependency injection az alapvető minta, amely a NestJS teljes architektúráját támogatja — így kapnak a kontrollerek service-eket, a service-ek megkapják az adattárolókat és más service-eket, és így kerül az egész alkalmazás összekapcsolásra.

Fontos megérteni, mert szinte minden NestJS osztály részt vesz a DI-ben: deklarálod a függőségeket a konstruktorban, és a keretrendszer IoC tárolója automatikusan feloldja és biztosítja azokat, kiküszöbölve a kézi instanciálást és a szoros csatolást.

Az előnyök szignifikánsak és kulcsfontosságúak abban, hogy miért becsülik a NestJS-t: **laza csatolás** (absztrakciótól függenek), **tesztelhetőség** (mock-okat injektálj valós függőségek helyett — ami könnyűvé teszi az alapos egység tesztelést), újrafelhasználhatóság (megosztott singletonok), és karbantarthatóság.

A DI az Angular és Spring keretrendszerekből kölcsönzött, és az ovládása — hogyan kell deklarálni, regisztrálni, injektálni és mockolni függőségeket — szükséges a jól strukturált, tesztelhető NestJS alkalmazások építéséhez, és az egyik legfontosabb fogalom, amit mélyen meg kell érteni a keretrendszerben.