@venok/core 1.0.0

package/module/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./configurable-module.builder"), exports);
+__exportStar(require("../interfaces/modules/configurable"), exports);

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@venok/core",
+  "version": "1.0.0",
+  "description": "",
+  "author": "0x303133",
+  "homepage": "",
+  "main": "index.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/venokjs/venok.git",
+    "directory": "packages/core"
+  },
+  "scripts": {
+    "build": "venok build",
+    "postbuild": "ts-node ../../tools/move.ts core",
+    "test": "mocha test/**/*.spec.ts"
+  },
+  "dependencies": {
+    "fast-safe-stringify": "^2.1.1",
+    "uid": "^2.0.2",
+    "uuid": "^9.0.1"
+  },
+  "mocha": {
+    "require": [
+      "ts-node/register",
+      "tsconfig-paths/register",
+      "../../node_modules/reflect-metadata/Reflect.js",
+      "../../hooks/mocha-init-hook.ts"
+    ],
+    "exit": true
+  }
+}

package/pipes/consumer.d.ts

@@ -0,0 +1,9 @@
+import { ArgumentMetadata, PipeTransform } from "@venok/core/interfaces/features/pipes.interface";
+export declare class PipesConsumer {
+    apply<TInput = unknown>(value: TInput, { metatype, type, data }: ArgumentMetadata, pipes: PipeTransform[]): Promise<TInput>;
+    applyPipes<TInput = unknown>(value: TInput, { metatype, type, data }: {
+        metatype: any;
+        type?: any;
+        data?: any;
+    }, transforms: PipeTransform[]): Promise<TInput>;
+}

package/pipes/consumer.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipesConsumer = void 0;
+class PipesConsumer {
+    async apply(value, { metatype, type, data }, pipes) {
+        return this.applyPipes(value, { metatype, type, data }, pipes);
+    }
+    async applyPipes(value, { metatype, type, data }, transforms) {
+        return transforms.reduce(async (deferredValue, pipe) => {
+            const val = await deferredValue;
+            return pipe.transform(val, { metatype, type, data });
+        }, Promise.resolve(value));
+    }
+}
+exports.PipesConsumer = PipesConsumer;

package/pipes/context-creator.d.ts

@@ -0,0 +1,18 @@
+import { VenokContainer } from "@venok/core/injector/container";
+import { ContextCreator } from "@venok/core/context/creator";
+import { ApplicationConfig } from "@venok/core/application/config";
+import { InstanceWrapper } from "@venok/core/injector/instance/wrapper";
+import { PipeTransform } from "@venok/core/interfaces/features/pipes.interface";
+import { Type } from "@venok/core/interfaces";
+export declare class PipesContextCreator extends ContextCreator {
+    private readonly container;
+    private readonly config?;
+    private moduleContext;
+    constructor(container: VenokContainer, config?: ApplicationConfig | undefined);
+    create(instance: object, callback: (...args: unknown[]) => unknown, moduleKey: string, contextId?: import("@venok/core/injector/instance/wrapper").ContextId, inquirerId?: string): PipeTransform[];
+    createConcreteContext<T extends any[], R extends any[]>(metadata: T, contextId?: import("@venok/core/injector/instance/wrapper").ContextId, inquirerId?: string): R;
+    getPipeInstance(pipe: Function | PipeTransform, contextId?: import("@venok/core/injector/instance/wrapper").ContextId, inquirerId?: string): PipeTransform | null;
+    getInstanceByMetatype(metatype: Type<unknown>): InstanceWrapper | undefined;
+    getGlobalMetadata<T extends unknown[]>(contextId?: import("@venok/core/injector/instance/wrapper").ContextId, inquirerId?: string): T;
+    setModuleContext(context: string): void;
+}

