Merge branch 'thg303-feature/add-FileFieldsInterceptor'

Author: kamilmysliwiec

bundle/common/interceptors/file-fields.interceptor.d.ts

@@ -0,0 +1,10 @@
+import * as multer from 'multer';
+import { Observable } from 'rxjs';
+import { MulterOptions } from '../interfaces/external/multer-options.interface';
+import { ExecutionContext } from '../interfaces';
+export declare function FileFieldsInterceptor(uploadFields: multer.Field[], options?: MulterOptions): {
+    new (): {
+        readonly upload: any;
+        intercept(context: ExecutionContext, call$: Observable<any>): Promise<Observable<any>>;
+    };
+};

bundle/common/interceptors/file-fields.interceptor.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const multer = require("multer");
+const multer_utils_1 = require("./multer/multer.utils");
+function FileFieldsInterceptor(uploadFields, options) {
+    const Interceptor = class {
+        constructor() {
+            this.upload = multer(options);
+        }
+        async intercept(context, call$) {
+            const ctx = context.switchToHttp();
+            await new Promise((resolve, reject) => this.upload.fields(uploadFields)(ctx.getRequest(), ctx.getResponse(), err => {
+                if (err) {
+                    const error = multer_utils_1.transformException(err);
+                    return reject(error);
+                }
+                resolve();
+            }));
+            return call$;
+        }
+    };
+    return Interceptor;
+}
+exports.FileFieldsInterceptor = FileFieldsInterceptor;

packages/common/decorators/http/route-params.decorator.ts

@@ -2,8 +2,8 @@ import 'reflect-metadata';
 import { ROUTE_ARGS_METADATA } from '../../constants';
 import { RouteParamtypes } from '../../enums/route-paramtypes.enum';
 import { PipeTransform } from '../../index';
-import { isNil, isString } from '../../utils/shared.utils';
 import { Type } from '../../interfaces';
