@venok/core 1.1.0 → 2.0.1-next.1

package/injector/module/lazy/loader.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LazyModuleLoader = void 0;
-const ref_1 = require("@venok/core/injector/module/ref");
-const silent_helper_1 = require("@venok/core/helpers/silent.helper");
-class LazyModuleLoader {
-    constructor(dependenciesScanner, instanceLoader, moduleCompiler, modulesContainer, moduleOverrides) {
-        this.dependenciesScanner = dependenciesScanner;
-        this.instanceLoader = instanceLoader;
-        this.moduleCompiler = moduleCompiler;
-        this.modulesContainer = modulesContainer;
-        this.moduleOverrides = moduleOverrides;
-    }
-    async load(loaderFn, loadOpts) {
-        this.registerLoggerConfiguration(loadOpts);
-        const moduleClassOrDynamicDefinition = await loaderFn();
-        const moduleInstances = await this.dependenciesScanner.scanForModules({
-            moduleDefinition: moduleClassOrDynamicDefinition,
-            overrides: this.moduleOverrides,
-            lazy: true,
-        });
-        if (moduleInstances.length === 0) {
-            // The module has been loaded already. In this case, we must
-            // retrieve a module reference from the existing container.
-            const { token } = await this.moduleCompiler.compile(moduleClassOrDynamicDefinition);
-            const moduleInstance = this.modulesContainer.get(token);
-            return moduleInstance && this.getTargetModuleRef(moduleInstance);
-        }
-        const lazyModulesContainer = this.createLazyModulesContainer(moduleInstances);
-        await this.dependenciesScanner.scanModulesForDependencies(lazyModulesContainer);
-        await this.instanceLoader.createInstancesOfDependencies(lazyModulesContainer);
-        const [targetModule] = moduleInstances;
-        return this.getTargetModuleRef(targetModule);
-    }
-    registerLoggerConfiguration(loadOpts) {
-        if (loadOpts?.logger === false) {
-            this.instanceLoader.setLogger(new silent_helper_1.SilentLogger());
-        }
-    }
-    createLazyModulesContainer(moduleInstances) {
-        moduleInstances = Array.from(new Set(moduleInstances));
-        return new Map(moduleInstances.map((ref) => [ref.token, ref]));
-    }
-    getTargetModuleRef(moduleInstance) {
-        const moduleRefInstanceWrapper = moduleInstance.getProviderByKey(ref_1.ModuleRef);
-        return moduleRefInstanceWrapper.instance;
-    }
-}
-exports.LazyModuleLoader = LazyModuleLoader;

package/injector/module/lazy/options.d.ts

@@ -1,6 +0,0 @@
-export interface LazyModuleLoaderLoadOptions {
-    /**
-     * If `false`, no logs will be generated when loading some module lazily.
-     */
-    logger?: boolean;
-}

package/injector/module/lazy/options.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/injector/module/module.d.ts

