@depup/nestjs__core 11.1.17-depup.0

package/nest-application.js

@@ -0,0 +1,328 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestApplication = void 0;
+const common_1 = require("@nestjs/common");
+const logger_service_1 = require("@nestjs/common/services/logger.service");
+const load_package_util_1 = require("@nestjs/common/utils/load-package.util");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const iterare_1 = require("iterare");
+const os_1 = require("os");
+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 utils_1 = require("./middleware/utils");
+const nest_application_context_1 = require("./nest-application-context");
+const routes_resolver_1 = require("./router/routes-resolver");
+const { SocketModule } = (0, optional_require_1.optionalRequire)('@nestjs/websockets/socket-module', () => require('@nestjs/websockets/socket-module'));
+const { MicroservicesModule } = (0, optional_require_1.optionalRequire)('@nestjs/microservices/microservices-module', () => require('@nestjs/microservices/microservices-module'));
+/**
+ * @publicApi
+ */
+class NestApplication extends nest_application_context_1.NestApplicationContext {
+    constructor(container, httpAdapter, config, graphInspector, appOptions = {}) {
+        super(container, appOptions);
+        this.httpAdapter = httpAdapter;
+        this.config = config;
+        this.graphInspector = graphInspector;
+        this.logger = new logger_service_1.Logger(NestApplication.name, {
+            timestamp: true,
+        });
+        this.middlewareContainer = new container_1.MiddlewareContainer(this.container);
+        this.microservicesModule = MicroservicesModule && new MicroservicesModule();
+        this.socketModule = SocketModule && new SocketModule();
+        this.microservices = [];
+        this.isListening = false;
+        this.selectContextModule();
+        this.registerHttpServer();
+        this.injector = new injector_1.Injector({
+            preview: this.appOptions.preview,
+            instanceDecorator: appOptions.instrument?.instanceDecorator,
+        });
+        this.middlewareModule = new middleware_module_1.MiddlewareModule();
+        this.routesResolver = new routes_resolver_1.RoutesResolver(this.container, this.config, this.injector, this.graphInspector);
+    }
+    async dispose() {
+        this.socketModule && (await this.socketModule.close());
+        this.microservicesModule && (await this.microservicesModule.close());
+        this.httpAdapter && (await this.httpAdapter.close());
+        await Promise.all((0, iterare_1.iterate)(this.microservices).map(async (microservice) => {
+            microservice.setIsTerminated(true);
+            await microservice.close();
+        }));
+    }
+    getHttpAdapter() {
+        return this.httpAdapter;
+    }
+    registerHttpServer() {
+        this.httpServer = this.createServer();
+    }
+    getUnderlyingHttpServer() {
+        return this.httpAdapter.getHttpServer();
+    }
+    applyOptions() {
+        if (!this.appOptions || !this.appOptions.cors) {
+            return undefined;
+        }
+        const passCustomOptions = (0, shared_utils_1.isObject)(this.appOptions.cors) || (0, shared_utils_1.isFunction)(this.appOptions.cors);
+        if (!passCustomOptions) {
+            return this.enableCors();
+        }
+        return this.enableCors(this.appOptions.cors);
+    }
+    createServer() {
+        this.httpAdapter.initHttpServer(this.appOptions);
+        return this.httpAdapter.getHttpServer();
+    }
+    async registerModules() {
+        this.registerWsModule();
+        if (this.microservicesModule) {
+            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, this.graphInspector, this.appOptions);
+    }
+    registerWsModule() {
+        if (!this.socketModule) {
+            return;
+        }
+        this.socketModule.register(this.container, this.config, this.graphInspector, this.appOptions, this.httpServer);
+    }
+    async init() {
+        if (this.isInitialized) {
+            return this;
+        }
+        this.applyOptions();
+        await this.httpAdapter?.init?.();
+        const useBodyParser = this.appOptions && this.appOptions.bodyParser !== false;
+        useBodyParser && this.registerParserMiddleware();
+        await this.registerModules();
+        await this.registerRouter();
+        await this.callInitHook();
+        await this.registerRouterHooks();
+        await this.callBootstrapHook();
+        this.isInitialized = true;
+        this.logger.log(constants_1.MESSAGES.APPLICATION_READY);
+        return this;
+    }
+    registerParserMiddleware() {
+        const prefix = this.config.getGlobalPrefix();
+        const rawBody = !!this.appOptions?.rawBody;
+        this.httpAdapter.registerParserMiddleware(prefix, rawBody);
+    }
+    async registerRouter() {
+        await this.registerMiddleware(this.httpAdapter);
+        const prefix = this.config.getGlobalPrefix();
+        const basePath = (0, shared_utils_1.addLeadingSlash)(prefix);
+        this.routesResolver.resolve(this.httpAdapter, basePath);
+    }
+    async registerRouterHooks() {
+        this.routesResolver.registerNotFoundHandler();
+        this.routesResolver.registerExceptionHandler();
+    }
+    connectMicroservice(microserviceOptions, hybridAppOptions = {}) {
+        const { NestMicroservice } = (0, load_package_util_1.loadPackage)('@nestjs/microservices', 'NestFactory', () => require('@nestjs/microservices'));
+        const { inheritAppConfig } = hybridAppOptions;
+        const applicationConfig = inheritAppConfig
+            ? this.config
+            : new application_config_1.ApplicationConfig();
+        const instance = new NestMicroservice(this.container, microserviceOptions, this.graphInspector, applicationConfig);
+        if (!hybridAppOptions.deferInitialization) {
+            instance.registerListeners();
+            instance.setIsInitialized(true);
+            instance.setIsInitHookCalled(true);
+        }
+        this.microservices.push(instance);
+        return instance;
+    }
+    getMicroservices() {
+        return this.microservices;
+    }
+    getHttpServer() {
+        return this.httpServer;
+    }
+    async startAllMicroservices() {
+        this.assertNotInPreviewMode('startAllMicroservices');
+        await Promise.all(this.microservices.map(msvc => msvc.listen()));
+        return this;
+    }
+    use(...args) {
+        this.httpAdapter.use(...args);
+        return this;
+    }
+    useBodyParser(...args) {
+        if (!('useBodyParser' in this.httpAdapter)) {
+            this.logger.warn('Your HTTP Adapter does not support `.useBodyParser`.');
+            return this;
+        }
+        const [parserType, ...otherArgs] = args;
+        const rawBody = !!this.appOptions.rawBody;
+        this.httpAdapter.useBodyParser?.(...[parserType, rawBody, ...otherArgs]);
+        return this;
+    }
+    enableCors(options) {
+        this.httpAdapter.enableCors(options);
+    }
+    enableVersioning(options = { type: common_1.VersioningType.URI }) {
+        this.config.enableVersioning(options);
+        return this;
+    }
+    async listen(port, ...args) {
+        this.assertNotInPreviewMode('listen');
+        if (!this.isInitialized) {
+            await this.init();
+        }
+        const httpAdapterHost = this.container.getHttpAdapterHostRef();
+        return new Promise((resolve, reject) => {
+            const errorHandler = (e) => {
+                this.logger.error(e?.toString?.());
+                reject(e);
+            };
+            this.httpServer.once('error', errorHandler);
+            const isCallbackInOriginalArgs = (0, shared_utils_1.isFunction)(args[args.length - 1]);
+            const listenFnArgs = isCallbackInOriginalArgs
+                ? args.slice(0, args.length - 1)
+                : args;
+            this.httpAdapter.listen(port, ...listenFnArgs, (...originalCallbackArgs) => {
+                if (this.appOptions?.autoFlushLogs ?? true) {
+                    this.flushLogs();
+                }
+                if (originalCallbackArgs[0] instanceof Error) {
+                    return reject(originalCallbackArgs[0]);
+                }
+                const address = this.httpServer.address();
+                if (address) {
+                    this.httpServer.removeListener('error', errorHandler);
+                    this.isListening = true;
+                    httpAdapterHost.listening = true;
+                    resolve(this.httpServer);
+                }
+                if (isCallbackInOriginalArgs) {
+                    args[args.length - 1](...originalCallbackArgs);
+                }
+            });
+        });
+    }
+    async getUrl() {
+        return new Promise((resolve, reject) => {
+            if (!this.isListening) {
+                this.logger.error(constants_1.MESSAGES.CALL_LISTEN_FIRST);
+                reject(constants_1.MESSAGES.CALL_LISTEN_FIRST);
+                return;
+            }
+            const address = this.httpServer.address();
+            resolve(this.formatAddress(address));
+        });
+    }
+    formatAddress(address) {
+        if ((0, shared_utils_1.isString)(address)) {
+            if ((0, os_1.platform)() === 'win32') {
+                return address;
+            }
+            const basePath = encodeURIComponent(address);
+            return `${this.getProtocol()}+unix://${basePath}`;
+        }
+        let host = this.host();
+        if (address && address.family === 'IPv6') {
+            if (host === '::') {
+                host = '[::1]';
+            }
+            else {
+                host = `[${host}]`;
+            }
+        }
+        else if (host === '0.0.0.0') {
+            host = '127.0.0.1';
+        }
+        return `${this.getProtocol()}://${host}:${address.port}`;
+    }
+    setGlobalPrefix(prefix, options) {
+        this.config.setGlobalPrefix(prefix);
+        if (options) {
+            const exclude = options?.exclude
+                ? (0, utils_1.mapToExcludeRoute)(options.exclude)
+                : [];
+            this.config.setGlobalPrefixOptions({
+                ...options,
+                exclude,
+            });
+        }
+        return this;
+    }
+    useWebSocketAdapter(adapter) {
+        this.config.setIoAdapter(adapter);
+        return this;
+    }
+    useGlobalFilters(...filters) {
+        filters = this.applyInstanceDecoratorIfRegistered(...filters);
+        this.config.useGlobalFilters(...filters);
+        filters.forEach(item => this.graphInspector.insertOrphanedEnhancer({
+            subtype: 'filter',
+            ref: item,
+        }));
+        return this;
+    }
+    useGlobalPipes(...pipes) {
+        pipes = this.applyInstanceDecoratorIfRegistered(...pipes);
+        this.config.useGlobalPipes(...pipes);
+        pipes.forEach(item => this.graphInspector.insertOrphanedEnhancer({
+            subtype: 'pipe',
+            ref: item,
+        }));
+        return this;
+    }
+    useGlobalInterceptors(...interceptors) {
+        interceptors = this.applyInstanceDecoratorIfRegistered(...interceptors);
+        this.config.useGlobalInterceptors(...interceptors);
+        interceptors.forEach(item => this.graphInspector.insertOrphanedEnhancer({
+            subtype: 'interceptor',
+            ref: item,
+        }));
+        return this;
+    }
+    useGlobalGuards(...guards) {
+        guards = this.applyInstanceDecoratorIfRegistered(...guards);
+        this.config.useGlobalGuards(...guards);
+        guards.forEach(item => this.graphInspector.insertOrphanedEnhancer({
+            subtype: 'guard',
+            ref: item,
+        }));
+        return this;
+    }
+    useStaticAssets(pathOrOptions, options) {
+        this.httpAdapter.useStaticAssets &&
+            this.httpAdapter.useStaticAssets(pathOrOptions, options);
+        return this;
+    }
+    setBaseViewsDir(path) {
+        this.httpAdapter.setBaseViewsDir && this.httpAdapter.setBaseViewsDir(path);
+        return this;
+    }
+    setViewEngine(engineOrOptions) {
+        this.httpAdapter.setViewEngine &&
+            this.httpAdapter.setViewEngine(engineOrOptions);
+        return this;
+    }
+    host() {
+        const address = this.httpServer.address();
+        if ((0, shared_utils_1.isString)(address)) {
+            return undefined;
+        }
+        return address && address.address;
+    }
+    getProtocol() {
+        return this.appOptions && this.appOptions.httpsOptions ? 'https' : 'http';
+    }
+    async registerMiddleware(instance) {
+        await this.middlewareModule.registerMiddleware(this.middlewareContainer, instance);
+    }
+    applyInstanceDecoratorIfRegistered(...instances) {
+        if (this.appOptions.instrument?.instanceDecorator) {
+            return instances.map(instance => this.appOptions.instrument.instanceDecorator(instance));
+        }
+        return instances;
+    }
+}
+exports.NestApplication = NestApplication;

