@venok/core 1.1.0 → 2.0.0

package/dist/injector/injector.js

@@ -0,0 +1,490 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/injector/injector.ts
+import { InstanceWrapper } from "../injector/instance/wrapper.js";
+import { Logger } from "../services/logger.service.js";
+import { SettlementSignal } from "../injector/settlement-signal.js";
+import { STATIC_CONTEXT } from "../injector/constants.js";
+import { Barrier } from "../injector/helpers/barrier.js";
+import { CircularDependencyException } from "../errors/exceptions/circular-dependency.exception.js";
+import { UndefinedDependencyException } from "../errors/exceptions/undefined-dependency.exception.js";
+import { UnknownDependenciesException } from "../errors/exceptions/unknown-dependencies.exception.js";
+import { RuntimeException } from "../errors/exceptions/runtime.exception.js";
+import { colors } from "../helpers/color.helper.js";
+import { isFunction, isNull, isObject, isString, isSymbol, isUndefined } from "../helpers/shared.helper.js";
+import {
+  INQUIRER,
+  OPTIONAL_DEPS_METADATA,
+  OPTIONAL_PROPERTY_DEPS_METADATA,
+  PARAMTYPES_METADATA,
+  PROPERTY_DEPS_METADATA,
+  SELF_DECLARED_DEPS_METADATA
+} from "../constants.js";
+import { Reflector } from "../services/reflector.service.js";
+import { ModulesContainer } from "../injector/module/container.js";
+import { VenokContextCreator } from "../context/context.js";
+import { ConsoleLogger } from "../services/console.service.js";
+import { VenokContainer } from "../injector/container.js";
+import { LazyModuleLoader } from "../injector/module/lazy/loader.js";
+import { SerializedGraph } from "../inspector/serialized-graph.js";
+
+class Injector {
+  options;
+  logger = new Logger("InjectorLogger");
+  constructor(options) {
+    this.options = options;
+  }
+  loadPrototype({ token }, collection, contextId = STATIC_CONTEXT) {
+    if (!collection) {
+      return;
+    }
+    const target = collection.get(token);
+    const instance = target.createPrototype(contextId);
+    if (instance) {
+      const wrapper = new InstanceWrapper({
+        ...target,
+        instance
+      });
+      collection.set(token, wrapper);
+    }
+  }
+  async loadInstance(wrapper, collection, moduleRef, contextId = STATIC_CONTEXT, inquirer) {
+    const inquirerId = this.getInquirerId(inquirer);
+    const instanceHost = wrapper.getInstanceByContextId(this.getContextId(contextId, wrapper), inquirerId);
+    if (instanceHost.isPending) {
+      const settlementSignal2 = wrapper.settlementSignal;
+      if (inquirer && settlementSignal2?.isCycle(inquirer.id))
+        throw new CircularDependencyException(`"${wrapper.name}"`);
+      return instanceHost.donePromise.then((err) => {
+        if (err)
+          throw err;
+      });
+    }
+    const settlementSignal = this.applySettlementSignal(instanceHost, wrapper);
+    const token = wrapper.token || wrapper.name;
+    const { inject } = wrapper;
+    const targetWrapper = collection.get(token);
+    if (isUndefined(targetWrapper)) {
+      throw new RuntimeException;
+    }
+    if (instanceHost.isResolved) {
+      return settlementSignal.complete();
+    }
+    try {
+      const t0 = this.getNowTimestamp();
+      const callback = async (instances) => {
+        const properties = await this.resolveProperties(wrapper, moduleRef, inject, contextId, wrapper, inquirer);
+        const instance = await this.instantiateClass(instances, wrapper, targetWrapper, contextId, inquirer);
+        this.applyProperties(instance, properties);
+        wrapper.initTime = this.getNowTimestamp() - t0;
+        settlementSignal.complete();
+      };
+      await this.resolveConstructorParams(wrapper, moduleRef, inject, callback, contextId, wrapper, inquirer);
+    } catch (err) {
+      wrapper.removeInstanceByContextId(this.getContextId(contextId, wrapper), inquirerId);
+      settlementSignal.error(err);
+      throw err;
+    }
+  }
+  async loadInjectable(wrapper, moduleRef, contextId = STATIC_CONTEXT, inquirer) {
+    const injectables = moduleRef.injectables;
+    await this.loadInstance(wrapper, injectables, moduleRef, contextId, inquirer);
+  }
+  async loadProvider(wrapper, moduleRef, contextId = STATIC_CONTEXT, inquirer) {
+    const providers = moduleRef.providers;
+    await this.loadInstance(wrapper, providers, moduleRef, contextId, inquirer);
+    await this.loadEnhancersPerContext(wrapper, contextId, wrapper);
+  }
+  applySettlementSignal(instancePerContext, host) {
+    const settlementSignal = new SettlementSignal;
+    instancePerContext.donePromise = settlementSignal.asPromise();
+    instancePerContext.isPending = true;
+    host.settlementSignal = settlementSignal;
+    return settlementSignal;
+  }
+  async resolveConstructorParams(wrapper, moduleRef, inject, callback, contextId = STATIC_CONTEXT, inquirer, parentInquirer) {
+    const inquirerId = this.getInquirerId(inquirer);
+    const metadata = wrapper.getCtorMetadata();
+    if (metadata && contextId !== STATIC_CONTEXT) {
+      const deps = await this.loadCtorMetadata(metadata, contextId, inquirer, parentInquirer);
+      return callback(deps);
+    }
+    const isFactoryProvider = !isNull(inject);
+    const [dependencies, optionalDependenciesIds] = isFactoryProvider ? this.getFactoryProviderDependencies(wrapper) : this.getClassDependencies(wrapper);
+    const paramBarrier = new Barrier(dependencies.length);
+    let isResolved = true;
+    const resolveParam = async (param, index) => {
+      try {
+        if (this.isInquirer(param, parentInquirer)) {
+          paramBarrier.signal();
+          return parentInquirer && parentInquirer.instance;
+        }
+        if (inquirer?.isTransient && parentInquirer) {
+          inquirer.attachRootInquirer(parentInquirer);
+        }
+        const paramWrapper = await this.resolveSingleParam(wrapper, param, { index, dependencies }, moduleRef, contextId, inquirer, index);
+        await paramBarrier.signalAndWait();
+        const paramWrapperWithInstance = await this.resolveComponentHost(moduleRef, paramWrapper, contextId, inquirer);
+        const instanceHost = paramWrapperWithInstance.getInstanceByContextId(this.getContextId(contextId, paramWrapperWithInstance), inquirerId);
+        if (!instanceHost.isResolved && !paramWrapperWithInstance.forwardRef) {
+          isResolved = false;
+        }
+        return instanceHost?.instance;
+      } catch (err) {
+        paramBarrier.signal();
+        const isOptional = optionalDependenciesIds.includes(index);
+        if (!isOptional) {
+          throw err;
+        }
+        return;
+      }
+    };
+    const instances = await Promise.all(dependencies.map(resolveParam));
+    isResolved && await callback(instances);
+  }
+  getClassDependencies(wrapper) {
+    const ctorRef = wrapper.metatype;
+    return [this.reflectConstructorParams(ctorRef), this.reflectOptionalParams(ctorRef)];
+  }
+  getFactoryProviderDependencies(wrapper) {
+    const optionalDependenciesIds = [];
+    function isOptionalFactoryDependency(value) {
+      return !isUndefined(value.token) && !isUndefined(value.optional) && !value.prototype;
+    }
+    const mapFactoryProviderInjectArray = (item, index) => {
+      if (typeof item !== "object") {
+        return item;
+      }
+      if (isOptionalFactoryDependency(item)) {
+        if (item.optional)
+          optionalDependenciesIds.push(index);
+        return item?.token;
+      }
+      return item;
+    };
+    return [wrapper.inject?.map?.(mapFactoryProviderInjectArray), optionalDependenciesIds];
+  }
+  reflectConstructorParams(type) {
+    const paramtypes = [...Reflect.getMetadata(PARAMTYPES_METADATA, type) || []];
+    const selfParams = this.reflectSelfParams(type);
+    selfParams.forEach(({ index, param }) => paramtypes[index] = param);
+    return paramtypes;
+  }
+  reflectOptionalParams(type) {
+    return Reflect.getMetadata(OPTIONAL_DEPS_METADATA, type) || [];
+  }
+  reflectSelfParams(type) {
+    return Reflect.getMetadata(SELF_DECLARED_DEPS_METADATA, type) || [];
+  }
+  async resolveSingleParam(wrapper, param, dependencyContext, moduleRef, contextId = STATIC_CONTEXT, inquirer, keyOrIndex) {
+    if (isUndefined(param)) {
+      this.logger.log("Venok encountered an undefined dependency. This may be due to a circular import or a missing dependency declaration.");
+      throw new UndefinedDependencyException(wrapper.name, dependencyContext, moduleRef);
+    }
+    let token = this.resolveParamToken(wrapper, param);
+    switch (token.name) {
+      case "Reflector":
+        token = Reflector;
+        break;
+      case "ModulesContainer":
+        token = ModulesContainer;
+        break;
+      case "ExternalContextCreator":
+        token = VenokContextCreator;
+        break;
+      case "NestContainer":
+        token = VenokContainer;
+        break;
+      case "LazyModuleLoader":
+        token = LazyModuleLoader;
+        break;
+      case "SerializedGraph":
+        token = SerializedGraph;
+        break;
+      case "Logger":
+        token = Logger;
+        break;
+      case "ConsoleLogger":
+        token = ConsoleLogger;
+        break;
+    }
+    return this.resolveComponentWrapper(moduleRef, token, dependencyContext, wrapper, contextId, inquirer, keyOrIndex);
+  }
+  resolveParamToken(wrapper, param) {
+    if (!param.forwardRef) {
+      return param;
+    }
+    wrapper.forwardRef = true;
+    return param.forwardRef();
+  }
+  async resolveComponentWrapper(moduleRef, token, dependencyContext, wrapper, contextId = STATIC_CONTEXT, inquirer, keyOrIndex) {
+    this.printResolvingDependenciesLog(token, inquirer);
+    this.printLookingForProviderLog(token, moduleRef);
+    const providers = moduleRef.providers;
+    return this.lookupComponent(providers, moduleRef, { ...dependencyContext, name: token }, wrapper, contextId, inquirer, keyOrIndex);
+  }
+  async resolveComponentHost(moduleRef, instanceWrapper, contextId = STATIC_CONTEXT, inquirer) {
+    const inquirerId = this.getInquirerId(inquirer);
+    const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
+    if (!instanceHost.isResolved && !instanceWrapper.forwardRef) {
+      inquirer?.settlementSignal?.insertRef(instanceWrapper.id);
+      await this.loadProvider(instanceWrapper, instanceWrapper.host ?? moduleRef, contextId, inquirer);
+    } else if (!instanceHost.isResolved && instanceWrapper.forwardRef && (contextId !== STATIC_CONTEXT || !!inquirerId)) {
+      instanceHost.donePromise && instanceHost.donePromise.then(() => this.loadProvider(instanceWrapper, moduleRef, contextId, inquirer));
+    }
+    if (instanceWrapper.async) {
+      const host = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
+      host.instance = await host.instance;
+      instanceWrapper.setInstanceByContextId(contextId, host, inquirerId);
+    }
+    return instanceWrapper;
+  }
+  async lookupComponent(providers, moduleRef, dependencyContext, wrapper, contextId = STATIC_CONTEXT, inquirer, keyOrIndex) {
+    const token = wrapper.token || wrapper.name;
+    const { name } = dependencyContext;
+    if (wrapper && token === name) {
+      throw new UnknownDependenciesException(wrapper.name, dependencyContext, moduleRef, { id: wrapper.id });
+    }
+    if (name && providers.has(name)) {
+      const instanceWrapper = providers.get(name);
+      this.printFoundInModuleLog(name, moduleRef);
+      this.addDependencyMetadata(keyOrIndex ?? "", wrapper, instanceWrapper);
+      return instanceWrapper;
+    }
+    return this.lookupComponentInParentModules(dependencyContext, moduleRef, wrapper, contextId, inquirer, keyOrIndex);
+  }
+  async lookupComponentInParentModules(dependencyContext, moduleRef, wrapper, contextId = STATIC_CONTEXT, inquirer, keyOrIndex) {
+    const instanceWrapper = await this.lookupComponentInImports(moduleRef, dependencyContext.name, wrapper, [], contextId, inquirer, keyOrIndex);
+    if (isNull(instanceWrapper)) {
+      throw new UnknownDependenciesException(wrapper.name, dependencyContext, moduleRef, { id: wrapper.id });
+    }
+    return instanceWrapper;
+  }
+  async lookupComponentInImports(moduleRef, name, wrapper, moduleRegistry = [], contextId = STATIC_CONTEXT, inquirer, keyOrIndex, isTraversing) {
+    let instanceWrapperRef = null;
+    const imports = moduleRef.imports || new Set;
+    const identity = (item) => item;
+    let children = [...imports.values()].filter(identity);
+    if (isTraversing) {
+      const contextModuleExports = moduleRef.exports;
+      children = children.filter((child) => contextModuleExports.has(child.metatype));
+    }
+    for (const relatedModule of children) {
+      if (moduleRegistry.includes(relatedModule.id)) {
+        continue;
+      }
+      this.printLookingForProviderLog(name, relatedModule);
+      moduleRegistry.push(relatedModule.id);
+      const { providers, exports } = relatedModule;
+      if (!exports.has(name) || !providers.has(name)) {
+        const instanceRef = await this.lookupComponentInImports(relatedModule, name, wrapper, moduleRegistry, contextId, inquirer, keyOrIndex, true);
+        if (instanceRef && keyOrIndex) {
+          this.addDependencyMetadata(keyOrIndex, wrapper, instanceRef);
+          return instanceRef;
+        }
+        continue;
+      }
+      this.printFoundInModuleLog(name, relatedModule);
+      instanceWrapperRef = providers.get(name);
+      this.addDependencyMetadata(keyOrIndex ?? "", wrapper, instanceWrapperRef);
+      const inquirerId = this.getInquirerId(inquirer);
+      const instanceHost = instanceWrapperRef.getInstanceByContextId(this.getContextId(contextId, instanceWrapperRef), inquirerId);
+      if (!instanceHost.isResolved && !instanceWrapperRef.forwardRef) {
+        break;
+      }
+    }
+    return instanceWrapperRef;
+  }
+  async resolveProperties(wrapper, moduleRef, inject, contextId = STATIC_CONTEXT, inquirer, parentInquirer) {
+    if (!isNull(inject)) {
+      return [];
+    }
+    const metadata = wrapper.getPropertiesMetadata();
+    if (metadata && contextId !== STATIC_CONTEXT) {
+      return this.loadPropertiesMetadata(metadata, contextId, inquirer);
+    }
+    const properties = this.reflectProperties(wrapper.metatype);
+    const propertyBarrier = new Barrier(properties.length);
+    const instances = await Promise.all(properties.map(async (item) => {
+      try {
+        const dependencyContext = {
+          key: item.key,
+          name: item.name
+        };
+        if (this.isInquirer(item.name, parentInquirer)) {
+          propertyBarrier.signal();
+          return parentInquirer && parentInquirer.instance;
+        }
+        const paramWrapper = await this.resolveSingleParam(wrapper, item.name, dependencyContext, moduleRef, contextId, inquirer, item.key);
+        await propertyBarrier.signalAndWait();
+        const paramWrapperWithInstance = await this.resolveComponentHost(moduleRef, paramWrapper, contextId, inquirer);
+        if (!paramWrapperWithInstance)
+          return;
+        const inquirerId = this.getInquirerId(inquirer);
+        const instanceHost = paramWrapperWithInstance.getInstanceByContextId(this.getContextId(contextId, paramWrapperWithInstance), inquirerId);
+        return instanceHost.instance;
+      } catch (err) {
+        propertyBarrier.signal();
+        if (!item.isOptional) {
+          throw err;
+        }
+        return;
+      }
+    }));
+    return properties.map((item, index) => ({
+      ...item,
+      instance: instances[index]
+    }));
+  }
+  reflectProperties(type) {
+    const properties = Reflect.getMetadata(PROPERTY_DEPS_METADATA, type) || [];
+    const optionalKeys = Reflect.getMetadata(OPTIONAL_PROPERTY_DEPS_METADATA, type) || [];
+    return properties.map((item) => ({
+      ...item,
+      name: item.type,
+      isOptional: optionalKeys.includes(item.key)
+    }));
+  }
+  applyProperties(instance, properties) {
+    if (!isObject(instance)) {
+      return;
+    }
+    properties.filter((item) => !isNull(item.instance)).forEach((item) => {
+      instance[item.key] = item.instance;
+    });
+  }
+  async instantiateClass(instances, wrapper, targetMetatype, contextId = STATIC_CONTEXT, inquirer) {
+    const { metatype, inject } = wrapper;
+    const inquirerId = this.getInquirerId(inquirer);
+    const instanceHost = targetMetatype.getInstanceByContextId(this.getContextId(contextId, targetMetatype), inquirerId);
+    const isInContext = wrapper.isStatic(contextId, inquirer) || wrapper.isInRequestScope(contextId, inquirer) || wrapper.isLazyTransient(contextId, inquirer) || wrapper.isExplicitlyRequested(contextId, inquirer);
+    if (this.options?.preview && !wrapper.host?.initOnPreview) {
+      instanceHost.isResolved = true;
+      return instanceHost.instance;
+    }
+    if (isNull(inject) && isInContext) {
+      instanceHost.instance = wrapper.forwardRef ? Object.assign(instanceHost.instance, new metatype(...instances)) : new metatype(...instances);
+      instanceHost.isConstructorCalled = true;
+    } else if (isInContext) {
+      const factoryReturnValue = targetMetatype.metatype(...instances);
+      instanceHost.instance = await factoryReturnValue;
+      instanceHost.isConstructorCalled = true;
+    }
+    instanceHost.isResolved = true;
+    return instanceHost.instance;
+  }
+  async loadPerContext(instance, moduleRef, collection, ctx, wrapper) {
+    if (!wrapper) {
+      const injectionToken = instance.constructor;
+      wrapper = collection.get(injectionToken);
+    }
+    await this.loadInstance(wrapper, collection, moduleRef, ctx, wrapper);
+    await this.loadEnhancersPerContext(wrapper, ctx, wrapper);
+    const host = wrapper.getInstanceByContextId(this.getContextId(ctx, wrapper), wrapper.id);
+    return host && host.instance;
+  }
+  async loadEnhancersPerContext(wrapper, ctx, inquirer) {
+    const enhancers = wrapper.getEnhancersMetadata() || [];
+    const loadEnhancer = (item) => {
+      const hostModule = item.host;
+      return this.loadInstance(item, hostModule.injectables, hostModule, ctx, inquirer);
+    };
+    await Promise.all(enhancers.map(loadEnhancer));
+  }
+  async loadCtorMetadata(metadata, contextId, inquirer, parentInquirer) {
+    const hosts = await Promise.all(metadata.map(async (item) => this.resolveScopedComponentHost(item, contextId, inquirer, parentInquirer)));
+    const inquirerId = this.getInquirerId(inquirer);
+    return hosts.map((item) => item?.getInstanceByContextId(this.getContextId(contextId, item), inquirerId).instance);
+  }
+  async loadPropertiesMetadata(metadata, contextId, inquirer) {
+    const dependenciesHosts = await Promise.all(metadata.map(async ({ wrapper: item, key }) => ({
+      key,
+      host: await this.resolveComponentHost(item.host, item, contextId, inquirer)
+    })));
+    const inquirerId = this.getInquirerId(inquirer);
+    return dependenciesHosts.map(({ key, host }) => ({
+      key,
+      name: key,
+      instance: host.getInstanceByContextId(this.getContextId(contextId, host), inquirerId).instance
+    }));
+  }
+  getInquirerId(inquirer) {
+    return inquirer && inquirer.id;
+  }
+  resolveScopedComponentHost(item, contextId, inquirer, parentInquirer) {
+    return this.isInquirerRequest(item, parentInquirer) ? parentInquirer : this.resolveComponentHost(item.host, item, contextId, inquirer);
+  }
+  isInquirerRequest(item, parentInquirer) {
+    return item.isTransient && item.name === INQUIRER && parentInquirer;
+  }
+  isInquirer(param, parentInquirer) {
+    return param === INQUIRER && parentInquirer;
+  }
+  addDependencyMetadata(keyOrIndex, hostWrapper, instanceWrapper) {
+    if (isSymbol(keyOrIndex) || isString(keyOrIndex)) {
+      hostWrapper.addPropertiesMetadata(keyOrIndex, instanceWrapper);
+    } else {
+      hostWrapper.addCtorMetadata(keyOrIndex, instanceWrapper);
+    }
+  }
+  getTokenName(token) {
+    return isFunction(token) ? token.name : token.toString();
+  }
+  printResolvingDependenciesLog(token, inquirer) {
+    if (!this.isDebugMode()) {
+      return;
+    }
+    const tokenName = this.getTokenName(token);
+    const dependentName = (inquirer?.name && inquirer.name.toString?.()) ?? "unknown";
+    const isAlias = dependentName === tokenName;
+    const messageToPrint = `Resolving dependency ${colors.cyanBright(tokenName)}${colors.green(" in the ")}${colors.yellow(dependentName)}${colors.green(` provider ${isAlias ? "(alias)" : ""}`)}`;
+    this.logger.log(messageToPrint);
+  }
+  printLookingForProviderLog(token, moduleRef) {
+    if (!this.isDebugMode()) {
+      return;
+    }
+    const tokenName = this.getTokenName(token);
+    const moduleRefName = moduleRef?.metatype?.name ?? "unknown";
+    this.logger.log(`Looking for ${colors.cyanBright(tokenName)}${colors.green(" in ")}${colors.magentaBright(moduleRefName)}`);
+  }
+  printFoundInModuleLog(token, moduleRef) {
+    if (!this.isDebugMode()) {
+      return;
+    }
+    const tokenName = this.getTokenName(token);
+    const moduleRefName = moduleRef?.metatype?.name ?? "unknown";
+    this.logger.log(`Found ${colors.cyanBright(tokenName)}${colors.green(" in ")}${colors.magentaBright(moduleRefName)}`);
+  }
+  isDebugMode() {
+    return !!process.env.VENOK_DEBUG;
+  }
+  getContextId(contextId, instanceWrapper) {
+    return contextId.getParent ? contextId.getParent({
+      token: instanceWrapper.token,
+      isTreeDurable: instanceWrapper.isDependencyTreeDurable()
+    }) : contextId;
+  }
+  getNowTimestamp() {
+    return performance.now();
+  }
+}
+export {
+  Injector
+};