@@ -1,74 +0,0 @@
-import { InstanceWrapper } from "@venok/core/injector/instance/wrapper";
-import { ClassProvider, DynamicModule, ExistingProvider, FactoryProvider, InjectionToken, Provider, ValueProvider, VenokModule } from "@venok/core/interfaces/modules";
-import { Type } from "@venok/core/interfaces";
-import { EnhancerSubtype } from "@venok/core/constants";
-import { ModuleRef } from "@venok/core/injector/module/ref";
-import { VenokContainer } from "@venok/core/injector/container";
-import { Injectable } from "@venok/core/interfaces/injectable.interface";
-export declare class Module {
-    private readonly _metatype;
-    private readonly container;
-    private readonly _id;
-    private readonly _imports;
-    private readonly _providers;
-    private readonly _injectables;
-    private readonly _entryProviderKeys;
-    private readonly _exports;
-    private _distance;
-    private _initOnPreview;
-    private _isGlobal;
-    private _token;
-    constructor(_metatype: Type, container: VenokContainer);
-    get id(): string;
-    get token(): string;
-    set token(token: string);
-    get name(): string;
-    get isGlobal(): boolean;
-    set isGlobal(global: boolean);
-    get initOnPreview(): boolean;
-    set initOnPreview(initOnPreview: boolean);
-    get providers(): Map<InjectionToken, InstanceWrapper<Injectable>>;
-    get imports(): Set<Module>;
-    get injectables(): Map<InjectionToken, InstanceWrapper<Injectable>>;
-    get entryProviders(): Array<InstanceWrapper<Injectable>>;
-    get exports(): Set<InjectionToken>;
-    get instance(): VenokModule;
-    get metatype(): Type;
-    get distance(): number;
-    set distance(value: number);
-    addCoreProviders(): void;
-    addModuleRef(): void;
-    addModuleAsProvider(): void;
-    addApplicationConfig(): void;
-    addInjectable<T extends Injectable>(injectable: Provider, enhancerSubtype: EnhancerSubtype, host?: Type<T>): string | symbol | Function | InstanceWrapper<unknown>;
-    addProvider(provider: Provider, enhancerSubtype?: EnhancerSubtype): InjectionToken;
-    isCustomProvider(provider: Provider): provider is ClassProvider | FactoryProvider | ValueProvider | ExistingProvider;
-    addCustomProvider(provider: ClassProvider | FactoryProvider | ValueProvider | ExistingProvider, collection: Map<Function | string | symbol, any>, enhancerSubtype?: EnhancerSubtype): InjectionToken;
-    isCustomClass(provider: any): provider is ClassProvider;
-    isCustomValue(provider: any): provider is ValueProvider;
-    isCustomFactory(provider: any): provider is FactoryProvider;
-    isCustomUseExisting(provider: any): provider is ExistingProvider;
-    isDynamicModule(exported: any): exported is DynamicModule;
-    addCustomClass(provider: ClassProvider, collection: Map<InjectionToken, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
-    addCustomValue(provider: ValueProvider, collection: Map<Function | string | symbol, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
-    addCustomFactory(provider: FactoryProvider, collection: Map<Function | string | symbol, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
-    addCustomUseExisting(provider: ExistingProvider, collection: Map<Function | string | symbol, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
-    addExportedProvider(provider: Provider | string | symbol | DynamicModule): Set<InjectionToken> | undefined;
-    addCustomExportedProvider(provider: FactoryProvider | ValueProvider | ClassProvider | ExistingProvider): Set<InjectionToken> | undefined;
-    validateExportedProvider(token: InjectionToken): InjectionToken;
-    addImport(moduleRef: Module): void;
-    /**
-     * @deprecated
-     */
-    addRelatedModule(module: Module): void;
-    replace(toReplace: InjectionToken, options: any): void;
-    hasProvider(token: InjectionToken): boolean;
-    hasInjectable(token: InjectionToken): boolean;
-    getProviderByKey<T = any>(name: InjectionToken): InstanceWrapper<T>;
-    getProviderById<T = any>(id: string): InstanceWrapper<T> | undefined;
-    getInjectableById<T = any>(id: string): InstanceWrapper<T> | undefined;
-    getNonAliasProviders(): Array<[InjectionToken, InstanceWrapper<Injectable>]>;
-    createModuleReferenceType(): Type<ModuleRef>;
-    private isEntryProvider;
-    private generateUuid;
-}

package/injector/module/module.js

@@ -1,383 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Module = void 0;
-const wrapper_1 = require("@venok/core/injector/instance/wrapper");
-const exceptions_1 = require("@venok/core/errors/exceptions");
-const constants_1 = require("@venok/core/constants");
-const shared_helper_1 = require("@venok/core/helpers/shared.helper");
-const uuid_helper_1 = require("@venok/core/helpers/uuid.helper");
-const random_string_generator_helper_1 = require("@venok/core/helpers/random-string-generator.helper");
-const ref_1 = require("@venok/core/injector/module/ref");
-const class_scope_helper_1 = require("@venok/core/injector/helpers/class-scope.helper");
-const is_durable_helper_1 = require("@venok/core/injector/helpers/is-durable.helper");
-const config_1 = require("@venok/core/application/config");
-const context_id_factory_helper_1 = require("@venok/core/helpers/context-id-factory.helper");
-class Module {
-    constructor(_metatype, container) {
-        this._metatype = _metatype;
-        this.container = container;
-        this._imports = new Set();
-        this._providers = new Map();
-        this._injectables = new Map();
-        this._entryProviderKeys = new Set();
-        this._exports = new Set();
-        this._distance = 0;
-        this._initOnPreview = false;
-        this._isGlobal = false;
-        this.addCoreProviders();
-        this._id = this.generateUuid();
-    }
-    get id() {
-        return this._id;
-    }
-    get token() {
-        return this._token;
-    }
-    set token(token) {
-        this._token = token;
-    }
-    get name() {
-        return this.metatype.name;
-    }
-    get isGlobal() {
-        return this._isGlobal;
-    }
-    set isGlobal(global) {
-        this._isGlobal = global;
-    }
-    get initOnPreview() {
-        return this._initOnPreview;
-    }
-    set initOnPreview(initOnPreview) {
-        this._initOnPreview = initOnPreview;
-    }
-    get providers() {
-        return this._providers;
-    }
-    get imports() {
-        return this._imports;
-    }
-    get injectables() {
-        return this._injectables;
-    }
-    get entryProviders() {
-        return Array.from(this._entryProviderKeys)
-            .map((token) => this.providers.get(token))
-            .filter(Boolean);
-    }
-    get exports() {
-        return this._exports;
-    }
-    get instance() {
-        if (!this._providers.has(this._metatype)) {
-            throw new exceptions_1.RuntimeException();
-        }
-        const module = this._providers.get(this._metatype);
-        return module.instance;
-    }
-    get metatype() {
-        return this._metatype;
-    }
-    get distance() {
-        return this._distance;
-    }
-    set distance(value) {
-        this._distance = value;
-    }
-    addCoreProviders() {
-        this.addModuleAsProvider();
-        this.addModuleRef();
-        this.addApplicationConfig();
-    }
-    addModuleRef() {
-        const moduleRef = this.createModuleReferenceType();
-        this._providers.set(ref_1.ModuleRef, new wrapper_1.InstanceWrapper({
-            token: ref_1.ModuleRef,
-            name: ref_1.ModuleRef.name,
-            metatype: ref_1.ModuleRef,
-            isResolved: true,
-            instance: new moduleRef(),
-            host: this,
-        }));
-    }
-    addModuleAsProvider() {
-        this._providers.set(this._metatype, new wrapper_1.InstanceWrapper({
-            token: this._metatype,
-            name: this._metatype.name,
-            metatype: this._metatype,
-            isResolved: false,
-            instance: null,
-            host: this,
-        }));
-    }
-    addApplicationConfig() {
-        this._providers.set(config_1.ApplicationConfig, new wrapper_1.InstanceWrapper({
-            token: config_1.ApplicationConfig,
-            name: config_1.ApplicationConfig.name,
-            isResolved: true,
-            instance: this.container.applicationConfig,
-            host: this,
-        }));
-    }
-    addInjectable(injectable, enhancerSubtype, host) {
-        if (this.isCustomProvider(injectable)) {
-            return this.addCustomProvider(injectable, this._injectables, enhancerSubtype);
-        }
-        let instanceWrapper = this.injectables.get(injectable);
-        if (!instanceWrapper) {
-            instanceWrapper = new wrapper_1.InstanceWrapper({
-                token: injectable,
-                name: injectable.name,
-                metatype: injectable,
-                instance: null,
-                isResolved: false,
-                scope: (0, class_scope_helper_1.getClassScope)(injectable),
-                durable: (0, is_durable_helper_1.isDurable)(injectable),
-                subtype: enhancerSubtype,
-                host: this,
-            });
-            this._injectables.set(injectable, instanceWrapper);
-        }
-        if (host) {
-            const hostWrapper = this._providers.get(host);
-            hostWrapper && hostWrapper.addEnhancerMetadata(instanceWrapper);
-        }
-        return instanceWrapper;
-    }
-    // public addProvider(provider: Provider): InjectionToken;
-    // public addProvider(provider: Provider, enhancerSubtype: EnhancerSubtype): InjectionToken;
-    addProvider(provider, enhancerSubtype) {
-        if (this.isCustomProvider(provider)) {
-            if (this.isEntryProvider(provider.provide)) {
-                this._entryProviderKeys.add(provider.provide);
-            }
-            return this.addCustomProvider(provider, this._providers, enhancerSubtype);
-        }
-        this._providers.set(provider, new wrapper_1.InstanceWrapper({
-            token: provider,
-            name: provider.name,
-            metatype: provider,
-            instance: null,
-            isResolved: false,
-            scope: (0, class_scope_helper_1.getClassScope)(provider),
-            durable: (0, is_durable_helper_1.isDurable)(provider),
-            host: this,
-        }));
-        if (this.isEntryProvider(provider)) {
-            this._entryProviderKeys.add(provider);
-        }
-        return provider;
-    }
-    isCustomProvider(provider) {
-        return !(0, shared_helper_1.isNull)(provider.provide);
-    }
-    addCustomProvider(provider, collection, enhancerSubtype) {
-        if (this.isCustomClass(provider)) {
-            this.addCustomClass(provider, collection, enhancerSubtype);
-        }
-        else if (this.isCustomValue(provider)) {
-            this.addCustomValue(provider, collection, enhancerSubtype);
-        }
-        else if (this.isCustomFactory(provider)) {
-            this.addCustomFactory(provider, collection, enhancerSubtype);
-        }
-        else if (this.isCustomUseExisting(provider)) {
-            this.addCustomUseExisting(provider, collection, enhancerSubtype);
-        }
-        return provider.provide;
-    }
-    isCustomClass(provider) {
-        return !(0, shared_helper_1.isUndefined)(provider.useClass);
-    }
-    isCustomValue(provider) {
-        return (0, shared_helper_1.isObject)(provider) && Object.prototype.hasOwnProperty.call(provider, "useValue");
-    }
-    isCustomFactory(provider) {
-        return !(0, shared_helper_1.isUndefined)(provider.useFactory);
-    }
-    isCustomUseExisting(provider) {
-        return !(0, shared_helper_1.isUndefined)(provider.useExisting);
-    }
-    isDynamicModule(exported) {
-        return exported && exported.module;
-    }
-    addCustomClass(provider, collection, enhancerSubtype) {
-        let { scope, durable } = provider;
-        const { useClass } = provider;
-        if ((0, shared_helper_1.isUndefined)(scope)) {
-            scope = (0, class_scope_helper_1.getClassScope)(useClass);
-        }
-        if ((0, shared_helper_1.isUndefined)(durable)) {
-            durable = (0, is_durable_helper_1.isDurable)(useClass);
-        }
-        const token = provider.provide;
-        collection.set(token, new wrapper_1.InstanceWrapper({
-            token,
-            name: useClass?.name ?? useClass,
-            metatype: useClass,
-            instance: null,
-            isResolved: false,
-            scope,
-            durable,
-            host: this,
-            subtype: enhancerSubtype,
-        }));
-    }
-    addCustomValue(provider, collection, enhancerSubtype) {
-        const { useValue: value, provide: providerToken } = provider;
-        collection.set(providerToken, new wrapper_1.InstanceWrapper({
-            token: providerToken,
-            name: providerToken?.name ?? providerToken,
-            metatype: null,
-            instance: value,
-            isResolved: true,
-            async: value instanceof Promise,
-            host: this,
-            subtype: enhancerSubtype,
-        }));
-    }
-    addCustomFactory(provider, collection, enhancerSubtype) {
-        const { useFactory: factory, inject, scope, durable, provide: providerToken } = provider;
-        collection.set(providerToken, new wrapper_1.InstanceWrapper({
-            token: providerToken,
-            name: providerToken?.name ?? providerToken,
-            metatype: factory,
-            instance: null,
-            isResolved: false,
-            inject: inject || [],
-            scope,
-            durable,
-            host: this,
-            subtype: enhancerSubtype,
-        }));
-    }
-    addCustomUseExisting(provider, collection, enhancerSubtype) {
-        const { useExisting, provide: providerToken } = provider;
-        collection.set(providerToken, new wrapper_1.InstanceWrapper({
-            token: providerToken,
-            name: providerToken?.name ?? providerToken,
-            metatype: ((instance) => instance),
-            instance: null,
-            isResolved: false,
-            inject: [useExisting],
-            host: this,
-            isAlias: true,
-            subtype: enhancerSubtype,
-        }));
-    }
-    addExportedProvider(provider) {
-        const addExportedUnit = (token) => this._exports.add(this.validateExportedProvider(token));
-        if (this.isCustomProvider(provider)) {
-            return this.addCustomExportedProvider(provider);
-        }
-        else if ((0, shared_helper_1.isString)(provider) || (0, shared_helper_1.isSymbol)(provider)) {
-            return addExportedUnit(provider);
-        }
-        else if (this.isDynamicModule(provider)) {
-            const { module: moduleClassRef } = provider;
-            return addExportedUnit(moduleClassRef);
-        }
-        addExportedUnit(provider);
-    }
-    addCustomExportedProvider(provider) {
-        const provide = provider.provide;
-        if ((0, shared_helper_1.isString)(provide) || (0, shared_helper_1.isSymbol)(provide)) {
-            return this._exports.add(this.validateExportedProvider(provide));
-        }
-        this._exports.add(this.validateExportedProvider(provide));
-    }
-    validateExportedProvider(token) {
-        if (this._providers.has(token)) {
-            return token;
-        }
-        const imports = Array.from(this._imports.values())
-            .filter(Boolean)
-            .map(({ metatype }) => metatype)
-            .filter(Boolean);
-        if (!imports.includes(token)) {
-            const { name } = this.metatype;
-            const providerName = (0, shared_helper_1.isFunction)(token) ? token.name : token;
-            throw new exceptions_1.UnknownExportException(providerName, name);
-        }
-        return token;
-    }
-    addImport(moduleRef) {
-        this._imports.add(moduleRef);
-    }
-    /**
-     * @deprecated
-     */
-    addRelatedModule(module) {
-        this._imports.add(module);
-    }
-    replace(toReplace, options) {
-        if (options.isProvider && this.hasProvider(toReplace)) {
-            const originalProvider = this._providers.get(toReplace);
-            return originalProvider.mergeWith({ provide: toReplace, ...options });
-        }
-        else if (!options.isProvider && this.hasInjectable(toReplace)) {
-            const originalInjectable = this._injectables.get(toReplace);
-            return originalInjectable.mergeWith({
-                provide: toReplace,
-                ...options,
-            });
-        }
-    }
-    hasProvider(token) {
-        return this._providers.has(token);
-    }
-    hasInjectable(token) {
-        return this._injectables.has(token);
-    }
-    getProviderByKey(name) {
-        return this._providers.get(name);
-    }
-    getProviderById(id) {
-        return Array.from(this._providers.values()).find((item) => item.id === id);
-    }
-    getInjectableById(id) {
-        return Array.from(this._injectables.values()).find((item) => item.id === id);
-    }
-    getNonAliasProviders() {
-        return [...this._providers].filter(([_, wrapper]) => !wrapper.isAlias);
-    }
-    createModuleReferenceType() {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const self = this;
-        return class extends ref_1.ModuleRef {
-            constructor() {
-                super(self.container);
-            }
-            get(typeOrToken, options = {}) {
-                options.strict ??= true;
-                options.each ??= false;
-                return this.find(typeOrToken, options.strict
-                    ? {
-                        moduleId: self.id,
-                        each: options.each,
-                    }
-                    : options);
-            }
-            resolve(typeOrToken, contextId = (0, context_id_factory_helper_1.createContextId)(), options = {}) {
-                options.strict ??= true;
-                options.each ??= false;
-                return this.resolvePerContext(typeOrToken, self, contextId, options);
-            }
-            async create(type, contextId) {
-                if (!(type && (0, shared_helper_1.isFunction)(type) && type.prototype)) {
-                    throw new exceptions_1.InvalidClassException(type);
-                }
-                return this.instantiateClass(type, self, contextId);
-            }
-        };
-    }
-    isEntryProvider(metatype) {
-        return typeof metatype === "function" ? !!Reflect.getMetadata(constants_1.ENTRY_PROVIDER_WATERMARK, metatype) : false;
-    }
-    generateUuid() {
-        const prefix = "M_";
-        const key = this.name?.toString() ?? this.token?.toString();
-        return key ? uuid_helper_1.UuidFactory.get(`${prefix}_${key}`) : (0, random_string_generator_helper_1.randomStringGenerator)();
-    }
-}
-exports.Module = Module;

package/injector/module/ref.d.ts

@@ -1,106 +0,0 @@
-import { Injector } from "@venok/core/injector/injector";
-import { Type } from "@venok/core/interfaces";
-import { ContextId } from "@venok/core/injector/instance/wrapper";
-import { IntrospectionResult } from "@venok/core/interfaces/modules";
-import { Module } from "@venok/core/injector/module/module";
-import { AbstractInstanceResolver } from "@venok/core/injector/instance/resolver";
-import { InstanceLinksHost } from "@venok/core/injector/instance/links-host";
-import { VenokContainer } from "@venok/core/injector/container";
-export interface ModuleRefGetOrResolveOpts {
-    /**
-     * If enabled, lookup will only be performed in the host module.
-     * @default true
-     */
-    strict?: boolean;
-    /**
-     * If enabled, instead of returning a first instance registered under a given token,
-     * a list of instances will be returned.
-     * @default false
-     */
-    each?: boolean;
-}
-export declare abstract class ModuleRef extends AbstractInstanceResolver {
-    protected readonly container: VenokContainer;
-    protected readonly injector: Injector;
-    private _instanceLinksHost;
-    protected get instanceLinksHost(): InstanceLinksHost;
-    constructor(container: VenokContainer);
-    /**
-     * Retrieves an instance of either injectable or controller, otherwise, throws exception.
-     * @returns {TResult}
-     */
-    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol): TResult;
-    /**
-     * Retrieves an instance of either injectable or controller, otherwise, throws exception.
-     * @returns {TResult}
-     */
-    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
-        /**
-         * If enabled, lookup will only be performed in the host module.
-         * @default true
-         */
-        strict?: boolean;
-        /** This indicates that only the first instance registered will be returned. */
-        each?: undefined | false;
-    }): TResult;
-    /**
-     * Retrieves a list of instances of either injectables or controllers, otherwise, throws exception.
-     * @returns {Array<TResult>}
-     */
-    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
-        /**
-         * If enabled, lookup will only be performed in the host module.
-         * @default true
-         */
-        strict?: boolean;
-        /** This indicates that a list of instances will be returned. */
-        each: true;
-    }): Array<TResult>;
-    /**
-     * Retrieves an instance (or a list of instances) of either injectable or controller, otherwise, throws exception.
-     * @returns {TResult | Array<TResult>}
-     */
-    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options?: ModuleRefGetOrResolveOpts): TResult | Array<TResult>;
-    /**
-     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
-     * @returns {Array<TResult>}
-     */
-    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol): Promise<TResult>;
-    /**
-     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
-     * @returns {Array<TResult>}
-     */
-    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
-        id: number;
-    }): Promise<TResult>;
-    /**
-     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
-     * @returns {Array<TResult>}
-     */
-    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
-        id: number;
-    }, options?: {
-        strict?: boolean;
-        each?: undefined | false;
-    }): Promise<TResult>;
-    /**
-     * Resolves transient or request-scoped instances of either injectables or controllers, otherwise, throws exception.
-     * @returns {Array<TResult>}
-     */
-    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
-        id: number;
-    }, options?: {
-        strict?: boolean;
-        each: true;
-    }): Promise<Array<TResult>>;
-    /**
-     * Resolves transient or request-scoped instance (or a list of instances) of either injectable or controller, otherwise, throws exception.
-     * @returns {Promise<TResult | Array<TResult>>}
-     */
-    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
-        id: number;
-    }, options?: ModuleRefGetOrResolveOpts): Promise<TResult | Array<TResult>>;
-    abstract create<T = any>(type: Type<T>, contextId?: ContextId): Promise<T>;
-    introspect<T = any>(token: Type<T> | string | symbol): IntrospectionResult;
-    protected instantiateClass<T = any>(type: Type<T>, moduleRef: Module, contextId?: ContextId): Promise<T>;
-}