package/pipes/context-creator.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipesContextCreator = void 0;
+const creator_1 = require("@venok/core/context/creator");
+const constants_1 = require("@venok/core/injector/constants");
+const constants_2 = require("@venok/core/constants");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+class PipesContextCreator extends creator_1.ContextCreator {
+    constructor(container, config) {
+        super();
+        this.container = container;
+        this.config = config;
+    }
+    create(instance, callback, moduleKey, contextId = constants_1.STATIC_CONTEXT, inquirerId) {
+        this.moduleContext = moduleKey;
+        return this.createContext(instance, callback, constants_2.PIPES_METADATA, contextId, inquirerId);
+    }
+    createConcreteContext(metadata, contextId = constants_1.STATIC_CONTEXT, inquirerId) {
+        if ((0, shared_helper_1.isEmpty)(metadata)) {
+            return [];
+        }
+        return metadata
+            .filter((pipe) => pipe && (pipe.name || pipe.transform))
+            .map((pipe) => this.getPipeInstance(pipe, contextId, inquirerId))
+            .filter((pipe) => pipe && pipe.transform && (0, shared_helper_1.isFunction)(pipe.transform));
+    }
+    getPipeInstance(pipe, contextId = constants_1.STATIC_CONTEXT, inquirerId) {
+        const isObject = pipe.transform;
+        // @ts-ignore
+        if (isObject) {
+            return pipe;
+        }
+        const instanceWrapper = this.getInstanceByMetatype(pipe);
+        if (!instanceWrapper) {
+            return null;
+        }
+        const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
+        return instanceHost && instanceHost.instance;
+    }
+    getInstanceByMetatype(metatype) {
+        if (!this.moduleContext) {
+            return;
+        }
+        const collection = this.container.getModules();
+        const moduleRef = collection.get(this.moduleContext);
+        if (!moduleRef) {
+            return;
+        }
+        return moduleRef.injectables.get(metatype);
+    }
+    getGlobalMetadata(contextId = constants_1.STATIC_CONTEXT, inquirerId) {
+        if (!this.config) {
+            return [];
+        }
+        const globalPipes = this.config.getGlobalPipes();
+        if (contextId === constants_1.STATIC_CONTEXT && !inquirerId) {
+            return globalPipes;
+        }
+        const scopedPipeWrappers = this.config.getGlobalRequestPipes();
+        const scopedPipes = scopedPipeWrappers
+            .map((wrapper) => wrapper.getInstanceByContextId(this.getContextId(contextId, wrapper), inquirerId))
+            .filter((host) => !!host)
+            .map((host) => host.instance);
+        return globalPipes.concat(scopedPipes);
+    }
+    setModuleContext(context) {
+        this.moduleContext = context;
+    }
+}
+exports.PipesContextCreator = PipesContextCreator;

package/pipes/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./consumer";
+export * from "./context-creator";

package/pipes/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./consumer"), exports);
+__exportStar(require("./context-creator"), exports);

package/scanner.d.ts