package/dist/injector/instance/links-host.js

@@ -0,0 +1,68 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/injector/instance/links-host.ts
+import { UnknownElementException } from "../../errors/exceptions/unknown-element.exception.js";
+import { isFunction } from "../../helpers/shared.helper.js";
+
+class InstanceLinksHost {
+  container;
+  instanceLinks = new Map;
+  constructor(container) {
+    this.container = container;
+    this.initialize();
+  }
+  get(token, options = {}) {
+    const instanceLinksForGivenToken = this.instanceLinks.get(token);
+    if (!instanceLinksForGivenToken)
+      throw new UnknownElementException(this.getInstanceNameByToken(token));
+    if (options.each)
+      return instanceLinksForGivenToken;
+    const instanceLink = options.moduleId ? instanceLinksForGivenToken.find((item) => item.moduleId === options.moduleId) : instanceLinksForGivenToken[instanceLinksForGivenToken.length - 1];
+    if (!instanceLink)
+      throw new UnknownElementException(this.getInstanceNameByToken(token));
+    return instanceLink;
+  }
+  initialize() {
+    const modules = this.container.getModules();
+    modules.forEach((moduleRef) => {
+      const { providers, injectables } = moduleRef;
+      providers.forEach((wrapper, token) => this.addLink(wrapper, token, moduleRef, "providers"));
+      injectables.forEach((wrapper, token) => this.addLink(wrapper, token, moduleRef, "injectables"));
+    });
+  }
+  addLink(wrapper, token, moduleRef, collectionName) {
+    const instanceLink = {
+      moduleId: moduleRef.id,
+      wrapperRef: wrapper,
+      collection: moduleRef[collectionName],
+      token
+    };
+    const existingLinks = this.instanceLinks.get(token);
+    if (!existingLinks)
+      this.instanceLinks.set(token, [instanceLink]);
+    else
+      existingLinks.push(instanceLink);
+  }
+  getInstanceNameByToken(token) {
+    return isFunction(token) ? token?.name : token;
+  }
+}
+export {
+  InstanceLinksHost
+};

