డైనమిక్ మాడ్యూలులు దిగుమతి చేసినప్పుడు కాన్ఫిగర్ చేయబడే మాడ్యూలులు — స్థిర @Module({...}) బదులుగా, అవి స్టాటిక్ మెథడ్లను (సాంప్రదాయకంగా forRoot మరియు ) బహిర్గతం చేస్తాయి, ఇవి మీరు పాస్ చేసిన ఆర్గ్యుమెంట్లతో కాన్ఫిగర్ చేయబడిన మాడ్యూల్ను రిటర్న్ చేస్తాయి. ఇది కాన్ఫిగర్ చేయదగిన, పునర్వినియోగ చేయదగిన మాడ్యూలులు (config, database, JWT) ఎలా ఆప్షన్లను అంగీకరిస్తాయో తెలుస్తుంది.
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 {}
మాడ్యూలులను దిగుమతి చేసేటప్పుడు మీరు చూసే .forRoot()/.register()/.forFeature() కాల్లు డైనమిక్-మాడ్యూల్ మెథడ్లు, ఇవి కాన్ఫిగరేషన్ను అంగీకరిస్తాయి.
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)
నమూనా: గ్లోబల్/ఒక్క-సమయ కాన్ఫిగరేషన్ కోసం forRoot; బహుళ మాడ్యూలులలో కాల్ చేసే ఫీచర్ రిజిస్ట్రేషన్ కోసం forFeature.
@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" })
స్టాటిక్ మెథడ్ DynamicModule ఆబ్జెక్ట్ను (మాడ్యూల్ + providers + exports) రిటర్న్ చేస్తుంది, పాస్ చేసిన ఆప్షన్లను మాడ్యూల్ యొక్క providers లో (తరచుగా injection token ద్వారా) వైర్ చేస్తుంది.
// configure using OTHER injected dependencies (e.g. ConfigService) — async/factory
StorageModule.forRootAsync({
useFactory: (config: ConfigService) => ({ bucket: config.get("BUCKET") }),
inject: [ConfigService],
});
forRootAsync వేరియంట్ కాన్ఫిగరేషన్ను ఇతర providers (like ConfigService) పై ఆధారపడేలా అనుమతిస్తుంది — ఆప్షన్లు validated configuration నుండి రాబోయినప్పుడు అవసరం.
డైనమిక్ మాడ్యూలులు మరియు forRoot/forFeature నమూనా కాన్ఫిగర్ చేయదగిన, పునర్వినియోగ చేయదగిన మాడ్యూలులు నిర్మించడానికి ఒక ముఖ్యమైన NestJS కాన్సెప్ట్ — మరియు వాటిని అర్థం చేసుకోవడం ఈకోసిస్టమ్ను ఉపయోగించడం మరియు సంబంధిత మాడ్యూలులను నిర్మించడం రెండింటికీ విలువైనది.
ప్రతిটి ప్రధాన NestJS మాడ్యూల్ (ConfigModule, TypeOrmModule, JwtModule, BullModule, CacheModule) ఒక డైనమిక్ మాడ్యూల్, .forRoot()/.register()/.forFeature() ద్వారా కాన్ఫిగర్ చేయబడుతుంది, కాబట్టి ఈ కాల్లు ఏమిటో గుర్తించడం (కాన్ఫిగరేషన్ను మాడ్యూల్కు import సమయానికి పాస్ చేయడం, స్టాటిక్ import యొక్క బదులుగా) మొత్తం ఈకోసిస్టమ్ ఎలా వైర్ చేయబడిందో తెలియజేస్తుంది.
forRoot vs forFeature నమూనా (డేటాబేస్ కనెక్షన్ లేదా సీక్రెట్ వంటి ఒక-సమయ గ్లోబల్ సెటప్ కోసం forRoot; ప్రతి మాడ్యూలలో ఎంటిటీలను రిజిస్టర్ చేయడం వంటి ఫీచర్ రిజిస్ట్రేషన్ కోసం forFeature) ఎక్కువ సార్లు ఎదుర్కొనే నమూనా.
సీనియర్ డెవలపర్ల కోసం, మీ స్వంత డైనమిక్ మాడ్యూలులను ఎలా నిర్మించాలో (పాస్ చేసిన ఆప్షన్ల నుండి కాన్ఫిగర్ చేయబడిన providers లు కలిగిన DynamicModule రిటర్న్ చేయడం, తరచుగా injection tokens ద్వారా, config-dependent setup కోసం async variants లు) తెలుసుకోవడం మీకు పునర్వినియోగ చేయదగిన, కాన్ఫిగర్ చేయదగిన మాడ్యూలులను (storage, external API clients, custom config వంటి సంబంధిత infrastructure) సృష్టించడానికి అనుమతిస్తుంది — ఇవి మరనిపాటు నిర్దిష్ట సెట్టింగ్లతో దిగుమతి చేస్తాయి.
ఇది మరింత అధునాతన విషయం, కానీ ఇది NestJS యొక్క మాడ్యూలర్ ఆర్కిటెక్చర్ను లోతుగా అర్థం చేసుకోవడానికి మరియు ప్రফెషనల్, పునర్వినియోగ చేయదగిన మాడ్యూల్ లైబ్రరీలను నిర్మించడానికి ప్రాథమిక, ఇది పెద్ద, well-structured NestJS సిస్టమ్లను ఆర్కిటెక్ట్ చేయడానికి ఒక ముఖ్యమైన సామర్థ్యం.