Kako funkcionira dependency injection u NestJS-u?

Question

Accepted Answer

**Dependency Injection (DI)** je temeljni NestJS obrazac gdje framework **automatski kreira i pruža** ovisnosti koje klasa treba, umjesto da klasa sama kreira sebi. Deklarirате što vam treba u konstruktoru, a NestJS to pruža — što vodi do slabo povezane, testabilne kode.

## Kako funkcionira: deklaracija u 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 čita tipove parametara konstruktora, pronalazi odgovarajuće registrirane pružatelje, kreira ih (ako već nisu kreirani), i prosljeđuje ih — automatski rješavajući cijeli grafikon ovisnosti.

## DI tok

```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 i rješavanje

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

## Zašto je DI vrijedna

```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 — ključna 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();
```

Budući da klasa ne kreira svoje ovisnosti, možete zamijeniti mocks za testiranje — DI čini NestJS aplikacije visoko testabilnima.

## Injekcija ne-klasnih vrijednosti

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

## Zašto je to važno

Dependency injection je temeljna strategija koja podupire cijelu arhitekturu NestJS-a — to je način na koji kontroleri dobivaju usluge, usluge dobivaju spremišta i druge usluge, i kako je cijela aplikacija povezana.

Razumijevanje je bitno jer gotovo svaka NestJS klasa sudjeluje u DI: deklarirате ovisnosti u konstruktoru, a IoC spremnik frameworka ih automatski rješava i pruža, eliminirući ručnu instancijaciju i čvrsto povezivanje.

Prednosti su značajne i ključne za razloge zašto se NestJS cijeni: **slaba povezanost** (ovisnost o apstrakcijama), **testabilnost** (injekcija mocks umjesto stvarnih ovisnosti — što čini temeljito jedinično testiranje lako), ponovnu iskoristivost (dijeljena jedinka), i održavnost.

DI je posuđena iz frameworka poput Angular i Spring, i savladati je — kako deklarirati, registrirati, injecirati i ismjehati ovisnosti — nužna je za gradnju dobro strukturiranih, testabilnih NestJS aplikacija i jedan je od najvažnijih koncepata za duboko razumijevanje u frameworku.