+import { isNil, isString } from '../../utils/shared.utils';
 
 export type ParamData = object | string | number;
 export interface RouteParamsMetadata {
@@ -71,7 +71,7 @@ export const Next: () => ParameterDecorator = createRouteParamDecorator(
 export const Session: () => ParameterDecorator = createRouteParamDecorator(
   RouteParamtypes.SESSION,
 );
-export const UploadedFile: () => ParameterDecorator = createRouteParamDecorator(
+export const UploadedFile: (fileKey?: string) => ParameterDecorator = createRouteParamDecorator(
   RouteParamtypes.FILE,
 );
 export const UploadedFiles: () => ParameterDecorator = createRouteParamDecorator(

packages/common/interceptors/file-fields.interceptor.ts

@@ -0,0 +1,38 @@
+import * as multer from 'multer';
+import { Observable } from 'rxjs';
+import { ExecutionContext } from '../interfaces';
+import { MulterField, MulterOptions } from '../interfaces/external/multer-options.interface';
+import { NestInterceptor } from './../interfaces/features/nest-interceptor.interface';
+import { transformException } from './multer/multer.utils';
+
+export function FileFieldsInterceptor(
+  uploadFields: MulterField[],
+  options?: MulterOptions,
+) {
+  const Interceptor = class implements NestInterceptor {
+    readonly upload = multer(options);
+
+    async intercept(
+      context: ExecutionContext,
+      call$: Observable<any>,
+    ): Promise<Observable<any>> {
+      const ctx = context.switchToHttp();
+
+      await new Promise((resolve, reject) =>
+        this.upload.fields(uploadFields)(
+          ctx.getRequest(),
+          ctx.getResponse(),
+          err => {
+            if (err) {
+              const error = transformException(err);
+              return reject(error);
+            }
+            resolve();
+          },
+        ),
+      );
+      return call$;
+    }
+  };
+  return Interceptor;
+}

packages/common/interceptors/index.ts

@@ -1,2 +1,3 @@
+export * from './file-fields.interceptor';
 export * from './file.interceptor';
 export * from './files.interceptor';

packages/common/interceptors/multer/multer.utils.ts

@@ -1,9 +1,4 @@
-import {
-  InternalServerErrorException,
-  HttpException,
-  PayloadTooLargeException,
-  BadRequestException,
-} from './../../exceptions';
+import { BadRequestException, HttpException, PayloadTooLargeException } from './../../exceptions';
 import { multerExceptions } from './multer.constants';
 
 export function transformException(error: Error | undefined) {

packages/common/interfaces/external/multer-options.interface.ts

@@ -52,3 +52,10 @@ export interface MulterOptions {
     callback: (error: Error | null, acceptFile: boolean) => void,
   ): void;
 }
+
+export interface MulterField {
+  /** The field name. */
+  name: string;
+  /** Optional maximum number of files per field to accept. */
+  maxCount?: number;
+}

packages/common/test/interceptors/file-fields.interceptor.spec.ts

@@ -0,0 +1,57 @@
+import * as sinon from 'sinon';
+import { expect } from 'chai';
+import { FileFieldsInterceptor } from './../../interceptors/file-fields.interceptor';
+import { Observable, of } from 'rxjs';
+import { ExecutionContextHost } from '@nestjs/core/helpers/execution-context.host';
+
+describe('FileFieldsInterceptor', () => {
+  it('should return metatype with expected structure', async () => {
+    const targetClass = FileFieldsInterceptor([{name: 'file', maxCount: 1}, {name: 'anotherFile', maxCount: 1}]);
+    expect(targetClass.prototype.intercept).to.not.be.undefined;
+  });
+  describe('intercept', () => {
+    let stream$;
+    beforeEach(() => {
+      stream$ = of('test');
+    });
+    it('should call object with expected params', async () => {
+      const fieldName1 = 'file';
+      const maxCount1 = 1;
+      const fieldName2 = 'anotherFile';
+      const maxCount2 = 2;
+      const argument = [
+        {name: fieldName1, maxCount: maxCount1},
+        {name: fieldName2, maxCount: maxCount2}
+      ]
+      const target = new (FileFieldsInterceptor(argument))();
+
+      const callback = (req, res, next) => next();
+      const fieldsSpy = sinon
+        .stub((target as any).upload, 'fields')
+        .returns(callback);
+
+      await target.intercept(new ExecutionContextHost([]), stream$);
+
+      expect(fieldsSpy.called).to.be.true;
+      expect(fieldsSpy.calledWith(argument)).to.be.true;
+    });
+    it('should transform exception', async () => {
+      const fieldName1 = 'file';
+      const maxCount1 = 1;
+      const fieldName2 = 'anotherFile';
+      const maxCount2 = 2;
+      const argument = [
+        {name: fieldName1, maxCount: maxCount1},
+        {name: fieldName2, maxCount: maxCount2}
+      ]
+      const target = new (FileFieldsInterceptor(argument));
+      const err = {};
+      const callback = (req, res, next) => next(err);
+
+      (target as any).fields = {
+        array: () => callback,
+      };
+      expect(target.intercept(new ExecutionContextHost([]), stream$)).to.eventually.throw();
+    });
+  });
+});

packages/core/router/route-params-factory.ts

@@ -4,7 +4,7 @@ import { IRouteParamsFactory } from './interfaces/route-params-factory.interface
 export class RouteParamsFactory implements IRouteParamsFactory {
   public exchangeKeyForValue(
     key: RouteParamtypes | string,
-    data,
+    data: string | object | any,
     { req, res, next },
   ) {
     switch (key) {
@@ -25,7 +25,7 @@ export class RouteParamsFactory implements IRouteParamsFactory {
       case RouteParamtypes.SESSION:
         return req.session;
       case RouteParamtypes.FILE:
-        return req.file;
+        return req[data || 'file'];
       case RouteParamtypes.FILES:
         return req.files;
       default: