Bagaimana cara kerja dependency injection di NestJS?

Question

Accepted Answer

**Dependency Injection (DI)** adalah pola inti NestJS di mana framework **secara otomatis membuat dan menyediakan** dependencies yang dibutuhkan oleh sebuah class, bukan class itu sendiri yang membuatnya. Anda mendeklarasikan apa yang Anda butuhkan di constructor, dan NestJS menyediakannya — menghasilkan kode yang loosely-coupled dan testable.

## Cara kerjanya: deklarasi di constructor

```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 membaca tipe parameter constructor, mencari provider terdaftar yang sesuai, membuatnya (jika belum ada), dan meneruskannya — secara otomatis menyelesaikan seluruh dependency graph.

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

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

## Mengapa DI 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 — manfaat utama

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

Karena class tidak membuat dependencies-nya sendiri, Anda dapat mengganti dengan mocks untuk testing — DI membuat aplikasi NestJS sangat testable.

## Memasukkan nilai non-class

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

## Mengapa ini penting

Dependency injection adalah pola fundamental yang mendasari seluruh arsitektur NestJS — ini adalah cara controllers mendapatkan services, services mendapatkan repositories dan services lain, dan seluruh aplikasi terhubung bersama.

Memahaminya penting karena hampir setiap class NestJS berpartisipasi dalam DI: Anda mendeklarasikan dependencies di constructor dan IoC container framework secara otomatis menyelesaikan dan menyediakannya, menghilangkan instantiasi manual dan tight coupling.

Manfaatnya signifikan dan sentral untuk alasan mengapa NestJS dihargai: **loose coupling** (bergantung pada abstractions), **testability** (injeksi mocks alih-alih dependencies nyata — membuat thorough unit testing mudah), reusability (singletons bersama), dan maintainability.

DI dipinjam dari frameworks seperti Angular dan Spring, dan menguasainya — cara mendeklarasikan, mendaftarkan, menginjeksi, dan memocking dependencies — diperlukan untuk membangun aplikasi NestJS yang terstruktur dengan baik dan testable, dan merupakan salah satu konsep paling penting untuk dipahami secara mendalam dalam framework.