@@ -0,0 +1,81 @@
+import { ClassProvider, DynamicModule, ExistingProvider, FactoryProvider, ForwardReference, ModuleDefinition, Provider, Type, ValueProvider } from "@venok/core/interfaces";
+import { ModuleOverride } from "@venok/core/interfaces/modules/override.interface";
+import { MetadataScanner } from "@venok/core/metadata-scanner";
+import { GraphInspector } from "@venok/core/inspector/graph-inspector";
+import { ApplicationConfig } from "@venok/core/application/config";
+import { VenokContainer } from "@venok/core/injector/container";
+import { Module } from "@venok/core/injector/module/module";
+import { ENHANCER_KEY_TO_SUBTYPE_MAP, EnhancerSubtype } from "@venok/core/constants";
+import { InstanceWrapper } from "@venok/core/injector/instance/wrapper";
+import { Injectable } from "@venok/core/interfaces/injectable.interface";
+interface ModulesScanParameters {
+    moduleDefinition: ModuleDefinition;
+    scope?: Type<unknown>[];
+    ctxRegistry?: (ForwardReference | DynamicModule | Type<unknown>)[];
+    overrides?: ModuleOverride[];
+    lazy?: boolean;
+}
+export declare class DependenciesScanner {
+    private readonly container;
+    private readonly metadataScanner;
+    private readonly graphInspector;
+    private readonly applicationConfig;
+    private readonly applicationProvidersApplyMap;
+    constructor(container: VenokContainer, metadataScanner: MetadataScanner, graphInspector: GraphInspector, applicationConfig?: ApplicationConfig);
+    scan(module: Type<any>, options?: {
+        overrides?: ModuleOverride[];
+    }): Promise<void>;
+    scanForModules({ moduleDefinition, lazy, scope, ctxRegistry, overrides, }: ModulesScanParameters): Promise<Module[]>;
+    insertModule(moduleDefinition: any, scope: Type<unknown>[]): Promise<{
+        moduleRef: Module;
+        inserted: boolean;
+    } | undefined>;
+    scanModulesForDependencies(modules?: Map<string, Module>): Promise<void>;
+    reflectImports(module: Type<unknown>, token: string, context: string): Promise<void>;
+    reflectProviders(module: Type<any>, token: string): void;
+    reflectDynamicMetadata(cls: Type<Injectable>, token: string): void;
+    reflectExports(module: Type<unknown>, token: string): void;
+    reflectInjectables(component: Type<Injectable>, token: string, metadataKey: keyof typeof ENHANCER_KEY_TO_SUBTYPE_MAP): void;
+    reflectParamInjectables(component: Type<Injectable>, token: string, metadataKey: string): void;
+    reflectKeyMetadata(component: Type<Injectable>, key: string, methodKey: string): {
+        methodKey: string;
+        metadata: any;
+    } | undefined;
+    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 | Function | InstanceWrapper<unknown> | undefined;
+    insertInjectable(injectable: Type<Injectable> | object, token: string, host: Type<Injectable>, subtype: EnhancerSubtype, methodKey?: string): InstanceWrapper<any> | undefined;
+    insertExportedProvider(exportedProvider: Type<Injectable>, token: string): void;
+    private insertOrOverrideModule;
+    private getOverrideModuleByModule;
+    private overrideModule;
+    reflectMetadata<T = any>(metadataKey: string, metatype: Type<any>): T[];
+    registerCoreModule(overrides?: ModuleOverride[]): Promise<void>;
+    /**
+     * Add either request or transient globally scoped enhancers
+     * to all controllers metadata storage
+     */
+    addScopedEnhancersMetadata(): void;
+    applyApplicationProviders(): void;
+    getApplyProvidersMap(): {
+        [type: string]: Function;
+    };
+    getApplyRequestProvidersMap(): {
+        [type: string]: Function;
+    };
+    isDynamicModule(module: Type<any> | DynamicModule): module is DynamicModule;
+    /**
+     * @param metatype
+     * @returns `true` if `metatype` is annotated with the `@Injectable()` decorator.
+     */
+    private isInjectable;
+    /**
+     * @param metatype
+     * @returns `true` if `metatype` is annotated with the `@Catch()` decorator.
+     */
+    private isExceptionFilter;
+    private isForwardReference;
+    private isRequestOrTransient;
+}
+export {};

package/scanner.js

