feature() fix request scoped

kamilmysliwiec · kamilmysliwiec · commit 5352bba8f75f · 2018-12-15T23:02:04.000+01:00
diff --git a/packages/core/helpers/handler-metadata-storage.ts b/packages/core/helpers/handler-metadata-storage.ts
@@ -0,0 +1,36 @@
+import { Controller } from '@nestjs/common/interfaces';
+import { ParamProperties } from './context-utils';
+
+export const HANDLER_METADATA_SYMBOL = Symbol.for('handler_metadata:cache');
+
+export interface HandlerMetadata {
+  argsLength: number;
+  paramsOptions: (ParamProperties & { metatype?: any })[];
+  fnHandleResponse: <TResult, TResponse>(
+    result: TResult,
+    res: TResponse,
+  ) => any;
+}
+
+export class HandlerMetadataStorage<T = any> {
+  private readonly [HANDLER_METADATA_SYMBOL] = new Map<
+    string,
+    HandlerMetadata
+  >();
+
+  set(controller: T, methodName: string, metadata: HandlerMetadata) {
+    const metadataKey = this.getMetadataKey(controller, methodName);
+    this[HANDLER_METADATA_SYMBOL].set(metadataKey, metadata);
+  }
+
+  get(controller: T, methodName: string): HandlerMetadata | undefined {
+    const metadataKey = this.getMetadataKey(controller, methodName);
+    return this[HANDLER_METADATA_SYMBOL].get(metadataKey);
+  }
+
+  private getMetadataKey(controller: Controller, methodName: string): string {
+    const ctor = controller.constructor;
+    const controllerKey = ctor && ctor.name;
+    return controllerKey + methodName;
+  }
+}
diff --git a/packages/core/hooks/async-hooks-module.ts b/packages/core/hooks/async-hooks-module.ts
@@ -0,0 +1,13 @@
+import { Global, Module } from '@nestjs/common';
+import { AsyncContext } from './async-context';
+
+@Global()
+@Module({
+  providers: [
+    {
+      provide: AsyncContext,
+      useValue: AsyncContext.instance,
+    },
+  ],
+})
+export class AsyncHooksModule {}
diff --git a/packages/core/hooks/index.ts b/packages/core/hooks/index.ts
@@ -1 +1,2 @@
 export * from './async-context';
+export * from './async-hooks-module';
diff --git a/packages/core/injector/instance-wrapper.ts b/packages/core/injector/instance-wrapper.ts
@@ -2,7 +2,7 @@ import { Scope, Type } from '@nestjs/common';
 import { STATIC_CONTEXT } from './constants';
 import { Module } from './module';
 
