update(@core) increase router performance

Author: kamilmysliwiec

CHANGELOG.md

@@ -1,3 +1,6 @@
+## 4.5.3
+- **core**: [improvement] increase performance
+
 ## 4.5.2
 - **common**: [feature] rename `modules` to `imports` (`@Module()` decorator)
 - **core**: [feature] exception filters with empty `@Catch()` metadata handle each occurred exception 

src/core/router/router-execution-context.ts

@@ -75,40 +75,22 @@ export class RouterExecutionContext {
         type === RouteParamtypes.RESPONSE || type === RouteParamtypes.NEXT,
     );
     const paramsOptions = this.mergeParamsMetatypes(paramsMetadata, paramtypes);
+    const httpStatusCode = httpCode
+      ? httpCode
+      : this.responseController.getStatusByMethod(requestMethod);
+
+    const fnCanActivate = this.createGuardsFn(guards, instance, callback);
+    const fnApplyPipes = this.createPipesFn(pipes, paramsOptions);
+    const fnHandleResponse = this.createHandleResponseFn(
+      isResponseHandled,
+      httpStatusCode,
+    );
 
     return async (req, res, next) => {
       const args = this.createNullArray(argsLength);
-      const canActivate = await this.guardsConsumer.tryActivate(
-        guards,
-        req,
-        instance,
-        callback,
-      );
-      if (!canActivate) {
-        throw new HttpException(FORBIDDEN_MESSAGE, HttpStatus.FORBIDDEN);
-      }
-
-      await Promise.all(
-        paramsOptions.map(async param => {
-          const {
-            index,
-            extractValue,
-            type,
-            data,
-            metatype,
-            pipes: paramPipes,
-          } = param;
-          const value = extractValue(req, res, next);
+      await fnCanActivate(req);
+      await fnApplyPipes(args, req, res, next);
 
-          args[index] = await this.getParamValue(
-            value,
-            { metatype, type, data },
-            pipes.concat(
-              this.pipesContextCreator.createConcreteContext(paramPipes),
-            ),
-          );
-        }),
-      );
       const handler = () => callback.apply(instance, args);
       const result = await this.interceptorsConsumer.intercept(
         interceptors,
@@ -117,9 +99,7 @@ export class RouterExecutionContext {
         callback,
         handler,
       );
-      return !isResponseHandled
-        ? this.responseController.apply(result, res, requestMethod, httpCode)
-        : undefined;
+      fnHandleResponse(result, res);
     };
   }
 
@@ -215,4 +195,63 @@ export class RouterExecutionContext {
     }
     return Promise.resolve(value);
   }
+
+  public createGuardsFn(
+    guards: any[],
+    instance: Controller,
+    callback: (...args) => any,
+  ) {
+    const canActivateFn = async req => {
+      const canActivate = await this.guardsConsumer.tryActivate(
+        guards,
+        req,
+        instance,
+        callback,
+      );
+      if (!canActivate) {
+        throw new HttpException(FORBIDDEN_MESSAGE, HttpStatus.FORBIDDEN);
+      }
+    };
+    return guards.length ? canActivateFn : async req => undefined;
+  }
+
+  public createPipesFn(
+    pipes: any[],
+    paramsOptions: (ParamProperties & { metatype?: any })[],
+  ) {
+    const pipesFn = async (args, req, res, next) => {
+      await Promise.all(
+        paramsOptions.map(async param => {
+          const {
+            index,
+            extractValue,
+            type,
+            data,
+            metatype,
+            pipes: paramPipes,
+          } = param;
+          const value = extractValue(req, res, next);
+
+          args[index] = await this.getParamValue(
+            value,
+            { metatype, type, data },
+            pipes.concat(
+              this.pipesContextCreator.createConcreteContext(paramPipes),
+            ),
+          );
+        }),
+      );
+    };
+    return paramsOptions.length ? pipesFn : async (...args) => undefined;
+  }
+
+  public createHandleResponseFn(
+    isResponseHandled: boolean,
+    httpStatusCode: number,
+  ) {
+    return !isResponseHandled
+      ? (result, res) =>
+          this.responseController.apply(result, res, httpStatusCode)
+      : (...args) => undefined;
+  }
 }

src/core/router/router-response-controller.ts

