Los módulos dinámicos son módulos que pueden ser configurados cuando se importan — en lugar de un @Module({...}) estático, exponen métodos estáticos (convencionalmente forRoot y ) que retornan un módulo configurado con los argumentos que pasas. Así es como los módulos configurables y reutilizables (config, database, JWT) aceptan opciones.
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 {}
Las llamadas .forRoot()/.register()/.forFeature() que ves al importar módulos son métodos de módulos dinámicos que aceptan configuración.
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)
La convención: forRoot para configuración global/única; forFeature para registro por característica que llamas en múltiples módulos.
@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" })
El método estático retorna un objeto DynamicModule (módulo + providers + exports), conectando las opciones pasadas en los providers del módulo (a menudo mediante un injection token).
// configure using OTHER injected dependencies (e.g. ConfigService) — async/factory
StorageModule.forRootAsync({
useFactory: (config: ConfigService) => ({ bucket: config.get("BUCKET") }),
inject: [ConfigService],
});
La variante forRootAsync permite que la configuración dependa de otros providers (como ConfigService) — esencial cuando las opciones provienen de una configuración validada.
Los módulos dinámicos y el patrón forRoot/forFeature son un concepto importante de NestJS para construir módulos configurables y reutilizables — y comprenderlos es valioso tanto para usar el ecosistema como para construir módulos compartidos.
Casi todos los módulos principales de NestJS (ConfigModule, TypeOrmModule, JwtModule, BullModule, CacheModule) son módulos dinámicos configurados mediante .forRoot()/.register()/.forFeature(), por lo que reconocer qué son estas llamadas (pasar configuración a un módulo en tiempo de importación, en lugar de una importación estática) desmitifica cómo está conectado todo el ecosistema.
La convención forRoot vs forFeature (forRoot para configuración global única como una conexión a base de datos o secreto; forFeature para registro por característica como registrar entidades en cada módulo) es un patrón que encuentras constantemente.
Para desarrolladores senior, saber cómo construir tus propios módulos dinámicos (retornando un DynamicModule con providers configurados a partir de opciones pasadas, a menudo mediante injection tokens, con variantes asincrónicas para configuración dependiente) es lo que te permite crear módulos reutilizables y configurables — infraestructura compartida (almacenamiento, clientes de API externos, configuración personalizada) que otras partes de una aplicación u otros proyectos importan con sus propias configuraciones.
Este es un tema más avanzado, pero es fundamental para entender profundamente la arquitectura modular de NestJS y para construir librerías de módulos profesionales y reutilizables, convirtiéndolo en una capacidad importante para arquitectar sistemas NestJS grandes y bien estructurados.