Apakah dynamic module dan corak forRoot/forFeature?

Question

Accepted Answer

**Dynamic module** ialah modul yang boleh **dikonfigurasikan semasa diimport** — bukannya `@Module({...})` statik, ia mendedahkan kaedah statik (secara konvensyen **`forRoot`** dan **`forFeature`**) yang mengembalikan modul yang dikonfigurasikan dengan argumen yang anda hantar. Inilah cara modul yang boleh dikonfigurasikan dan boleh diguna semula (config, pangkalan data, JWT) menerima pilihan.

## Masalah yang diselesaikannya

```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 pun 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 semasa mengimport modul ialah kaedah dynamic-module yang menerima konfigurasi.

## Konvensyen forRoot lwn 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)
```

Konvensyennya: `forRoot` untuk konfigurasi global/sekali sahaja; `forFeature` untuk pendaftaran khusus ciri yang anda panggil dalam berbilang modul.

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

Kaedah statik itu mengembalikan objek `DynamicModule` (modul + provider + exports), menyambungkan pilihan yang dihantar ke dalam provider modul (selalunya melalui injection token).

## Konfigurasi async (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` membenarkan konfigurasi bergantung pada provider lain (seperti `ConfigService`) — penting apabila pilihan datang daripada konfigurasi yang disahkan.

## Mengapa ia penting

Dynamic module dan corak `forRoot`/`forFeature` ialah konsep NestJS yang penting untuk membina **modul yang boleh dikonfigurasikan dan boleh diguna semula** — dan memahaminya berharga untuk kedua-dua *menggunakan* ekosistem dan *membina* modul kongsi.

Hampir setiap modul NestJS utama (ConfigModule, TypeOrmModule, JwtModule, BullModule, CacheModule) ialah dynamic module yang dikonfigurasikan melalui `.forRoot()`/`.register()`/`.forFeature()`, jadi mengenali apa panggilan ini (menghantar konfigurasi kepada modul pada masa import, bukannya import statik) menjelaskan cara keseluruhan ekosistem disambungkan.

**Konvensyen forRoot lwn forFeature** (forRoot untuk persediaan global sekali sahaja seperti sambungan pangkalan data atau secret; forFeature untuk pendaftaran khusus ciri seperti mendaftarkan entiti dalam setiap modul) ialah corak yang anda temui secara berterusan.

Bagi pembangun senior, mengetahui cara **membina dynamic module anda sendiri** (mengembalikan `DynamicModule` dengan provider yang dikonfigurasikan daripada pilihan yang dihantar, selalunya melalui injection token, dengan varian async untuk persediaan yang bergantung pada config) ialah yang membolehkan anda mencipta modul yang boleh diguna semula dan boleh dikonfigurasikan — infrastruktur kongsi (storage, klien API luaran, config tersuai) yang diimport oleh bahagian lain aplikasi atau projek lain dengan tetapan mereka sendiri.

Ini topik yang lebih lanjutan, tetapi ia asas kepada memahami seni bina modular NestJS secara mendalam dan kepada membina pustaka modul yang profesional dan boleh diguna semula, menjadikannya satu keupayaan yang penting untuk menyeni bina sistem NestJS yang besar dan tersusun dengan baik.