@@ -6,18 +6,14 @@ export class RouterResponseController {
   public async apply(
     resultOrDeffered,
     response,
-    requestMethod: RequestMethod,
-    httpCode: number,
+    httpStatusCode: number,
   ) {
     const result = await this.transformToResult(resultOrDeffered);
-    const statusCode = httpCode
-      ? httpCode
-      : this.getStatusByMethod(requestMethod);
-    const res = response.status(statusCode);
+    const res = response.status(httpStatusCode);
     if (isNil(result)) {
       return res.send();
     }
-    return isObject(result) ? res.json(result) : res.send(String(result));
+    return isObject(result) ? res.json(result) : res.send(result);
   }
 
   public async transformToResult(resultOrDeffered) {

src/core/test/router/router-execution-context.spec.ts

@@ -137,7 +137,6 @@ describe('RouterExecutionContext', () => {
         instance,
         'callback',
       );
-      console.log(metadata);
 
       const expectedMetadata = {
         [`${RouteParamtypes.REQUEST}:0`]: {
@@ -314,4 +313,27 @@ describe('RouterExecutionContext', () => {
       });
     });
   });
+  describe('createPipesFn', () => {
+    describe('when "paramsOptions" is empty', () => {
+      it('returns identity(undefined)', async () => {
+        const pipesFn = contextCreator.createPipesFn([], []);
+        expect(await pipesFn()).to.be.undefined;
+      });
+    });
+  });
+  describe('createGuardsFn', () => {
+    it('should throw exception when "tryActivate" returns false', () => {
+      const guardsFn = contextCreator.createGuardsFn([null], null, null);
+      sinon.stub(guardsConsumer, 'tryActivate', () => false);
+      expect(guardsFn({})).to.eventually.throw();
+    });
+  });
+  describe('createHandleResponseFn', () => {
+    it('should throw exception when "tryActivate" returns false', () => {
+      const responseFn = contextCreator.createHandleResponseFn(false, 200);
+      const controllerApplySpy = sinon.spy((contextCreator['responseController'] as any), 'apply');
+      responseFn();
+      expect(controllerApplySpy.calledOnce).to.be.true;
+    });
+  });
 });

src/core/test/router/router-response-controller.spec.ts

@@ -27,22 +27,22 @@ describe('RouterResponseController', () => {
       describe('nil', () => {
         it('should call send()', async () => {
           const value = null;
-          await routerResponseController.apply(value, response, 1, 200);
+          await routerResponseController.apply(value, response, 200);
           expect(response.send.called).to.be.true;
         });
       });
       describe('string', () => {
         it('should call send(value)', async () => {
           const value = 'string';
-          await routerResponseController.apply(value, response, 1, 200);
+          await routerResponseController.apply(value, response, 200);
           expect(response.send.called).to.be.true;
           expect(response.send.calledWith(String(value))).to.be.true;
         });
       });
       describe('object', () => {
         it('should call json(value)', async () => {
           const value = { test: 'test' };
-          await routerResponseController.apply(value, response, 1, 200);
+          await routerResponseController.apply(value, response, 200);
           expect(response.json.called).to.be.true;
           expect(response.json.calledWith(value)).to.be.true;
         });

src/microservices/server/server.ts

@@ -3,6 +3,7 @@ import { MessageHandlers } from '../interfaces/message-handlers.interface';
 import { Observable } from 'rxjs/Observable';
 import { MicroserviceResponse } from '../index';
 import { Subscription } from 'rxjs/Subscription';
+import { isFunction } from '@nestjs/common/utils/shared.utils';
 import 'rxjs/add/operator/catch';
 import 'rxjs/add/operator/finally';
 import 'rxjs/add/observable/empty';
@@ -37,7 +38,7 @@ export abstract class Server {
   public transformToObservable(resultOrDeffered) {
     if (resultOrDeffered instanceof Promise) {
       return Observable.fromPromise(resultOrDeffered);
-    } else if (!(resultOrDeffered instanceof Observable)) {
+    } else if (!(resultOrDeffered && isFunction(resultOrDeffered.subscribe))) {
       return Observable.of(resultOrDeffered);
     }
     return resultOrDeffered;

src/websockets/web-sockets-controller.ts

@@ -17,6 +17,7 @@ import { MiddlewaresInjector } from './middlewares-injector';
 import { ApplicationConfig } from '@nestjs/core/application-config';
 import { WsContextCreator } from './context/ws-context-creator';
 import { Observable } from 'rxjs/Observable';
+import { isFunction } from '@nestjs/common/utils/shared.utils';
 import 'rxjs/add/observable/fromPromise';
 import 'rxjs/add/observable/of';
 import 'rxjs/add/operator/switchMap';
@@ -155,7 +156,7 @@ export class WebSocketsController {
     defferedResult: Promise<any>,
   ): Promise<Observable<any>> {
     const result = await defferedResult;
-    if (result instanceof Observable) {
+    if (result && isFunction(result.subscribe)) {
       return result;
     }
     if (result instanceof Promise) {