Dynamic module และแพทเทิร์น forRoot/forFeature คืออะไร?

Question

Accepted Answer

**Dynamic module** คือ module ที่สามารถ **ตั้งค่าได้ตอน import** แทนที่จะเป็น `@Module({...})` แบบ static มันเปิดเผย static method (ตามธรรมเนียมคือ **`forRoot`** และ **`forFeature`**) ที่คืน module ซึ่งถูกตั้งค่าด้วย argument ที่คุณส่งเข้าไป นี่คือวิธีที่ module ที่ตั้งค่าได้และนำกลับมาใช้ใหม่ได้ (config, database, JWT) รับตัวเลือกเข้ามา

## ปัญหาที่มันช่วยแก้

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

## คุณใช้มันมาแล้ว

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

การเรียก `.forRoot()`/`.register()`/`.forFeature()` ที่คุณเห็นตอน import module คือ method ของ dynamic module ที่รับ configuration เข้ามา

## ธรรมเนียม forRoot เทียบกับ 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)
```

ธรรมเนียมคือ: `forRoot` สำหรับการตั้งค่าครั้งเดียวแบบ global; `forFeature` สำหรับการลงทะเบียนเฉพาะ feature ที่คุณเรียกในหลาย module

## การสร้าง dynamic module ของคุณเอง

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

static method จะคืนออบเจ็กต์ `DynamicModule` (module + provider + export) โดยเชื่อมตัวเลือกที่ส่งเข้ามาเข้ากับ provider ของ module (มักผ่าน injection token)

## การตั้งค่าแบบ async (forRootAsync)

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

รูปแบบ `forRootAsync` ให้ configuration ขึ้นอยู่กับ provider อื่นได้ (เช่น `ConfigService`) ซึ่งจำเป็นเมื่อตัวเลือกมาจาก configuration ที่ผ่านการ validate แล้ว

## ทำไมจึงสำคัญ

Dynamic module และแพทเทิร์น `forRoot`/`forFeature` เป็นแนวคิดสำคัญของ NestJS สำหรับการสร้าง **module ที่ตั้งค่าได้และนำกลับมาใช้ใหม่ได้** และการเข้าใจมันมีค่าทั้งต่อการ *ใช้* ระบบนิเวศและต่อการ *สร้าง* shared module

เกือบทุก module หลักของ NestJS (ConfigModule, TypeOrmModule, JwtModule, BullModule, CacheModule) เป็น dynamic module ที่ตั้งค่าผ่าน `.forRoot()`/`.register()`/`.forFeature()` ดังนั้นการรู้ว่าการเรียกเหล่านี้คืออะไร (การส่ง configuration ให้ module ตอน import แทนที่จะเป็นการ import แบบ static) จะคลายปริศนาว่าทั้งระบบนิเวศถูกเชื่อมโยงเข้าด้วยกันอย่างไร

**ธรรมเนียม forRoot เทียบกับ forFeature** (forRoot สำหรับการตั้งค่า global ครั้งเดียวอย่าง database connection หรือ secret; forFeature สำหรับการลงทะเบียนเฉพาะ feature อย่างการลงทะเบียน entity ในแต่ละ module) เป็นแพทเทิร์นที่คุณพบเจออยู่ตลอด

สำหรับ developer ระดับ senior การรู้วิธี **สร้าง dynamic module ของคุณเอง** (คืน `DynamicModule` พร้อม provider ที่ตั้งค่าจากตัวเลือกที่ส่งเข้ามา มักผ่าน injection token พร้อมรูปแบบ async สำหรับการตั้งค่าที่ขึ้นกับ config) คือสิ่งที่ให้คุณสร้าง module ที่นำกลับมาใช้ใหม่และตั้งค่าได้ ได้แก่ โครงสร้างพื้นฐานที่ใช้ร่วมกัน (storage, external API client, custom config) ที่ส่วนอื่นของแอปหรือโปรเจกต์อื่น import เข้ามาพร้อมการตั้งค่าของตนเอง

นี่เป็นหัวข้อขั้นสูงกว่า แต่มันเป็นพื้นฐานสำหรับการเข้าใจสถาปัตยกรรมแบบ modular ของ NestJS อย่างลึกซึ้งและสำหรับการสร้าง library ของ module ที่นำกลับมาใช้ใหม่อย่างมืออาชีพ ทำให้มันเป็นความสามารถที่สำคัญสำหรับการออกแบบระบบ NestJS ขนาดใหญ่ที่มีโครงสร้างดี