package/nest-factory.d.ts

@@ -0,0 +1,83 @@
+import { DynamicModule, ForwardReference, INestApplication, INestApplicationContext, INestMicroservice, Type } from '@nestjs/common';
+import { NestMicroserviceOptions } from '@nestjs/common/interfaces/microservices/nest-microservice-options.interface';
+import { NestApplicationContextOptions } from '@nestjs/common/interfaces/nest-application-context-options.interface';
+import { NestApplicationOptions } from '@nestjs/common/interfaces/nest-application-options.interface';
+import { AbstractHttpAdapter } from './adapters/http-adapter';
+type IEntryNestModule = Type<any> | DynamicModule | ForwardReference | Promise<IEntryNestModule>;
+/**
+ * @publicApi
+ */
+export declare class NestFactoryStatic {
+    private readonly logger;
+    private abortOnError;
+    private autoFlushLogs;
+    /**
+     * Creates an instance of NestApplication.
+     *
+     * @param module Entry (root) application module class
+     * @param options List of options to initialize NestApplication
+     *
+     * @returns A promise that, when resolved,
+     * contains a reference to the NestApplication instance.
+     */
+    create<T extends INestApplication = INestApplication>(module: IEntryNestModule, options?: NestApplicationOptions): Promise<T>;
+    /**
+     * Creates an instance of NestApplication with the specified `httpAdapter`.
+     *
+     * @param module Entry (root) application module class
+     * @param httpAdapter Adapter to proxy the request/response cycle to
+     *    the underlying HTTP server
+     * @param options List of options to initialize NestApplication
+     *
+     * @returns A promise that, when resolved,
+     * contains a reference to the NestApplication instance.
+     */
+    create<T extends INestApplication = INestApplication>(module: IEntryNestModule, httpAdapter: AbstractHttpAdapter, options?: NestApplicationOptions): Promise<T>;
+    /**
+     * Creates an instance of NestMicroservice.
+     *
+     * @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>(moduleCls: IEntryNestModule, options?: NestMicroserviceOptions & T): Promise<INestMicroservice>;
+    /**
+     * Creates an instance of NestApplicationContext.
+     *
+     * @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(moduleCls: IEntryNestModule, options?: NestApplicationContextOptions): Promise<INestApplicationContext>;
+    private createNestInstance;
+    private initialize;
+    private handleInitializationError;
+    private createProxy;
+    private createExceptionProxy;
+    private createExceptionZone;
+    private registerLoggerConfiguration;
+    private createHttpAdapter;
+    private isHttpServer;
+    private setAbortOnError;
+    private createAdapterProxy;
+    private createGraphInspector;
+}
+/**
+ * Use NestFactory to create an application instance.
+ *
+ * ### Specifying an entry module
+ *
+ * Pass the required *root module* for the application via the module parameter.
+ * By convention, it is usually called `ApplicationModule`.  Starting with this
+ * module, Nest assembles the dependency graph and begins the process of
+ * Dependency Injection and instantiates the classes needed to launch your
+ * application.
+ *
+ * @publicApi
+ */
+export declare const NestFactory: NestFactoryStatic;
+export {};

package/nest-factory.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestFactory = exports.NestFactoryStatic = void 0;
+const console_logger_service_1 = require("@nestjs/common/services/console-logger.service");
+const logger_service_1 = require("@nestjs/common/services/logger.service");
+const load_package_util_1 = require("@nestjs/common/utils/load-package.util");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const application_config_1 = require("./application-config");
+const constants_1 = require("./constants");
+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 uuid_factory_1 = require("./inspector/uuid-factory");
+const metadata_scanner_1 = require("./metadata-scanner");
+const nest_application_1 = require("./nest-application");
+const nest_application_context_1 = require("./nest-application-context");
+const scanner_1 = require("./scanner");
+/**
+ * @publicApi
+ */
+class NestFactoryStatic {
+    constructor() {
+        this.logger = new logger_service_1.Logger('NestFactory', {
+            timestamp: true,
+        });
+        this.abortOnError = true;
+        this.autoFlushLogs = false;
+    }
+    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, appOptions);
+        const graphInspector = this.createGraphInspector(appOptions, container);
+        this.setAbortOnError(serverOrOptions, options);
+        this.registerLoggerConfiguration(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 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(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, options);
+        const graphInspector = this.createGraphInspector(options, container);
+        this.setAbortOnError(options);
+        this.registerLoggerConfiguration(options);
+        await this.initialize(moduleCls, container, graphInspector, applicationConfig, options);
+        return this.createNestInstance(new NestMicroservice(container, options, graphInspector, applicationConfig));
+    }
+    /**
+     * Creates an instance of NestApplicationContext.
+     *
+     * @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(moduleCls, options) {
+        const applicationConfig = new application_config_1.ApplicationConfig();
+        const container = new container_1.NestContainer(applicationConfig, options);
+        const graphInspector = this.createGraphInspector(options, container);
+        this.setAbortOnError(options);
+        this.registerLoggerConfiguration(options);
+        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, options, root));
+        if (this.autoFlushLogs) {
+            context.flushLogsOnOverride();
+        }
+        return context.init();
+    }
+    createNestInstance(instance) {
+        return this.createProxy(instance);
+    }
+    async initialize(module, container, graphInspector, config = new application_config_1.ApplicationConfig(), options = {}, httpServer = null) {
+        uuid_factory_1.UuidFactory.mode = options.snapshot
+            ? uuid_factory_1.UuidFactoryMode.Deterministic
+            : uuid_factory_1.UuidFactoryMode.Random;
+        const injector = new injector_1.Injector({
+            preview: options.preview,
+            instanceDecorator: options.instrument?.instanceDecorator,
+        });
+        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, graphInspector, config);
+        container.setHttpAdapter(httpServer);
+        const teardown = this.abortOnError === false ? rethrow_1.rethrow : undefined;
+        await httpServer?.init?.();
+        try {
+            this.logger.log(constants_1.MESSAGES.APPLICATION_START);
+            await exceptions_zone_1.ExceptionsZone.asyncRun(async () => {
+                await dependenciesScanner.scan(module);
+                await instanceLoader.createInstancesOfDependencies();
+                dependenciesScanner.applyApplicationProviders();
+            }, teardown, this.autoFlushLogs);
+        }
+        catch (e) {
+            this.handleInitializationError(e);
+        }
+    }
+    handleInitializationError(err) {
+        if (this.abortOnError) {
+            process.abort();
+        }
+        (0, rethrow_1.rethrow)(err);
+    }
+    createProxy(target) {
+        const proxy = this.createExceptionProxy();
+        return new Proxy(target, {
+            get: proxy,
+            set: proxy,
+        });
+    }
+    createExceptionProxy() {
+        return (receiver, prop) => {
+            if (!(prop in receiver)) {
+                return;
+            }
+            if ((0, shared_utils_1.isFunction)(receiver[prop])) {
+                return this.createExceptionZone(receiver, prop);
+            }
+            return receiver[prop];
+        };
+    }
+    createExceptionZone(receiver, prop) {
+        const teardown = this.abortOnError === false ? rethrow_1.rethrow : undefined;
+        return (...args) => {
+            let result;
+            exceptions_zone_1.ExceptionsZone.run(() => {
+                result = receiver[prop](...args);
+            }, teardown, this.autoFlushLogs);
+            return result;
+        };
+    }
+    registerLoggerConfiguration(options) {
+        if (!options) {
+            return;
+        }
+        const { logger, bufferLogs, autoFlushLogs, forceConsole } = options;
+        if (logger !== true && !(0, shared_utils_1.isNil)(logger)) {
+            logger_service_1.Logger.overrideLogger(logger);
+        }
+        else if (forceConsole) {
+            // If no custom logger is provided but forceConsole is true,
+            // create a ConsoleLogger with forceConsole option
+            const consoleLogger = new console_logger_service_1.ConsoleLogger({ forceConsole: true });
+            logger_service_1.Logger.overrideLogger(consoleLogger);
+        }
+        if (bufferLogs) {
+            logger_service_1.Logger.attachBuffer();
+        }
+        this.autoFlushLogs = autoFlushLogs ?? true;
+    }
+    createHttpAdapter(httpServer) {
+        const { ExpressAdapter } = (0, load_adapter_1.loadAdapter)('@nestjs/platform-express', 'HTTP', () => require('@nestjs/platform-express'));
+        return new ExpressAdapter(httpServer);
+    }
+    isHttpServer(serverOrOptions) {
+        return !!(serverOrOptions && serverOrOptions.patch);
+    }
+    setAbortOnError(serverOrOptions, options) {
+        this.abortOnError = this.isHttpServer(serverOrOptions)
+            ? !(options && options.abortOnError === false)
+            : !(serverOrOptions && serverOrOptions.abortOnError === false);
+    }
+    createAdapterProxy(app, adapter) {
+        const proxy = new Proxy(app, {
+            get: (receiver, prop) => {
+                const mapToProxy = (result) => {
+                    return result instanceof Promise
+                        ? result.then(mapToProxy)
+                        : result instanceof nest_application_1.NestApplication
+                            ? proxy
+                            : result;
+                };
+                if (!(prop in receiver) && prop in adapter) {
+                    return (...args) => {
+                        const result = this.createExceptionZone(adapter, prop)(...args);
+                        return mapToProxy(result);
+                    };
+                }
+                if ((0, shared_utils_1.isFunction)(receiver[prop])) {
+                    return (...args) => {
+                        const result = receiver[prop](...args);
+                        return mapToProxy(result);
+                    };
+                }
+                return receiver[prop];
+            },
+        });
+        return proxy;
+    }
+    createGraphInspector(appOptions, container) {
+        return appOptions?.snapshot
+            ? new graph_inspector_1.GraphInspector(container)
+            : noop_graph_inspector_1.NoopGraphInspector;
+    }
+}
+exports.NestFactoryStatic = NestFactoryStatic;
+/**
+ * Use NestFactory to create an application instance.
+ *
+ * ### Specifying an entry module
+ *
+ * Pass the required *root module* for the application via the module parameter.
+ * By convention, it is usually called `ApplicationModule`.  Starting with this
+ * module, Nest assembles the dependency graph and begins the process of
+ * Dependency Injection and instantiates the classes needed to launch your
+ * application.
+ *
+ * @publicApi
+ */
+exports.NestFactory = new NestFactoryStatic();