@nestjs/core 9.2.1 → 9.3.0-beta.2

package/inspector/serialized-graph.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializedGraph = void 0;
+const application_config_1 = require("../application-config");
+const external_context_creator_1 = require("../helpers/external-context-creator");
+const http_adapter_host_1 = require("../helpers/http-adapter-host");
+const inquirer_constants_1 = require("../injector/inquirer/inquirer-constants");
+const lazy_module_loader_1 = require("../injector/lazy-module-loader/lazy-module-loader");
+const module_ref_1 = require("../injector/module-ref");
+const modules_container_1 = require("../injector/modules-container");
+const request_constants_1 = require("../router/request/request-constants");
+const reflector_service_1 = require("../services/reflector.service");
+const deterministic_uuid_registry_1 = require("./deterministic-uuid-registry");
+class SerializedGraph {
+    constructor() {
+        this.nodes = new Map();
+        this.edges = new Map();
+        this.entrypoints = new Map();
+        this.extras = {
+            orphanedEnhancers: [],
+            attachedEnhancers: [],
+        };
+    }
+    insertNode(nodeDefinition) {
+        if (nodeDefinition.metadata.type === 'provider' &&
+            SerializedGraph.INTERNAL_PROVIDERS.includes(nodeDefinition.metadata.token)) {
+            nodeDefinition.metadata = Object.assign(Object.assign({}, nodeDefinition.metadata), { internal: true });
+        }
+        if (this.nodes.has(nodeDefinition.id)) {
+            return this.nodes.get(nodeDefinition.id);
+        }
+        this.nodes.set(nodeDefinition.id, nodeDefinition);
+        return nodeDefinition;
+    }
+    insertEdge(edgeDefinition) {
+        var _a;
+        if (edgeDefinition.metadata.type === 'class-to-class' &&
+            (SerializedGraph.INTERNAL_PROVIDERS.includes(edgeDefinition.metadata.sourceClassToken) ||
+                SerializedGraph.INTERNAL_PROVIDERS.includes(edgeDefinition.metadata.targetClassToken))) {
+            edgeDefinition.metadata = Object.assign(Object.assign({}, edgeDefinition.metadata), { internal: true });
+        }
+        const id = (_a = edgeDefinition.id) !== null && _a !== void 0 ? _a : this.generateUuidByEdgeDefinition(edgeDefinition);
+        const edge = Object.assign(Object.assign({}, edgeDefinition), { id });
+        this.edges.set(id, edge);
+        return edge;
+    }
+    insertEntrypoint(definition, parentId) {
+        if (this.entrypoints.has(parentId)) {
+            const existingCollection = this.entrypoints.get(parentId);
+            existingCollection.push(definition);
+        }
+        else {
+            this.entrypoints.set(parentId, [definition]);
+        }
+    }
+    insertOrphanedEnhancer(entry) {
+        this.extras.orphanedEnhancers.push(entry);
+    }
+    insertAttachedEnhancer(nodeId) {
+        this.extras.attachedEnhancers.push({
+            nodeId,
+        });
+    }
+    getNodeById(id) {
+        return this.nodes.get(id);
+    }
+    toJSON() {
+        return {
+            nodes: Object.fromEntries(this.nodes),
+            edges: Object.fromEntries(this.edges),
+            entrypoints: Object.fromEntries(this.entrypoints),
+            extras: this.extras,
+        };
+    }
+    toString() {
+        const replacer = (key, value) => {
+            var _a;
+            if (typeof value === 'symbol') {
+                return value.toString();
+            }
+            return typeof value === 'function' ? (_a = value.name) !== null && _a !== void 0 ? _a : 'Function' : value;
+        };
+        return JSON.stringify(this.toJSON(), replacer, 2);
+    }
+    generateUuidByEdgeDefinition(edgeDefinition) {
+        const UUID_NAMESPACE = '7a6d19ab-ec88-419f-a833-062532c468a7';
+        return deterministic_uuid_registry_1.DeterministicUuidRegistry.get(JSON.stringify(edgeDefinition), UUID_NAMESPACE);
+    }
+}
+exports.SerializedGraph = SerializedGraph;
+SerializedGraph.INTERNAL_PROVIDERS = [
+    application_config_1.ApplicationConfig,
+    module_ref_1.ModuleRef,
+    http_adapter_host_1.HttpAdapterHost,
+    lazy_module_loader_1.LazyModuleLoader,
+    external_context_creator_1.ExternalContextCreator,
+    modules_container_1.ModulesContainer,
+    reflector_service_1.Reflector,
+    SerializedGraph,
+    http_adapter_host_1.HttpAdapterHost.name,
+    reflector_service_1.Reflector.name,
+    request_constants_1.REQUEST,
+    inquirer_constants_1.INQUIRER,
+];

