Dynamische modules zijn modules die kunnen worden geconfigureerd wanneer ze worden geïmporteerd — in plaats van een statische @Module({...}), stellen ze statische methoden bloot (conventioneel forRoot en ) die een module retourneren die is geconfigureerd met de argumenten die je doorgeeft. Dit is hoe configureerbare, herbruikbare modules (config, database, JWT) opties accepteren.
forFeatureA 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.
@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 {}
De .forRoot()/.register()/.forFeature() aanroepen die je ziet bij het importeren van modules zijn dynamische-module methoden die configuratie accepteren.
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)
De conventie: forRoot voor globale/eenmalige configuratie; forFeature voor per-feature registratie die je in meerdere modules aanroept.
@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" })
De statische methode retourneert een DynamicModule object (module + providers + exports), waarbij de doorgegeven opties in de providers van de module worden bedraden (vaak via een injection token).
// configure using OTHER injected dependencies (e.g. ConfigService) — async/factory
StorageModule.forRootAsync({
useFactory: (config: ConfigService) => ({ bucket: config.get("BUCKET") }),
inject: [ConfigService],
});
De forRootAsync variant stelt je in staat om configuratie afhankelijk te maken van andere providers (zoals ConfigService) — essentieel wanneer opties afkomstig zijn van gevalideerde configuratie.
Dynamische modules en het forRoot/forFeature patroon zijn een belangrijk NestJS-concept voor het bouwen van configureerbare, herbruikbare modules — en het begrijpen ervan is waardevol zowel voor het gebruiken van het ecosysteem als voor het bouwen van gedeelde modules.
Bijna elke grote NestJS module (ConfigModule, TypeOrmModule, JwtModule, BullModule, CacheModule) is een dynamische module die is geconfigureerd via .forRoot()/.register()/.forFeature(), dus het herkennen wat deze aanroepen zijn (het doorgeven van configuratie aan een module bij import time, in plaats van een statische import) maakt duidelijk hoe het hele ecosysteem is bedraden.
De forRoot vs forFeature conventie (forRoot voor eenmalige globale setup zoals een database connection of secret; forFeature voor per-feature registratie zoals het registreren van entities in elke module) is een patroon dat je voortdurend tegenkomt.
Voor senior developers is weten hoe je je eigen dynamische modules bouwt (een DynamicModule retourneren met providers die zijn geconfigureerd op basis van doorgegeven opties, vaak via injection tokens, met async varianten voor config-afhankelijke setup) wat je in staat stelt om herbruikbare, configureerbare modules te creëren — gedeelde infrastructuur (opslag, externe API clients, aangepaste config) die andere delen van een app of andere projecten importeren met hun eigen instellingen.
Dit is een meer geavanceerd onderwerp, maar het is fundamenteel voor het diep begrijpen van NestJS's modulaire architectuur en voor het bouwen van professionele, herbruikbare module libraries, waardoor het een belangrijke mogelijkheid is voor het ontwerpen van grote, goed gestructureerde NestJS-systemen.