Co jsou dynamické moduly a vzor forRoot/forFeature?

Question

IT Interview Practice · 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.

Problém, který řeší

Už jste je používali

Konvence forRoot vs forFeature

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

Asynchronní konfigurace (forRootAsync)

Proč na tom záleží

Související otázky