Apa iku modul dinamis lan pola forRoot/forFeature?

Question

Accepted Answer

**Modul dinamis** yaiku modul sing bisa **dikonfigurasi nalika diimpor** — tinimbang `@Module({...})` sing statis, luwih-luwih nampilake metode statis (konvensional **`forRoot`** lan **`forFeature`**) sing mengembaliak modul sing dikonfigurasi kanthi argumen sing sampeyan kirim. Iki carane modul sing bisa dikonfigurasi lan digunakake maneh (config, database, JWT) nampa opsi.

## Masalah sing ditatasi

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

## Sampeyan wis ngguna

```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()` sing sampeyan delok nalika ngimpor modul yaiku metode modul dinamis nampa konfigurasi.

## Konvensional forRoot lan 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)
```

Konvensional: `forRoot` kanggo konfigurasi global/sak-sapisan; `forFeature` kanggo registrasi per-feature sing sampeyan bisa diarani ing pirang-pirang modul.

## Bangun modul dinamis dhewe

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

Metode statis mengembaliak obyek `DynamicModule` (modul + penyedia + ekspor), ngiket opsi sing kirim menyang penyedia modul (asring liwat token injeksi).

## 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` ndadekake konfigurasi bisa gumantung karo penyedia liyane (kaya `ConfigService`) — penting banget nalika opsi teka saka konfigurasi sing wis disahresi.

## Iku pentinge

Modul dinamis lan pola `forRoot`/`forFeature` yaiku konsep NestJS penting kanggo bangun **modul sing bisa dikonfigurasi lan digunakake maneh** — lan mangerti iku berharga kanggo *nggunakake* ekosistem lan kanggo *bangun* modul sing diparingan.

Sapersi modul NestJS gedhé-gedhe (ConfigModule, TypeOrmModule, JwtModule, BullModule, CacheModule) yaiku modul dinamis sing dikonfigurasi liwat `.forRoot()`/`.register()`/`.forFeature()`, dadi ngenali panggonan punika (ngirim konfigurasi menyang modul nalika impor, tinimbang impor statis) bakal gampang mangerti carane kabeh ekosistem dipasang.

Konvensional **forRoot lan forFeature** (forRoot kanggo setup global sak-sapisan kaya sambungan database utawa rahasia; forFeature kanggo registrasi per-feature kaya mendaftar entitas ing saben modul) yaiku pola sing lagi-lagi sampeyan ketemu.

Kanggo pengembang senior, ngerti carane **bangun modul dinamis dhewe** (mengembaliak `DynamicModule` kanthi penyedia sing dikonfigurasi saka opsi sing kirim, asring liwat token injeksi, kanthi variasi asinkron kanggo setup sing gumantung konfigurasi) yaiku sing ndadekake sampeyan bisa bangun modul sing bisa digunakake maneh lan bisa dikonfigurasi — infrastruktur sing diparingan (panyimpen, klien API eksternal, config ubahan) sing bagean liyane saka aplikasi utawa proyek liyane impor kanthi setelan dhewe.

Iki topik sing luwih maju, nanging iku dhasar kanggo mangerti arsitektur modular NestJS kanthi jero lan kanggo bangun pustaka modul sing propesional lan bisa digunakake maneh, ndadekake iku kapabilitas penting kanggo merancang sistem NestJS gedhé lan terstruktur kanthi becik.