@@ -0,0 +1,374 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependenciesScanner = void 0;
+const interfaces_1 = require("@venok/core/interfaces");
+const config_1 = require("@venok/core/application/config");
+const constants_1 = require("@venok/core/constants");
+const undefined_module_exception_1 = require("@venok/core/errors/exceptions/undefined-module.exception");
+const invalid_module_exception_1 = require("@venok/core/errors/exceptions/invalid-module.exception");
+const invalid_class_module_exception_1 = require("@venok/core/errors/exceptions/invalid-class-module.exception");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+const exceptions_1 = require("@venok/core/errors/exceptions");
+const uuid_helper_1 = require("@venok/core/helpers/uuid.helper");
+const class_scope_helper_1 = require("@venok/core/injector/helpers/class-scope.helper");
+const internal_core_module_factory_1 = require("@venok/core/injector/internal-core-module/internal-core-module-factory");
+const flatten_helper_1 = require("@venok/core/helpers/flatten.helper");
+class DependenciesScanner {
+    constructor(container, metadataScanner, graphInspector, applicationConfig = new config_1.ApplicationConfig()) {
+        this.container = container;
+        this.metadataScanner = metadataScanner;
+        this.graphInspector = graphInspector;
+        this.applicationConfig = applicationConfig;
+        this.applicationProvidersApplyMap = [];
+    }
+    async scan(module, options) {
+        await this.registerCoreModule(options?.overrides);
+        await this.scanForModules({
+            moduleDefinition: module,
+            overrides: options?.overrides,
+        });
+        await this.scanModulesForDependencies();
+        this.calculateModulesDistance();
+        this.addScopedEnhancersMetadata();
+        this.container.bindGlobalScope();
+    }
+    async scanForModules({ moduleDefinition, lazy, scope = [], ctxRegistry = [], overrides = [], }) {
+        const { moduleRef: moduleInstance, inserted: moduleInserted } = (await this.insertOrOverrideModule(moduleDefinition, overrides, scope)) ?? {};
+        moduleDefinition = this.getOverrideModuleByModule(moduleDefinition, overrides)?.newModule ?? moduleDefinition;
+        moduleDefinition = moduleDefinition instanceof Promise ? await moduleDefinition : moduleDefinition;
+        ctxRegistry.push(moduleDefinition);
+        if (this.isForwardReference(moduleDefinition)) {
+            moduleDefinition = moduleDefinition.forwardRef();
+        }
+        const modules = !this.isDynamicModule(moduleDefinition)
+            ? this.reflectMetadata(constants_1.MODULE_METADATA.IMPORTS, moduleDefinition)
+            : [
+                ...this.reflectMetadata(constants_1.MODULE_METADATA.IMPORTS, moduleDefinition.module),
+                ...(moduleDefinition.imports || []),
+            ];
+        let registeredModuleRefs = [];
+        for (const [index, innerModule] of modules.entries()) {
+            // In case of a circular dependency (ES module system), JavaScript will resolve the type to `undefined`.
+            if (innerModule === undefined) {
+                throw new undefined_module_exception_1.UndefinedModuleException(moduleDefinition, index, scope);
+            }
+            if (!innerModule) {
+                throw new invalid_module_exception_1.InvalidModuleException(moduleDefinition, index, scope);
+            }
+            if (ctxRegistry.includes(innerModule)) {
+                continue;
+            }
+            const moduleRefs = await this.scanForModules({
+                moduleDefinition: innerModule,
+                // Maybe Error
+                scope: scope.concat(moduleDefinition),
+                ctxRegistry,
+                overrides,
+                lazy,
+            });
+            registeredModuleRefs = registeredModuleRefs.concat(moduleRefs);
+        }
+        if (!moduleInstance) {
+            return registeredModuleRefs;
+        }
+        if (lazy && moduleInserted) {
+            this.container.bindGlobalsToImports(moduleInstance);
+        }
+        return [moduleInstance].concat(registeredModuleRefs);
+    }
+    async insertModule(moduleDefinition, scope) {
+        const moduleToAdd = this.isForwardReference(moduleDefinition) ? moduleDefinition.forwardRef() : moduleDefinition;
+        if (this.isInjectable(moduleToAdd) || this.isExceptionFilter(moduleToAdd)) {
+            throw new invalid_class_module_exception_1.InvalidClassModuleException(moduleDefinition, scope);
+        }
+        return this.container.addModule(moduleToAdd, scope);
+    }
+    async scanModulesForDependencies(modules = this.container.getModules()) {
+        for (const [token, { metatype }] of modules) {
+            await this.reflectImports(metatype, token, metatype.name);
+            this.reflectProviders(metatype, token);
+            this.reflectExports(metatype, token);
+        }
+    }
+    async reflectImports(module, token, context) {
+        const modules = [
+            ...this.reflectMetadata(constants_1.MODULE_METADATA.IMPORTS, module),
+            ...this.container.getDynamicMetadataByToken(token, constants_1.MODULE_METADATA.IMPORTS),
+        ];
+        for (const related of modules) {
+            await this.insertImport(related, token, context);
+        }
+    }
+    reflectProviders(module, token) {
+        const providers = [
+            ...this.reflectMetadata(constants_1.MODULE_METADATA.PROVIDERS, module),
+            ...this.container.getDynamicMetadataByToken(token, constants_1.MODULE_METADATA.PROVIDERS),
+        ];
+        providers.forEach((provider) => {
+            this.insertProvider(provider, token);
+            this.reflectDynamicMetadata(provider, token);
+        });
+    }
+    reflectDynamicMetadata(cls, token) {
+        if (!cls || !cls.prototype) {
+            return;
+        }
+        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 = [
+            ...this.reflectMetadata(constants_1.MODULE_METADATA.EXPORTS, module),
+            ...this.container.getDynamicMetadataByToken(token, constants_1.MODULE_METADATA.EXPORTS),
+        ];
+        exports.forEach((exportedProvider) => this.insertExportedProvider(exportedProvider, token));
+    }
+    reflectInjectables(component, token, metadataKey) {
+        const Injectables = this.reflectMetadata(metadataKey, component);
+        const methodInjectables = this.metadataScanner.getAllMethodNames(component.prototype).reduce((acc, method) => {
+            const methodInjectable = this.reflectKeyMetadata(component, metadataKey, method);
+            if (methodInjectable) {
+                acc.push(methodInjectable);
+            }
+            return acc;
+        }, []);
+        Injectables.forEach((injectable) => this.insertInjectable(injectable, token, component, constants_1.ENHANCER_KEY_TO_SUBTYPE_MAP[metadataKey]));
+        methodInjectables.forEach((methodInjectable) => {
+            methodInjectable.metadata.forEach((injectable) => this.insertInjectable(injectable, token, component, constants_1.ENHANCER_KEY_TO_SUBTYPE_MAP[metadataKey], methodInjectable.methodKey));
+        });
+    }
+    reflectParamInjectables(component, token, metadataKey) {
+        const paramsMethods = this.metadataScanner.getAllMethodNames(component.prototype);
+        paramsMethods.forEach((methodKey) => {
+            const metadata = Reflect.getMetadata(metadataKey, component, methodKey);
+            if (!metadata) {
+                return;
+            }
+            const params = Object.values(metadata);
+            params
+                .map((item) => item.pipes)
+                .flat(1)
+                .forEach((injectable) => this.insertInjectable(injectable, token, component, "pipe", methodKey));
+        });
+    }
+    reflectKeyMetadata(component, key, methodKey) {
+        let prototype = component.prototype;
+        do {
+            const descriptor = Reflect.getOwnPropertyDescriptor(prototype, methodKey);
+            if (!descriptor) {
+                continue;
+            }
+            const metadata = Reflect.getMetadata(key, descriptor.value);
+            if (!metadata) {
+                return;
+            }
+            return { methodKey, metadata };
+        } while ((prototype = Reflect.getPrototypeOf(prototype)) && prototype !== Object.prototype && prototype);
+        return undefined;
+    }
+    calculateModulesDistance() {
+        const modulesGenerator = this.container.getModules().values();
+        // Skip "InternalCoreModule" from calculating distance
+        modulesGenerator.next();
+        const modulesStack = [];
+        const calculateDistance = (moduleRef, distance = 1) => {
+            if (!moduleRef || modulesStack.includes(moduleRef)) {
+                return;
+            }
+            modulesStack.push(moduleRef);
+            const moduleImports = moduleRef.imports;
+            moduleImports.forEach((importedModuleRef) => {
+                if (importedModuleRef) {
+                    if (distance > importedModuleRef.distance) {
+                        importedModuleRef.distance = distance;
+                    }
+                    calculateDistance(importedModuleRef, distance + 1);
+                }
+            });
+        };
+        const rootModule = modulesGenerator.next().value;
+        calculateDistance(rootModule);
+    }
+    async insertImport(related, token, context) {
+        if ((0, shared_helper_1.isUndefined)(related)) {
+            throw new exceptions_1.CircularDependencyException(context);
+        }
+        if (this.isForwardReference(related)) {
+            return this.container.addImport(related.forwardRef(), token);
+        }
+        await this.container.addImport(related, token);
+    }
+    isCustomProvider(provider) {
+        return provider && !(0, shared_helper_1.isNull)(provider.provide);
+    }
+    insertProvider(provider, token) {
+        const isCustomProvider = this.isCustomProvider(provider);
+        if (!isCustomProvider) {
+            return this.container.addProvider(provider, token);
+        }
+        const applyProvidersMap = this.getApplyProvidersMap();
+        const providersKeys = Object.keys(applyProvidersMap);
+        const type = provider.provide;
+        if (!providersKeys.includes(type)) {
+            return this.container.addProvider(provider, token);
+        }
+        const uuid = uuid_helper_1.UuidFactory.get(type.toString());
+        const providerToken = `${type} (UUID: ${uuid})`;
+        let scope = provider.scope;
+        if ((0, shared_helper_1.isNull)(scope) && provider.useClass) {
+            scope = (0, class_scope_helper_1.getClassScope)(provider.useClass);
+        }
+        this.applicationProvidersApplyMap.push({
+            type,
+            moduleKey: token,
+            providerKey: providerToken,
+            scope,
+        });
+        const newProvider = {
+            ...provider,
+            provide: providerToken,
+            scope,
+        };
+        const enhancerSubtype = constants_1.ENHANCER_TOKEN_TO_SUBTYPE_MAP[type];
+        const factoryOrClassProvider = newProvider;
+        if (this.isRequestOrTransient(factoryOrClassProvider.scope)) {
+            return this.container.addInjectable(newProvider, token, enhancerSubtype);
+        }
+        this.container.addProvider(newProvider, token, enhancerSubtype);
+    }
+    insertInjectable(injectable, token, host, subtype, methodKey) {
+        if ((0, shared_helper_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,
+            });
+        }
+    }
+    insertExportedProvider(exportedProvider, token) {
+        this.container.addExportedProvider(exportedProvider, token);
+    }
+    insertOrOverrideModule(moduleDefinition, overrides, scope) {
+        const overrideModule = this.getOverrideModuleByModule(moduleDefinition, overrides);
+        if (overrideModule !== undefined) {
+            return this.overrideModule(moduleDefinition, overrideModule.newModule, scope);
+        }
+        return this.insertModule(moduleDefinition, scope);
+    }
+    getOverrideModuleByModule(module, overrides) {
+        if (this.isForwardReference(module)) {
+            return overrides.find((moduleToOverride) => {
+                return (moduleToOverride.moduleToReplace === module.forwardRef() ||
+                    moduleToOverride.moduleToReplace.forwardRef?.() === module.forwardRef());
+            });
+        }
+        return overrides.find((moduleToOverride) => moduleToOverride.moduleToReplace === module);
+    }
+    async overrideModule(moduleToOverride, newModule, scope) {
+        return this.container.replaceModule(this.isForwardReference(moduleToOverride) ? moduleToOverride.forwardRef() : moduleToOverride, this.isForwardReference(newModule) ? newModule.forwardRef() : newModule, scope);
+    }
+    reflectMetadata(metadataKey, metatype) {
+        return Reflect.getMetadata(metadataKey, metatype) || [];
+    }
+    async registerCoreModule(overrides) {
+        const moduleDefinition = internal_core_module_factory_1.InternalCoreModuleFactory.create(this.container, this, this.container.getModuleCompiler(), this.graphInspector, overrides);
+        const [instance] = await this.scanForModules({
+            moduleDefinition,
+            overrides,
+        });
+        this.container.registerCoreModuleRef(instance);
+    }
+    /**
+     * Add either request or transient globally scoped enhancers
+     * to all controllers metadata storage
+     */
+    addScopedEnhancersMetadata() {
+        this.applicationProvidersApplyMap
+            .filter((wrapper) => this.isRequestOrTransient(wrapper.scope))
+            .forEach(({ moduleKey, providerKey }) => {
+            const modulesContainer = this.container.getModules();
+            const { injectables } = modulesContainer.get(moduleKey);
+            const instanceWrapper = injectables.get(providerKey);
+            const iterableIterator = modulesContainer.values();
+            (0, flatten_helper_1.flatten)([...iterableIterator].map((moduleRef) => moduleRef.entryProviders)).forEach((EntryProvider) => EntryProvider.addEnhancerMetadata(instanceWrapper));
+        });
+    }
+    applyApplicationProviders() {
+        const applyProvidersMap = this.getApplyProvidersMap();
+        const applyRequestProvidersMap = this.getApplyRequestProvidersMap();
+        const getInstanceWrapper = (moduleKey, providerKey, collectionKey) => {
+            const modules = this.container.getModules();
+            const collection = modules.get(moduleKey)[collectionKey];
+            return collection.get(providerKey);
+        };
+        // Add global enhancers to the application config
+        this.applicationProvidersApplyMap.forEach(({ moduleKey, providerKey, type, scope }) => {
+            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);
+        });
+    }
+    getApplyProvidersMap() {
+        return {
+            [constants_1.APP_INTERCEPTOR]: (interceptor) => this.applicationConfig.addGlobalInterceptor(interceptor),
+            [constants_1.APP_PIPE]: (pipe) => this.applicationConfig.addGlobalPipe(pipe),
+            [constants_1.APP_GUARD]: (guard) => this.applicationConfig.addGlobalGuard(guard),
+            [constants_1.APP_FILTER]: (filter) => this.applicationConfig.addGlobalFilter(filter),
+        };
+    }
+    getApplyRequestProvidersMap() {
+        return {
+            [constants_1.APP_INTERCEPTOR]: (interceptor) => this.applicationConfig.addGlobalRequestInterceptor(interceptor),
+            [constants_1.APP_PIPE]: (pipe) => this.applicationConfig.addGlobalRequestPipe(pipe),
+            [constants_1.APP_GUARD]: (guard) => this.applicationConfig.addGlobalRequestGuard(guard),
+            [constants_1.APP_FILTER]: (filter) => this.applicationConfig.addGlobalRequestFilter(filter),
+        };
+    }
+    isDynamicModule(module) {
+        return module && !!module.module;
+    }
+    /**
+     * @param metatype
+     * @returns `true` if `metatype` is annotated with the `@Injectable()` decorator.
+     */
+    isInjectable(metatype) {
+        return !!Reflect.getMetadata(constants_1.INJECTABLE_WATERMARK, metatype);
+    }
+    /**
+     * @param metatype
+     * @returns `true` if `metatype` is annotated with the `@Catch()` decorator.
+     */
+    isExceptionFilter(metatype) {
+        return !!Reflect.getMetadata(constants_1.CATCH_WATERMARK, metatype);
+    }
+    isForwardReference(module) {
+        return module && !!module.forwardRef;
+    }
+    isRequestOrTransient(scope) {
+        return scope === interfaces_1.Scope.REQUEST || scope === interfaces_1.Scope.TRANSIENT;
+    }
+}
+exports.DependenciesScanner = DependenciesScanner;