fix(core): fix override and replace logic nestjs#2070

Author: kamilmysliwiec

packages/core/injector/injector.ts

@@ -80,7 +80,7 @@ export class Injector {
     }
     const loadInstance = (instances: any[]) => {
       targetWrapper.instance = targetWrapper.isDependencyTreeStatic()
-        ? new metatype(...instances)
+        ? new (metatype as Type<any>)(...instances)
         : Object.create(metatype.prototype);
     };
     await this.resolveConstructorParams(
@@ -190,7 +190,7 @@ export class Injector {
       throw new RuntimeException();
     }
     if (instanceHost.isResolved) {
-      return;
+      return done();
     }
     const callback = async (instances: any[]) => {
       const properties = await this.resolveProperties(
@@ -235,10 +235,10 @@ export class Injector {
       return callback(deps);
     }
     const dependencies = isNil(inject)
-      ? this.reflectConstructorParams(wrapper.metatype)
+      ? this.reflectConstructorParams(wrapper.metatype as Type<any>)
       : inject;
     const optionalDependenciesIds = isNil(inject)
-      ? this.reflectOptionalParams(wrapper.metatype)
+      ? this.reflectOptionalParams(wrapper.metatype as Type<any>)
       : [];
 
     let isResolved = true;
@@ -504,7 +504,7 @@ export class Injector {
     if (metadata && contextId !== STATIC_CONTEXT) {
       return this.loadPropertiesMetadata(metadata, contextId, inquirer);
     }
-    const properties = this.reflectProperties(wrapper.metatype);
+    const properties = this.reflectProperties(wrapper.metatype as Type<any>);
     const instances = await Promise.all(
       properties.map(async (item: PropertyDependency) => {
         try {
@@ -589,8 +589,11 @@ export class Injector {
 
     if (isNil(inject) && isInContext) {
       instanceHost.instance = wrapper.forwardRef
-        ? Object.assign(instanceHost.instance, new metatype(...instances))
-        : new metatype(...instances);
+        ? Object.assign(
+            instanceHost.instance,
+            new (metatype as Type<any>)(...instances),
+          )
+        : new (metatype as Type<any>)(...instances);
     } else if (isInContext) {
       const factoryReturnValue = ((targetMetatype.metatype as any) as Function)(
         ...instances,

packages/core/injector/instance-wrapper.ts

@@ -1,4 +1,9 @@
-import { Scope, Type } from '@nestjs/common';
+import { Provider, Scope, Type } from '@nestjs/common';
+import {
+  ClassProvider,
+  FactoryProvider,
+  ValueProvider,
+} from '@nestjs/common/interfaces';
 import { randomStringGenerator } from '@nestjs/common/utils/random-string-generator.util';
 import { isNil, isUndefined } from '@nestjs/common/utils/shared.utils';
 import { STATIC_CONTEXT } from './constants';
@@ -30,11 +35,11 @@ interface InstanceMetadataStore {
 
 export class InstanceWrapper<T = any> {
   public readonly name: any;
-  public readonly metatype: Type<T>;
-  public readonly inject?: (string | symbol | Function | Type<any>)[];
   public readonly async?: boolean;
   public readonly host?: Module;
   public readonly scope?: Scope = Scope.DEFAULT;
+  public metatype: Type<T> | Function;
+  public inject?: (string | symbol | Function | Type<any>)[];
   public forwardRef?: boolean;
 
   private readonly values = new WeakMap<ContextId, InstancePerContext<T>>();
@@ -293,6 +298,22 @@ export class InstanceWrapper<T = any> {
       .filter(item => !!item);
   }
 
+  public mergeWith(provider: Provider) {
+    if ((provider as ValueProvider).useValue) {
+      this.metatype = null;
+      this.setInstanceByContextId(STATIC_CONTEXT, {
+        instance: (provider as ValueProvider).useValue,
+        isResolved: true,
+        isPending: false,
+      });
+    } else if ((provider as ClassProvider).useClass) {
+      this.metatype = (provider as ClassProvider).useClass;
+    } else if ((provider as FactoryProvider).useFactory) {
+      this.metatype = (provider as FactoryProvider).useFactory;
+      this.inject = (provider as FactoryProvider).inject || [];
+    }
+  }
+
   private isNewable(): boolean {
     return isNil(this.inject) && this.metatype && this.metatype.prototype;
   }

packages/core/injector/module.ts

@@ -365,9 +365,13 @@ export class Module {
 
   public replace(toReplace: string | symbol | Type<any>, options: any) {
     if (options.isProvider && this.hasProvider(toReplace)) {
-      return this.addProvider({ provide: toReplace, ...options });
+      const name = this.getProviderStaticToken(toReplace);
+      const originalProvider = this._providers.get(name);
+      return originalProvider.mergeWith({ provide: toReplace, ...options });
     } else if (!options.isProvider && this.hasInjectable(toReplace)) {
-      this.addInjectable({
+      const name = this.getProviderStaticToken(toReplace);
+      const originalInjectable = this._injectables.get(name);
+      return originalInjectable.mergeWith({
         provide: toReplace,
         ...options,
       });

packages/core/router/routes-resolver.ts

@@ -1,6 +1,6 @@
 import { BadRequestException, NotFoundException } from '@nestjs/common';
 import { MODULE_PATH } from '@nestjs/common/constants';
-import { HttpServer } from '@nestjs/common/interfaces';
+import { HttpServer, Type } from '@nestjs/common/interfaces';
 import { Controller } from '@nestjs/common/interfaces/controllers/controller.interface';
 import { Logger } from '@nestjs/common/services/logger.service';
 import { ApplicationConfig } from '../application-config';
@@ -60,7 +60,10 @@ export class RoutesResolver implements Resolver {
   ) {
     routes.forEach(instanceWrapper => {
       const { metatype } = instanceWrapper;
-      const path = this.routerBuilder.extractRouterPath(metatype, basePath);
+      const path = this.routerBuilder.extractRouterPath(
+        metatype as Type<any>,
+        basePath,
+      );
       const controllerName = metatype.name;
 
       this.logger.log(CONTROLLER_MAPPING_MESSAGE(controllerName, path));

packages/websockets/web-sockets-controller.ts

@@ -28,7 +28,7 @@ export class WebSocketsController {
 
   public mergeGatewayAndServer(
     instance: NestGateway,
-    metatype: Type<any>,
+    metatype: Type<any> | Function,
     module: string,
   ) {
     const options = Reflect.getMetadata(GATEWAY_OPTIONS, metatype) || {};