Što su dinamički moduli i obrazac forRoot/forFeature?

Question

Accepted Answer

**Dinamički moduli** su moduli koji se mogu **konfigurirati pri importanju** — umjesto statičkog `@Module({...})`, izlažu statičke metode (konvencionalno **`forRoot`** i **`forFeature`**) koje vraćaju modul konfiguriran argumentima koje proslijedite. Na taj se način konfigurabilni, ponovno iskoristivi moduli (config, baza podataka, JWT) mogu prihvatiti opcije.

## Problem koji rješavaju

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

## Već ste ih koristili

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

Pozivi `.forRoot()`/`.register()`/`.forFeature()` koje vidite pri importanju modula su metode dinamičkih modula koje prihvaćaju konfiguraciju.

## forRoot nasuprot forFeature konvencije

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

Konvencija: `forRoot` za globalnu/jednokratnu konfiguraciju; `forFeature` za registraciju po značajci koju pozivate u više modula.

## Izgradnja vlastitog dinamičkog modula

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

Statička metoda vraća `DynamicModule` objekt (modul + provideri + exporti), связывајući proslijeđene opcije u providere modula (često preko tokena injekcije).

## Asinkrona konfiguracija (forRootAsync)

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

Varijanta `forRootAsync` omogućava da konfiguracija ovisi o drugim providerima (kao što je `ConfigService`) — neophodno kada opcije dolaze iz validirane konfiguracije.

## Zašto je to važno

Dinamički moduli i obrazac `forRoot`/`forFeature` su važan NestJS koncept za izgradnju **konfigurabilnih, ponovno iskoristljivih modula** — i razumijevanje njih je dragocjeno kako za *korištenje* ekosustava tako i za *izgradnju* dijeljenih modula.

Skoro svaki glavni NestJS modul (ConfigModule, TypeOrmModule, JwtModule, BullModule, CacheModule) je dinamički modul konfiguriran preko `.forRoot()`/`.register()`/`.forFeature()`, pa prepoznavanje što su ti pozivi (proslijeđivanje konfiguracije modulu pri importanju, umjesto statičkog importanja) pojašnjava kako je cijeli ekosustav spojen.

**Konvencija forRoot nasuprot forFeature** (forRoot za jednokratnu globalnu postavu kao što je veza s bazom podataka ili tajnom; forFeature za registraciju po značajci kao što je registracija entiteta u svakom modulu) je obrazac s kojim se stalno susrećete.

Za senior razvijače, znanje kako **izgraditi vlastite dinamičke module** (vraćanje `DynamicModule` objekta s providerima konfiguriranim iz proslijeđenih opcija, često preko tokena injekcije, sa asinkronim varijantama za postavu koja ovisi o konfiguraciji) je ono što vam omogućava izgradnju ponovno iskoristivih, konfigurabilnih modula — dijeljene infrastrukture (pohrana, klijenti vanjskih API-ja, prilagođena konfiguracija) koju drugi dijelovi aplikacije ili drugi projekti importaju sa svojim postavama.

Ovo je naprednije gradivo, ali temeljno je za duboko razumijevanje NestJS-ove modularne arhitekture i za izgradnju profesionalnih, ponovno iskoristivih biblioteka modula, čineći to važnom mogućnošću za arhitekturiranje velikih, dobro strukturiranih NestJS sustava.