Kako deluje dependency injection v NestJS-u?

Question

Accepted Answer

**Dependency Injection (DI)** je osnovni NestJS vzorec, pri katerem **okvir samodejno ustvari in zagotavlja** odvisnosti, ki jih razred potrebuje, namesto da bi jih razred ustvaril sam. Deklariramo, kaj potrebujemo v konstruktorju, in NestJS ga zagotovi — rezultat je slabo sklopljena in testabilna koda.

## Kako deluje: deklaracija v konstruktorju

```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 prebere vrste parametrov konstruktorja, poišče ustrezne registrirane ponudnike, jih ustvari (če še niso), in jih prosledi — samodejno reševanje celotnega grafa odvisnosti.

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

## Registracija in razrešitev

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

## Zakaj je DI dragocen

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

## Testabilnost — glavna prednost

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

Ker razred ne konstruira svojih odvisnosti, lahko v testih zamenjamo z napačnimi predmeti — DI naredi NestJS aplikacije zelo testabilne.

## Vbrizgavanje vrednosti, ki niso razredi

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

## Zakaj je to pomembno

Dependency injection je temeljni vzorec, ki je osnova celotne NestJS arhitekture — tako je način, na katerega krmilniki dobijo storitve, storitve dobijo repozitorije in druge storitve, in kako je celotna aplikacija povezana.

Razumevanje je bistvenega pomena, ker se v DI-ju vsak NestJS razred udeležuje: v konstruktorju deklariramo odvisnosti, IoC kontejner ogrodja pa jih samodejno razreši in zagotovi, kar odpravlja ročno instanciranje in tesno sklapljanje.

Korist je velika in osrednja razlogi, zakaj je NestJS cenjen: **slaba sklapljanje** (odvisnost od abstrakcij), **testabilnost** (vbrizgavanje napačnih predmetov namesto resničnih odvisnosti — omogoča preprosto temeljito testiranje enot), ponovno uporabnost (deljeni singleton-i) in vzdrževanje.

DI je izposojen iz ogrodij kot Angular in Spring, in obvladovanje — kako deklarirati, registrirati, vbrizgavati in napačne odvisnosti — je potrebno za gradnjo dobro strukturiranih in testabilnih NestJS aplikacij ter je eden najpomembnejših konceptov za globoko razumevanje v ogrodju.