Co jsou dynamické moduly a vzor forRoot/forFeature?

Question

Accepted Answer

**Dynamické moduly** jsou moduly, které lze **konfigurovat při importu** — místo statického `@Module({...})` vystavují statické metody (konvenčně **`forRoot`** a **`forFeature`**), které vrací modul konfigurovaný s argumenty, které předáte. Takto konfigurabilní, opakovaně použitelné moduly (config, databáze, JWT) přijímají volby.

## Problém, který řeší

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

## Už jste je používali

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

Volání `.forRoot()`/`.register()`/`.forFeature()`, která vidíte při importu modulů, jsou metody dynamických modulů přijímající konfiguraci.

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

Konvence: `forRoot` pro globální/jednorázovou konfiguraci; `forFeature` pro registraci na úrovni funkce, kterou voláte v několika modulech.

## Vytváření vlastního dynamického modulu

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

Statická metoda vrací objekt `DynamicModule` (modul + poskytovatelé + exporty), který propojuje předané volby s poskytovateli modulu (často přes injekční token).

## Asynchronní konfigurace (forRootAsync)

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

Varianta `forRootAsync` umožňuje konfiguraci závisí na jiných poskytovatelích (jako `ConfigService`) — zásadní, když volby pocházejí z ověřené konfigurace.

## Proč na tom záleží

Dynamické moduly a vzor `forRoot`/`forFeature` jsou důležitý koncept NestJS pro vytváření **konfigurovatelných, opakovaně použitelných modulů** — a jejich porozumění je cenné jak pro *používání* ekosystému, tak pro *vytváření* sdílených modulů.

Skoro každý velký modul NestJS (ConfigModule, TypeOrmModule, JwtModule, BullModule, CacheModule) je dynamický modul konfigurovaný prostřednictvím `.forRoot()`/`.register()`/`.forFeature()`, takže rozpoznání, co tato volání jsou (předávání konfigurace modulu v čase importu, místo statického importu), objasňuje, jak je celý ekosystém propojen.

**Konvence forRoot vs forFeature** (forRoot pro jednorázové globální nastavení jako připojení k databázi nebo tajemství; forFeature pro registraci na úrovni funkce, jako registraci entit v každém modulu) je vzor, se kterým se setkáváte neustále.

Pro senior vývojáře znamená znalost, jak **vytvářet vlastní dynamické moduly** (vrácení `DynamicModule` s poskytovateli konfigurovanými z předaných voleb, často přes injekční tokeny, s asynchronními variantami pro nastavení závislé na konfiguraci), že si můžete vytvářet opakovaně použitelné, konfigurovatelné moduly — sdílenou infrastrukturu (úložiště, klienty externích API, vlastní config), kterou jiné části aplikace nebo jiné projekty importují s vlastním nastavením.

Jde o pokročilejší téma, ale je to zásadní pro hluboké pochopení modulární architektury NestJS a pro vytváření profesionálních, opakovaně použitelných knihoven modulů, což z toho dělá důležitou schopnost pro navrhování velkých, dobře strukturovaných systémů NestJS.