@nestjs/core 5.3.14 → 5.4.1

package/Readme.md

@@ -14,7 +14,7 @@
 <a href="https://www.npmjs.com/~nestjscore"><img src="https://img.shields.io/npm/dm/@nestjs/core.svg" alt="NPM Downloads" /></a>
 <a href="https://travis-ci.org/nestjs/nest"><img src="https://api.travis-ci.org/nestjs/nest.svg?branch=master" alt="Travis" /></a>
 <a href="https://travis-ci.org/nestjs/nest"><img src="https://img.shields.io/travis/nestjs/nest/master.svg?label=linux" alt="Linux" /></a>
-<a href="https://coveralls.io/github/nestjs/nest?branch=master"><img src="https://coveralls.io/repos/github/nestjs/nest/badge.svg?branch=master#7" alt="Coverage" /></a>
+<a href="https://coveralls.io/github/nestjs/nest?branch=master"><img src="https://coveralls.io/repos/github/nestjs/nest/badge.svg?branch=master#8" alt="Coverage" /></a>
 <a href="https://gitter.im/nestjs/nestjs?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=body_badge"><img src="https://badges.gitter.im/nestjs/nestjs.svg" alt="Gitter" /></a>
 <a href="https://opencollective.com/nest#backer"><img src="https://opencollective.com/nest/backers/badge.svg" alt="Backers on Open Collective" /></a>
 <a href="https://opencollective.com/nest#sponsor"><img src="https://opencollective.com/nest/sponsors/badge.svg" alt="Sponsors on Open Collective" /></a>
@@ -53,12 +53,12 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
 <a href="http://xtremis.com/"><img src="https://nestjs.com/img/logo-xtremis.svg" width="220" /></a> 
 
 #### Silver Sponsors
-
-<a href="https://neoteric.eu/"><img src="https://nestjs.com/img/neoteric-cut.png" width="120" /></a> &nbsp; <a href="https://www.swingdev.io"><img src="https://nestjs.com/img/swingdev-logo.svg#1" width="150" /></a>
+<a href="https://neoteric.eu/"><img src="https://nestjs.com/img/neoteric-cut.png" width="120" /></a> &nbsp;
+  <a href="http://gojob.com"><img src="http://nestjs.com/img/gojob-logo.png" valign="bottom" height="95" /></a> &nbsp; <a href="https://www.swingdev.io"><img src="https://nestjs.com/img/swingdev-logo.svg#1" width="150" /> </a>
 
 #### Sponsors
 
-<a href="https://scal.io"><img src="https://nestjs.com/img/scalio-logo.svg" width="110" /></a> &nbsp; <a href="http://angularity.io"><img src="http://angularity.io/media/logo.svg" height="30" /></a> &nbsp; <a href="http://gojob.com"><img src="https://gojob.com/w/wp-content/uploads/2017/02/cropped-Logo-web-home.png" height="40" /> &nbsp; <!--<a href="https://keycdn.com"><img src="https://nestjs.com/img/keycdn.svg" height="30" /></a> &nbsp;--> <a href="https://hostpresto.com"><img src="https://nestjs.com/img/hostpresto.png" height="30" /></a> &nbsp; <a href="https://genuinebee.com/"><img src="https://nestjs.com/img/genuinebee.svg" height="38" /></a> &nbsp; <a href="http://architectnow.net/"><img src="https://nestjs.com/img/architectnow.png" height="24" /></a> &nbsp; <a href="https://quander.io/"><img src="https://nestjs.com/img/quander.png" height="28" /></a>
+<a href="https://scal.io"><img src="https://nestjs.com/img/scalio-logo.svg" width="110" /></a> &nbsp; <a href="http://angularity.io"><img src="http://angularity.io/media/logo.svg" height="30" /></a> &nbsp; <!--<a href="https://keycdn.com"><img src="https://nestjs.com/img/keycdn.svg" height="30" /></a> &nbsp;--> <a href="https://hostpresto.com"><img src="https://nestjs.com/img/hostpresto.png" height="30" /></a> &nbsp; <a href="https://genuinebee.com/"><img src="https://nestjs.com/img/genuinebee.svg" height="38" /></a> &nbsp; <a href="http://architectnow.net/"><img src="https://nestjs.com/img/architectnow.png" height="24" /></a> &nbsp; <a href="https://quander.io/"><img src="https://nestjs.com/img/quander.png" height="28" /></a>
 
 
 ## Backers

