Kepiye cara kerja injeksi ketergantungan ing NestJS?

Question

Accepted Answer

**Dependency Injection (DI)** minangka pola inti NestJS ing ngendi framework **sacara otomatis nggawe lan nyedhiyani** ketergantungan sing kibutuhake kelas kasebut, tinimbang kelas kasebut nggawe dheweke dhewe. Sampeyan nyatakake apa sing kibutuhake ing konstruktor, lan NestJS nyedhiyakake — ndadékaké kode sing loosely-coupled lan testable.

## Kepiye cara kerjane: nyatakake ing konstruktor

```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 maca tipe parameter konstruktor, nggoleki provider sing kadhaftar sing cocog, nggawakake (yen durung), lan nglalasake - nggedhekake grafo ketergantungan kabeh kanthi otomatis.

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

## Pendaftaran lan resolusi

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

## Napa DI iku berharga

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

## Testability — kauntungan sing paling penting

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

Amarga kelas ora nggawe ketergantungane, sampeyan bisa nggantos mocks kanggo testing — DI ndadékaké aplikasi NestJS sing highly testable.

## Injeksi nilai non-kelas

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

## Napa iku penting

Injeksi ketergantungan minangka pola dasar sing ngedheng-edheng arsitektur kabeh NestJS — cara controller njaluk layanan, layanan njaluk repository lan layanan liya, lan aplikasi kabeh dikoneksikake.

Ngerten iki penting amarga meh kabeh kelas NestJS nglibatake DI: sampeyan nyatakake ketergantungan ing konstruktor lan IoC container framework nglalasake lan nyedhiyakake secara otomatis, ngilangi instantiasi manual lan tight coupling.

Kauntungan iku significant lan penting banget kanggo alasan NestJS dihargai: **loose coupling** (gumantung ing abstraksi), **testability** (injeksi mocks tinimbang ketergantungan nyata — ndadékaké unit testing sing lengkap itu gampang), reusability (singleton sing diobong), lan maintainability.

DI dijupuk saka framework kaya Angular lan Spring, lan mahir iku — cara nyatakake, ndaftar, injeksi, lan mock ketergantungan — perlu kanggo nggawe aplikasi NestJS sing terstruktur lan testable kanthi apik, lan minangka salah sawijining konsep paling penting sing kudu dimangerteni kanthi jero ing framework.