ਡਾਇਨਾਮਿਕ ਮਾਡਿਊਲ ਉਹ ਮਾਡਿਊਲ ਹਨ ਜੋ ਆਯਾਤ ਕਰਦੇ ਸਮੇਂ ਸਿੰਪਿਆ ਜਾ ਸਕਦਾ ਹੈ — ਸਥਿਰ @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 ਵਸਤੂ ਵਾਪਸ ਕਰਦਾ ਹੈ (ਮਾਡਿਊਲ + ਫਰਾਹਮ ਕਰਨ ਵਾਲੇ + ਨਿਰਯਾਤ)، ਪਾਸ ਕੀਤੇ ਗਏ ਵਿਕਲਪਾਂ ਨੂੰ ਮਾਡਿਊਲ ਦੇ ਫਰਾਹਮ ਕਰਨ ਵਾਲਿਆਂ ਵਿੱਚ ਤਾਰ-ਤਾਰ ਕਰਦਾ ਹੈ (ਅਕਸਰ injection ਟੋਕਨ ਦੇ ਰਾਹੀਂ)।
// configure using OTHER injected dependencies (e.g. ConfigService) — async/factory
StorageModule.forRootAsync({
useFactory: (config: ConfigService) => ({ bucket: config.get("BUCKET") }),
inject: [ConfigService],
});
forRootAsync ਰੂਪ ਸਿੰਪਣ ਨੂੰ ਦੂਸਰੇ ਫਰਾਹਮ ਕਰਨ ਵਾਲਿਆਂ 'ਤੇ ਨਿਰਭਰ ਕਰਨ ਦਿੰਦਾ ਹੈ (ਜਿਵੇਂ ConfigService) — ਜਦੋਂ ਵਿਕਲਪ ਤਸਦੀਕ ਕੀਤੀ ਗਈ ਸਿੰਪਣ ਤੋਂ ਆਉਂਦੇ ਹਨ ਤਾਂ ਜ਼ਰੂਰੀ।
ਡਾਇਨਾਮਿਕ ਮਾਡਿਊਲ ਅਤੇ forRoot/forFeature ਪੈਟਰਨ NestJS ਲਈ ਸਿੰਪਿਆ ਜਾ ਸਕਣ ਵਾਲਾ, ਮੁੜ ਵਰਤਯੋਗ ਮਾਡਿਊਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਸੰਕਲਪ ਹੈ — ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਮਝਣਾ ਈਕੋਸਿਸਟਮ ਦੀ ਵਰਤੋਂ ਅਤੇ ਸਾਂਝੇ ਮਾਡਿਊਲ ਬਣਾਉਣ ਦੋਵਾਂ ਲਈ ਮੁੱਲਵਾਨ ਹੈ।
ਲਗਭਗ ਹਰ ਵੱਡਾ NestJS ਮਾਡਿਊਲ (ConfigModule, TypeOrmModule, JwtModule, BullModule, CacheModule) ਡਾਇਨਾਮਿਕ ਮਾਡਿਊਲ ਹੈ ਜੋ .forRoot()/.register()/.forFeature() ਦੇ ਮਾਧਿਅਮ ਤੋਂ ਸਿੰਪਿਆ ਹੁੰਦਾ ਹੈ، ਇਸ ਲਈ ਇਹ ਪਛਾਣਨਾ ਕਿ ਇਹ ਕਾਲਾਂ ਕੀ ਹਨ (ਆਯਾਤ ਦੇ ਸਮੇਂ ਸਿੰਪਣ ਮਾਡਿਊਲ ਨੂੰ ਦੇਣਾ، ਸਥਿਰ ਆਯਾਤ ਦੀ ਬਜਾਏ) ਪੂਰੀ ਈਕੋਸਿਸਟਮ ਨੂੰ ਕਿਵੇਂ ਤਾਰ-ਤਾਰ ਕੀਤਾ ਗਿਆ ਹੈ ਇਹ ਸਮਝਣ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦਾ ਹੈ।
forRoot vs forFeature ਰਵਾਇਤ (forRoot ਇੱਕ ਵਾਰ ਗਲੋਬਲ ਸੈਟ ਅਪ ਲਈ ਜਿਵੇਂ ਡੇਟਾਬੇਸ ਕਨੈਕਸ਼ਨ ਜਾਂ ਰਾਜ਼؛ forFeature ਪ੍ਰਤੀ-ਵਿਸ਼ੇਸ਼ ਪੰਜੀਕਰਨ ਲਈ ਜਿਵੇਂ ਹਰ ਮਾਡਿਊਲ ਵਿੱਚ entities ਪੰਜੀਕ੍ਰਿਤ ਕਰਨਾ) ਉਹ ਪੈਟਰਨ ਹੈ ਜੋ ਤੁਸੀਂ ਲਗਾਤਾਰ ਲੱਭਦੇ ਹੋ।
ਸਿਨੀਅਰ ਡਿਵੈਲਪਰਾਂ ਲਈ، ਆਪਣੇ ਡਾਇਨਾਮਿਕ ਮਾਡਿਊਲ ਬਣਾਉਣਾ ਜਾਣਨਾ (ਪਾਸ ਕੀਤੇ ਗਏ ਵਿਕਲਪਾਂ ਤੋਂ ਸਿੰਪਿਆ ਹੋਇਆ ਫਰਾਹਮ ਕਰਨ ਵਾਲਿਆਂ ਨਾਲ DynamicModule ਵਾਪਸ ਕਰਨਾ، ਅਕਸਰ injection tokens ਦੇ ਰਾਹੀਂ، ਸਿੰਪਣ-ਨਿਰਭਰ ਸੈਟ ਅਪ ਲਈ async ਰੂਪਾਂ ਦੇ ਨਾਲ) ਉਹ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਮੁੜ ਵਰਤਯੋਗ، ਸਿੰਪਣ ਯੋਗ ਮਾਡਿਊਲ ਬਣਾਉਣ ਦਿੰਦਾ ਹੈ — ਸਾਂਝਾ ਢਾਂਚਾ (ਸਟੋਰੇਜ, ਬਾਹਰੀ API ਕਲਾਇਂਟ, ਕਸਟਮ ਸਿੰਪਣ) ਜੋ ਐਪ ਦੇ ਦੂਸਰੇ ਭਾਗ ਜਾਂ ਦੂਸਰੀਆਂ ਪ੍ਰਾਜੈਕਟਾਂ ਆਪਣੀਆਂ ਸੈਟਿੰਗਾਂ ਨਾਲ ਆਯਾਤ ਕਰਦੇ ਹਨ।
ਇਹ ਇੱਕ ਹੋਰ ਅੱਗੇ ਵਾਲਾ ਵਿਸ਼ਾ ਹੈ، ਲੇਕਿਨ ਇਹ NestJS ਦੇ ਮਾਡਿਊਲਰ ਆਰਕੀਟੈਕਚਰ ਨੂੰ ਡੂੰਘੀ ਤੌਰ 'ਤੇ ਸਮਝਣ ਦੇ ਲਈ ਅਤੇ ਪੇਸ਼ਾਵਰ، ਮੁੜ ਵਰਤਯੋਗ ਮਾਡਿਊਲ ਲਾਇਬ੍ਰੇਰੀਆਂ ਬਣਾਉਣ ਦੇ ਲਈ ਨੀਂਹ ਹੈ، ਇਸ ਨੂੰ ਵੱਡੀਆਂ، ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਰਚਿਤ NestJS ਪ੍ਰਣਾਲੀਆਂ ਨੂੰ ਆਰਕੀਟੈਕਟ ਕਰਨ ਲਈ ਮਹੱਤਵਪੂਰਨ ਸਮਰੱਥਾ ਬਣਾਉਂਦਾ ਹੈ।
ਵਿਸਤ੍ਰਿਤ ਜਵਾਬਾਂ ਨਾਲ IT ਇੰਟਰਵਿਊ ਸਵਾਲਾਂ ਦੀ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ — ਜੂਨੀਅਰ ਤੋਂ ਸੀਨੀਅਰ ਤੱਕ।
ਦਾਨ ਕਰੋ