-export const INSTANCE_METADATA_SYMBOL = Symbol.for('metadata:cache');
+export const INSTANCE_METADATA_SYMBOL = Symbol.for('instance_metadata:cache');
 
 export interface ContextId {
   readonly id: number;
diff --git a/packages/core/injector/module.ts b/packages/core/injector/module.ts
@@ -20,7 +20,6 @@ import { RuntimeException } from '../errors/exceptions/runtime.exception';
 import { UnknownExportException } from '../errors/exceptions/unknown-export.exception';
 import { ApplicationReferenceHost } from '../helpers/application-ref-host';
 import { ExternalContextCreator } from '../helpers/external-context-creator';
-import { AsyncContext } from '../hooks/async-context';
 import { Reflector } from '../services/reflector.service';
 import { NestContainer } from './container';
 import { InstanceWrapper } from './instance-wrapper';
@@ -138,17 +137,6 @@ export class Module {
     this.addExternalContextCreator(container.getExternalContextCreator());
     this.addModulesContainer(container.getModulesContainer());
     this.addApplicationRefHost(container.getApplicationRefHost());
-
-    this._providers.set(
-      AsyncContext.name,
-      new InstanceWrapper({
-        name: AsyncContext.name,
-        metatype: AsyncContext as any,
-        isResolved: true,
-        instance: AsyncContext.instance,
-        host: this,
-      }),
-    );
   }
 
   public addModuleRef() {
diff --git a/packages/core/middleware/middleware-module.ts b/packages/core/middleware/middleware-module.ts
@@ -1,5 +1,7 @@
 import { HttpServer } from '@nestjs/common';
+import { SCOPE_OPTIONS_METADATA } from '@nestjs/common/constants';
 import { RequestMethod } from '@nestjs/common/enums/request-method.enum';
+import { Scope } from '@nestjs/common/interfaces';
 import {
   MiddlewareConfiguration,
   RouteInfo,
@@ -182,6 +184,13 @@ export class MiddlewareModule {
         middlewareInstance,
         path,
       );
+
+    const classScope = this.getClassScope(instance);
+    if (classScope === Scope.REQUEST) {
+      return bindWithProxy(async (...args: unknown[]) =>
+        (await instance.resolve())(...args),
+      );
+    }
     const middleware = await instance.resolve();
     bindWithProxy(middleware);
   }
@@ -201,4 +210,9 @@ export class MiddlewareModule {
     const basePath = validatePath(prefix);
     router(basePath + path, proxy);
   }
+
+  private getClassScope(instance: NestMiddleware): Scope {
+    const metadata = Reflect.getMetadata(SCOPE_OPTIONS_METADATA, instance);
+    return metadata && metadata.scope;
+  }
 }
diff --git a/packages/core/router/router-execution-context.ts b/packages/core/router/router-execution-context.ts
@@ -24,6 +24,10 @@ import { FORBIDDEN_MESSAGE } from '../guards/constants';
 import { GuardsConsumer } from '../guards/guards-consumer';
 import { GuardsContextCreator } from '../guards/guards-context-creator';
 import { ContextUtils } from '../helpers/context-utils';
+import {
+  HandlerMetadata,
+  HandlerMetadataStorage,
+} from '../helpers/handler-metadata-storage';
 import { STATIC_CONTEXT } from '../injector/constants';
 import { InterceptorsConsumer } from '../interceptors/interceptors-consumer';
 import { InterceptorsContextCreator } from '../interceptors/interceptors-context-creator';
@@ -48,6 +52,7 @@ export interface ParamProperties {
 }
 
 export class RouterExecutionContext {
+  private readonly handlerMetadataStorage = new HandlerMetadataStorage();
   private readonly contextUtils = new ContextUtils();
   private readonly responseController: RouterResponseController;
 
@@ -72,23 +77,18 @@ export class RouterExecutionContext {
     requestMethod: RequestMethod,
     contextId = STATIC_CONTEXT,
   ) {
-    const metadata =
-      this.contextUtils.reflectCallbackMetadata(
-        instance,
-        methodName,
-        ROUTE_ARGS_METADATA,
-      ) || {};
-    const keys = Object.keys(metadata);
-    const argsLength = this.contextUtils.getArgumentsLength(keys, metadata);
-    const pipes = this.pipesContextCreator.create(
+    const { argsLength, paramsOptions, fnHandleResponse } = this.getMetadata(
       instance,
       callback,
+      methodName,
       module,
-      contextId,
+      requestMethod,
     );
-    const paramtypes = this.contextUtils.reflectCallbackParamtypes(
+    const pipes = this.pipesContextCreator.create(
       instance,
-      methodName,
+      callback,
+      module,
+      contextId,
     );
     const guards = this.guardsContextCreator.create(
       instance,
@@ -102,27 +102,10 @@ export class RouterExecutionContext {
       module,
       contextId,
     );
-    const httpCode = this.reflectHttpStatusCode(callback);
-    const paramsMetadata = this.exchangeKeysForValues(keys, metadata, module);
-    const isResponseHandled = paramsMetadata.some(
-      ({ type }) =>
-        type === RouteParamtypes.RESPONSE || type === RouteParamtypes.NEXT,
-    );
-    const paramsOptions = this.contextUtils.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(
-      callback,
-      isResponseHandled,
-      httpStatusCode,
-    );
+
     const handler = <TRequest, TResponse>(
       args: any[],
       req: TRequest,
@@ -152,6 +135,57 @@ export class RouterExecutionContext {
     };
   }
 
+  public getMetadata(
+    instance: Controller,
+    callback: (...args: any[]) => any,
+    methodName: string,
+    module: string,
+    requestMethod: RequestMethod,
+  ): HandlerMetadata {
+    const cacheMetadata = this.handlerMetadataStorage.get(instance, methodName);
+    if (cacheMetadata) {
+      return cacheMetadata;
+    }
+    const metadata =
+      this.contextUtils.reflectCallbackMetadata(
+        instance,
+        methodName,
+        ROUTE_ARGS_METADATA,
+      ) || {};
+    const keys = Object.keys(metadata);
+    const argsLength = this.contextUtils.getArgumentsLength(keys, metadata);
+    const paramtypes = this.contextUtils.reflectCallbackParamtypes(
+      instance,
+      methodName,
+    );
+    const httpCode = this.reflectHttpStatusCode(callback);
+    const paramsMetadata = this.exchangeKeysForValues(keys, metadata, module);
+    const isResponseHandled = paramsMetadata.some(
+      ({ type }) =>
+        type === RouteParamtypes.RESPONSE || type === RouteParamtypes.NEXT,
+    );
+    const paramsOptions = this.contextUtils.mergeParamsMetatypes(
+      paramsMetadata,
+      paramtypes,
+    );
+    const httpStatusCode = httpCode
+      ? httpCode
+      : this.responseController.getStatusByMethod(requestMethod);
+
+    const fnHandleResponse = this.createHandleResponseFn(
+      callback,
+      isResponseHandled,
+      httpStatusCode,
+    );
+    const handlerMetadata: HandlerMetadata = {
+      argsLength,
+      paramsOptions,
+      fnHandleResponse,
+    };
+    this.handlerMetadataStorage.set(instance, methodName, handlerMetadata);
+    return handlerMetadata;
+  }
+
   public reflectHttpStatusCode(callback: (...args: any[]) => any): number {
     return Reflect.getMetadata(HTTP_CODE_METADATA, callback);
   }
diff --git a/packages/core/router/router-explorer.ts b/packages/core/router/router-explorer.ts
@@ -1,5 +1,9 @@
-import { HttpServer } from '@nestjs/common';
-import { METHOD_METADATA, PATH_METADATA } from '@nestjs/common/constants';
+import { HttpServer, Scope } from '@nestjs/common';
+import {
+  METHOD_METADATA,
+  PATH_METADATA,
+  SCOPE_OPTIONS_METADATA,
+} from '@nestjs/common/constants';
 import { RequestMethod } from '@nestjs/common/enums/request-method.enum';
 import { Controller } from '@nestjs/common/interfaces/controllers/controller.interface';
 import { Type } from '@nestjs/common/interfaces/type.interface';
@@ -163,7 +167,36 @@ export class RouterExplorer {
     const stripSlash = (str: string) =>
       str[str.length - 1] === '/' ? str.slice(0, str.length - 1) : str;
     const fullPath = stripSlash(basePath) + path;
-    // TODO:
+
+    const classScope = this.getClassScope(instance);
+    const isRequestScoped = classScope === Scope.REQUEST;
+    if (isRequestScoped) {
+      routerMethod(
+        stripSlash(fullPath) || '/',
+        async <TRequest, TResponse>(
+          req: TRequest,
+          res: TResponse,
+          next: Function,
+        ) => {
+          const contextId = { id: 1 }; // asyncId
+          const contextInstance = await this.injector.loadControllerPerContext(
+            instance,
+            this.container.getModules(),
+            module,
+            contextId,
+          );
+          this.createCallbackProxy(
+            contextInstance,
+            contextInstance[methodName],
+            methodName,
+            module,
+            requestMethod,
+            contextId,
+          )(req, res, next);
+        },
+      );
+      return;
+    }
     const proxy = this.createCallbackProxy(
       instance,
       targetCallback,
@@ -172,31 +205,6 @@ export class RouterExplorer {
       requestMethod,
     );
     routerMethod(stripSlash(fullPath) || '/', proxy);
-    /*routerMethod(
-      stripSlash(fullPath) || '/',
-      async <TRequest, TResponse>(
-        req: TRequest,
-        res: TResponse,
-        next: Function,
-      ) => {
-        const ctx = { id: 2 }; // asyncId
-        const contextInstance = await this.injector.loadControllerPerContext(
-          instance,
-          this.container.getModules(),
-          module,
-          ctx,
-        );
-        const proxy = this.createCallbackProxy(
-          contextInstance,
-          contextInstance[methodName],
-          methodName,
-          module,
-          requestMethod,
-          ctx,
-        );
-        proxy(req, res, next);
-      },
-    );*/
   }
 
   private createCallbackProxy(
@@ -223,4 +231,9 @@ export class RouterExplorer {
     );
     return this.routerProxy.createProxy(executionContext, exceptionFilter);
   }
+
+  private getClassScope(controller: Controller): Scope {
+    const metadata = Reflect.getMetadata(SCOPE_OPTIONS_METADATA, controller);
+    return metadata && metadata.scope;
+  }
 }

Original file line number	Diff line number	Diff line change
`@@ -1 +1,2 @@`
`1`	`1`	`export * from './async-context';`
	`2`	`+export * from './async-hooks-module';`