feature(common) add MulterModule

Author: kamilmysliwiec

…/interceptors/file-fields.interceptor.ts …/common/files/file-fields.interceptor.tspackages/common/interceptors/file-fields.interceptor.ts renamed to packages/common/files/file-fields.interceptor.ts packages/common/interceptors/file-fields.interceptor.ts renamed to packages/common/files/file-fields.interceptor.ts

@@ -1,17 +1,36 @@
 import * as multer from 'multer';
 import { Observable } from 'rxjs';
+import { Inject, Optional } from '../decorators';
 import { mixin } from '../decorators/core/component.decorator';
 import { ExecutionContext } from '../interfaces';
-import { MulterField, MulterOptions } from '../interfaces/external/multer-options.interface';
+import {
+  MulterField,
+  MulterOptions,
+} from '../interfaces/external/multer-options.interface';
 import { NestInterceptor } from './../interfaces/features/nest-interceptor.interface';
+import { MULTER_MODULE_OPTIONS } from './files.constants';
+import { MulterModuleOptions } from './interfaces';
 import { transformException } from './multer/multer.utils';
 
+type MulterInstance = any;
+
 export function FileFieldsInterceptor(
   uploadFields: MulterField[],
-  options?: MulterOptions,
+  localOptions?: MulterOptions,
 ) {
-  const Interceptor = mixin(class implements NestInterceptor {
-    readonly upload = multer(options);
+  class MixinInterceptor implements NestInterceptor {
+    readonly upload: MulterInstance;
+
+    constructor(
+      @Optional()
+      @Inject(MULTER_MODULE_OPTIONS)
+      options: MulterModuleOptions = {},
+    ) {
+      this.upload = multer({
+        ...options,
+        ...localOptions,
+      });
+    }
 
     async intercept(
       context: ExecutionContext,
@@ -34,6 +53,7 @@ export function FileFieldsInterceptor(
       );
       return call$;
     }
-  });
+  }
+  const Interceptor = mixin(MixinInterceptor);
   return Interceptor;
 }

packages/common/files/file.interceptor.ts

@@ -0,0 +1,56 @@
+import * as multer from 'multer';
+import { Observable } from 'rxjs';
+import { Inject, Optional } from '../decorators';
+import { mixin } from '../decorators/core/component.decorator';
+import { ExecutionContext } from '../interfaces';
+import { MulterOptions } from '../interfaces/external/multer-options.interface';
+import { NestInterceptor } from './../interfaces/features/nest-interceptor.interface';
+import { MULTER_MODULE_OPTIONS } from './files.constants';
+import { MulterModuleOptions } from './interfaces';
+import { transformException } from './multer/multer.utils';
+
+type MulterInstance = any;
+
+export function FileInterceptor(
+  fieldName: string,
+  localOptions?: MulterOptions,
+) {
+  class MixinInterceptor implements NestInterceptor {
+    readonly upload: MulterInstance;
+
+    constructor(
+      @Optional()
+      @Inject(MULTER_MODULE_OPTIONS)
+      options: MulterModuleOptions = {},
+    ) {
+      this.upload = multer({
+        ...options,
+        ...localOptions,
+      });
+    }
+
+    async intercept(
+      context: ExecutionContext,
+      call$: Observable<any>,
+    ): Promise<Observable<any>> {
+      const ctx = context.switchToHttp();
+
+      await new Promise((resolve, reject) =>
+        this.upload.single(fieldName)(
+          ctx.getRequest(),
+          ctx.getResponse(),
+          err => {
+            if (err) {
+              const error = transformException(err);
+              return reject(error);
+            }
+            resolve();
+          },
+        ),
+      );
+      return call$;
+    }
+  }
+  const Interceptor = mixin(MixinInterceptor);
+  return Interceptor;
+}

packages/common/files/files.constants.ts

@@ -0,0 +1 @@
+export const MULTER_MODULE_OPTIONS = 'MULTER_MODULE_OPTIONS';

…common/interceptors/files.interceptor.ts …ckages/common/files/files.interceptor.tspackages/common/interceptors/files.interceptor.ts renamed to packages/common/files/files.interceptor.ts packages/common/interceptors/files.interceptor.ts renamed to packages/common/files/files.interceptor.ts

@@ -1,18 +1,34 @@
 import * as multer from 'multer';
 import { Observable } from 'rxjs';
