Fixed client module issue with ConfigModule.

examples/client-app/.env

@@ -0,0 +1,4 @@
+REDIS_CONSUMER=api-1
+REDIS_CONSUMER_GROUP=api
+REDIS_MAX_BLOCK_TIME_MS=5000
+REDIS_URL=0.0.0.0:6379

examples/client-app/package.json

@@ -22,6 +22,7 @@
   },
   "dependencies": {
     "@nestjs/common": "^9.0.0",
+    "@nestjs/config": "^3.1.1",
     "@nestjs/core": "^9.0.0",
     "@nestjs/platform-express": "^9.0.0",
     "@tamimaj/nestjs-redis-streams": "file:../..",

examples/client-app/src/app.module.ts

@@ -5,6 +5,7 @@ import {
 } from '@tamimaj/nestjs-redis-streams';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
+import { ConfigModule, ConfigService } from '@nestjs/config';
 
 // Any class that implements createRedisStreamClientModuleOptions method.
 // ConfigService is a good candidate.
@@ -21,18 +22,42 @@ class ClassOptions {
 
 @Module({
   imports: [
-    // Register / forRoot.
-    RedisStreamClientModule.register({
-      connection: { url: '0.0.0.0:6379' },
-      streams: { consumer: 'api-1', block: 5000, consumerGroup: 'api' },
-      responseStreams: ['users:created', 'users:created:copy'],
-    }),
+    ///////////////////////////////////
+    // SYNC CONFIGURATION
+    ///////////////////////////////////
 
-    // registerAsync / forRootAsync.
+    // RedisStreamClientModule.forRoot({
+    //   connection: { url: '0.0.0.0:6379' },
+    //   streams: { consumer: 'api-1', block: 5000, consumerGroup: 'api' },
+    //   responseStreams: ['users:created', 'users:created:copy'],
+    // }),
+
+    ///////////////////////////////////////////
+    // ASYNC CONFIGURATION with ConfigModule
+    ///////////////////////////////////////////
+
+    ConfigModule.forRoot(),
+    RedisStreamClientModule.forRootAsync({
+      imports: [ConfigModule],
+      useFactory: (configService: ConfigService) => {
+        return {
+          connection: {
+            url: configService.get('REDIS_URL'),
+          },
+          streams: {
+            consumer: configService.get('REDIS_CONSUMER'),
+            consumerGroup: configService.get('REDIS_CONSUMER_GROUP'),
+            block: configService.get('REDIS_MAX_BLOCK_TIME_MS'),
+          },
+          responseStreams: ['users:created', 'users:created:copy'],
+        };
+      },
+      inject: [ConfigService],
+    }),
 
-    //////////////////////
-    // Use Factory.     //
-    //////////////////////
+    ///////////////////////////////////////////
+    // ASYNC CONFIGURATION with useFactory
+    ///////////////////////////////////////////
 
     // RedisStreamClientModule.registerAsync({
     //   useFactory: async () => {
@@ -44,9 +69,10 @@ class ClassOptions {
     //   },
     // }),
 
-    //////////////////////
-    // Use Class.       //
-    //////////////////////
+    ///////////////////////////////////////////////////////////////////////////
+    // ASYNC CONFIGURATION with useClass
+    // class must implement createRedisStreamClientModuleOptions method.
+    ///////////////////////////////////////////////////////////////////////////
 
     // RedisStreamClientModule.forRootAsync({
     //   useClass: ClassOptions,

lib/redis-stream-client.core-module.ts

@@ -6,6 +6,8 @@ import {
 } from './interfaces';
 import { RedisStreamClient } from './redis.client';
 
+const REDIS_STREAM_CLIENT_MODULE_OPTIONS = 'REDIS_STREAM_CLIENT_MODULE_OPTIONS';
+
 @Global()
 @Module({})
 export class RedisStreamClientCoreModule {
@@ -26,14 +28,22 @@ export class RedisStreamClientCoreModule {
   public static forRootAsync(
     options: RedisStreamModuleAsyncOptions,
   ): DynamicModule {
-    console.log('forRootAsync options', options);
+    const redisStreamClientProvider: Provider = {
+      provide: RedisStreamClient,
+      useFactory: (options: ClientConstructorOptions) => {
+        return new RedisStreamClient(options);
+      },
+      inject: [REDIS_STREAM_CLIENT_MODULE_OPTIONS],
+    };
 
     return {
       module: RedisStreamClientCoreModule,
       imports: options.imports,
-      providers: [...this.createAsyncProviders(options)], // here we let the logic to create the provider pending on the type of the
-      // useFactory, useClass or useExisting
-      exports: [RedisStreamClient], // this means we will export the RedisStreamClient provider
+      providers: [
+        ...this.createAsyncProviders(options),
+        redisStreamClientProvider,
+      ],
+      exports: [redisStreamClientProvider],
     };
   }
 
@@ -70,27 +80,17 @@ export class RedisStreamClientCoreModule {
     // if is a useFactory, get options then return the RedisStreamClient
     if (options.useFactory) {
       return {
-        provide: RedisStreamClient,
-        useFactory: async () => {
-          const clientOptions = await options.useFactory();
-          return new RedisStreamClient(clientOptions);
-        },
+        provide: REDIS_STREAM_CLIENT_MODULE_OPTIONS,
+        useFactory: options.useFactory,
         inject: options.inject || [],
       };
     }
 
-    // if is a useClass or useExisting,
-    // get the options from the ProvidedClass.createRedisStreamClientModuleOptions()
-    // that must be implemented by the provided class.
     return {
-      provide: RedisStreamClient,
-      async useFactory(
+      provide: REDIS_STREAM_CLIENT_MODULE_OPTIONS,
+      useFactory: async (
         optionsFactory: RedisStreamClientModuleOptionsFactory,
-      ): Promise<RedisStreamClient> {
-        const options =
-          await optionsFactory.createRedisStreamClientModuleOptions();
-        return new RedisStreamClient(options);
-      },
+      ) => optionsFactory.createRedisStreamClientModuleOptions(),
       inject: [options.useClass || options.useExisting],
     };
   }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamimaj/nestjs-redis-streams",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Redis Streams Transport for NestJS.",
   "author": "Tamim Abbas Aljuratli <https://tamim.es>",
   "private": false,