feature(common) add async support (HttpModule) and extraProviders (cache/http)

Author: kamilmysliwiec

packages/common/cache/cache.module.ts

@@ -24,7 +24,10 @@ export class CacheModule {
     return {
       module: CacheModule,
       imports: options.imports,
-      providers: this.createAsyncProviders(options),
+      providers: [
+        ...this.createAsyncProviders(options),
+        ...(options.extraProviders || []),
+      ],
     };
   }
 
@@ -55,7 +58,8 @@ export class CacheModule {
     }
     return {
       provide: CACHE_MODULE_OPTIONS,
-      useFactory: async (optionsFactory: CacheOptionsFactory) => optionsFactory.createCacheOptions(),
+      useFactory: async (optionsFactory: CacheOptionsFactory) =>
+        optionsFactory.createCacheOptions(),
       inject: [options.useExisting || options.useClass],
     };
   }

packages/common/cache/interfaces/cache-module.interface.ts

@@ -1,4 +1,4 @@
-import { ModuleMetadata, Type } from '../../interfaces';
+import { ModuleMetadata, Provider, Type } from '../../interfaces';
 import { CacheManagerOptions } from './cache-manager.interface';
 
 export interface CacheModuleOptions extends CacheManagerOptions {
@@ -14,7 +14,8 @@ export interface CacheModuleAsyncOptions
   useExisting?: Type<CacheOptionsFactory>;
   useClass?: Type<CacheOptionsFactory>;
   useFactory?: (
-    ...args: any[],
+    ...args: any[]
   ) => Promise<CacheModuleOptions> | CacheModuleOptions;
   inject?: any[];
+  extraProviders?: Provider[];
 }

packages/common/http/http.constants.ts

@@ -1,2 +1,3 @@
 export const AXIOS_INSTANCE_TOKEN = 'AXIOS_INSTANCE_TOKEN';
 export const HTTP_MODULE_ID = 'HTTP_MODULE_ID';
+export const HTTP_MODULE_OPTIONS = 'HTTP_MODULE_OPTIONS';

packages/common/http/http.module.ts

@@ -1,9 +1,18 @@
-import Axios, { AxiosRequestConfig } from 'axios';
+import Axios from 'axios';
 import { Module } from '../decorators/modules/module.decorator';
-import { DynamicModule } from '../interfaces';
+import { DynamicModule, Provider } from '../interfaces';
 import { randomStringGenerator } from '../utils/random-string-generator.util';
-import { AXIOS_INSTANCE_TOKEN, HTTP_MODULE_ID } from './http.constants';
+import {
+  AXIOS_INSTANCE_TOKEN,
+  HTTP_MODULE_ID,
+  HTTP_MODULE_OPTIONS,
+} from './http.constants';
 import { HttpService } from './http.service';
+import {
+  HttpModuleAsyncOptions,
+  HttpModuleOptions,
+  HttpModuleOptionsFactory,
+} from './interfaces';
 
 @Module({
   providers: [
@@ -16,7 +25,7 @@ import { HttpService } from './http.service';
   exports: [HttpService],
 })
 export class HttpModule {
-  static register(config: AxiosRequestConfig): DynamicModule {
+  static register(config: HttpModuleOptions): DynamicModule {
     return {
       module: HttpModule,
       providers: [
@@ -31,4 +40,52 @@ export class HttpModule {
       ],
     };
   }
+
+  static registerAsync(options: HttpModuleAsyncOptions): DynamicModule {
+    return {
+      module: HttpModule,
+      imports: options.imports,
+      providers: [
+        ...this.createAsyncProviders(options),
+        {
+          provide: HTTP_MODULE_ID,
+          useValue: randomStringGenerator(),
+        },
+        ...(options.extraProviders || []),
+      ],
+    };
+  }
+
+  private static createAsyncProviders(
+    options: HttpModuleAsyncOptions,
+  ): Provider[] {
+    if (options.useExisting || options.useFactory) {
+      return [this.createAsyncOptionsProvider(options)];
+    }
+    return [
+      this.createAsyncOptionsProvider(options),
+      {
+        provide: options.useClass,
+        useClass: options.useClass,
+      },
+    ];
+  }
+
+  private static createAsyncOptionsProvider(
+    options: HttpModuleAsyncOptions,
+  ): Provider {
+    if (options.useFactory) {
+      return {
+        provide: HTTP_MODULE_OPTIONS,
+        useFactory: options.useFactory,
+        inject: options.inject || [],
+      };
+    }
+    return {
+      provide: HTTP_MODULE_OPTIONS,
+      useFactory: async (optionsFactory: HttpModuleOptionsFactory) =>
+        optionsFactory.createHttpOptions(),
+      inject: [options.useExisting || options.useClass],
+    };
+  }
 }

packages/common/http/interfaces/http-module.interface.ts

@@ -0,0 +1,19 @@
+import { AxiosRequestConfig } from 'axios';
+import { ModuleMetadata, Provider, Type } from '../../interfaces';
+
+export interface HttpModuleOptions extends AxiosRequestConfig {}
+
+export interface HttpModuleOptionsFactory {
+  createHttpOptions(): Promise<HttpModuleOptions> | HttpModuleOptions;
+}
+
+export interface HttpModuleAsyncOptions
+  extends Pick<ModuleMetadata, 'imports'> {
+  useExisting?: Type<HttpModuleOptions>;
+  useClass?: Type<HttpModuleOptions>;
+  useFactory?: (
+    ...args: any[]
+  ) => Promise<HttpModuleOptions> | HttpModuleOptions;
+  inject?: any[];
+  extraProviders?: Provider[];
+}

packages/common/http/interfaces/index.ts

@@ -0,0 +1 @@
+export * from './http-module.interface';