+import { Inject, Optional } from '../decorators';
 import { mixin } from '../decorators/core/component.decorator';
 import { ExecutionContext } from '../interfaces';
 import { MulterOptions } from '../interfaces/external/multer-options.interface';
 import { NestInterceptor } from './../interfaces/features/nest-interceptor.interface';
+import { MULTER_MODULE_OPTIONS } from './files.constants';
+import { MulterModuleOptions } from './interfaces';
 import { transformException } from './multer/multer.utils';
 
+type MulterInstance = any;
+
 export function FilesInterceptor(
   fieldName: string,
   maxCount?: number,
-  options?: MulterOptions,
+  localOptions?: MulterOptions,
 ) {
-  const Interceptor = mixin(class implements NestInterceptor {
-    readonly upload = multer(options);
+  class MixinInterceptor implements NestInterceptor {
+    readonly upload: MulterInstance;
+
+    constructor(
+      @Optional()
+      @Inject(MULTER_MODULE_OPTIONS)
+      options: MulterModuleOptions = {},
+    ) {
+      this.upload = multer({
+        ...options,
+        ...localOptions,
+      });
+    }
 
     async intercept(
       context: ExecutionContext,
@@ -35,6 +51,7 @@ export function FilesInterceptor(
       );
       return call$;
     }
-  });
+  }
+  const Interceptor = mixin(MixinInterceptor);
   return Interceptor;
 }

packages/common/interceptors/index.ts packages/common/files/index.tspackages/common/interceptors/index.ts renamed to packages/common/files/index.ts

@@ -1,3 +1,5 @@
 export * from './file-fields.interceptor';
 export * from './file.interceptor';
 export * from './files.interceptor';
+export * from './interfaces';
+export * from './multer.module';

packages/common/files/interfaces/files-upload-module.interface.ts

@@ -0,0 +1,18 @@
+import { ModuleMetadata, Type } from '@nestjs/common/interfaces';
+import { MulterOptions } from './../../interfaces/external/multer-options.interface';
+
+export interface MulterModuleOptions extends MulterOptions {}
+
+export interface MulterOptionsFactory {
+  createMulterOptions(): Promise<MulterModuleOptions> | MulterModuleOptions;
+}
+
+export interface MulterModuleAsyncOptions
+  extends Pick<ModuleMetadata, 'imports'> {
+  useExisting?: Type<MulterOptionsFactory>;
+  useClass?: Type<MulterOptionsFactory>;
+  useFactory?: (
+    ...args: any[],
+  ) => Promise<MulterModuleOptions> | MulterModuleOptions;
+  inject?: any[];
+}

packages/common/files/interfaces/index.ts

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

packages/common/files/multer.module.ts

@@ -0,0 +1,60 @@
+import { DynamicModule, Module, Provider } from '@nestjs/common';
+import { MULTER_MODULE_OPTIONS } from './files.constants';
+import {
+  MulterModuleAsyncOptions,
+  MulterModuleOptions,
+  MulterOptionsFactory,
+} from './interfaces/files-upload-module.interface';
+
+@Module({})
+export class MulterModule {
+  static register(options: MulterModuleOptions): DynamicModule {
+    return {
+      module: MulterModule,
+      providers: [{ provide: MULTER_MODULE_OPTIONS, useValue: options }],
+      exports: [MULTER_MODULE_OPTIONS],
+    };
+  }
+
+  static registerAsync(options: MulterModuleAsyncOptions): DynamicModule {
+    return {
+      module: MulterModule,
+      imports: options.imports,
+      providers: this.createAsyncProviders(options),
+      exports: [MULTER_MODULE_OPTIONS],
+    };
+  }
+
+  private static createAsyncProviders(
+    options: MulterModuleAsyncOptions,
+  ): Provider[] {
+    if (options.useExisting || options.useFactory) {
+      return [this.createAsyncOptionsProvider(options)];
+    }
+    return [
+      this.createAsyncOptionsProvider(options),
+      {
+        provide: options.useClass,
+        useClass: options.useClass,
+      },
+    ];
+  }
+
+  private static createAsyncOptionsProvider(
+    options: MulterModuleAsyncOptions,
+  ): Provider {
+    if (options.useFactory) {
+      return {
+        provide: MULTER_MODULE_OPTIONS,
+        useFactory: options.useFactory,
+        inject: options.inject || [],
+      };
+    }
+    return {
+      provide: MULTER_MODULE_OPTIONS,
+      useFactory: async (optionsFactory: MulterOptionsFactory) =>
+        await optionsFactory.createMulterOptions(),
+      inject: [options.useExisting || options.useClass],
+    };
+  }
+}