tests() fix unit tests, update enhancers

Author: kamilmysliwiec

packages/core/injector/container.ts

@@ -1,5 +1,6 @@
 import { DynamicModule } from '@nestjs/common';
 import { GLOBAL_MODULE_METADATA } from '@nestjs/common/constants';
+import { Injectable } from '@nestjs/common/interfaces/injectable.interface';
 import { Type } from '@nestjs/common/interfaces/type.interface';
 import { ApplicationConfig } from '../application-config';
 import { CircularDependencyException } from '../errors/exceptions/circular-dependency.exception';
@@ -101,6 +102,10 @@ export class NestContainer {
     return this.modules;
   }
 
+  public getModuleByKey(moduleKey: string): Module {
+    return this.modulesContainer.get(moduleKey);
+  }
+
   public async addImport(
     relatedModule: Type<any> | DynamicModule,
     token: string,
@@ -130,12 +135,16 @@ export class NestContainer {
     return module.addProvider(provider);
   }
 
-  public addInjectable(injectable: Type<any>, token: string) {
+  public addInjectable(
+    injectable: Type<any>,
+    token: string,
+    host: Type<Injectable>,
+  ) {
     if (!this.modules.has(token)) {
       throw new UnknownModuleException();
     }
     const module = this.modules.get(token);
-    module.addInjectable(injectable);
+    module.addInjectable(injectable, host);
   }
 
   public addExportedProvider(provider: Type<any>, token: string) {

packages/core/injector/injector.ts

@@ -1,4 +1,3 @@
-import { Scope } from '@nestjs/common';
 import {
   OPTIONAL_DEPS_METADATA,
   OPTIONAL_PROPERTY_DEPS_METADATA,
@@ -18,15 +17,13 @@ import {
 import { RuntimeException } from '../errors/exceptions/runtime.exception';
 import { UndefinedDependencyException } from '../errors/exceptions/undefined-dependency.exception';
 import { UnknownDependenciesException } from '../errors/exceptions/unknown-dependencies.exception';
-import { AsyncContext } from './../hooks';
 import { STATIC_CONTEXT } from './constants';
 import {
   ContextId,
   InstancePerContext,
   InstanceWrapper,
 } from './instance-wrapper';
 import { Module } from './module';
-import { ModulesContainer } from './modules-container';
 
 /**
  * The type of an injectable dependency
@@ -75,17 +72,14 @@ export class Injector {
     contextId = STATIC_CONTEXT,
   ) {
     const { metatype } = wrapper;
-    const targetMetatype = collection.get(metatype.name);
-    if (targetMetatype.instance !== null) {
+    const targetWrapper = collection.get(metatype.name);
+    if (targetWrapper.instance !== null) {
       return;
     }
     const loadInstance = (instances: any[]) => {
-      const instanceWrapper = new InstanceWrapper({
-        instance: new metatype(...instances),
-        metatype,
-        host: module,
-      });
-      collection.set(metatype.name, instanceWrapper);
+      targetWrapper.instance = targetWrapper.isDependencyTreeStatic()
+        ? new metatype(...instances)
+        : Object.create(metatype);
     };
     await this.resolveConstructorParams(
       wrapper,
@@ -199,7 +193,6 @@ export class Injector {
         instances,
         wrapper,
         targetWrapper,
-        module.id,
         contextId,
       );
       this.applyProperties(instance, properties);
@@ -526,89 +519,55 @@ export class Injector {
     instances: any[],
     wrapper: InstanceWrapper,
     targetMetatype: InstanceWrapper,
-    moduleId: string,
     contextId = STATIC_CONTEXT,
   ): Promise<T> {
-    const { metatype, inject, name, scope } = wrapper;
+    const { metatype, inject } = wrapper;
     const instanceHost = targetMetatype.getInstanceByContextId(contextId);
-    const instanceKey = moduleId + name;
+    const isDependencyTreeStatic = wrapper.isDependencyTreeStatic();
+    const isInContext =
+      (isDependencyTreeStatic && contextId === STATIC_CONTEXT) ||
+      (!isDependencyTreeStatic && contextId !== STATIC_CONTEXT);
 
-    if (isNil(inject)) {
+    if (isNil(inject) && isInContext) {
       const targetInstance = wrapper.getInstanceByContextId(contextId);
+
       targetInstance.instance = wrapper.forwardRef
         ? Object.assign(targetInstance.instance, new metatype(...instances))
         : new metatype(...instances);
-
-      if (scope === Scope.LAZY_ASYNC) {
-        this.mergeAsyncProxy(
-          instances,
-          targetInstance,
-          instanceKey,
-          metatype,
-          (...args: any[]) => new metatype(...args),
-        );
-      }
-    } else {
+    } else if (isInContext) {
       const factoryReturnValue = ((targetMetatype.metatype as any) as Function)(
         ...instances,
       );
       instanceHost.instance = await factoryReturnValue;
-      if (scope === Scope.LAZY_ASYNC) {
-        this.mergeAsyncProxy(
-          instances,
-          instanceHost,
-          instanceKey,
-          metatype,
-          (...args: any[]) =>
-            ((targetMetatype.metatype as any) as Function)(...args),
-        );
-      }
     }
     instanceHost.isResolved = true;
     return instanceHost.instance;
   }
 
-  mergeAsyncProxy(
-    instances: any[],
-    targetInstance: InstancePerContext<any>,
-    instanceKey: string,
-    metatype: Type<any>,
-    factory: (...intances: any[]) => any,
-  ) {
-    const asyncContext = AsyncContext.getInstance();
-    asyncContext.set(instanceKey, targetInstance.instance);
-
-    const proxy = (target: unknown, property: string | number | symbol) => {
-      if (!(property in (target as object))) {
-        return;
-      }
-      const cachedInstance = asyncContext.get(instanceKey);
-      if (cachedInstance) {
-        return cachedInstance[property];
-      }
-      const value = factory(...instances);
-      asyncContext.set(instanceKey, value);
-      return value[property];
-    };
-    targetInstance.instance = new Proxy(targetInstance.instance, {
-      get: proxy,
-      set: proxy,
-    });
-  }
-
-  async loadControllerPerContext<T>(
-    instance: Controller,
-    modulesContainer: ModulesContainer,
-    moduleKey: string,
+  async loadPerContext<T = any>(
+    instance: T,
+    module: Module,
+    collection: Map<string, InstanceWrapper>,
     ctx: ContextId,
   ): Promise<T> {
-    const module = modulesContainer.get(moduleKey);
+    const wrapper = collection.get(
+      instance.constructor && instance.constructor.name,
+    );
+    await this.loadInstance(wrapper, collection, module, ctx);
+    await this.loadEnhancersPerContext(wrapper, module, ctx);
 
-    const { controllers } = module;
-    const controller = controllers.get(instance.constructor.name);
-    await this.loadInstance(controller, controllers, module, ctx);
+    const host = wrapper.getInstanceByContextId(ctx);
+    return host && (host.instance as T);
+  }
 
-    const wrapper = controller.getInstanceByContextId(ctx);
-    return wrapper && (wrapper.instance as T);
+  async loadEnhancersPerContext(
+    wrapper: InstanceWrapper,
+    module: Module,
+    ctx: ContextId,
+  ) {
+    const enhancers = wrapper.getEnhancersMetadata();
+    const loadEnhancer = (item: InstanceWrapper) =>
+      this.loadInstance(item, module.injectables, module, ctx);
+    await Promise.all(enhancers.map(loadEnhancer));
   }
 }

packages/core/injector/instance-wrapper.ts

@@ -19,9 +19,10 @@ export interface PropertyMetadata {
   wrapper: InstanceWrapper;
 }
 
-export interface InstanceMetadataStore {
+interface InstanceMetadataStore {
   dependencies?: InstanceWrapper[];
   properties?: PropertyMetadata[];
+  enhancers?: InstanceWrapper[];
 }
 
 export class InstanceWrapper<T = any> {
@@ -91,19 +92,36 @@ export class InstanceWrapper<T = any> {
     return this[INSTANCE_METADATA_SYMBOL].properties;
   }
 
+  addEnhancerMetadata(wrapper: InstanceWrapper) {
+    if (!this[INSTANCE_METADATA_SYMBOL].enhancers) {
+      this[INSTANCE_METADATA_SYMBOL].enhancers = [];
+    }
+    this[INSTANCE_METADATA_SYMBOL].enhancers.push(wrapper);
+  }
+
+  getEnhancersMetadata(): InstanceWrapper[] {
+    return this[INSTANCE_METADATA_SYMBOL].enhancers;
+  }
+
   isDependencyTreeStatic(): boolean {
     if (this.scope === Scope.REQUEST) {
       return false;
     }
-    const { dependencies, properties } = this[INSTANCE_METADATA_SYMBOL];
-    const isStatic =
+    const { dependencies, properties, enhancers } = this[
+      INSTANCE_METADATA_SYMBOL
+    ];
+    let isStatic =
       (dependencies && this.isWrapperStatic(dependencies)) || !dependencies;
 
     if (!properties || !isStatic) {
       return isStatic;
     }
-    const propHosts = properties.map(item => item.wrapper);
-    return isStatic && this.isWrapperStatic(propHosts);
+    const propertiesHosts = properties.map(item => item.wrapper);
+    isStatic = isStatic && this.isWrapperStatic(propertiesHosts);
+    if (!enhancers || !isStatic) {
+      return isStatic;
+    }
+    return this.isWrapperStatic(enhancers);
   }
 
   private isWrapperStatic(tree: InstanceWrapper[]) {

packages/core/injector/module.ts

@@ -233,21 +233,27 @@ export class Module {
     );
   }
 
-  public addInjectable<T = Injectable>(injectable: Type<T>) {
+  public addInjectable<T extends Injectable>(
+    injectable: Type<T>,
+    host?: Type<T>,
+  ) {
     if (this.isCustomProvider(injectable)) {
       return this.addCustomProvider(injectable, this._injectables);
     }
-    this._injectables.set(
-      injectable.name,
-      new InstanceWrapper({
-        name: injectable.name,
-        metatype: injectable,
-        instance: null,
-        isResolved: false,
-        scope: this.getClassScope(injectable),
-        host: this,
-      }),
-    );
+    const instanceWrapper = new InstanceWrapper({
+      name: injectable.name,
+      metatype: injectable,
+      instance: null,
+      isResolved: false,
+      scope: this.getClassScope(injectable),
+      host: this,
+    });
+    this._injectables.set(injectable.name, instanceWrapper);
+
+    if (host) {
+      const hostWrapper = this._controllers.get(host && host.name);
+      hostWrapper && hostWrapper.addEnhancerMetadata(instanceWrapper);
+    }
   }
 
   public addProvider(provider: ProviderMetatype): string {

packages/core/middleware/container.ts

@@ -1,3 +1,5 @@
+import { Scope, Type } from '@nestjs/common';
+import { SCOPE_OPTIONS_METADATA } from '@nestjs/common/constants';
 import { MiddlewareConfiguration } from '@nestjs/common/interfaces/middleware/middleware-configuration.interface';
 import { InstanceWrapper } from './../injector/instance-wrapper';
 
@@ -8,46 +10,51 @@ export class MiddlewareContainer {
     Set<MiddlewareConfiguration>
   >();
 
-  public getMiddleware(module: string): Map<string, InstanceWrapper> {
+  public getMiddlewareCollection(module: string): Map<string, InstanceWrapper> {
     return this.middleware.get(module) || new Map();
   }
 
-  public getConfigs(): Map<string, Set<MiddlewareConfiguration>> {
+  public getConfigurations(): Map<string, Set<MiddlewareConfiguration>> {
     return this.configurationSets;
   }
 
-  public addConfig(configList: MiddlewareConfiguration[], module: string) {
-    const middleware = this.getCurrentMiddleware(module);
-    const targetConfig = this.getCurrentConfig(module);
+  public insertConfig(configList: MiddlewareConfiguration[], module: string) {
+    const middleware = this.getTargetMiddleware(module);
+    const targetConfig = this.getTargetConfig(module);
 
     const configurations = configList || [];
+    const insertMiddleware = <T extends Type<any>>(metatype: T) => {
+      const token = metatype.name;
+      middleware.set(
+        token,
+        new InstanceWrapper({
+          scope: this.getClassScope(metatype),
+          metatype,
+        }),
+      );
+    };
     configurations.forEach(config => {
-      const callback = metatype => {
-        const token = metatype.name;
-        middleware.set(
-          token,
-          new InstanceWrapper({
-            instance: null,
-            metatype,
-          }),
-        );
-      };
-      [].concat(config.middleware).map(callback);
+      [].concat(config.middleware).map(insertMiddleware);
       targetConfig.add(config);
     });
   }
 
-  private getCurrentMiddleware(module: string) {
+  private getTargetMiddleware(module: string) {
     if (!this.middleware.has(module)) {
       this.middleware.set(module, new Map<string, InstanceWrapper>());
     }
     return this.middleware.get(module);
   }
 
-  private getCurrentConfig(module: string) {
+  private getTargetConfig(module: string) {
     if (!this.configurationSets.has(module)) {
       this.configurationSets.set(module, new Set<MiddlewareConfiguration>());
     }
     return this.configurationSets.get(module);
   }
+
+  private getClassScope<T = any>(type: Type<T>): Scope {
+    const metadata = Reflect.getMetadata(SCOPE_OPTIONS_METADATA, type);
+    return metadata && metadata.scope;
+  }
 }