package/errors/exceptions/invalid-class.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from './runtime.exception';
+export declare class InvalidClassException extends RuntimeException {
+    constructor(value: any);
+}

package/errors/exceptions/invalid-class.exception.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class InvalidClassException extends runtime_exception_1.RuntimeException {
+    constructor(value) {
+        super(messages_1.INVALID_CLASS_MESSAGE `${value}`);
+    }
+}
+exports.InvalidClassException = InvalidClassException;

package/errors/exceptions/undefined-dependency.exception.d.ts

@@ -1,5 +1,6 @@
 import { InjectorDependencyContext } from '../../injector/injector';
 import { RuntimeException } from './runtime.exception';
+import { Module } from '../../injector/module';
 export declare class UndefinedDependencyException extends RuntimeException {
-    constructor(type: string, undefinedDependencyContext: InjectorDependencyContext);
+    constructor(type: string, undefinedDependencyContext: InjectorDependencyContext, module?: Module);
 }

package/errors/exceptions/undefined-dependency.exception.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const messages_1 = require("../messages");
 const runtime_exception_1 = require("./runtime.exception");
 class UndefinedDependencyException extends runtime_exception_1.RuntimeException {
-    constructor(type, undefinedDependencyContext) {
-        super(messages_1.UNKNOWN_DEPENDENCIES_MESSAGE(type, undefinedDependencyContext));
+    constructor(type, undefinedDependencyContext, module) {
+        super(messages_1.UNKNOWN_DEPENDENCIES_MESSAGE(type, undefinedDependencyContext, module));
     }
 }
 exports.UndefinedDependencyException = UndefinedDependencyException;

package/errors/exceptions/unknown-dependencies.exception.d.ts

@@ -1,5 +1,6 @@
 import { InjectorDependencyContext } from '../../injector/injector';
 import { RuntimeException } from './runtime.exception';
+import { Module } from '../../injector/module';
 export declare class UnknownDependenciesException extends RuntimeException {
-    constructor(type: string, unknownDependencyContext: InjectorDependencyContext);
+    constructor(type: string, unknownDependencyContext: InjectorDependencyContext, module?: Module);
 }

package/errors/exceptions/unknown-dependencies.exception.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const messages_1 = require("../messages");
 const runtime_exception_1 = require("./runtime.exception");
 class UnknownDependenciesException extends runtime_exception_1.RuntimeException {
-    constructor(type, unknownDependencyContext) {
-        super(messages_1.UNKNOWN_DEPENDENCIES_MESSAGE(type, unknownDependencyContext));
+    constructor(type, unknownDependencyContext, module) {
+        super(messages_1.UNKNOWN_DEPENDENCIES_MESSAGE(type, unknownDependencyContext, module));
     }
 }
 exports.UnknownDependenciesException = UnknownDependenciesException;

package/errors/messages.d.ts

@@ -1,8 +1,10 @@
 import { InjectorDependencyContext } from '../injector/injector';
-export declare const UNKNOWN_DEPENDENCIES_MESSAGE: (type: string, unknownDependencyContext: InjectorDependencyContext) => string;
+import { Module } from '../injector/module';
+export declare const UNKNOWN_DEPENDENCIES_MESSAGE: (type: string, unknownDependencyContext: InjectorDependencyContext, module: Module) => string;
 export declare const INVALID_MIDDLEWARE_MESSAGE: (text: any, name: string) => string;
 export declare const INVALID_MODULE_MESSAGE: (text: any, scope: string) => string;
 export declare const UNKNOWN_EXPORT_MESSAGE: (text: any, module: string) => string;
+export declare const INVALID_CLASS_MESSAGE: (text: any, value: any) => string;
 export declare const INVALID_MIDDLEWARE_CONFIGURATION = "Invalid middleware configuration passed inside the module 'configure()' method.";
 export declare const UNKNOWN_REQUEST_MAPPING = "Request mapping properties not defined in the @RequestMapping() annotation!";
 export declare const UNHANDLED_RUNTIME_EXCEPTION = "Unhandled Runtime Exception.";

package/errors/messages.js

@@ -1,25 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+// TODO: Replace `any` with `unknown` type when TS 3.0.0 is supported
+/**
+ * Returns the name of an instance
+ * @param instance The instance which should get the name from
+ */
+const getInstanceName = (instance) => (instance && instance.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 shoul get displayed
+ * @param dependency The dependency whichs name should get displayed
+ */
+const getDependencyName = (dependency) => 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 getDependencyName = (dependency) => (dependency && dependency.name) || dependency || '+';
-exports.UNKNOWN_DEPENDENCIES_MESSAGE = (type, unknownDependencyContext) => {
-    const { index, dependencies } = unknownDependencyContext;
+const getModuleName = (module) => (module && getInstanceName(module.metatype)) || 'current';
+exports.UNKNOWN_DEPENDENCIES_MESSAGE = (type, unknownDependencyContext, module) => {
+    const { index, dependencies, key } = unknownDependencyContext;
     let message = `Nest can't resolve dependencies of the ${type}`;
-    message += ` (`;
-    const dependenciesName = dependencies.map(getDependencyName);
+    if (shared_utils_1.isNil(index)) {
+        message += `. Please make sure that the "${key}" property is available in the current context.`;
+        return message;
+    }
+    const dependenciesName = (dependencies || []).map(getDependencyName);
     dependenciesName[index] = '?';
+    message += ` (`;
     message += dependenciesName.join(', ');
-    message += `). Please make sure that the argument at index [${index}] is available in the current context.`;
+    message += `). Please make sure that the argument at index [${index}] is available in the ${getModuleName(module)} context.`;
     return message;
 };
 exports.INVALID_MIDDLEWARE_MESSAGE = (text, name) => `The middleware doesn't provide the 'resolve' method (${name})`;
 exports.INVALID_MODULE_MESSAGE = (text, scope) => `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}]`;
 exports.UNKNOWN_EXPORT_MESSAGE = (text, module) => `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.`;
+exports.INVALID_CLASS_MESSAGE = (text, value) => `ModuleRef cannot instantiate class (${value} is not constructable).`;
 exports.INVALID_MIDDLEWARE_CONFIGURATION = `Invalid middleware configuration passed inside the module 'configure()' method.`;
 exports.UNKNOWN_REQUEST_MAPPING = `Request mapping properties not defined in the @RequestMapping() annotation!`;
 exports.UNHANDLED_RUNTIME_EXCEPTION = `Unhandled Runtime Exception.`;

package/exceptions/base-exception-filter.d.ts

@@ -1,8 +1,10 @@
 import { ArgumentsHost, ExceptionFilter, HttpServer } from '@nestjs/common';
+import { ApplicationReferenceHost } from './../helpers/application-ref-host';
 export declare class BaseExceptionFilter<T = any> implements ExceptionFilter<T> {
     protected readonly applicationRef: HttpServer;
     private static readonly logger;
-    constructor(applicationRef: HttpServer);
+    protected readonly applicationRefHost?: ApplicationReferenceHost;
+    constructor(applicationRef?: HttpServer);
     catch(exception: T, host: ArgumentsHost): void;
     isExceptionObject(err: any): err is Error;
 }

package/exceptions/base-exception-filter.js

@@ -1,19 +1,31 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const common_1 = require("@nestjs/common");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const constants_1 = require("../constants");
+const application_ref_host_1 = require("./../helpers/application-ref-host");
 class BaseExceptionFilter {
     constructor(applicationRef) {
         this.applicationRef = applicationRef;
     }
     catch(exception, host) {
+        const applicationRef = this.applicationRef ||
+            (this.applicationRefHost && this.applicationRefHost.applicationRef);
         if (!(exception instanceof common_1.HttpException)) {
             const body = {
                 statusCode: common_1.HttpStatus.INTERNAL_SERVER_ERROR,
                 message: constants_1.MESSAGES.UNKNOWN_EXCEPTION_MESSAGE,
             };
-            this.applicationRef.reply(host.getArgByIndex(1), body, body.statusCode);
+            applicationRef.reply(host.getArgByIndex(1), body, body.statusCode);
             if (this.isExceptionObject(exception)) {
                 return BaseExceptionFilter.logger.error(exception.message, exception.stack);
             }
@@ -26,11 +38,16 @@ class BaseExceptionFilter {
                 statusCode: exception.getStatus(),
                 message: res,
             };
-        this.applicationRef.reply(host.getArgByIndex(1), message, exception.getStatus());
+        applicationRef.reply(host.getArgByIndex(1), message, exception.getStatus());
     }
     isExceptionObject(err) {
         return shared_utils_1.isObject(err) && !!err.message;
     }
 }
 BaseExceptionFilter.logger = new common_1.Logger('ExceptionsHandler');
+__decorate([
+    common_1.Optional(),
+    common_1.Inject(),
+    __metadata("design:type", application_ref_host_1.ApplicationReferenceHost)
+], BaseExceptionFilter.prototype, "applicationRefHost", void 0);
 exports.BaseExceptionFilter = BaseExceptionFilter;

package/exceptions/exceptions-handler.d.ts

@@ -1,10 +1,9 @@
-import { HttpException, HttpServer } from '@nestjs/common';
+import { HttpException } from '@nestjs/common';
 import { ExceptionFilterMetadata } from '@nestjs/common/interfaces/exceptions/exception-filter-metadata.interface';
 import { ArgumentsHost } from '@nestjs/common/interfaces/features/arguments-host.interface';
 import { BaseExceptionFilter } from './base-exception-filter';
 export declare class ExceptionsHandler extends BaseExceptionFilter {
     private filters;
-    constructor(applicationRef: HttpServer);
     next(exception: Error | HttpException | any, ctx: ArgumentsHost): void;
     setCustomFilters(filters: ExceptionFilterMetadata[]): void;
     invokeCustomFilters(exception: any, response: any): boolean;

package/exceptions/exceptions-handler.js

@@ -4,8 +4,8 @@ const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const invalid_exception_filter_exception_1 = require("../errors/exceptions/invalid-exception-filter.exception");
 const base_exception_filter_1 = require("./base-exception-filter");
 class ExceptionsHandler extends base_exception_filter_1.BaseExceptionFilter {
-    constructor(applicationRef) {
-        super(applicationRef);
+    constructor() {
+        super(...arguments);
         this.filters = [];
     }
     next(exception, ctx) {

package/injector/container-scanner.d.ts

@@ -0,0 +1,11 @@
+import { Type } from '@nestjs/common';
+import { NestContainer } from './container';
+import { Module } from './module';
+export declare class ContainerScanner {
+    private readonly container;
+    private flatContainer;
+    constructor(container: NestContainer);
+    find<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol): TResult;
+    findInstanceByPrototypeOrToken<TInput = any, TResult = TInput>(metatypeOrToken: Type<TInput> | string | symbol, contextModule: Partial<Module>): TResult;
+    private initFlatContainer();
+}

package/injector/container-scanner.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const unknown_element_exception_1 = require("../errors/exceptions/unknown-element.exception");
+class ContainerScanner {
+    constructor(container) {
+        this.container = container;
+    }
+    find(typeOrToken) {
+        this.initFlatContainer();
+        return this.findInstanceByPrototypeOrToken(typeOrToken, this.flatContainer);
+    }
+    findInstanceByPrototypeOrToken(metatypeOrToken, contextModule) {
+        const dependencies = new Map([
+            ...contextModule.components,
+            ...contextModule.routes,
+            ...contextModule.injectables,
+        ]);
+        const name = shared_utils_1.isFunction(metatypeOrToken)
+            ? metatypeOrToken.name
+            : metatypeOrToken;
+        const instanceWrapper = dependencies.get(name);
+        if (!instanceWrapper) {
+            throw new unknown_element_exception_1.UnknownElementException();
+        }
+        return instanceWrapper.instance;
+    }
+    initFlatContainer() {
+        if (this.flatContainer) {
+            return undefined;
+        }
+        const modules = this.container.getModules();
+        const initialValue = {
+            components: [],
+            routes: [],
+            injectables: [],
+        };
+        const merge = (initial, arr) => [...initial, ...arr];
+        this.flatContainer = [...modules.values()].reduce((current, next) => ({
+            components: merge(current.components, next.components),
+            routes: merge(current.routes, next.routes),
+            injectables: merge(current.injectables, next.injectables),
+        }), initialValue);
+    }
+}
+exports.ContainerScanner = ContainerScanner;

package/injector/injector.d.ts

@@ -8,11 +8,24 @@ import { Module } from './module';
  * The type of an injectable dependency
  */
 export declare type InjectorDependency = Type<any> | Function | string;
+/**
+ * The property-based dependency
+ */
+export interface PropertyDependency {
+    key: string;
+    name: InjectorDependency;
+    isOptional?: boolean;
+    instance?: any;
+}
 /**
  * Context of a dependency which gets injected by
  * the injector
  */
 export interface InjectorDependencyContext {
+    /**
+     * The name of the property key (property-based injection)
+     */
+    key?: string;
     /**
      * The name of the function or injection token
      */
@@ -21,11 +34,11 @@ export interface InjectorDependencyContext {
      * The index of the dependency which gets injected
      * from the dependencies array
      */
-    index: number;
+    index?: number;
     /**
      * The dependency array which gets injected
      */
-    dependencies: InjectorDependency[];
+    dependencies?: InjectorDependency[];
 }
 export declare class Injector {
     loadInstanceOfMiddleware(wrapper: MiddlewareWrapper, collection: Map<string, MiddlewareWrapper>, module: Module): Promise<void>;
@@ -34,7 +47,7 @@ export declare class Injector {
     loadPrototypeOfInstance<T>({metatype, name}: InstanceWrapper<T>, collection: Map<string, InstanceWrapper<T>>): any;
     loadInstanceOfComponent(wrapper: InstanceWrapper<Injectable>, module: Module): Promise<void>;
     applyDoneHook<T>(wrapper: InstanceWrapper<T>): () => void;
-    loadInstance<T>(wrapper: InstanceWrapper<T>, collection: any, module: Module): Promise<void>;
+    loadInstance<T>(wrapper: InstanceWrapper<T>, collection: Map<string, InstanceWrapper<any>>, module: Module): Promise<void>;
     resolveConstructorParams<T>(wrapper: InstanceWrapper<T>, module: Module, inject: InjectorDependency[], callback: (args) => void): Promise<void>;
     reflectConstructorParams<T>(type: Type<T>): any[];
     reflectOptionalParams<T>(type: Type<T>): any[];
@@ -45,5 +58,8 @@ export declare class Injector {
     lookupComponent<T = any>(components: Map<string, any>, module: Module, dependencyContext: InjectorDependencyContext, wrapper: InstanceWrapper<T>): Promise<any>;
     lookupComponentInExports<T = any>(dependencyContext: InjectorDependencyContext, module: Module, wrapper: InstanceWrapper<T>): Promise<any>;
     lookupComponentInRelatedModules(module: Module, name: any, moduleRegistry?: any[]): any;
-    instantiateClass(instances: any[], wrapper: InstanceWrapper<any>, targetMetatype: InstanceWrapper<any>, done: Function): Promise<void>;
+    resolveProperties<T>(wrapper: InstanceWrapper<T>, module: Module, inject?: InjectorDependency[]): Promise<PropertyDependency[]>;
+    reflectProperties<T>(type: Type<T>): PropertyDependency[];
+    applyProperties<T = any>(instance: T, properties: PropertyDependency[]): any;
+    instantiateClass<T = any>(instances: any[], wrapper: InstanceWrapper<any>, targetMetatype: InstanceWrapper<any>): Promise<T>;
 }

package/injector/injector.js

@@ -55,23 +55,29 @@ class Injector {
         }
         const done = this.applyDoneHook(wrapper);
         const { name, inject } = wrapper;
-        const targetMetatype = collection.get(name);
-        if (shared_utils_1.isUndefined(targetMetatype)) {
+        const targetWrapper = collection.get(name);
+        if (shared_utils_1.isUndefined(targetWrapper)) {
             throw new runtime_exception_1.RuntimeException();
         }
-        if (targetMetatype.isResolved) {
+        if (targetWrapper.isResolved) {
             return;
         }
-        await this.resolveConstructorParams(wrapper, module, inject, async (instances) => this.instantiateClass(instances, wrapper, targetMetatype, done));
+        const callback = async (instances) => {
+            const properties = await this.resolveProperties(wrapper, module, inject);
+            const instance = await this.instantiateClass(instances, wrapper, targetWrapper);
+            this.applyProperties(instance, properties);
+            done();
+        };
+        await this.resolveConstructorParams(wrapper, module, inject, callback);
     }
     async resolveConstructorParams(wrapper, module, inject, callback) {
-        let isResolved = true;
         const dependencies = shared_utils_1.isNil(inject)
             ? this.reflectConstructorParams(wrapper.metatype)
             : inject;
         const optionalDependenciesIds = shared_utils_1.isNil(inject)
             ? this.reflectOptionalParams(wrapper.metatype)
             : [];
+        let isResolved = true;
         const instances = await Promise.all(dependencies.map(async (param, index) => {
             try {
                 const paramWrapper = await this.resolveSingleParam(wrapper, param, { index, dependencies }, module);
@@ -104,7 +110,7 @@ class Injector {
     }
     async resolveSingleParam(wrapper, param, dependencyContext, module) {
         if (shared_utils_1.isUndefined(param)) {
-            throw new undefined_dependency_exception_1.UndefinedDependencyException(wrapper.name, dependencyContext);
+            throw new undefined_dependency_exception_1.UndefinedDependencyException(wrapper.name, dependencyContext, module);
         }
         const token = this.resolveParamToken(wrapper, param);
         return this.resolveComponentInstance(module, shared_utils_1.isFunction(token) ? token.name : token, dependencyContext, wrapper);
@@ -118,7 +124,7 @@ class Injector {
     }
     async resolveComponentInstance(module, name, dependencyContext, wrapper) {
         const components = module.components;
-        const instanceWrapper = await this.lookupComponent(components, module, Object.assign({ name }, dependencyContext), wrapper);
+        const instanceWrapper = await this.lookupComponent(components, module, Object.assign({}, dependencyContext, { name }), wrapper);
         if (!instanceWrapper.isResolved && !instanceWrapper.forwardRef) {
             await this.loadInstanceOfComponent(instanceWrapper, module);
         }
@@ -135,7 +141,7 @@ class Injector {
     async lookupComponentInExports(dependencyContext, module, wrapper) {
         const instanceWrapper = await this.lookupComponentInRelatedModules(module, dependencyContext.name);
         if (shared_utils_1.isNil(instanceWrapper)) {
-            throw new unknown_dependencies_exception_1.UnknownDependenciesException(wrapper.name, dependencyContext);
+            throw new unknown_dependencies_exception_1.UnknownDependenciesException(wrapper.name, dependencyContext, module);
         }
         return instanceWrapper;
     }
@@ -164,17 +170,55 @@ class Injector {
         }
         return componentRef;
     }
-    async instantiateClass(instances, wrapper, targetMetatype, done) {
+    async resolveProperties(wrapper, module, inject) {
+        if (!shared_utils_1.isNil(inject)) {
+            return [];
+        }
+        const properties = this.reflectProperties(wrapper.metatype);
+        const instances = await Promise.all(properties.map(async (item) => {
+            try {
+                const dependencyContext = {
+                    key: item.key,
+                    name: item.name,
+                };
+                const paramWrapper = await this.resolveSingleParam(wrapper, item.name, dependencyContext, module);
+                return (paramWrapper && paramWrapper.instance) || undefined;
+            }
+            catch (err) {
+                if (!item.isOptional) {
+                    throw err;
+                }
+                return undefined;
+            }
+        }));
+        return properties.map((item, index) => (Object.assign({}, item, { instance: instances[index] })));
+    }
+    reflectProperties(type) {
+        const properties = Reflect.getMetadata(constants_1.PROPERTY_DEPS_METADATA, type) || [];
+        const optionalKeys = Reflect.getMetadata(constants_1.OPTIONAL_PROPERTY_DEPS_METADATA, type) || [];
+        return properties.map(item => (Object.assign({}, item, { name: item.type, isOptional: optionalKeys.includes(item.key) })));
+    }
+    applyProperties(instance, properties) {
+        if (!shared_utils_1.isObject(instance)) {
+            return undefined;
+        }
+        properties
+            .filter(item => !shared_utils_1.isNil(item.instance))
+            .forEach(item => (instance[item.key] = item.instance));
+    }
+    async instantiateClass(instances, wrapper, targetMetatype) {
         const { metatype, inject } = wrapper;
         if (shared_utils_1.isNil(inject)) {
-            targetMetatype.instance = Object.assign(targetMetatype.instance, new metatype(...instances));
+            targetMetatype.instance = wrapper.forwardRef
+                ? Object.assign(targetMetatype.instance, new metatype(...instances))
+                : new metatype(...instances);
         }
         else {
             const factoryResult = targetMetatype.metatype(...instances);
             targetMetatype.instance = await factoryResult;
         }
         targetMetatype.isResolved = true;
-        done();
+        return targetMetatype.instance;
     }
 }
 exports.Injector = Injector;

package/injector/module-ref.d.ts

@@ -3,12 +3,14 @@ import { NestContainer } from './container';
 import { Module } from './module';
 export declare abstract class ModuleRef {
     protected readonly container: NestContainer;
-    private flattenModuleFixture;
+    private readonly injector;
+    private readonly containerScanner;
     constructor(container: NestContainer);
     abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, options?: {
         strict: boolean;
     }): TResult;
+    abstract create<T = any>(type: Type<T>): Promise<T>;
     protected find<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol): TResult;
+    protected instantiateClass<T = any>(type: Type<T>, module: Module): Promise<T>;
     protected findInstanceByPrototypeOrToken<TInput = any, TResult = TInput>(metatypeOrToken: Type<TInput> | string | symbol, contextModule: Partial<Module>): TResult;
-    private initFlattenModule();
 }

package/injector/module-ref.js

@@ -1,45 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const unknown_element_exception_1 = require("../errors/exceptions/unknown-element.exception");
+const container_scanner_1 = require("./container-scanner");
+const injector_1 = require("./injector");
 class ModuleRef {
     constructor(container) {
         this.container = container;
+        this.injector = new injector_1.Injector();
+        this.containerScanner = new container_scanner_1.ContainerScanner(container);
     }
     find(typeOrToken) {
-        this.initFlattenModule();
-        return this.findInstanceByPrototypeOrToken(typeOrToken, this.flattenModuleFixture);
+        return this.containerScanner.find(typeOrToken);
     }
-    findInstanceByPrototypeOrToken(metatypeOrToken, contextModule) {
-        const dependencies = new Map([
-            ...contextModule.components,
-            ...contextModule.routes,
-            ...contextModule.injectables,
-        ]);
-        const name = shared_utils_1.isFunction(metatypeOrToken)
-            ? metatypeOrToken.name
-            : metatypeOrToken;
-        const instanceWrapper = dependencies.get(name);
-        if (!instanceWrapper) {
-            throw new unknown_element_exception_1.UnknownElementException();
-        }
-        return instanceWrapper.instance;
-    }
-    initFlattenModule() {
-        if (this.flattenModuleFixture) {
-            return;
-        }
-        const modules = this.container.getModules();
-        const initialValue = {
-            components: [],
-            routes: [],
-            injectables: [],
+    async instantiateClass(type, module) {
+        const wrapper = {
+            name: type.name,
+            metatype: type,
+            instance: undefined,
+            isResolved: false,
         };
-        this.flattenModuleFixture = [...modules.values()].reduce((flatten, curr) => ({
-            components: [...flatten.components, ...curr.components],
-            routes: [...flatten.routes, ...curr.routes],
-            injectables: [...flatten.injectables, ...curr.injectables],
-        }), initialValue);
+        return new Promise(async (resolve, reject) => {
+            try {
+                const callback = async (instances) => {
+                    const properties = await this.injector.resolveProperties(wrapper, module);
+                    const instance = new type(...instances);
+                    this.injector.applyProperties(instance, properties);
+                    resolve(instance);
+                };
+                await this.injector.resolveConstructorParams(wrapper, module, undefined, callback);
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    findInstanceByPrototypeOrToken(metatypeOrToken, contextModule) {
+        return this.containerScanner.findInstanceByPrototypeOrToken(metatypeOrToken, contextModule);
     }
 }
 exports.ModuleRef = ModuleRef;

package/injector/module.d.ts

@@ -38,7 +38,7 @@ export declare class Module {
     readonly components: Map<string, InstanceWrapper<Injectable>>;
     readonly injectables: Map<string, InstanceWrapper<Injectable>>;
     readonly routes: Map<string, InstanceWrapper<Controller>>;
-    readonly exports: Set<string>;
+    readonly exports: Set<string | symbol>;
     readonly instance: NestModule;
     readonly metatype: Type<any>;
     addCoreInjectables(container: NestContainer): void;
@@ -60,9 +60,9 @@ export declare class Module {
     addCustomClass(component: CustomClass, collection: Map<string, any>): void;
     addCustomValue(component: CustomValue, collection: Map<string, any>): void;
     addCustomFactory(component: CustomFactory, collection: Map<string, any>): void;
-    addExportedComponent(exportedComponent: ComponentMetatype | string | DynamicModule): Set<string>;
-    addCustomExportedComponent(exportedComponent: CustomFactory | CustomValue | CustomClass): Set<string>;
-    validateExportedProvider(token: string): string;
+    addExportedComponent(exportedComponent: ComponentMetatype | string | symbol | DynamicModule): Set<string | symbol>;
+    addCustomExportedComponent(exportedComponent: CustomFactory | CustomValue | CustomClass): Set<string | symbol>;
+    validateExportedProvider(token: string | symbol): string | symbol;
     addRoute(route: Type<Controller>): void;
     addRelatedModule(relatedModule: any): void;
     replace(toReplace: any, options: any): string;

package/injector/module.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const random_string_generator_util_1 = require("@nestjs/common/utils/random-string-generator.util");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const invalid_class_exception_1 = require("../errors/exceptions/invalid-class.exception");
 const runtime_exception_1 = require("../errors/exceptions/runtime.exception");
 const unknown_export_exception_1 = require("../errors/exceptions/unknown-export.exception");
 const application_ref_host_1 = require("../helpers/application-ref-host");
@@ -206,7 +207,7 @@ class Module {
         if (this.isCustomProvider(exportedComponent)) {
             return this.addCustomExportedComponent(exportedComponent);
         }
-        else if (shared_utils_1.isString(exportedComponent)) {
+        else if (shared_utils_1.isString(exportedComponent) || shared_utils_1.isSymbol(exportedComponent)) {
             return addExportedUnit(exportedComponent);
         }
         else if (this.isDynamicModule(exportedComponent)) {
@@ -267,6 +268,12 @@ class Module {
                 }
                 return this.findInstanceByPrototypeOrToken(typeOrToken, self);
             }
+            async create(type) {
+                if (!(type && shared_utils_1.isFunction(type) && type.prototype)) {
+                    throw new invalid_class_exception_1.InvalidClassException(type);
+                }
+                return this.instantiateClass(type, self);
+            }
         };
     }
 }

package/nest-application-context.d.ts

@@ -2,11 +2,12 @@ import { INestApplicationContext, LoggerService, OnApplicationBootstrap, OnModul
 import { Type } from '@nestjs/common/interfaces/type.interface';
 import { NestContainer } from './injector/container';
 import { Module } from './injector/module';
-import { ModuleRef } from './injector/module-ref';
-export declare class NestApplicationContext extends ModuleRef implements INestApplicationContext {
+export declare class NestApplicationContext implements INestApplicationContext {
+    protected readonly container: NestContainer;
     private readonly scope;
-    protected contextModule: Module;
+    private contextModule;
     private readonly moduleTokenFactory;
+    private readonly containerScanner;
     constructor(container: NestContainer, scope: Type<any>[], contextModule: Module);
     selectContextModule(): void;
     select<T>(module: Type<T>): INestApplicationContext;
@@ -25,4 +26,6 @@ export declare class NestApplicationContext extends ModuleRef implements INestAp
     protected callBootstrapHook(): Promise<any>;
     protected callModuleBootstrapHook(module: Module): Promise<any>;
     protected hasOnAppBotstrapHook(instance: any): instance is OnApplicationBootstrap;
+    protected find<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol): TResult;
+    protected findInstanceByPrototypeOrToken<TInput = any, TResult = TInput>(metatypeOrToken: Type<TInput> | string | symbol, contextModule: Partial<Module>): TResult;
 }

package/nest-application-context.js

@@ -4,14 +4,15 @@ const common_1 = require("@nestjs/common");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const iterare_1 = require("iterare");
 const unknown_module_exception_1 = require("./errors/exceptions/unknown-module.exception");
-const module_ref_1 = require("./injector/module-ref");
+const container_scanner_1 = require("./injector/container-scanner");
 const module_token_factory_1 = require("./injector/module-token-factory");
-class NestApplicationContext extends module_ref_1.ModuleRef {
+class NestApplicationContext {
     constructor(container, scope, contextModule) {
-        super(container);
+        this.container = container;
         this.scope = scope;
         this.contextModule = contextModule;
         this.moduleTokenFactory = new module_token_factory_1.ModuleTokenFactory();
+        this.containerScanner = new container_scanner_1.ContainerScanner(container);
     }
     selectContextModule() {
         const modules = this.container.getModules().values();
@@ -116,5 +117,11 @@ class NestApplicationContext extends module_ref_1.ModuleRef {
     hasOnAppBotstrapHook(instance) {
         return !shared_utils_1.isUndefined(instance.onApplicationBootstrap);
     }
+    find(typeOrToken) {
+        return this.containerScanner.find(typeOrToken);
+    }
+    findInstanceByPrototypeOrToken(metatypeOrToken, contextModule) {
+        return this.containerScanner.findInstanceByPrototypeOrToken(metatypeOrToken, contextModule);
+    }
 }
 exports.NestApplicationContext = NestApplicationContext;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "5.3.14",
+  "version": "5.4.1",
   "description": "Nest - modern, fast, powerful node.js web framework (@core)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",