add async function

README.md

@@ -30,6 +30,23 @@ import { RedisModule} from 'nestjs-redis'
 })
 export class AppModule {}
 ```
+With Async
+```typescript
+import { Module } from '@nestjs/common';
+import { RedisModule} from 'nestjs-redis'
+
+@Module({
+    imports: [
+        RedisModuleforRootAsync({
+            useFactory: (configService: ConfigService) => configService.get('redis'),         // or use async method
+            //useFactory: async (configService: ConfigService) => configService.get('redis'),
+            inject:[ConfigService]
+        }),
+    ],
+})
+export class AppModule {}
+```
+
 Options
 ```typescript
 interface RedisOptions {

dist/redis-client.provider.d.ts

 import * as Redis from "ioredis";
-import { RedisModuleOptions } from "./redis.interface";
+import { RedisModuleOptions, RedisModuleAsyncOptions } from "./redis.interface";
 export declare const createClient: () => {
     provide: symbol;
     useFactory: (options: RedisModuleOptions) => Redis.Redis;
     inject: symbol[];
 };
+export declare const createAsyncClientOptions: (options: RedisModuleAsyncOptions) => {
+    provide: symbol;
+    useFactory: (...args: any[]) => RedisModuleOptions | Promise<RedisModuleOptions>;
+    inject: any[];
+};

dist/redis-client.provider.js

@@ -9,3 +9,8 @@ exports.createClient = () => ({
     },
     inject: [redis_constants_1.REDIS_MODULE_OPTIONS]
 });
+exports.createAsyncClientOptions = (options) => ({
+    provide: redis_constants_1.REDIS_MODULE_OPTIONS,
+    useFactory: options.useFactory,
+    inject: options.inject
+});

dist/redis.interface.d.ts

+import { ModuleMetadata } from '@nestjs/common/interfaces';
 import { RedisOptions } from 'ioredis';
 export interface RedisModuleOptions extends RedisOptions {
 }
+export interface RedisModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    useFactory?: (...args: any[]) => RedisModuleOptions | Promise<RedisModuleOptions>;
+    inject?: any[];
+}

dist/redis.module.d.ts

 import { DynamicModule } from '@nestjs/common';
-import { RedisModuleOptions } from './redis.interface';
+import { RedisModuleOptions, RedisModuleAsyncOptions } from './redis.interface';
 export declare class RedisModule {
     static register(options: RedisModuleOptions): DynamicModule;
+    static forRootAsync(options: RedisModuleAsyncOptions): DynamicModule;
 }

dist/redis.module.js

@@ -22,6 +22,17 @@ let RedisModule = RedisModule_1 = class RedisModule {
             exports: [redis_service_1.RedisService]
         };
     }
+    static forRootAsync(options) {
+        return {
+            module: RedisModule_1,
+            imports: options.imports,
+            providers: [
+                redis_client_provider_1.createClient(),
+                redis_client_provider_1.createAsyncClientOptions(options),
+            ],
+            exports: [redis_service_1.RedisService]
+        };
+    }
 };
 RedisModule = RedisModule_1 = __decorate([
     common_1.Global(),

lib/redis-client.provider.ts

 import * as Redis from "ioredis"
 import { REDIS_CLIENT, REDIS_MODULE_OPTIONS } from './redis.constants';
-import { RedisModuleOptions } from "./redis.interface";
+import { RedisModuleOptions, RedisModuleAsyncOptions } from "./redis.interface";
 
 export const createClient = () => ({
   provide: REDIS_CLIENT,
@@ -9,3 +9,10 @@ export const createClient = () => ({
   },
   inject:[REDIS_MODULE_OPTIONS]
 })
+
+export const createAsyncClientOptions = (options:RedisModuleAsyncOptions) => ({
+  provide: REDIS_MODULE_OPTIONS,
+  useFactory: options.useFactory,
+  inject: options.inject
+})
+  
\ No newline at end of file

lib/redis.interface.ts

-import { RedisOptions } from 'ioredis'
+import { ModuleMetadata } from '@nestjs/common/interfaces';
+import { RedisOptions } from 'ioredis';
 
 export interface RedisModuleOptions extends RedisOptions {}
+
+export interface RedisModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+  useFactory?: (...args: any[]) => RedisModuleOptions | Promise<RedisModuleOptions>,
+  inject?: any[];
+}
\ No newline at end of file

lib/redis.module.ts

 import { DynamicModule, Module, Global } from '@nestjs/common';
-import { RedisModuleOptions } from './redis.interface';
+import { RedisModuleOptions, RedisModuleAsyncOptions } from './redis.interface';
 import { REDIS_MODULE_OPTIONS } from './redis.constants';
 import { RedisService } from './redis.service';
-import { createClient } from './redis-client.provider';
+import { createClient, createAsyncClientOptions } from './redis-client.provider';
 
 @Global()
 @Module({
@@ -15,7 +15,19 @@ export class RedisModule {
       module: RedisModule,
       providers: [
         createClient(),
-        { provide: REDIS_MODULE_OPTIONS,useValue:options}
+        { provide: REDIS_MODULE_OPTIONS, useValue:options}
+      ],
+      exports: [RedisService]
+    }
+  }
+
+  static forRootAsync(options: RedisModuleAsyncOptions) : DynamicModule {
+    return {
+      module: RedisModule,
+      imports: options.imports,
+      providers: [
+        createClient(),
+        createAsyncClientOptions(options),
       ],
       exports: [RedisService]
     }