package/dist/injector/instance/loader.js

@@ -0,0 +1,95 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/injector/instance/loader.ts
+import { InternalCoreModule } from "../../injector/internal-core-module/internal-core-module.js";
+import { Logger } from "../../services/logger.service.js";
+import { MODULE_INIT_MESSAGE } from "../../helpers/messages.helper.js";
+
+class InstanceLoader {
+  container;
+  injector;
+  graphInspector;
+  logger;
+  constructor(container, injector, graphInspector, logger = new Logger(InstanceLoader.name, {
+    timestamp: true
+  })) {
+    this.container = container;
+    this.injector = injector;
+    this.graphInspector = graphInspector;
+    this.logger = logger;
+  }
+  setLogger(logger) {
+    this.logger = logger;
+  }
+  async createInstancesOfDependencies(modules = this.container.getModules()) {
+    this.createPrototypes(modules);
+    try {
+      await this.createInstances(modules);
+    } catch (err) {
+      this.graphInspector.inspectModules(modules);
+      this.graphInspector.registerPartial(err);
+      throw err;
+    }
+    this.graphInspector.inspectModules(modules);
+  }
+  createPrototypes(modules) {
+    modules.forEach((moduleRef) => {
+      this.createPrototypesOfProviders(moduleRef);
+      this.createPrototypesOfInjectables(moduleRef);
+    });
+  }
+  async createInstances(modules) {
+    await Promise.all([...modules.values()].map(async (moduleRef) => {
+      await this.createInstancesOfProviders(moduleRef);
+      await this.createInstancesOfInjectables(moduleRef);
+      const { name } = moduleRef;
+      this.isModuleWhitelisted(name) && this.logger.log(MODULE_INIT_MESSAGE`${name}`);
+    }));
+  }
+  createPrototypesOfProviders(moduleRef) {
+    const { providers } = moduleRef;
+    providers.forEach((wrapper) => this.injector.loadPrototype(wrapper, providers));
+  }
+  async createInstancesOfProviders(moduleRef) {
+    const { providers } = moduleRef;
+    const wrappers = [...providers.values()];
+    await Promise.all(wrappers.map(async (item) => {
+      await this.injector.loadProvider(item, moduleRef);
+      this.graphInspector.inspectInstanceWrapper(item, moduleRef);
+    }));
+  }
+  createPrototypesOfInjectables(moduleRef) {
+    const { injectables } = moduleRef;
+    injectables.forEach((wrapper) => this.injector.loadPrototype(wrapper, injectables));
+  }
+  async createInstancesOfInjectables(moduleRef) {
+    const { injectables } = moduleRef;
+    const wrappers = [...injectables.values()];
+    await Promise.all(wrappers.map(async (item) => {
+      await this.injector.loadInjectable(item, moduleRef);
+      this.graphInspector.inspectInstanceWrapper(item, moduleRef);
+    }));
+  }
+  isModuleWhitelisted(name) {
+    return name !== InternalCoreModule.name;
+  }
+}
+export {
+  InstanceLoader
+};