update(@nestjs) update to 4.3.0 version

Author: kamilmysliwiec

CHANGELOG.md

@@ -1,3 +1,11 @@
+## 4.3.0
+- **core**: `json` and `urlencoded` (`body-parser`) middlewares are applied by default now, bugfix #252
+- **core** more informative error message (injector) #223
+example: `[ExceptionHandler] Nest can't resolve dependencies of the UsersService (+, +, ?, +, +, +). Please verify whether [2] argument is available in the current context.`
+- **core**: bugfix #240 - middlewares container state
+- **core**: bugifx #257 - `@Next()` issue
+- **testing**: testing module is now independent from `@nestjs/microservices`
+
 ## 4.2.2
 - **websockets**: bugfix #242
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nestjs",
-  "version": "4.2.0",
+  "version": "4.3.0",
   "description": "Modern, fast, powerful node.js web framework",
   "main": "index.js",
   "scripts": {
@@ -41,7 +41,7 @@
   "devDependencies": {
     "@types/chai": "^3.5.2",
     "@types/chai-as-promised": "0.0.31",
-    "@types/express": "^4.0.36",
+    "@types/express": "^4.0.39",
     "@types/mocha": "^2.2.38",
     "@types/node": "^7.0.5",
     "@types/redis": "^0.12.36",

src/core/errors/exceptions/undefined-dependency.exception.ts

@@ -2,7 +2,7 @@ import { RuntimeException } from './runtime.exception';
 import { UnknownDependenciesMessage } from '../messages';
 
 export class UndefinedDependencyException extends RuntimeException {
-    constructor(type: string) {
-        super(UnknownDependenciesMessage(type));
+    constructor(type: string, index: number, length: number) {
+        super(UnknownDependenciesMessage(type, index, length));
     }
 }

src/core/errors/exceptions/unknown-dependencies.exception.ts

@@ -2,7 +2,7 @@ import { RuntimeException } from './runtime.exception';
 import { UnknownDependenciesMessage } from '../messages';
 
 export class UnknownDependenciesException extends RuntimeException {
-    constructor(type: string) {
-        super(UnknownDependenciesMessage(type));
+    constructor(type: string, index: number, length: number) {
+        super(UnknownDependenciesMessage(type, index, length));
     }
 }

src/core/errors/messages.ts

@@ -1,12 +1,21 @@
+export const UnknownDependenciesMessage = (type: string, index: number, length: number) => {
+  let message = `Nest can't resolve dependencies of the ${type}`;
+  message += ` (`;
+
+  const args = new Array(length).fill('+');
+  args[index] = '?';
+  message += args.join(', ');
+
+  message += `). Please verify whether [${index}] argument is available in the current context.`;
+  return message;
+};
+
 export const InvalidMiddlewareMessage = (name: string) =>
     `The middleware doesn't provide the 'resolve' method (${name})`;
 
 export const InvalidModuleMessage = (scope: string) =>
     `Nest can't create the module instance. The frequent reason of this exception is the circular dependency between modules. Use forwardRef() to avoid it (read more https://docs.nestjs.com/advanced/circular-dependency). Scope [${scope}]`;
 
-export const UnknownDependenciesMessage = (type: string) =>
-    `Nest can't resolve dependencies of the ${type}. Please verify whether all of them are available in the current context.`;
-
 export const UnknownExportMessage = (name: string) =>
     `You are trying to export unknown component (${name}). Remember - your component should be listed both in exports and components arrays!`;
 

src/core/injector/injector.ts

@@ -100,8 +100,14 @@ export class Injector {
     let isResolved = true;
     const args = isNil(inject) ? this.reflectConstructorParams(wrapper.metatype) : inject;
 
-    const instances = await Promise.all(args.map(async (param) => {
-      const paramWrapper = await this.resolveSingleParam<T>(wrapper, param, module, context);
+    const instances = await Promise.all(args.map(async (param, index) => {
+      const paramWrapper = await this.resolveSingleParam<T>(
+        wrapper,
+        param,
+        { index, length: args.length },
+        module,
+        context,
+      );
       if (!paramWrapper.isResolved && !paramWrapper.forwardRef) {
         isResolved = false;
       }
@@ -125,16 +131,18 @@ export class Injector {
   public async resolveSingleParam<T>(
     wrapper: InstanceWrapper<T>,
     param: Metatype<any> | string | symbol | any,
+    { index, length }: { index: number, length: number },
     module: Module,
-    context: Module[]) {
-
+    context: Module[],
+  ) {
     if (isUndefined(param)) {
-      throw new UndefinedDependencyException(wrapper.name);
+      throw new UndefinedDependencyException(wrapper.name, index, length);
     }
     const token = this.resolveParamToken(wrapper, param);
     return await this.resolveComponentInstance<T>(
       module,
       isFunction(token) ? (token as Metatype<any>).name : token,
+      { index, length },
       wrapper,
       context,
     );
@@ -151,10 +159,21 @@ export class Injector {
     return param.forwardRef();
   }
 
-  public async resolveComponentInstance<T>(module: Module, name: any, wrapper: InstanceWrapper<T>, context: Module[]) {
+  public async resolveComponentInstance<T>(
+    module: Module,
+    name: any,
+    { index, length }: { index: number, length: number },
+    wrapper: InstanceWrapper<T>,
+    context: Module[],
+  ) {
     const components = module.components;
-    const instanceWrapper = await this.scanForComponent(components, name, module, wrapper, context);
-
+    const instanceWrapper = await this.scanForComponent(
+      components,
+      module,
+      { name, index, length },
+      wrapper,
+      context,
+    );
     if (!instanceWrapper.isResolved && !instanceWrapper.forwardRef) {
       await this.loadInstanceOfComponent(instanceWrapper, module);
     }
@@ -164,36 +183,62 @@ export class Injector {
     return instanceWrapper;
   }
 
-  public async scanForComponent(components: Map<string, any>, name: any, module: Module, { metatype }, context: Module[] = []) {
-    const component = await this.scanForComponentInScopes(context, name, metatype);
+  public async scanForComponent(
+    components: Map<string, any>,
+    module: Module,
+    { name, index, length }: { name: any, index: number, length: number },
+    { metatype },
+    context: Module[] = [],
+  ) {
+    const component = await this.scanForComponentInScopes(context, { name, index, length }, metatype);
     if (component) {
       return component;
     }
-    const scanInExports = () => this.scanForComponentInExports(components, name, module, metatype, context);
+    const scanInExports = () => this.scanForComponentInExports(
+      components,
+      { name, index, length },
+      module,
+      metatype,
+      context,
+    );
     return components.has(name) ? components.get(name) : await scanInExports();
   }
 
-  public async scanForComponentInExports(components: Map<string, any>, name: any, module: Module, metatype, context: Module[] = []) {
+  public async scanForComponentInExports(
+    components: Map<string, any>,
+    { name, index, length }: { name: any, index: number, length: number },
+    module: Module,
+    metatype,
+    context: Module[] = [],
+  ) {
     const instanceWrapper = await this.scanForComponentInRelatedModules(module, name, context);
     if (isNil(instanceWrapper)) {
-      throw new UnknownDependenciesException(metatype.name);
+      throw new UnknownDependenciesException(metatype.name, index, length);
     }
     return instanceWrapper;
   }
 
-  public async scanForComponentInScopes(context: Module[], name: any, metatype) {
+  public async scanForComponentInScopes(
+    context: Module[],
+    { name, index, length }: { name: any, index: number, length: number },
+    metatype,
+  ) {
     context = context || [];
     for (const ctx of context) {
-      const component = await this.scanForComponentInScope(ctx, name, metatype);
+      const component = await this.scanForComponentInScope(ctx, { name, index, length }, metatype);
       if (component) return component;
     }
     return null;
   }
 
-  public async scanForComponentInScope(context: Module, name: any, metatype) {
+  public async scanForComponentInScope(
+    context: Module,
+    { name, index, length }: { name: any, index: number, length: number },
+    metatype,
+  ) {
     try {
       const component = await this.scanForComponent(
-        context.components, name, context, { metatype }, null,
+        context.components, context, { name, index, length }, { metatype }, null,
       );
       if (!component.isResolved && !component.forwardRef) {
         await this.loadInstanceOfComponent(component, context);

src/core/middlewares/middlewares-module.ts

@@ -21,71 +21,84 @@ import { RouterExceptionFilters } from './../router/router-exception-filters';
 
 export class MiddlewaresModule {
     private static readonly routesMapper = new RoutesMapper();
-    private static readonly container = new MiddlewaresContainer();
     private static readonly routerProxy = new RouterProxy();
     private static readonly routerMethodFactory = new RouterMethodFactory();
     private static routerExceptionFilter: RouterExceptionFilters;
     private static resolver: MiddlewaresResolver;
 
-    public static async setup(container: NestContainer, config: ApplicationConfig) {
+    public static async setup(
+        middlewaresContainer: MiddlewaresContainer,
+        container: NestContainer,
+        config: ApplicationConfig,
+    ) {
         this.routerExceptionFilter = new RouterExceptionFilters(config);
-        this.resolver = new MiddlewaresResolver(this.container);
+        this.resolver = new MiddlewaresResolver(middlewaresContainer);
 
         const modules = container.getModules();
-        await this.resolveMiddlewares(modules);
+        await this.resolveMiddlewares(middlewaresContainer, modules);
     }
 
-    public static getContainer(): MiddlewaresContainer {
-        return this.container;
-    }
-
-    public static async resolveMiddlewares(modules: Map<string, Module>) {
+    public static async resolveMiddlewares(
+        middlewaresContainer: MiddlewaresContainer,
+        modules: Map<string, Module>,
+    ) {
         await Promise.all([...modules.entries()].map(async ([name, module]) => {
             const instance = module.instance;
 
-            this.loadConfiguration(instance, name);
+            this.loadConfiguration(middlewaresContainer, instance, name);
             await this.resolver.resolveInstances(module, name);
         }));
     }
 
-    public static loadConfiguration(instance: NestModule, module: string) {
+    public static loadConfiguration(
+        middlewaresContainer: MiddlewaresContainer,
+        instance: NestModule,
+        module: string,
+    ) {
         if (!instance.configure) return;
 
         const middlewaresBuilder = new MiddlewareBuilder(this.routesMapper);
         instance.configure(middlewaresBuilder);
+
         if (!(middlewaresBuilder instanceof MiddlewareBuilder)) return;
 
         const config = middlewaresBuilder.build();
-        this.container.addConfig(config, module);
+        middlewaresContainer.addConfig(config, module);
     }
 
-    public static async setupMiddlewares(app) {
-        const configs = this.container.getConfigs();
+    public static async setupMiddlewares(middlewaresContainer: MiddlewaresContainer, app) {
+        const configs = middlewaresContainer.getConfigs();
         await Promise.all([...configs.entries()].map(async ([module, moduleConfigs]) => {
             await Promise.all([...moduleConfigs].map(async (config: MiddlewareConfiguration) => {
-                await this.setupMiddlewareConfig(config, module, app);
+                await this.setupMiddlewareConfig(middlewaresContainer, config, module, app);
             }));
         }));
     }
 
-    public static async setupMiddlewareConfig(config: MiddlewareConfiguration, module: string, app) {
+    public static async setupMiddlewareConfig(
+        middlewaresContainer: MiddlewaresContainer, 
+        config: MiddlewareConfiguration, 
+        module: string,
+        app,
+    ) {
         const { forRoutes } = config;
         await Promise.all(forRoutes.map(async (route: ControllerMetadata & { method: RequestMethod }) => {
-            await this.setupRouteMiddleware(route, config, module, app);
+            await this.setupRouteMiddleware(middlewaresContainer, route, config, module, app);
         }));
     }
 
     public static async setupRouteMiddleware(
+        middlewaresContainer: MiddlewaresContainer,
         route: ControllerMetadata & { method: RequestMethod },
         config: MiddlewareConfiguration,
         module: string,
-        app) {
-
+        app,
+    ) {
         const { path, method } = route;
 
         const middlewares = [].concat(config.middlewares);
         await Promise.all(middlewares.map(async (metatype: Metatype<NestMiddleware>) => {
-            const collection = this.container.getMiddlewares(module);
+            const collection = middlewaresContainer.getMiddlewares(module);
             const middleware = collection.get(metatype.name);
             if (isUndefined(middleware)) {
                 throw new RuntimeException();

src/core/nest-application.ts

@@ -1,5 +1,6 @@
 import * as http from 'http';
 import * as optional from 'optional';
+import * as bodyParser from 'body-parser';
 import iterate from 'iterare';
 import {
     CanActivate,
@@ -22,13 +23,15 @@ import { MiddlewaresModule } from './middlewares/middlewares-module';
 import { Resolver } from './router/interfaces/resolver.interface';
 import { RoutesResolver } from './router/routes-resolver';
 import { MicroservicesPackageNotFoundException } from './errors/exceptions/microservices-package-not-found.exception';
+import { MiddlewaresContainer } from './middlewares/container';
 
 const { SocketModule } = optional('@nestjs/websockets/socket-module') || {} as any;
 const { MicroservicesModule } = optional('@nestjs/microservices/microservices-module') || {} as any;
 const { NestMicroservice } = optional('@nestjs/microservices/nest-microservice') || {} as any;
 const { IoAdapter } = optional('@nestjs/websockets/adapters/io-adapter') || {} as any;
 
 export class NestApplication implements INestApplication {
+    private readonly middlewaresContainer = new MiddlewaresContainer();
     private readonly logger = new Logger(NestApplication.name, true);
     private readonly httpServer: http.Server = null;
     private readonly routesResolver: Resolver = null;
@@ -40,6 +43,7 @@ export class NestApplication implements INestApplication {
         private readonly container: NestContainer,
         private readonly express,
     ) {
+        this.setupParserMiddlewares();
         this.httpServer = http.createServer(express);
 
         const ioAdapter = IoAdapter ? new IoAdapter(this.httpServer) : null;
@@ -49,14 +53,23 @@ export class NestApplication implements INestApplication {
         );
     }
 
+    public setupParserMiddlewares() {
+      this.express.use(bodyParser.json());
+      this.express.use(bodyParser.urlencoded({ extended: true }));
+    }
+
     public async setupModules() {
         SocketModule && SocketModule.setup(this.container, this.config);
 
         if (MicroservicesModule) {
           MicroservicesModule.setup(this.container, this.config);
           MicroservicesModule.setupClients(this.container);
         }
-        await MiddlewaresModule.setup(this.container, this.config);
+        await MiddlewaresModule.setup(
+          this.middlewaresContainer,
+          this.container,
+          this.config,
+        );
     }
 
     public async init() {
@@ -158,7 +171,7 @@ export class NestApplication implements INestApplication {
     }
 
     private async setupMiddlewares(instance) {
-        await MiddlewaresModule.setupMiddlewares(instance);
+        await MiddlewaresModule.setupMiddlewares(this.middlewaresContainer, instance);
     }
 
     private listenToPromise(microservice: INestMicroservice) {

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

@@ -45,7 +45,7 @@ export class RouterExecutionContext {
         const interceptors = this.interceptorsContextCreator.create(instance, callback, module);
         const httpCode = this.reflectHttpStatusCode(callback);
         const paramsMetadata = this.exchangeKeysForValues(keys, metadata);
-        const isResponseObj = paramsMetadata.some(({ type }) => type === RouteParamtypes.RESPONSE);
+        const isResponseHandled = paramsMetadata.some(({ type }) => type === RouteParamtypes.RESPONSE || type === RouteParamtypes.NEXT);
         const paramsOptions = this.mergeParamsMetatypes(paramsMetadata, paramtypes);
 
         return async (req, res, next) => {
@@ -68,7 +68,7 @@ export class RouterExecutionContext {
             const result = await this.interceptorsConsumer.intercept(
                 interceptors, req, instance, callback, handler,
             );
-            return !isResponseObj ?
+            return !isResponseHandled ?
                 this.responseController.apply(result, res, requestMethod, httpCode) :
                 undefined;
         };