package/middleware/container.js

@@ -25,11 +25,12 @@ class MiddlewareContainer {
         const targetConfig = this.getTargetConfig(moduleKey);
         const configurations = configList || [];
         const insertMiddleware = (metatype) => {
+            var _a;
             const token = metatype;
             middleware.set(token, new instance_wrapper_1.InstanceWrapper({
                 scope: (0, get_class_scope_1.getClassScope)(metatype),
                 durable: (0, is_durable_1.isDurable)(metatype),
-                name: token,
+                name: (_a = token === null || token === void 0 ? void 0 : token.name) !== null && _a !== void 0 ? _a : token,
                 metatype,
                 token,
             }));

package/middleware/middleware-module.d.ts

@@ -4,6 +4,7 @@ import { ApplicationConfig } from '../application-config';
 import { NestContainer } from '../injector/container';
 import { Injector } from '../injector/injector';
 import { Module } from '../injector/module';
+import { GraphInspector } from '../inspector/graph-inspector';
 import { RoutePathFactory } from '../router/route-path-factory';
 import { MiddlewareContainer } from './container';
 export declare class MiddlewareModule {
@@ -17,8 +18,9 @@ export declare class MiddlewareModule {
     private config;
     private container;
     private httpAdapter;
+    private graphInspector;
     constructor(routePathFactory: RoutePathFactory);
-    register(middlewareContainer: MiddlewareContainer, container: NestContainer, config: ApplicationConfig, injector: Injector, httpAdapter: HttpServer): Promise<void>;
+    register(middlewareContainer: MiddlewareContainer, container: NestContainer, config: ApplicationConfig, injector: Injector, httpAdapter: HttpServer, graphInspector: GraphInspector): Promise<void>;
     resolveMiddleware(middlewareContainer: MiddlewareContainer, modules: Map<string, Module>): Promise<void>;
     loadConfiguration(middlewareContainer: MiddlewareContainer, moduleRef: Module, moduleKey: string): Promise<void>;
     registerMiddleware(middlewareContainer: MiddlewareContainer, applicationRef: any): Promise<void>;

package/middleware/middleware-module.js

@@ -22,15 +22,16 @@ class MiddlewareModule {
         this.routerProxy = new router_proxy_1.RouterProxy();
         this.exceptionFiltersCache = new WeakMap();
     }
-    async register(middlewareContainer, container, config, injector, httpAdapter) {
+    async register(middlewareContainer, container, config, injector, httpAdapter, graphInspector) {
         const appRef = container.getHttpAdapterRef();
         this.routerExceptionFilter = new router_exception_filters_1.RouterExceptionFilters(container, config, appRef);
         this.routesMapper = new routes_mapper_1.RoutesMapper(container);
-        this.resolver = new resolver_1.MiddlewareResolver(middlewareContainer);
+        this.resolver = new resolver_1.MiddlewareResolver(middlewareContainer, injector);
         this.config = config;
         this.injector = injector;
         this.container = container;
         this.httpAdapter = httpAdapter;
+        this.graphInspector = graphInspector;
         const modules = container.getModules();
         await this.resolveMiddleware(middlewareContainer, modules);
     }
@@ -77,6 +78,7 @@ class MiddlewareModule {
         }
     }
     async registerRouteMiddleware(middlewareContainer, routeInfo, config, moduleKey, applicationRef) {
+        var _a;
         const middlewareCollection = [].concat(config.middleware);
         const moduleRef = this.container.getModuleByKey(moduleKey);
         for (const metatype of middlewareCollection) {
@@ -88,6 +90,20 @@ class MiddlewareModule {
             if (instanceWrapper.isTransient) {
                 return;
             }
+            this.graphInspector.insertClassNode(moduleRef, instanceWrapper, 'middleware');
+            const middlewareDefinition = {
+                type: 'middleware',
+                methodName: 'use',
+                className: instanceWrapper.name,
+                classNodeId: instanceWrapper.id,
+                metadata: {
+                    key: routeInfo.path,
+                    path: routeInfo.path,
+                    requestMethod: (_a = request_method_enum_1.RequestMethod[routeInfo.method]) !== null && _a !== void 0 ? _a : 'ALL',
+                    version: routeInfo.version,
+                },
+            };
+            this.graphInspector.insertEntrypointDefinition(middlewareDefinition, instanceWrapper.id);
             await this.bindHandler(instanceWrapper, applicationRef, routeInfo, moduleRef, collection);
         }
     }

package/middleware/resolver.d.ts

@@ -1,9 +1,10 @@
+import { Injector } from '../injector/injector';
 import { Module } from '../injector/module';
 import { MiddlewareContainer } from './container';
 export declare class MiddlewareResolver {
     private readonly middlewareContainer;
-    private readonly instanceLoader;
-    constructor(middlewareContainer: MiddlewareContainer);
+    private readonly injector;
+    constructor(middlewareContainer: MiddlewareContainer, injector: Injector);
     resolveInstances(moduleRef: Module, moduleName: string): Promise<void>;
     private resolveMiddlewareInstance;
 }

package/middleware/resolver.js

@@ -1,19 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MiddlewareResolver = void 0;
-const injector_1 = require("../injector/injector");
 class MiddlewareResolver {
-    constructor(middlewareContainer) {
+    constructor(middlewareContainer, injector) {
         this.middlewareContainer = middlewareContainer;
-        this.instanceLoader = new injector_1.Injector();
+        this.injector = injector;
     }
     async resolveInstances(moduleRef, moduleName) {
-        const middleware = this.middlewareContainer.getMiddlewareCollection(moduleName);
-        const resolveInstance = async (wrapper) => this.resolveMiddlewareInstance(wrapper, middleware, moduleRef);
-        await Promise.all([...middleware.values()].map(resolveInstance));
+        const middlewareMap = this.middlewareContainer.getMiddlewareCollection(moduleName);
+        const resolveInstance = async (wrapper) => this.resolveMiddlewareInstance(wrapper, middlewareMap, moduleRef);
+        await Promise.all([...middlewareMap.values()].map(resolveInstance));
     }
-    async resolveMiddlewareInstance(wrapper, middleware, moduleRef) {
-        await this.instanceLoader.loadMiddleware(wrapper, middleware, moduleRef);
+    async resolveMiddlewareInstance(wrapper, middlewareMap, moduleRef) {
+        await this.injector.loadMiddleware(wrapper, middlewareMap, moduleRef);
     }
 }
 exports.MiddlewareResolver = MiddlewareResolver;

package/middleware/routes-mapper.d.ts

@@ -2,7 +2,7 @@ import { RouteInfo, Type } from '@nestjs/common/interfaces';
 import { NestContainer } from '../injector/container';
 export declare class RoutesMapper {
     private readonly container;
-    private readonly routerExplorer;
+    private readonly pathsExplorer;
     constructor(container: NestContainer);
     mapRouteToRouteInfo(route: Type<any> | RouteInfo | string): RouteInfo[];
     private getRouteInfoFromPath;

package/middleware/routes-mapper.js

@@ -4,12 +4,12 @@ exports.RoutesMapper = void 0;
 const constants_1 = require("@nestjs/common/constants");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const metadata_scanner_1 = require("../metadata-scanner");
-const router_explorer_1 = require("../router/router-explorer");
+const paths_explorer_1 = require("../router/paths-explorer");
 const router_module_1 = require("../router/router-module");
 class RoutesMapper {
     constructor(container) {
         this.container = container;
-        this.routerExplorer = new router_explorer_1.RouterExplorer(new metadata_scanner_1.MetadataScanner(), container);
+        this.pathsExplorer = new paths_explorer_1.PathsExplorer(new metadata_scanner_1.MetadataScanner());
     }
     mapRouteToRouteInfo(route) {
         if ((0, shared_utils_1.isString)(route)) {
@@ -41,7 +41,7 @@ class RoutesMapper {
         return [routeInfo];
     }
     getRouteInfoFromController(controller, routePath) {
-        const controllerPaths = this.routerExplorer.scanForPaths(Object.create(controller), controller.prototype);
+        const controllerPaths = this.pathsExplorer.scanForPaths(Object.create(controller), controller.prototype);
         const moduleRef = this.getHostModuleOfController(controller);
         const modulePath = this.getModulePath(moduleRef === null || moduleRef === void 0 ? void 0 : moduleRef.metatype);
         const concatPaths = (acc, currentValue) => acc.concat(currentValue);

package/nest-application-context.d.ts

@@ -1,5 +1,6 @@
-import { INestApplicationContext, LoggerService, LogLevel, ShutdownSignal } from '@nestjs/common';
+import { INestApplicationContext, Logger, LoggerService, LogLevel, ShutdownSignal } from '@nestjs/common';
 import { DynamicModule, Type } from '@nestjs/common/interfaces';
+import { NestApplicationContextOptions } from '@nestjs/common/interfaces/nest-application-context-options.interface';
 import { AbstractInstanceResolver } from './injector/abstract-instance-resolver';
 import { NestContainer } from './injector/container';
 import { Injector } from './injector/injector';
@@ -9,12 +10,14 @@ import { Module } from './injector/module';
 /**
  * @publicApi
  */
-export declare class NestApplicationContext extends AbstractInstanceResolver implements INestApplicationContext {
+export declare class NestApplicationContext<TOptions extends NestApplicationContextOptions = NestApplicationContextOptions> extends AbstractInstanceResolver implements INestApplicationContext {
     protected readonly container: NestContainer;
-    private readonly scope;
+    protected readonly appOptions: TOptions;
     private contextModule;
+    private readonly scope;
     protected isInitialized: boolean;
-    protected readonly injector: Injector;
+    protected injector: Injector;
+    protected readonly logger: Logger;
     private shouldFlushLogsOnOverride;
     private readonly activeShutdownSignals;
     private readonly moduleCompiler;
@@ -22,7 +25,7 @@ export declare class NestApplicationContext extends AbstractInstanceResolver imp
     private _instanceLinksHost;
     private _moduleRefsByDistance?;
     protected get instanceLinksHost(): InstanceLinksHost;
-    constructor(container: NestContainer, scope?: Type<any>[], contextModule?: Module);
+    constructor(container: NestContainer, appOptions?: TOptions, contextModule?: Module, scope?: Type<any>[]);
     selectContextModule(): void;
     /**
      * Allows navigating through the modules tree, for example, to pull out a specific instance from the selected module.
@@ -161,5 +164,7 @@ export declare class NestApplicationContext extends AbstractInstanceResolver imp
      * modules and children.
      */
     protected callBeforeShutdownHook(signal?: string): Promise<void>;
+    protected assertNotInPreviewMode(methodName: string): void;
     private getModulesSortedByDistance;
+    private printInPreviewModeWarning;
 }

package/nest-application-context.js

@@ -16,16 +16,23 @@ const instance_links_host_1 = require("./injector/instance-links-host");
  * @publicApi
  */
 class NestApplicationContext extends abstract_instance_resolver_1.AbstractInstanceResolver {
-    constructor(container, scope = new Array(), contextModule = null) {
+    constructor(container, appOptions = {}, contextModule = null, scope = new Array()) {
         super();
         this.container = container;
-        this.scope = scope;
+        this.appOptions = appOptions;
         this.contextModule = contextModule;
+        this.scope = scope;
         this.isInitialized = false;
-        this.injector = new injector_1.Injector();
+        this.logger = new common_1.Logger(NestApplicationContext.name, {
+            timestamp: true,
+        });
         this.shouldFlushLogsOnOverride = false;
         this.activeShutdownSignals = new Array();
         this.moduleCompiler = new compiler_1.ModuleCompiler();
+        this.injector = new injector_1.Injector();
+        if (this.appOptions.preview) {
+            this.printInPreviewModeWarning();
+        }
     }
     get instanceLinksHost() {
         if (!this._instanceLinksHost) {
@@ -52,7 +59,7 @@ class NestApplicationContext extends abstract_instance_resolver_1.AbstractInstan
         if (!selectedModule) {
             throw new exceptions_1.UnknownModuleException();
         }
-        return new NestApplicationContext(this.container, scope, selectedModule);
+        return new NestApplicationContext(this.container, this.appOptions, selectedModule, scope);
     }
     /**
      * Retrieves an instance (or a list of instances) of either injectable or controller, otherwise, throws exception.
@@ -205,6 +212,9 @@ class NestApplicationContext extends abstract_instance_resolver_1.AbstractInstan
      * modules and its children.
      */
     async callInitHook() {
+        if (this.appOptions.preview) {
+            return;
+        }
         const modulesSortedByDistance = this.getModulesSortedByDistance();
         for (const module of modulesSortedByDistance) {
             await (0, hooks_1.callModuleInitHook)(module);
@@ -215,6 +225,9 @@ class NestApplicationContext extends abstract_instance_resolver_1.AbstractInstan
      * modules and its children.
      */
     async callDestroyHook() {
+        if (this.appOptions.preview) {
+            return;
+        }
         const modulesSortedByDistance = this.getModulesSortedByDistance();
         for (const module of modulesSortedByDistance) {
             await (0, hooks_1.callModuleDestroyHook)(module);
@@ -225,6 +238,9 @@ class NestApplicationContext extends abstract_instance_resolver_1.AbstractInstan
      * modules and its children.
      */
     async callBootstrapHook() {
+        if (this.appOptions.preview) {
+            return;
+        }
         const modulesSortedByDistance = this.getModulesSortedByDistance();
         for (const module of modulesSortedByDistance) {
             await (0, hooks_1.callModuleBootstrapHook)(module);
@@ -235,6 +251,9 @@ class NestApplicationContext extends abstract_instance_resolver_1.AbstractInstan
      * modules and children.
      */
     async callShutdownHook(signal) {
+        if (this.appOptions.preview) {
+            return;
+        }
         const modulesSortedByDistance = this.getModulesSortedByDistance();
         for (const module of modulesSortedByDistance) {
             await (0, hooks_1.callAppShutdownHook)(module, signal);
@@ -245,11 +264,21 @@ class NestApplicationContext extends abstract_instance_resolver_1.AbstractInstan
      * modules and children.
      */
     async callBeforeShutdownHook(signal) {
+        if (this.appOptions.preview) {
+            return;
+        }
         const modulesSortedByDistance = this.getModulesSortedByDistance();
         for (const module of modulesSortedByDistance) {
             await (0, hooks_1.callBeforeAppShutdownHook)(module, signal);
         }
     }
+    assertNotInPreviewMode(methodName) {
+        if (this.appOptions.preview) {
+            const error = `Calling the "${methodName}" in the preview mode is not supported.`;
+            this.logger.error(error);
+            throw new Error(error);
+        }
+    }
     getModulesSortedByDistance() {
         if (this._moduleRefsByDistance) {
             return this._moduleRefsByDistance;
@@ -259,5 +288,11 @@ class NestApplicationContext extends abstract_instance_resolver_1.AbstractInstan
         this._moduleRefsByDistance = Array.from(modulesContainer.values()).sort(compareFn);
         return this._moduleRefsByDistance;
     }
+    printInPreviewModeWarning() {
+        this.logger.warn('------------------------------------------------');
+        this.logger.warn('Application is running in the PREVIEW mode!');
+        this.logger.warn('Providers/controllers will not be instantiated.');
+        this.logger.warn('------------------------------------------------');
+    }
 }
 exports.NestApplicationContext = NestApplicationContext;

package/nest-application.d.ts

@@ -1,18 +1,20 @@
 import { CanActivate, ExceptionFilter, HttpServer, INestApplication, INestMicroservice, NestHybridApplicationOptions, NestInterceptor, PipeTransform, VersioningOptions, WebSocketAdapter } from '@nestjs/common';
 import { GlobalPrefixOptions, NestApplicationOptions } from '@nestjs/common/interfaces';
 import { CorsOptions, CorsOptionsDelegate } from '@nestjs/common/interfaces/external/cors-options.interface';
+import { Logger } from '@nestjs/common/services/logger.service';
 import { AbstractHttpAdapter } from './adapters';
 import { ApplicationConfig } from './application-config';
 import { NestContainer } from './injector/container';
+import { GraphInspector } from './inspector/graph-inspector';
 import { NestApplicationContext } from './nest-application-context';
 /**
  * @publicApi
  */
-export declare class NestApplication extends NestApplicationContext implements INestApplication {
+export declare class NestApplication extends NestApplicationContext<NestApplicationOptions> implements INestApplication {
     private readonly httpAdapter;
     private readonly config;
-    private readonly appOptions;
-    private readonly logger;
+    private readonly graphInspector;
+    protected readonly logger: Logger;
     private readonly middlewareModule;
     private readonly middlewareContainer;
     private readonly microservicesModule;
@@ -21,7 +23,7 @@ export declare class NestApplication extends NestApplicationContext implements I
     private readonly microservices;
     private httpServer;
     private isListening;
-    constructor(container: NestContainer, httpAdapter: HttpServer, config: ApplicationConfig, appOptions?: NestApplicationOptions);
+    constructor(container: NestContainer, httpAdapter: HttpServer, config: ApplicationConfig, graphInspector: GraphInspector, appOptions?: NestApplicationOptions);
     protected dispose(): Promise<void>;
     getHttpAdapter(): AbstractHttpAdapter;
     registerHttpServer(): void;

package/nest-application.js

@@ -11,6 +11,7 @@ const pathToRegexp = require("path-to-regexp");
 const application_config_1 = require("./application-config");
 const constants_1 = require("./constants");
 const optional_require_1 = require("./helpers/optional-require");
+const injector_1 = require("./injector/injector");
 const container_1 = require("./middleware/container");
 const middleware_module_1 = require("./middleware/middleware-module");
 const nest_application_context_1 = require("./nest-application-context");
@@ -22,11 +23,11 @@ const { MicroservicesModule } = (0, optional_require_1.optionalRequire)('@nestjs
  * @publicApi
  */
 class NestApplication extends nest_application_context_1.NestApplicationContext {
-    constructor(container, httpAdapter, config, appOptions = {}) {
-        super(container);
+    constructor(container, httpAdapter, config, graphInspector, appOptions = {}) {
+        super(container, appOptions);
         this.httpAdapter = httpAdapter;
         this.config = config;
-        this.appOptions = appOptions;
+        this.graphInspector = graphInspector;
         this.logger = new logger_service_1.Logger(NestApplication.name, {
             timestamp: true,
         });
@@ -37,8 +38,9 @@ class NestApplication extends nest_application_context_1.NestApplicationContext
         this.isListening = false;
         this.selectContextModule();
         this.registerHttpServer();
+        this.injector = new injector_1.Injector({ preview: this.appOptions.preview });
         this.middlewareModule = new middleware_module_1.MiddlewareModule(new route_path_factory_1.RoutePathFactory(config));
-        this.routesResolver = new routes_resolver_1.RoutesResolver(this.container, this.config, this.injector);
+        this.routesResolver = new routes_resolver_1.RoutesResolver(this.container, this.config, this.injector, this.graphInspector);
     }
     async dispose() {
         this.socketModule && (await this.socketModule.close());
@@ -75,16 +77,16 @@ class NestApplication extends nest_application_context_1.NestApplicationContext
     async registerModules() {
         this.registerWsModule();
         if (this.microservicesModule) {
-            this.microservicesModule.register(this.container, this.config);
+            this.microservicesModule.register(this.container, this.graphInspector, this.config, this.appOptions);
             this.microservicesModule.setupClients(this.container);
         }
-        await this.middlewareModule.register(this.middlewareContainer, this.container, this.config, this.injector, this.httpAdapter);
+        await this.middlewareModule.register(this.middlewareContainer, this.container, this.config, this.injector, this.httpAdapter, this.graphInspector);
     }
     registerWsModule() {
         if (!this.socketModule) {
             return;
         }
-        this.socketModule.register(this.container, this.config, this.httpServer);
+        this.socketModule.register(this.container, this.config, this.graphInspector, this.appOptions, this.httpServer);
     }
     async init() {
         var _a;
@@ -123,7 +125,7 @@ class NestApplication extends nest_application_context_1.NestApplicationContext
         const applicationConfig = inheritAppConfig
             ? this.config
             : new application_config_1.ApplicationConfig();
-        const instance = new NestMicroservice(this.container, microserviceOptions, applicationConfig);
+        const instance = new NestMicroservice(this.container, microserviceOptions, this.graphInspector, applicationConfig);
         instance.registerListeners();
         instance.setIsInitialized(true);
         instance.setIsInitHookCalled(true);
@@ -137,6 +139,7 @@ class NestApplication extends nest_application_context_1.NestApplicationContext
         return this.httpServer;
     }
     async startAllMicroservices() {
+        this.assertNotInPreviewMode('startAllMicroservices');
         await Promise.all(this.microservices.map(msvc => msvc.listen()));
         return this;
     }
@@ -152,6 +155,7 @@ class NestApplication extends nest_application_context_1.NestApplicationContext
         return this;
     }
     async listen(port, ...args) {
+        this.assertNotInPreviewMode('listen');
         !this.isInitialized && (await this.init());
         return new Promise((resolve, reject) => {
             const errorHandler = (e) => {
@@ -242,18 +246,34 @@ class NestApplication extends nest_application_context_1.NestApplicationContext
     }
     useGlobalFilters(...filters) {
         this.config.useGlobalFilters(...filters);
+        filters.forEach(item => this.graphInspector.insertOrphanedEnhancer({
+            subtype: 'filter',
+            ref: item,
+        }));
         return this;
     }
     useGlobalPipes(...pipes) {
         this.config.useGlobalPipes(...pipes);
+        pipes.forEach(item => this.graphInspector.insertOrphanedEnhancer({
+            subtype: 'pipe',
+            ref: item,
+        }));
         return this;
     }
     useGlobalInterceptors(...interceptors) {
         this.config.useGlobalInterceptors(...interceptors);
+        interceptors.forEach(item => this.graphInspector.insertOrphanedEnhancer({
+            subtype: 'interceptor',
+            ref: item,
+        }));
         return this;
     }
     useGlobalGuards(...guards) {
         this.config.useGlobalGuards(...guards);
+        guards.forEach(item => this.graphInspector.insertOrphanedEnhancer({
+            subtype: 'guard',
+            ref: item,
+        }));
         return this;
     }
     useStaticAssets(pathOrOptions, options) {

package/nest-factory.d.ts

@@ -35,23 +35,23 @@ export declare class NestFactoryStatic {
     /**
      * 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.
      */
-    createMicroservice<T extends object>(module: any, options?: NestMicroserviceOptions & T): Promise<INestMicroservice>;
+    createMicroservice<T extends object>(moduleCls: any, options?: NestMicroserviceOptions & T): Promise<INestMicroservice>;
     /**
      * 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.
      */
-    createApplicationContext(module: any, options?: NestApplicationContextOptions): Promise<INestApplicationContext>;
+    createApplicationContext(moduleCls: any, options?: NestApplicationContextOptions): Promise<INestApplicationContext>;
     private createNestInstance;
     private initialize;
     private handleInitializationError;
@@ -63,6 +63,7 @@ export declare class NestFactoryStatic {
     private isHttpServer;
     private setAbortOnError;
     private createAdapterProxy;
+    private createGraphInspector;
 }
 /**
  * Use NestFactory to create an application instance.