ਡਾਇਨਾਮਿਕ ਮਾਡਿਊਲ ਅਤੇ forRoot/forFeature ਪੈਟਰਨ ਕੀ ਹਨ?

Question

Accepted Answer

**ਡਾਇਨਾਮਿਕ ਮਾਡਿਊਲ** ਉਹ ਮਾਡਿਊਲ ਹਨ ਜੋ **ਆਯਾਤ ਕਰਦੇ ਸਮੇਂ ਸਿੰਪਿਆ ਜਾ ਸਕਦਾ ਹੈ** — ਸਥਿਰ `@Module({...})` ਦੀ ਬਜਾਏ، ਉਹ ਸਥਿਰ ਢੰਗ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ (ਰਵਾਇਤੀ ਤੌਰ 'ਤੇ **`forRoot`** ਅਤੇ **`forFeature`**) ਜੋ ਆਪ ਦੁਆਰਾ ਪਾਸ ਕੀਤੀਆਂ ਗਈਆਂ ਦਲੀਲਾਂ ਨਾਲ ਸਿੰਪਿਆ ਹੋਇਆ ਮਾਡਿਊਲ ਵਾਪਸ ਕਰਦੇ ਹਨ। ਇਹ ਹੀ ਤਰੀਕਾ ਹੈ ਜਿਸ ਨਾਲ ਸਿੰਪਣ ਯੋਗ, ਮੁੜ ਵਰਤਯੋਗ ਮਾਡਿਊਲ (config, database, JWT) ਵਿਕਲਪ ਸਵੀਕਾਰ ਕਰਦੇ ਹਨ।

## ਸਮੱਸਿਆ ਜੋ ਉਹ ਹੱਲ ਕਰਦੇ ਹਨ

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

## ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਉਨ੍ਹਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਚੁੱਕੇ ਹੋ

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

ਜਿਹਨਾਂ `.forRoot()`/`.register()`/`.forFeature()` ਕਾਲਾਂ ਨੂੰ ਤੁਸੀਂ ਮਾਡਿਊਲ ਆਯਾਤ ਕਰਦੇ ਸਮੇਂ ਦੇਖਦੇ ਹੋ، ਉਹ ਸਿੰਪਣ ਸਵੀਕਾਰ ਕਰਨ ਵਾਲੇ ਡਾਇਨਾਮਿਕ-ਮਾਡਿਊਲ ਢੰਗ ਹਨ।

## forRoot vs forFeature ਰਵਾਇਤ

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

ਰਵਾਇਤ: ਗਲੋਬਲ/ਇੱਕ ਵਾਰ ਸਿੰਪਣ ਲਈ `forRoot`؛ ਬਹੁ-ਵਿਸ਼ੇਸ਼ ਪੰਜੀਕਰਨ ਲਈ `forFeature` ਜੋ ਤੁਸੀਂ ਕਈ ਮਾਡਿਊਲਾਂ ਵਿੱਚ ਕਾਲ ਕਰਦੇ ਹੋ।

## ਆਪਣਾ ਡਾਇਨਾਮਿਕ ਮਾਡਿਊਲ ਬਣਾਉਣਾ

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

ਸਥਿਰ ਢੰਗ `DynamicModule` ਵਸਤੂ ਵਾਪਸ ਕਰਦਾ ਹੈ (ਮਾਡਿਊਲ + ਫਰਾਹਮ ਕਰਨ ਵਾਲੇ + ਨਿਰਯਾਤ)، ਪਾਸ ਕੀਤੇ ਗਏ ਵਿਕਲਪਾਂ ਨੂੰ ਮਾਡਿਊਲ ਦੇ ਫਰਾਹਮ ਕਰਨ ਵਾਲਿਆਂ ਵਿੱਚ ਤਾਰ-ਤਾਰ ਕਰਦਾ ਹੈ (ਅਕਸਰ injection ਟੋਕਨ ਦੇ ਰਾਹੀਂ)।

## ਅਸਿੰਕ ਸਿੰਪਣ (forRootAsync)

```ts
// 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 ਪ੍ਰਣਾਲੀਆਂ ਨੂੰ ਆਰਕੀਟੈਕਟ ਕਰਨ ਲਈ ਮਹੱਤਵਪੂਰਨ ਸਮਰੱਥਾ ਬਣਾਉਂਦਾ ਹੈ।