package/injector/module/ref.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModuleRef = void 0;
-const injector_1 = require("@venok/core/injector/injector");
-const interfaces_1 = require("@venok/core/interfaces");
-const wrapper_1 = require("@venok/core/injector/instance/wrapper");
-const resolver_1 = require("@venok/core/injector/instance/resolver");
-const links_host_1 = require("@venok/core/injector/instance/links-host");
-const class_scope_helper_1 = require("@venok/core/injector/helpers/class-scope.helper");
-const is_durable_helper_1 = require("@venok/core/injector/helpers/is-durable.helper");
-class ModuleRef extends resolver_1.AbstractInstanceResolver {
-    get instanceLinksHost() {
-        if (!this._instanceLinksHost) {
-            this._instanceLinksHost = new links_host_1.InstanceLinksHost(this.container);
-        }
-        return this._instanceLinksHost;
-    }
-    constructor(container) {
-        super();
-        this.container = container;
-        this.injector = new injector_1.Injector();
-    }
-    introspect(token) {
-        const { wrapperRef } = this.instanceLinksHost.get(token);
-        let scope = interfaces_1.Scope.DEFAULT;
-        if (!wrapperRef.isDependencyTreeStatic()) {
-            scope = interfaces_1.Scope.REQUEST;
-        }
-        else if (wrapperRef.isTransient) {
-            scope = interfaces_1.Scope.TRANSIENT;
-        }
-        return { scope };
-    }
-    // public registerRequestByContextId<T = any>(request: T, contextId: ContextId) {
-    //   this.container.registerRequestProvider(request, contextId);
-    // }
-    async instantiateClass(type, moduleRef, contextId) {
-        const wrapper = new wrapper_1.InstanceWrapper({
-            name: type && type.name,
-            metatype: type,
-            isResolved: false,
-            scope: (0, class_scope_helper_1.getClassScope)(type),
-            durable: (0, is_durable_helper_1.isDurable)(type),
-            host: moduleRef,
-        });
-        return new Promise(async (resolve, reject) => {
-            try {
-                const callback = async (instances) => {
-                    const properties = await this.injector.resolveProperties(wrapper, moduleRef, undefined, contextId);
-                    const instance = new type(...instances);
-                    this.injector.applyProperties(instance, properties);
-                    resolve(instance);
-                };
-                await this.injector.resolveConstructorParams(wrapper, moduleRef, null, callback, contextId);
-            }
-            catch (err) {
-                reject(err);
-            }
-        });
-    }
-}
-exports.ModuleRef = ModuleRef;