refactor: general refactor reorganize, rename things

Author: kamilmysliwiec

packages/common/pipes/validation.pipe.ts

@@ -1,10 +1,10 @@
 import { Optional } from '../decorators';
+import { Injectable } from '../decorators/core';
 import { ArgumentMetadata, BadRequestException } from '../index';
 import { ValidatorOptions } from '../interfaces/external/validator-options.interface';
 import { PipeTransform } from '../interfaces/features/pipe-transform.interface';
 import { loadPackage } from '../utils/load-package.util';
 import { isNil } from '../utils/shared.utils';
-import { Injectable } from '../decorators/core/component.decorator';
 
 export interface ValidationPipeOptions extends ValidatorOptions {
   transform?: boolean;

packages/common/test/decorators/component.decorator.spec.ts

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { Component, MiddlewareFunction, Interceptor, mixin, Injectable } from '../../index';
+import { Component, Injectable, Interceptor, mixin } from '../../index';
 
 describe('@Component', () => {
   @Component()

packages/common/utils/bind-resolve-values.util.ts

@@ -1,6 +1,6 @@
-import { Constructor } from './merge-with-values.util';
+import { Injectable } from '../decorators/core';
 import { NestMiddleware } from '../interfaces/middleware/nest-middleware.interface';
-import { Injectable } from '../decorators/core/component.decorator';
+import { Constructor } from './merge-with-values.util';
 
 export const BindResolveMiddlewareValues = <
   T extends Constructor<NestMiddleware>

packages/core/errors/messages.ts

@@ -12,21 +12,23 @@ import { Module } from '../injector/module';
  * @param instance The instance which should get the name from
  */
 const getInstanceName = (instance: any) =>
-  (instance && (instance as Type<any>).name);
+  instance && (instance as Type<any>).name;
 
 /**
  * Returns the name of the dependency
  * Tries to get the class name, otherwise the string value
  * (= injection token). As fallback it returns '+'
  * @param dependency The dependency whichs name should get displayed
  */
-const getDependencyName = (dependency: InjectorDependency) => getInstanceName(dependency) || dependency || '+';
+const getDependencyName = (dependency: InjectorDependency) =>
+  getInstanceName(dependency) || dependency || '+';
 /**
  * Returns the name of the module
  * Tries to get the class name. As fallback it returns 'current'.
  * @param module The module which should get displayed
  */
-const getModuleName = (module: Module) => (module && getInstanceName(module.metatype)) || 'current';
+const getModuleName = (module: Module) =>
+  (module && getInstanceName(module.metatype)) || 'current';
 
 export const UNKNOWN_DEPENDENCIES_MESSAGE = (
   type: string,
@@ -45,7 +47,9 @@ export const UNKNOWN_DEPENDENCIES_MESSAGE = (
 
   message += ` (`;
   message += dependenciesName.join(', ');
-  message += `). Please make sure that the argument at index [${index}] is available in the ${getModuleName(module)} context.`;
+  message += `). Please make sure that the argument at index [${index}] is available in the ${getModuleName(
+    module,
+  )} context.`;
   return message;
 };
 
@@ -56,7 +60,7 @@ export const INVALID_MODULE_MESSAGE = (text, scope: string) =>
   `Nest cannot create the module instance. Often, this is because of a circular dependency between modules. Use forwardRef() to avoid it. (Read more https://docs.nestjs.com/advanced/circular-dependency.) Scope [${scope}]`;
 
 export const UNKNOWN_EXPORT_MESSAGE = (text, module: string) =>
-  `Nest cannot export a component/module that is not a part of the currently processed module (${module}). Please verify whether each exported unit is available in this particular context.`;
+  `Nest cannot export a provider/module that is not a part of the currently processed module (${module}). Please verify whether each exported unit is available in this particular context.`;
 
 export const INVALID_CLASS_MESSAGE = (text, value: any) =>
   `ModuleRef cannot instantiate class (${value} is not constructable).`;

packages/core/exceptions/base-exception-filter.ts

@@ -44,7 +44,7 @@ export class BaseExceptionFilter<T = any> implements ExceptionFilter<T> {
     );
   }
 
-  public isExceptionObject(err): err is Error {
+  public isExceptionObject(err: any): err is Error {
     return isObject(err) && !!(err as Error).message;
   }
 }

packages/core/exceptions/exceptions-handler.ts

@@ -26,7 +26,10 @@ export class ExceptionsHandler extends BaseExceptionFilter {
     this.filters = filters;
   }
 
-  public invokeCustomFilters(exception, response): boolean {
+  public invokeCustomFilters<T = any>(
+    exception: T,
+    ctx: ArgumentsHost,
+  ): boolean {
     if (isEmpty(this.filters)) return false;
 
     const filter = this.filters.find(({ exceptionMetatypes }) => {
@@ -37,7 +40,7 @@ export class ExceptionsHandler extends BaseExceptionFilter {
         );
       return hasMetatype;
     });
-    filter && filter.func(exception, response);
+    filter && filter.func(exception, ctx);
     return !!filter;
   }
 }

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

@@ -123,19 +123,19 @@ export class ExternalContextCreator {
       return '';
     }
     for (const [key, module] of [...this.modulesContainer.entries()]) {
-      if (this.findComponentByClassName(module, className)) {
+      if (this.findProviderByClassName(module, className)) {
         return key;
       }
     }
     return '';
   }
 
-  public findComponentByClassName(module: Module, className: string): boolean {
-    const { components } = module;
-    const hasComponent = [...components.keys()].some(
-      component => component === className,
+  public findProviderByClassName(module: Module, className: string): boolean {
+    const { providers } = module;
+    const hasProvider = [...providers.keys()].some(
+      provider => provider === className,
     );
-    return hasComponent;
+    return hasProvider;
   }
 
   public exchangeKeysForValues<TMetadata = any>(
@@ -211,7 +211,7 @@ export class ExternalContextCreator {
     );
   }
 
-  public async transformToResult(resultOrDeffered) {
+  public async transformToResult(resultOrDeffered: any) {
     if (resultOrDeffered && isFunction(resultOrDeffered.subscribe)) {
       return resultOrDeffered.toPromise();
     }

packages/core/helpers/router-method-factory.ts

@@ -1,7 +1,8 @@
+import { HttpServer } from '@nestjs/common';
 import { RequestMethod } from '@nestjs/common/enums/request-method.enum';
 
 export class RouterMethodFactory {
-  public get(target, requestMethod: RequestMethod) {
+  public get(target: HttpServer, requestMethod: RequestMethod): Function {
     switch (requestMethod) {
       case RequestMethod.POST:
         return target.post;

packages/core/injector/container-scanner.ts

@@ -24,8 +24,8 @@ export class ContainerScanner {
     contextModule: Partial<Module>,
   ): TResult {
     const dependencies = new Map([
-      ...contextModule.components,
-      ...contextModule.routes,
+      ...contextModule.providers,
+      ...contextModule.controllers,
       ...contextModule.injectables,
     ]);
     const name = isFunction(metatypeOrToken)
@@ -44,8 +44,8 @@ export class ContainerScanner {
     }
     const modules = this.container.getModules();
     const initialValue = {
-      components: [],
-      routes: [],
+      providers: [],
+      controllers: [],
       injectables: [],
     };
     const merge = <T = any>(
@@ -55,8 +55,8 @@ export class ContainerScanner {
 
     this.flatContainer = ([...modules.values()].reduce(
       (current, next) => ({
-        components: merge(current.components, next.components),
-        routes: merge(current.routes, next.routes),
+        providers: merge(current.providers, next.providers),
+        controllers: merge(current.controllers, next.controllers),
         injectables: merge(current.injectables, next.injectables),
       }),
       initialValue,

packages/core/injector/container.ts

@@ -27,7 +27,7 @@ export class NestContainer {
   private applicationRef: any;
 
   constructor(
-    private readonly _applicationConfig: ApplicationConfig = void 0,
+    private readonly _applicationConfig: ApplicationConfig = undefined,
   ) {}
 
   get applicationConfig(): ApplicationConfig | undefined {
@@ -120,15 +120,15 @@ export class NestContainer {
     module.addRelatedModule(related);
   }
 
-  public addComponent(component: Type<any>, token: string): string {
-    if (!component) {
+  public addProvider(provider: Type<any>, token: string): string {
+    if (!provider) {
       throw new CircularDependencyException();
     }
     if (!this.modules.has(token)) {
       throw new UnknownModuleException();
     }
     const module = this.modules.get(token);
-    return module.addComponent(component);
+    return module.addProvider(provider);
   }
 
   public addInjectable(injectable: Type<any>, token: string) {
@@ -139,20 +139,20 @@ export class NestContainer {
     module.addInjectable(injectable);
   }
 
-  public addExportedComponent(exportedComponent: Type<any>, token: string) {
+  public addExportedProvider(provider: Type<any>, token: string) {
     if (!this.modules.has(token)) {
       throw new UnknownModuleException();
     }
     const module = this.modules.get(token);
-    module.addExportedComponent(exportedComponent);
+    module.addExportedProvider(provider);
   }
 
   public addController(controller: Type<any>, token: string) {
     if (!this.modules.has(token)) {
       throw new UnknownModuleException();
     }
     const module = this.modules.get(token);
-    module.addRoute(controller);
+    module.addController(controller);
   }
 
   public clear() {