feature(common): Add file interceptor for multer

Author: Samox

packages/platform-express/multer/interceptors/any-files.interceptor.ts

@@ -0,0 +1,60 @@
+import {
+  CallHandler,
+  ExecutionContext,
+  Inject,
+  mixin,
+  NestInterceptor,
+  Optional,
+  Type,
+} from '@nestjs/common';
+import * as multer from 'multer';
+import { Observable } from 'rxjs';
+import { MULTER_MODULE_OPTIONS } from '../files.constants';
+import { MulterModuleOptions } from '../interfaces';
+import { MulterOptions } from '../interfaces/multer-options.interface';
+import { transformException } from '../multer/multer.utils';
+
+type MulterInstance = any;
+
+export function AnyFilesInterceptor(
+  localOptions?: MulterOptions,
+): Type<NestInterceptor> {
+  class MixinInterceptor implements NestInterceptor {
+    protected multer: MulterInstance;
+
+    constructor(
+      @Optional()
+      @Inject(MULTER_MODULE_OPTIONS)
+      options: MulterModuleOptions = {},
+    ) {
+      this.multer = (multer as any)({
+        ...options,
+        ...localOptions,
+      });
+    }
+
+    async intercept(
+      context: ExecutionContext,
+      next: CallHandler,
+    ): Promise<Observable<any>> {
+      const ctx = context.switchToHttp();
+
+      await new Promise((resolve, reject) =>
+        this.multer.any()(
+          ctx.getRequest(),
+          ctx.getResponse(),
+          (err: any) => {
+            if (err) {
+              const error = transformException(err);
+              return reject(error);
+            }
+            resolve();
+          },
+        ),
+      );
+      return next.handle();
+    }
+  }
+  const Interceptor = mixin(MixinInterceptor);
+  return Interceptor as Type<NestInterceptor>;
+}

packages/platform-express/test/multer/interceptors/any-files.interceptor.spec.ts

@@ -0,0 +1,46 @@
+import { CallHandler } from '@nestjs/common';
+import { ExecutionContextHost } from '@nestjs/core/helpers/execution-context-host';
+import { expect } from 'chai';
+import { of } from 'rxjs';
+import * as sinon from 'sinon';
+import { AnyFilesInterceptor } from '../../../multer/interceptors/any-files.interceptor';
+
+describe('FilesInterceptor', () => {
+  it('should return metatype with expected structure', async () => {
+    const targetClass = AnyFilesInterceptor();
+    expect(targetClass.prototype.intercept).to.not.be.undefined;
+  });
+  describe('intercept', () => {
+    let handler: CallHandler;
+    beforeEach(() => {
+      handler = {
+        handle: () => of('test'),
+      };
+    });
+    it('should call any() with expected params', async () => {
+      const target = new (AnyFilesInterceptor())();
+
+      const callback = (req, res, next) => next();
+      const arraySpy = sinon
+        .stub((target as any).multer, 'any')
+        .returns(callback);
+
+      await target.intercept(new ExecutionContextHost([]), handler);
+
+      expect(arraySpy.called).to.be.true;
+      expect(arraySpy.calledWith()).to.be.true;
+    });
+    it('should transform exception', async () => {
+      const target = new (AnyFilesInterceptor())();
+      const err = {};
+      const callback = (req, res, next) => next(err);
+
+      (target as any).multer = {
+        any: () => callback,
+      };
+      (target.intercept(new ExecutionContextHost([]), handler) as any).catch(
+        error => expect(error).to.not.be.undefined,
+      );
+    });
+  });
+});