Apa itu dynamic modules dan pola forRoot/forFeature?

Question

Accepted Answer

**Dynamic modules** adalah modul yang dapat **dikonfigurasi saat diimpor** — alih-alih decorator statis `@Module({...})`, mereka mengekspos method statis (secara konvensional **`forRoot`** dan **`forFeature`**) yang mengembalikan modul yang dikonfigurasi dengan argumen yang Anda berikan. Ini adalah cara modul yang dapat dikonfigurasi dan dapat digunakan kembali (config, database, JWT) menerima opsi.

## Masalah yang mereka selesaikan

```text
A static module is fixed — but reusable modules (DatabaseModule, ConfigModule,
JwtModule) need to be CONFIGURED per app (connection URL, secret, options).
Dynamic modules let a module accept configuration at import time.
```

## Anda sudah menggunakannya

```ts
@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),               // ← forRoot with options
    TypeOrmModule.forRoot({ type: "postgres", url: ... }),  // ← configured at import
    JwtModule.register({ secret: process.env.SECRET }),      // ← register variant
    TypeOrmModule.forFeature([User, Post]),                  // ← forFeature for specifics
  ],
})
export class AppModule {}
```

Panggilan `.forRoot()`/`.register()`/`.forFeature()` yang Anda lihat saat mengimpor modul adalah method dynamic-module yang menerima konfigurasi.

## Konvensi forRoot vs forFeature

```text
forRoot()    → configure the module ONCE, globally (the connection, the secret, core setup)
               called in the root/app module a single time
forFeature() → register feature-specific pieces in each feature module that needs them
               (e.g. TypeOrmModule.forFeature([User]) registers entities per module)
```

Konvensi: `forRoot` untuk konfigurasi global/satu kali; `forFeature` untuk registrasi per-fitur yang Anda panggil di beberapa modul.

## Membangun dynamic module Anda sendiri

```ts
@Module({})
export class StorageModule {
  static forRoot(options: StorageOptions): DynamicModule {
    return {                                  // returns a configured module
      module: StorageModule,
      providers: [
        { provide: "STORAGE_OPTIONS", useValue: options },   // inject the passed options
        StorageService,
      ],
      exports: [StorageService],
      global: true,                            // optionally make it global
    };
  }
}
// usage: StorageModule.forRoot({ bucket: "my-bucket", region: "us-east-1" })
```

Method statis mengembalikan objek `DynamicModule` (modul + providers + exports), menghubungkan opsi yang dilewatkan ke providers modul (sering kali melalui injection token).

## Konfigurasi asinkron (forRootAsync)

```ts
// configure using OTHER injected dependencies (e.g. ConfigService) — async/factory
StorageModule.forRootAsync({
  useFactory: (config: ConfigService) => ({ bucket: config.get("BUCKET") }),
  inject: [ConfigService],
});
```

Varian `forRootAsync` memungkinkan konfigurasi bergantung pada provider lain (seperti `ConfigService`) — penting ketika opsi berasal dari konfigurasi yang divalidasi.

## Mengapa ini penting

Dynamic modules dan pola `forRoot`/`forFeature` adalah konsep NestJS yang penting untuk membangun **modul yang dapat dikonfigurasi dan dapat digunakan kembali** — dan memahaminya berharga baik untuk *menggunakan* ekosistem maupun untuk *membangun* modul yang dibagikan.

Hampir setiap modul NestJS utama (ConfigModule, TypeOrmModule, JwtModule, BullModule, CacheModule) adalah dynamic module yang dikonfigurasi melalui `.forRoot()`/`.register()`/`.forFeature()`, jadi mengenali apa panggilan ini (melewatkan konfigurasi ke modul pada waktu impor, bukan impor statis) menjelaskan cara seluruh ekosistem terhubung.

Konvensi **forRoot vs forFeature** (forRoot untuk setup global satu kali seperti koneksi database atau rahasia; forFeature untuk registrasi per-fitur seperti mendaftarkan entitas di setiap modul) adalah pola yang Anda temui terus-menerus.

Untuk developer senior, mengetahui cara **membangun dynamic modules Anda sendiri** (mengembalikan `DynamicModule` dengan providers yang dikonfigurasi dari opsi yang dilewatkan, sering kali melalui injection tokens, dengan varian asinkron untuk setup yang bergantung pada config) adalah yang memungkinkan Anda membuat modul yang dapat digunakan kembali dan dapat dikonfigurasi — infrastruktur bersama (penyimpanan, klien API eksternal, config khusus) yang dapat diimpor bagian lain dari aplikasi atau proyek lain dengan pengaturan mereka sendiri.

Ini adalah topik yang lebih advanced, tetapi fundamental untuk memahami arsitektur modular NestJS secara mendalam dan untuk membangun library modul yang professional dan dapat digunakan kembali, menjadikannya kemampuan penting untuk merancang sistem NestJS yang besar dan terstruktur dengan baik.