@nestjs/core 9.2.1 → 9.3.0-beta.2

package/nest-factory.js

@@ -10,7 +10,10 @@ const exceptions_zone_1 = require("./errors/exceptions-zone");
 const load_adapter_1 = require("./helpers/load-adapter");
 const rethrow_1 = require("./helpers/rethrow");
 const container_1 = require("./injector/container");
+const injector_1 = require("./injector/injector");
 const instance_loader_1 = require("./injector/instance-loader");
+const graph_inspector_1 = require("./inspector/graph-inspector");
+const noop_graph_inspector_1 = require("./inspector/noop-graph-inspector");
 const metadata_scanner_1 = require("./metadata-scanner");
 const nest_application_1 = require("./nest-application");
 const nest_application_context_1 = require("./nest-application-context");
@@ -26,54 +29,58 @@ class NestFactoryStatic {
         this.abortOnError = true;
         this.autoFlushLogs = false;
     }
-    async create(module, serverOrOptions, options) {
+    async create(moduleCls, serverOrOptions, options) {
         const [httpServer, appOptions] = this.isHttpServer(serverOrOptions)
             ? [serverOrOptions, options]
             : [this.createHttpAdapter(), serverOrOptions];
         const applicationConfig = new application_config_1.ApplicationConfig();
         const container = new container_1.NestContainer(applicationConfig);
+        const graphInspector = this.createGraphInspector(appOptions, container);
         this.setAbortOnError(serverOrOptions, options);
         this.registerLoggerConfiguration(appOptions);
-        await this.initialize(module, container, applicationConfig, httpServer);
-        const instance = new nest_application_1.NestApplication(container, httpServer, applicationConfig, appOptions);
+        await this.initialize(moduleCls, container, graphInspector, applicationConfig, appOptions, httpServer);
+        const instance = new nest_application_1.NestApplication(container, httpServer, applicationConfig, graphInspector, appOptions);
         const target = this.createNestInstance(instance);
         return this.createAdapterProxy(target, httpServer);
     }
     /**
      * Creates an instance of NestMicroservice.
      *
-     * @param module Entry (root) application module class
+     * @param moduleCls Entry (root) application module class
      * @param options Optional microservice configuration
      *
      * @returns A promise that, when resolved,
      * contains a reference to the NestMicroservice instance.
      */
-    async createMicroservice(module, options) {
+    async createMicroservice(moduleCls, options) {
         const { NestMicroservice } = (0, load_package_util_1.loadPackage)('@nestjs/microservices', 'NestFactory', () => require('@nestjs/microservices'));
         const applicationConfig = new application_config_1.ApplicationConfig();
         const container = new container_1.NestContainer(applicationConfig);
+        const graphInspector = this.createGraphInspector(options, container);
         this.setAbortOnError(options);
         this.registerLoggerConfiguration(options);
-        await this.initialize(module, container, applicationConfig);
-        return this.createNestInstance(new NestMicroservice(container, options, applicationConfig));
+        await this.initialize(moduleCls, container, graphInspector, applicationConfig, options);
+        return this.createNestInstance(new NestMicroservice(container, options, graphInspector, applicationConfig));
     }
     /**
      * Creates an instance of NestApplicationContext.
      *
-     * @param module Entry (root) application module class
+     * @param moduleCls Entry (root) application module class
      * @param options Optional Nest application configuration
      *
      * @returns A promise that, when resolved,
      * contains a reference to the NestApplicationContext instance.
      */
-    async createApplicationContext(module, options) {
+    async createApplicationContext(moduleCls, options) {
         const container = new container_1.NestContainer();
+        const graphInspector = this.createGraphInspector(options, container);
         this.setAbortOnError(options);
         this.registerLoggerConfiguration(options);
-        await this.initialize(module, container);
+        const applicationConfig = undefined;
+        await this.initialize(moduleCls, container, graphInspector, applicationConfig, options);
         const modules = container.getModules().values();
         const root = modules.next().value;
-        const context = this.createNestInstance(new nest_application_context_1.NestApplicationContext(container, [], root));
+        const context = this.createNestInstance(new nest_application_context_1.NestApplicationContext(container, options, root));
         if (this.autoFlushLogs) {
             context.flushLogsOnOverride();
         }
@@ -82,10 +89,11 @@ class NestFactoryStatic {
     createNestInstance(instance) {
         return this.createProxy(instance);
     }
-    async initialize(module, container, config = new application_config_1.ApplicationConfig(), httpServer = null) {
-        const instanceLoader = new instance_loader_1.InstanceLoader(container);
+    async initialize(module, container, graphInspector, config = new application_config_1.ApplicationConfig(), options = {}, httpServer = null) {
+        const injector = new injector_1.Injector({ preview: options.preview });
+        const instanceLoader = new instance_loader_1.InstanceLoader(container, injector, graphInspector);
         const metadataScanner = new metadata_scanner_1.MetadataScanner();
-        const dependenciesScanner = new scanner_1.DependenciesScanner(container, metadataScanner, config);
+        const dependenciesScanner = new scanner_1.DependenciesScanner(container, metadataScanner, graphInspector, config);
         container.setHttpAdapter(httpServer);
         const teardown = this.abortOnError === false ? rethrow_1.rethrow : undefined;
         await (httpServer === null || httpServer === void 0 ? void 0 : httpServer.init());
@@ -187,6 +195,11 @@ class NestFactoryStatic {
         });
         return proxy;
     }
+    createGraphInspector(appOptions, container) {
+        return (appOptions === null || appOptions === void 0 ? void 0 : appOptions.snapshot)
+            ? new graph_inspector_1.GraphInspector(container)
+            : noop_graph_inspector_1.NoopGraphInspector;
+    }
 }
 exports.NestFactoryStatic = NestFactoryStatic;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "9.2.1",
+  "version": "9.3.0-beta.2",
   "description": "Nest - modern, fast, powerful node.js web framework (@core)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -36,7 +36,7 @@
     "uuid": "9.0.0"
   },
   "devDependencies": {
-    "@nestjs/common": "9.2.1"
+    "@nestjs/common": "^9.3.0-beta.2"
   },
   "peerDependencies": {
     "@nestjs/common": "^9.0.0",

package/router/paths-explorer.d.ts

@@ -0,0 +1,18 @@
+import { RequestMethod } from '@nestjs/common/enums';
+import { Controller } from '@nestjs/common/interfaces/controllers/controller.interface';
+import { VersionValue } from '@nestjs/common/interfaces/version-options.interface';
+import { MetadataScanner } from '../metadata-scanner';
+import { RouterProxyCallback } from './router-proxy';
+export interface RouteDefinition {
+    path: string[];
+    requestMethod: RequestMethod;
+    targetCallback: RouterProxyCallback;
+    methodName: string;
+    version?: VersionValue;
+}
+export declare class PathsExplorer {
+    private readonly metadataScanner;
+    constructor(metadataScanner: MetadataScanner);
+    scanForPaths(instance: Controller, prototype?: object): RouteDefinition[];
+    exploreMethodMetadata(instance: Controller, prototype: object, methodName: string): RouteDefinition;
+}

package/router/paths-explorer.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathsExplorer = void 0;
+const constants_1 = require("@nestjs/common/constants");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+class PathsExplorer {
+    constructor(metadataScanner) {
+        this.metadataScanner = metadataScanner;
+    }
+    scanForPaths(instance, prototype) {
+        const instancePrototype = (0, shared_utils_1.isUndefined)(prototype)
+            ? Object.getPrototypeOf(instance)
+            : prototype;
+        return this.metadataScanner.scanFromPrototype(instance, instancePrototype, method => this.exploreMethodMetadata(instance, instancePrototype, method));
+    }
+    exploreMethodMetadata(instance, prototype, methodName) {
+        const instanceCallback = instance[methodName];
+        const prototypeCallback = prototype[methodName];
+        const routePath = Reflect.getMetadata(constants_1.PATH_METADATA, prototypeCallback);
+        if ((0, shared_utils_1.isUndefined)(routePath)) {
+            return null;
+        }
+        const requestMethod = Reflect.getMetadata(constants_1.METHOD_METADATA, prototypeCallback);
+        const version = Reflect.getMetadata(constants_1.VERSION_METADATA, prototypeCallback);
+        const path = (0, shared_utils_1.isString)(routePath)
+            ? [(0, shared_utils_1.addLeadingSlash)(routePath)]
+            : routePath.map((p) => (0, shared_utils_1.addLeadingSlash)(p));
+        return {
+            path,
+            requestMethod,
+            targetCallback: instanceCallback,
+            methodName,
+            version,
+        };
+    }
+}
+exports.PathsExplorer = PathsExplorer;

package/router/router-explorer.d.ts

@@ -8,6 +8,7 @@ import { NestContainer } from '../injector/container';
 import { Injector } from '../injector/injector';
 import { InstanceWrapper } from '../injector/instance-wrapper';
 import { Module } from '../injector/module';
+import { GraphInspector } from '../inspector/graph-inspector';
 import { MetadataScanner } from '../metadata-scanner';
 import { ExceptionsFilter } from './interfaces/exceptions-filter.interface';
 import { RoutePathMetadata } from './interfaces/route-path-metadata.interface';
@@ -21,22 +22,20 @@ export interface RouteDefinition {
     version?: VersionValue;
 }
 export declare class RouterExplorer {
-    private readonly metadataScanner;
     private readonly container;
-    private readonly injector?;
-    private readonly routerProxy?;
-    private readonly exceptionsFilter?;
-    private readonly config?;
-    private readonly routePathFactory?;
+    private readonly injector;
+    private readonly routerProxy;
+    private readonly exceptionsFilter;
+    private readonly routePathFactory;
+    private readonly graphInspector;
     private readonly executionContextCreator;
+    private readonly pathsExplorer;
     private readonly routerMethodFactory;
     private readonly logger;
     private readonly exceptionFiltersCache;
-    constructor(metadataScanner: MetadataScanner, container: NestContainer, injector?: Injector, routerProxy?: RouterProxy, exceptionsFilter?: ExceptionsFilter, config?: ApplicationConfig, routePathFactory?: RoutePathFactory);
+    constructor(metadataScanner: MetadataScanner, container: NestContainer, injector: Injector, routerProxy: RouterProxy, exceptionsFilter: ExceptionsFilter, config: ApplicationConfig, routePathFactory: RoutePathFactory, graphInspector: GraphInspector);
     explore<T extends HttpServer = any>(instanceWrapper: InstanceWrapper, moduleKey: string, applicationRef: T, host: string | RegExp | Array<string | RegExp>, routePathMetadata: RoutePathMetadata): void;
     extractRouterPath(metatype: Type<Controller>): string[];
-    scanForPaths(instance: Controller, prototype?: object): RouteDefinition[];
-    exploreMethodMetadata(instance: Controller, prototype: object, methodName: string): RouteDefinition;
     applyPathsToRouterProxy<T extends HttpServer>(router: T, routeDefinitions: RouteDefinition[], instanceWrapper: InstanceWrapper, moduleKey: string, routePathMetadata: RoutePathMetadata, host: string | RegExp | Array<string | RegExp>): void;
     private applyCallbackToRouter;
     private applyHostFilter;

package/router/router-explorer.js

@@ -19,23 +19,24 @@ const interceptors_consumer_1 = require("../interceptors/interceptors-consumer")
 const interceptors_context_creator_1 = require("../interceptors/interceptors-context-creator");
 const pipes_consumer_1 = require("../pipes/pipes-consumer");
 const pipes_context_creator_1 = require("../pipes/pipes-context-creator");
+const paths_explorer_1 = require("./paths-explorer");
 const request_constants_1 = require("./request/request-constants");
 const route_params_factory_1 = require("./route-params-factory");
 const router_execution_context_1 = require("./router-execution-context");
 class RouterExplorer {
-    constructor(metadataScanner, container, injector, routerProxy, exceptionsFilter, config, routePathFactory) {
-        this.metadataScanner = metadataScanner;
+    constructor(metadataScanner, container, injector, routerProxy, exceptionsFilter, config, routePathFactory, graphInspector) {
         this.container = container;
         this.injector = injector;
         this.routerProxy = routerProxy;
         this.exceptionsFilter = exceptionsFilter;
-        this.config = config;
         this.routePathFactory = routePathFactory;
+        this.graphInspector = graphInspector;
         this.routerMethodFactory = new router_method_factory_1.RouterMethodFactory();
         this.logger = new logger_service_1.Logger(RouterExplorer.name, {
             timestamp: true,
         });
         this.exceptionFiltersCache = new WeakMap();
+        this.pathsExplorer = new paths_explorer_1.PathsExplorer(metadataScanner);
         const routeParamsFactory = new route_params_factory_1.RouteParamsFactory();
         const pipesContextCreator = new pipes_context_creator_1.PipesContextCreator(container, config);
         const pipesConsumer = new pipes_consumer_1.PipesConsumer();
@@ -47,7 +48,7 @@ class RouterExplorer {
     }
     explore(instanceWrapper, moduleKey, applicationRef, host, routePathMetadata) {
         const { instance } = instanceWrapper;
-        const routerPaths = this.scanForPaths(instance);
+        const routerPaths = this.pathsExplorer.scanForPaths(instance);
         this.applyPathsToRouterProxy(applicationRef, routerPaths, instanceWrapper, moduleKey, routePathMetadata, host);
     }
     extractRouterPath(metatype) {
@@ -60,32 +61,6 @@ class RouterExplorer {
         }
         return [(0, shared_utils_1.addLeadingSlash)(path)];
     }
-    scanForPaths(instance, prototype) {
-        const instancePrototype = (0, shared_utils_1.isUndefined)(prototype)
-            ? Object.getPrototypeOf(instance)
-            : prototype;
-        return this.metadataScanner.scanFromPrototype(instance, instancePrototype, method => this.exploreMethodMetadata(instance, instancePrototype, method));
-    }
-    exploreMethodMetadata(instance, prototype, methodName) {
-        const instanceCallback = instance[methodName];
-        const prototypeCallback = prototype[methodName];
-        const routePath = Reflect.getMetadata(constants_1.PATH_METADATA, prototypeCallback);
-        if ((0, shared_utils_1.isUndefined)(routePath)) {
-            return null;
-        }
-        const requestMethod = Reflect.getMetadata(constants_1.METHOD_METADATA, prototypeCallback);
-        const version = Reflect.getMetadata(constants_1.VERSION_METADATA, prototypeCallback);
-        const path = (0, shared_utils_1.isString)(routePath)
-            ? [(0, shared_utils_1.addLeadingSlash)(routePath)]
-            : routePath.map((p) => (0, shared_utils_1.addLeadingSlash)(p));
-        return {
-            path,
-            requestMethod,
-            targetCallback: instanceCallback,
-            methodName,
-            version,
-        };
-    }
     applyPathsToRouterProxy(router, routeDefinitions, instanceWrapper, moduleKey, routePathMetadata, host) {
         (routeDefinitions || []).forEach(routeDefinition => {
             const { version: methodVersion } = routeDefinition;
@@ -115,7 +90,23 @@ class RouterExplorer {
             }
             routePathMetadata.methodPath = path;
             const pathsToRegister = this.routePathFactory.create(routePathMetadata, requestMethod);
-            pathsToRegister.forEach(path => routerMethodRef(path, routeHandler));
+            pathsToRegister.forEach(path => {
+                const entrypointDefinition = {
+                    type: 'http-endpoint',
+                    methodName,
+                    className: instanceWrapper.name,
+                    classNodeId: instanceWrapper.id,
+                    metadata: {
+                        key: path,
+                        path,
+                        requestMethod: enums_1.RequestMethod[requestMethod],
+                        methodVersion: routePathMetadata.methodVersion,
+                        controllerVersion: routePathMetadata.controllerVersion,
+                    },
+                };
+                routerMethodRef(path, routeHandler);
+                this.graphInspector.insertEntrypointDefinition(entrypointDefinition, instanceWrapper.id);
+            });
             const pathsToLog = this.routePathFactory.create(Object.assign(Object.assign({}, routePathMetadata), { versioningOptions: undefined }), requestMethod);
             pathsToLog.forEach(path => {
                 if (isVersioned) {

package/router/routes-resolver.d.ts

@@ -1,8 +1,9 @@
-import { HttpServer, Controller } from '@nestjs/common/interfaces';
+import { Controller, HttpServer } from '@nestjs/common/interfaces';
 import { ApplicationConfig } from '../application-config';
 import { NestContainer } from '../injector/container';
 import { Injector } from '../injector/injector';
 import { InstanceWrapper } from '../injector/instance-wrapper';
+import { GraphInspector } from '../inspector/graph-inspector';
 import { Resolver } from './interfaces/resolver.interface';
 export declare class RoutesResolver implements Resolver {
     private readonly container;
@@ -13,7 +14,7 @@ export declare class RoutesResolver implements Resolver {
     private readonly routePathFactory;
     private readonly routerExceptionsFilter;
     private readonly routerExplorer;
-    constructor(container: NestContainer, applicationConfig: ApplicationConfig, injector: Injector);
+    constructor(container: NestContainer, applicationConfig: ApplicationConfig, injector: Injector, graphInspector: GraphInspector);
     resolve<T extends HttpServer>(applicationRef: T, globalPrefix: string): void;
     registerRouters(routes: Map<string | symbol | Function, InstanceWrapper<Controller>>, moduleName: string, globalPrefix: string, modulePath: string, applicationRef: HttpServer): void;
     registerNotFoundHandler(): void;

package/router/routes-resolver.js

@@ -11,7 +11,7 @@ const router_exception_filters_1 = require("./router-exception-filters");
 const router_explorer_1 = require("./router-explorer");
 const router_proxy_1 = require("./router-proxy");
 class RoutesResolver {
-    constructor(container, applicationConfig, injector) {
+    constructor(container, applicationConfig, injector, graphInspector) {
         this.container = container;
         this.applicationConfig = applicationConfig;
         this.injector = injector;
@@ -23,7 +23,7 @@ class RoutesResolver {
         this.routerExceptionsFilter = new router_exception_filters_1.RouterExceptionFilters(container, applicationConfig, httpAdapterRef);
         this.routePathFactory = new route_path_factory_1.RoutePathFactory(this.applicationConfig);
         const metadataScanner = new metadata_scanner_1.MetadataScanner();
-        this.routerExplorer = new router_explorer_1.RouterExplorer(metadataScanner, this.container, this.injector, this.routerProxy, this.routerExceptionsFilter, this.applicationConfig, this.routePathFactory);
+        this.routerExplorer = new router_explorer_1.RouterExplorer(metadataScanner, this.container, this.injector, this.routerProxy, this.routerExceptionsFilter, this.applicationConfig, this.routePathFactory, graphInspector);
     }
     resolve(applicationRef, globalPrefix) {
         const modules = this.container.getModules();

package/scanner.d.ts

@@ -1,18 +1,22 @@
 import { DynamicModule, ForwardReference, Provider } from '@nestjs/common';
+import { EnhancerSubtype } from '@nestjs/common/constants';
 import { ClassProvider, ExistingProvider, FactoryProvider, ValueProvider } from '@nestjs/common/interfaces';
 import { Controller } from '@nestjs/common/interfaces/controllers/controller.interface';
 import { Injectable } from '@nestjs/common/interfaces/injectable.interface';
 import { Type } from '@nestjs/common/interfaces/type.interface';
 import { ApplicationConfig } from './application-config';
 import { NestContainer } from './injector/container';
+import { InstanceWrapper } from './injector/instance-wrapper';
 import { Module } from './injector/module';
+import { GraphInspector } from './inspector/graph-inspector';
 import { MetadataScanner } from './metadata-scanner';
 export declare class DependenciesScanner {
     private readonly container;
     private readonly metadataScanner;
+    private readonly graphInspector;
     private readonly applicationConfig;
     private readonly applicationProvidersApplyMap;
-    constructor(container: NestContainer, metadataScanner: MetadataScanner, applicationConfig?: ApplicationConfig);
+    constructor(container: NestContainer, metadataScanner: MetadataScanner, graphInspector: GraphInspector, applicationConfig?: ApplicationConfig);
     scan(module: Type<any>): Promise<void>;
     scanForModules(moduleDefinition: ForwardReference | Type<unknown> | DynamicModule | Promise<DynamicModule>, scope?: Type<unknown>[], ctxRegistry?: (ForwardReference | DynamicModule | Type<unknown>)[]): Promise<Module[]>;
     insertModule(moduleDefinition: any, scope: Type<unknown>[]): Promise<Module | undefined>;
@@ -20,19 +24,22 @@ export declare class DependenciesScanner {
     reflectImports(module: Type<unknown>, token: string, context: string): Promise<void>;
     reflectProviders(module: Type<any>, token: string): void;
     reflectControllers(module: Type<any>, token: string): void;
-    reflectDynamicMetadata(obj: Type<Injectable>, token: string): void;
+    reflectDynamicMetadata(cls: Type<Injectable>, token: string): void;
     reflectExports(module: Type<unknown>, token: string): void;
     reflectInjectables(component: Type<Injectable>, token: string, metadataKey: string): void;
     reflectParamInjectables(component: Type<Injectable>, token: string, metadataKey: string): void;
-    reflectKeyMetadata(component: Type<Injectable>, key: string, method: string): any;
-    calculateModulesDistance(): Promise<void>;
+    reflectKeyMetadata(component: Type<Injectable>, key: string, methodKey: string): {
+        methodKey: string;
+        metadata: any;
+    };
+    calculateModulesDistance(): void;
     insertImport(related: any, token: string, context: string): Promise<void>;
     isCustomProvider(provider: Provider): provider is ClassProvider | ValueProvider | FactoryProvider | ExistingProvider;
-    insertProvider(provider: Provider, token: string): string | symbol | void | Function;
-    insertInjectable(injectable: Type<Injectable>, token: string, host: Type<Injectable>): void;
+    insertProvider(provider: Provider, token: string): string | symbol | Function | InstanceWrapper<unknown>;
+    insertInjectable(injectable: Type<Injectable> | object, token: string, host: Type<Injectable>, subtype: EnhancerSubtype, methodKey?: string): InstanceWrapper<any>;
     insertExportedProvider(exportedProvider: Type<Injectable>, token: string): void;
     insertController(controller: Type<Controller>, token: string): void;
-    reflectMetadata(metadataKey: string, metatype: Type<any>): any;
+    reflectMetadata<T = any>(metadataKey: string, metatype: Type<any>): T[];
     registerCoreModule(): Promise<void>;
     /**
      * Add either request or transient globally scoped enhancers
@@ -63,6 +70,5 @@ export declare class DependenciesScanner {
      */
     private isExceptionFilter;
     private isForwardReference;
-    private flatten;
     private isRequestOrTransient;
 }

package/scanner.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DependenciesScanner = void 0;
-const common_1 = require("@nestjs/common");
 const constants_1 = require("@nestjs/common/constants");
 const interfaces_1 = require("@nestjs/common/interfaces");
-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 iterare_1 = require("iterare");
 const application_config_1 = require("./application-config");
@@ -15,10 +13,12 @@ const invalid_module_exception_1 = require("./errors/exceptions/invalid-module.e
 const undefined_module_exception_1 = require("./errors/exceptions/undefined-module.exception");
 const get_class_scope_1 = require("./helpers/get-class-scope");
 const internal_core_module_factory_1 = require("./injector/internal-core-module/internal-core-module-factory");
+const deterministic_uuid_registry_1 = require("./inspector/deterministic-uuid-registry");
 class DependenciesScanner {
-    constructor(container, metadataScanner, applicationConfig = new application_config_1.ApplicationConfig()) {
+    constructor(container, metadataScanner, graphInspector, applicationConfig = new application_config_1.ApplicationConfig()) {
         this.container = container;
         this.metadataScanner = metadataScanner;
+        this.graphInspector = graphInspector;
         this.applicationConfig = applicationConfig;
         this.applicationProvidersApplyMap = [];
     }
@@ -114,15 +114,15 @@ class DependenciesScanner {
             this.reflectDynamicMetadata(item, token);
         });
     }
-    reflectDynamicMetadata(obj, token) {
-        if (!obj || !obj.prototype) {
+    reflectDynamicMetadata(cls, token) {
+        if (!cls || !cls.prototype) {
             return;
         }
-        this.reflectInjectables(obj, token, constants_1.GUARDS_METADATA);
-        this.reflectInjectables(obj, token, constants_1.INTERCEPTORS_METADATA);
-        this.reflectInjectables(obj, token, constants_1.EXCEPTION_FILTERS_METADATA);
-        this.reflectInjectables(obj, token, constants_1.PIPES_METADATA);
-        this.reflectParamInjectables(obj, token, constants_1.ROUTE_ARGS_METADATA);
+        this.reflectInjectables(cls, token, constants_1.GUARDS_METADATA);
+        this.reflectInjectables(cls, token, constants_1.INTERCEPTORS_METADATA);
+        this.reflectInjectables(cls, token, constants_1.EXCEPTION_FILTERS_METADATA);
+        this.reflectInjectables(cls, token, constants_1.PIPES_METADATA);
+        this.reflectParamInjectables(cls, token, constants_1.ROUTE_ARGS_METADATA);
     }
     reflectExports(module, token) {
         const exports = [
@@ -133,40 +133,50 @@ class DependenciesScanner {
     }
     reflectInjectables(component, token, metadataKey) {
         const controllerInjectables = this.reflectMetadata(metadataKey, component);
-        const methodsInjectables = this.metadataScanner.scanFromPrototype(null, component.prototype, this.reflectKeyMetadata.bind(this, component, metadataKey));
-        const flattenMethodsInjectables = this.flatten(methodsInjectables);
-        const combinedInjectables = [
-            ...controllerInjectables,
-            ...flattenMethodsInjectables,
-        ].filter(shared_utils_1.isFunction);
-        const injectables = Array.from(new Set(combinedInjectables));
-        injectables.forEach(injectable => this.insertInjectable(injectable, token, component));
+        const methodInjectables = this.metadataScanner.scanFromPrototype(null, component.prototype, this.reflectKeyMetadata.bind(this, component, metadataKey));
+        controllerInjectables.forEach(injectable => this.insertInjectable(injectable, token, component, constants_1.ENHANCER_KEY_TO_SUBTYPE_MAP[metadataKey]));
+        methodInjectables.forEach(({ methodKey, metadata }) => metadata.forEach(injectable => this.insertInjectable(injectable, token, component, constants_1.ENHANCER_KEY_TO_SUBTYPE_MAP[metadataKey], methodKey)));
     }
     reflectParamInjectables(component, token, metadataKey) {
-        const paramsMetadata = this.metadataScanner.scanFromPrototype(null, component.prototype, method => Reflect.getMetadata(metadataKey, component, method));
-        const paramsInjectables = this.flatten(paramsMetadata).map((param) => (0, common_1.flatten)(Object.keys(param).map(k => param[k].pipes)).filter(shared_utils_1.isFunction));
-        (0, common_1.flatten)(paramsInjectables).forEach((injectable) => this.insertInjectable(injectable, token, component));
+        const paramsMetadata = this.metadataScanner.scanFromPrototype(null, component.prototype, methodKey => {
+            const metadata = Reflect.getMetadata(metadataKey, component, methodKey);
+            if (!metadata) {
+                return;
+            }
+            return { methodKey, metadata };
+        });
+        paramsMetadata.forEach(({ methodKey, metadata }) => {
+            const params = Object.values(metadata);
+            params
+                .map(item => item.pipes)
+                .flat(1)
+                .forEach(injectable => this.insertInjectable(injectable, token, component, 'pipe', methodKey));
+        });
     }
-    reflectKeyMetadata(component, key, method) {
+    reflectKeyMetadata(component, key, methodKey) {
         let prototype = component.prototype;
         do {
-            const descriptor = Reflect.getOwnPropertyDescriptor(prototype, method);
+            const descriptor = Reflect.getOwnPropertyDescriptor(prototype, methodKey);
             if (!descriptor) {
                 continue;
             }
-            return Reflect.getMetadata(key, descriptor.value);
+            const metadata = Reflect.getMetadata(key, descriptor.value);
+            if (!metadata) {
+                return;
+            }
+            return { methodKey, metadata };
         } while ((prototype = Reflect.getPrototypeOf(prototype)) &&
             prototype !== Object.prototype &&
             prototype);
         return undefined;
     }
-    async calculateModulesDistance() {
+    calculateModulesDistance() {
         const modulesGenerator = this.container.getModules().values();
         // Skip "InternalCoreModule" from calculating distance
         modulesGenerator.next();
         const modulesStack = [];
         const calculateDistance = (moduleRef, distance = 1) => {
-            if (modulesStack.includes(moduleRef)) {
+            if (!moduleRef || modulesStack.includes(moduleRef)) {
                 return;
             }
             modulesStack.push(moduleRef);
@@ -204,7 +214,8 @@ class DependenciesScanner {
         if (!providersKeys.includes(type)) {
             return this.container.addProvider(provider, token);
         }
-        const providerToken = `${type} (UUID: ${(0, random_string_generator_util_1.randomStringGenerator)()})`;
+        const uuid = deterministic_uuid_registry_1.DeterministicUuidRegistry.get(type.toString());
+        const providerToken = `${type} (UUID: ${uuid})`;
         let scope = provider.scope;
         if ((0, shared_utils_1.isNil)(scope) && provider.useClass) {
             scope = (0, get_class_scope_1.getClassScope)(provider.useClass);
@@ -216,14 +227,35 @@ class DependenciesScanner {
             scope,
         });
         const newProvider = Object.assign(Object.assign({}, provider), { provide: providerToken, scope });
+        const enhancerSubtype = constants_2.ENHANCER_TOKEN_TO_SUBTYPE_MAP[type];
         const factoryOrClassProvider = newProvider;
         if (this.isRequestOrTransient(factoryOrClassProvider.scope)) {
-            return this.container.addInjectable(newProvider, token);
+            return this.container.addInjectable(newProvider, token, enhancerSubtype);
+        }
+        this.container.addProvider(newProvider, token, enhancerSubtype);
+    }
+    insertInjectable(injectable, token, host, subtype, methodKey) {
+        if ((0, shared_utils_1.isFunction)(injectable)) {
+            const instanceWrapper = this.container.addInjectable(injectable, token, subtype, host);
+            this.graphInspector.insertEnhancerMetadataCache({
+                moduleToken: token,
+                classRef: host,
+                enhancerInstanceWrapper: instanceWrapper,
+                targetNodeId: instanceWrapper.id,
+                subtype,
+                methodKey,
+            });
+            return instanceWrapper;
+        }
+        else {
+            this.graphInspector.insertEnhancerMetadataCache({
+                moduleToken: token,
+                classRef: host,
+                enhancerRef: injectable,
+                methodKey,
+                subtype,
+            });
         }
-        this.container.addProvider(newProvider, token);
-    }
-    insertInjectable(injectable, token, host) {
-        this.container.addInjectable(injectable, token, host);
     }
     insertExportedProvider(exportedProvider, token) {
         this.container.addExportedProvider(exportedProvider, token);
@@ -235,7 +267,7 @@ class DependenciesScanner {
         return Reflect.getMetadata(metadataKey, metatype) || [];
     }
     async registerCoreModule() {
-        const moduleDefinition = internal_core_module_factory_1.InternalCoreModuleFactory.create(this.container, this, this.container.getModuleCompiler(), this.container.getHttpAdapterHostRef());
+        const moduleDefinition = internal_core_module_factory_1.InternalCoreModuleFactory.create(this.container, this, this.container.getModuleCompiler(), this.container.getHttpAdapterHostRef(), this.graphInspector);
         const [instance] = await this.scanForModules(moduleDefinition);
         this.container.registerCoreModuleRef(instance);
     }
@@ -269,9 +301,11 @@ class DependenciesScanner {
             let instanceWrapper;
             if (this.isRequestOrTransient(scope)) {
                 instanceWrapper = getInstanceWrapper(moduleKey, providerKey, 'injectables');
+                this.graphInspector.insertAttachedEnhancer(instanceWrapper);
                 return applyRequestProvidersMap[type](instanceWrapper);
             }
             instanceWrapper = getInstanceWrapper(moduleKey, providerKey, 'providers');
+            this.graphInspector.insertAttachedEnhancer(instanceWrapper);
             applyProvidersMap[type](instanceWrapper.instance);
         });
     }
@@ -318,9 +352,6 @@ class DependenciesScanner {
     isForwardReference(module) {
         return module && !!module.forwardRef;
     }
-    flatten(arr) {
-        return arr.flat(1);
-    }
     isRequestOrTransient(scope) {
         return scope === interfaces_1.Scope.REQUEST || scope === interfaces_1.Scope.TRANSIENT;
     }