feature(@nestjs/core) extract helpers to context utils class

Author: kamilmysliwiec

packages/common/services/logger.service.ts

@@ -19,7 +19,7 @@ export class Logger implements LoggerService {
   private static readonly yellow = clc.xterm(3);
 
   constructor(
-    @Optional() private readonly context: string,
+    @Optional() private readonly context?: string,
     @Optional() private readonly isTimeDiffEnabled = false,
   ) {}
 

packages/common/test/decorators/create-route-param-metadata.spec.ts

@@ -1,18 +1,75 @@
+import { ParseIntPipe } from '@nestjs/common';
+import { ROUTE_ARGS_METADATA } from '@nestjs/common/constants';
 import { expect } from 'chai';
 import { createRouteParamDecorator } from '../../decorators/http/create-route-param-metadata.decorator';
-import { CUSTOM_ROUTE_AGRS_METADATA } from '../../constants';
 
 describe('createRouteParamDecorator', () => {
-  let key;
-  let reflector;
   let result;
 
   beforeEach(() => {
-    key = 'key';
-    reflector = (data, req, res, next) => true;
-    result = createRouteParamDecorator(reflector);
+    const fn = (data, req) => true;
+    result = createRouteParamDecorator(fn);
   });
   it('should return a function as a first element', () => {
     expect(result).to.be.a('function');
   });
+  describe('returned decorator', () => {
+    const factoryFn = (data, req) => true;
+    const Decorator = createRouteParamDecorator(factoryFn);
+
+    describe('when 0 pipes have been passed', () => {
+      const data = 'test';
+      class Test {
+        public test(@Decorator(data) param) {}
+      }
+      it('should enhance param with "data"', () => {
+        const metadata = Reflect.getMetadata(ROUTE_ARGS_METADATA, Test, 'test');
+        const key = Object.keys(metadata)[0];
+        expect(metadata[key]).to.be.eql({
+          data: 'test',
+          factory: factoryFn,
+          index: 0,
+          pipes: [],
+        });
+      });
+    });
+
+    describe('when > 0 pipes have been passed', () => {
+      const data = 'test';
+      const pipe = new ParseIntPipe();
+      class Test {
+        public test(
+          @Decorator(data, pipe)
+          param,
+        ) {}
+
+        public testNoData(@Decorator(pipe) param) {}
+      }
+      it('should enhance param with "data" and ParseIntPipe', () => {
+        const metadata = Reflect.getMetadata(ROUTE_ARGS_METADATA, Test, 'test');
+        const key = Object.keys(metadata)[0];
+        expect(metadata[key]).to.be.eql({
+          data: 'test',
+          factory: factoryFn,
+          index: 0,
+          pipes: [pipe],
+        });
+      });
+
+      it('should enhance param with ParseIntPipe', () => {
+        const metadata = Reflect.getMetadata(
+          ROUTE_ARGS_METADATA,
+          Test,
+          'testNoData',
+        );
+        const key = Object.keys(metadata)[0];
+        expect(metadata[key]).to.be.eql({
+          data: undefined,
+          factory: factoryFn,
+          index: 0,
+          pipes: [pipe],
+        });
+      });
+    });
+  });
 });

packages/common/test/decorators/route-params.decorator.spec.ts

@@ -1,7 +1,9 @@
-import 'reflect-metadata';
+import { Param } from '@nestjs/common';
 import { expect } from 'chai';
+import 'reflect-metadata';
+import { Body, Query } from '../../decorators';
 import { RequestMethod } from '../../enums/request-method.enum';
-import { Get, Post, Delete, All, Put, Patch } from '../../index';
+import { All, Delete, Get, Patch, Post, Put } from '../../index';
 
 describe('@Get', () => {
   const requestPath = 'test';
@@ -13,7 +15,7 @@ describe('@Get', () => {
   it('should enhance class with expected request metadata', () => {
     class Test {
       @Get(requestPath)
-      public static test() {}
+      public static test(@Param('id') params) {}
     }
 
     const path = Reflect.getMetadata('path', Test.test);
@@ -56,7 +58,7 @@ describe('@Post', () => {
   it('should set path on "/" by default', () => {
     class Test {
       @Post()
-      public static test() {}
+      public static test(@Query() query) {}
     }
     const path = Reflect.getMetadata('path', Test.test);
     expect(path).to.be.eql('/');
@@ -73,7 +75,7 @@ describe('@Delete', () => {
   it('should enhance class with expected request metadata', () => {
     class Test {
       @Delete(requestPath)
-      public static test() {}
+      public static test(@Body() body) {}
     }
 
     const path = Reflect.getMetadata('path', Test.test);

packages/core/helpers/context-utils.ts

@@ -0,0 +1,54 @@
+import { ParamData } from '@nestjs/common';
+import { PARAMTYPES_METADATA } from '@nestjs/common/constants';
+import { Controller, PipeTransform } from '@nestjs/common/interfaces';
+
+export interface ParamProperties<T = any, IExtractor extends Function = any> {
+  index: number;
+  type: T | string;
+  data: ParamData;
+  pipes: PipeTransform[];
+  extractValue: IExtractor;
+}
+
+export class ContextUtils {
+  public mapParamType(key: string): string {
+    const keyPair = key.split(':');
+    return keyPair[0];
+  }
+
+  public reflectCallbackParamtypes(
+    instance: Controller,
+    methodName: string,
+  ): any[] {
+    return Reflect.getMetadata(PARAMTYPES_METADATA, instance, methodName);
+  }
+
+  public reflectCallbackMetadata<T = any>(
+    instance: Controller,
+    methodName: string,
+    metadataKey: string,
+  ): T {
+    return Reflect.getMetadata(metadataKey, instance.constructor, methodName);
+  }
+
+  public getArgumentsLength<T>(keys: string[], metadata: T): number {
+    return Math.max(...keys.map(key => metadata[key].index)) + 1;
+  }
+
+  public createNullArray(length: number): any[] {
+    return Array.apply(null, { length }).fill(null);
+  }
+
+  public mergeParamsMetatypes(
+    paramsProperties: ParamProperties[],
+    paramtypes: any[],
+  ): (ParamProperties & { metatype?: any })[] {
+    if (!paramtypes) {
+      return paramsProperties;
+    }
+    return paramsProperties.map(param => ({
+      ...param,
+      metatype: paramtypes[param.index],
+    }));
+  }
+}

packages/core/helpers/external-context-creator.ts

@@ -1,5 +1,7 @@
-import { ForbiddenException } from '@nestjs/common';
-import { Controller } from '@nestjs/common/interfaces';
+import { ForbiddenException, ParamData } from '@nestjs/common';
+import { CUSTOM_ROUTE_AGRS_METADATA } from '@nestjs/common/constants';
+import { Controller, Transform } from '@nestjs/common/interfaces';
+import { isFunction, isUndefined } from '@nestjs/common/utils/shared.utils';
 import 'reflect-metadata';
 import { FORBIDDEN_MESSAGE } from '../guards/constants';
 import { GuardsConsumer } from '../guards/guards-consumer';
@@ -8,29 +10,81 @@ import { Module } from '../injector/module';
 import { ModulesContainer } from '../injector/modules-container';
 import { InterceptorsConsumer } from '../interceptors/interceptors-consumer';
 import { InterceptorsContextCreator } from '../interceptors/interceptors-context-creator';
+import { PipesConsumer } from '../pipes/pipes-consumer';
+import { PipesContextCreator } from '../pipes/pipes-context-creator';
+import { ContextUtils, ParamProperties } from './context-utils';
+
+export interface ParamsMetadata {
+  [prop: number]: {
+    index: number;
+    data?: ParamData;
+  };
+}
+
+export interface ParamsFactory {
+  exchangeKeyForValue(type: number, data: ParamData, args: any): any;
+}
 
 export class ExternalContextCreator {
+  private readonly contextUtils = new ContextUtils();
+
   constructor(
     private readonly guardsContextCreator: GuardsContextCreator,
     private readonly guardsConsumer: GuardsConsumer,
     private readonly interceptorsContextCreator: InterceptorsContextCreator,
     private readonly interceptorsConsumer: InterceptorsConsumer,
     private readonly modulesContainer: ModulesContainer,
+    private readonly pipesContextCreator: PipesContextCreator,
+    private readonly pipesConsumer: PipesConsumer,
   ) {}
 
-  public create(
+  public create<T extends ParamsMetadata = ParamsMetadata>(
     instance: Controller,
     callback: (...args) => any,
     methodName: string,
+    metadataKey?: string,
+    paramsFactory?: ParamsFactory,
   ) {
     const module = this.findContextModuleName(instance.constructor);
+    const pipes = this.pipesContextCreator.create(instance, callback, module);
+    const paramtypes = this.contextUtils.reflectCallbackParamtypes(
+      instance,
+      methodName,
+    );
     const guards = this.guardsContextCreator.create(instance, callback, module);
     const interceptors = this.interceptorsContextCreator.create(
       instance,
       callback,
       module,
     );
+
+    const metadata =
+      this.contextUtils.reflectCallbackMetadata<T>(
+        instance,
+        methodName,
+        metadataKey || '',
+      ) || {};
+    const keys = Object.keys(metadata);
+    const argsLength = this.contextUtils.getArgumentsLength(keys, metadata);
+    const paramsMetadata = paramsFactory
+      ? this.exchangeKeysForValues(keys, metadata, module, paramsFactory)
+      : null;
+
+    const paramsOptions = paramsMetadata
+      ? this.contextUtils.mergeParamsMetatypes(paramsMetadata, paramtypes)
+      : [];
+    const fnApplyPipes = this.createPipesFn(pipes, paramsOptions);
+
+    const handler = (initialArgs, ...args) => async () => {
+      if (fnApplyPipes) {
+        await fnApplyPipes(initialArgs, ...args);
+        return callback.apply(instance, initialArgs);
+      }
+      return callback.apply(instance, args);
+    };
+
     return async (...args) => {
+      const initialArgs = this.contextUtils.createNullArray(argsLength);
       const canActivate = await this.guardsConsumer.tryActivate(
         guards,
         args,
@@ -40,14 +94,14 @@ export class ExternalContextCreator {
       if (!canActivate) {
         throw new ForbiddenException(FORBIDDEN_MESSAGE);
       }
-      const handler = () => callback.apply(instance, args);
-      return await this.interceptorsConsumer.intercept(
+      const result = await this.interceptorsConsumer.intercept(
         interceptors,
         args,
         instance,
         callback,
-        handler,
+        handler(initialArgs, ...args),
       );
+      return await this.transformToResult(result);
     };
   }
 
@@ -71,4 +125,86 @@ export class ExternalContextCreator {
     );
     return !!hasComponent;
   }
+
+  public exchangeKeysForValues<TMetadata = any>(
+    keys: string[],
+    metadata: TMetadata,
+    moduleContext: string,
+    paramsFactory: ParamsFactory,
+  ): ParamProperties[] {
+    this.pipesContextCreator.setModuleContext(moduleContext);
+    return keys.map(key => {
+      const { index, data, pipes: pipesCollection } = metadata[key];
+      const pipes = this.pipesContextCreator.createConcreteContext(
+        pipesCollection,
+      );
+      const type = this.contextUtils.mapParamType(key);
+
+      if (key.includes(CUSTOM_ROUTE_AGRS_METADATA)) {
+        const { factory } = metadata[key];
+        const customExtractValue = this.getCustomFactory(factory, data);
+        return { index, extractValue: customExtractValue, type, data, pipes };
+      }
+      const numericType = Number(type);
+      const extractValue = (...args) =>
+        paramsFactory.exchangeKeyForValue(numericType, data, args);
+
+      return { index, extractValue, type: numericType, data, pipes };
+    });
+  }
+
+  public getCustomFactory(factory: (...args) => void, data): (...args) => any {
+    return !isUndefined(factory) && isFunction(factory)
+      ? (...args) => factory(data, args)
+      : () => null;
+  }
+
+  public createPipesFn(
+    pipes: any[],
+    paramsOptions: (ParamProperties & { metatype?: any })[],
+  ) {
+    const pipesFn = async (args, ...gqlArgs) => {
+      await Promise.all(
+        paramsOptions.map(async param => {
+          const {
+            index,
+            extractValue,
+            type,
+            data,
+            metatype,
+            pipes: paramPipes,
+          } = param;
+          const value = extractValue(...gqlArgs);
+
+          args[index] = await this.getParamValue(
+            value,
+            { metatype, type, data },
+            pipes.concat(paramPipes),
+          );
+        }),
+      );
+    };
+    return paramsOptions.length ? pipesFn : null;
+  }
+
+  public async getParamValue<T>(
+    value: T,
+    { metatype, type, data },
+    transforms: Transform<any>[],
+  ): Promise<any> {
+    return await this.pipesConsumer.apply(
+      value,
+      { metatype, type, data },
+      transforms,
+    );
+  }
+
+  public async transformToResult(resultOrDeffered) {
+    if (resultOrDeffered instanceof Promise) {
+      return await resultOrDeffered;
+    } else if (resultOrDeffered && isFunction(resultOrDeffered.subscribe)) {
+      return await resultOrDeffered.toPromise();
+    }
+    return resultOrDeffered;
+  }
 }