@venok/core 1.1.0 → 2.0.1-next.1

package/dist/application/config.js

@@ -0,0 +1,92 @@
+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/application/config.ts
+class ApplicationConfig {
+  globalPipes = [];
+  globalFilters = [];
+  globalInterceptors = [];
+  globalGuards = [];
+  globalRequestPipes = [];
+  globalRequestFilters = [];
+  globalRequestInterceptors = [];
+  globalRequestGuards = [];
+  addGlobalPipe(pipe) {
+    this.globalPipes.push(pipe);
+  }
+  useGlobalPipes(...pipes) {
+    this.globalPipes = this.globalPipes.concat(pipes);
+  }
+  getGlobalFilters() {
+    return this.globalFilters;
+  }
+  addGlobalFilter(filter) {
+    this.globalFilters.push(filter);
+  }
+  useGlobalFilters(...filters) {
+    this.globalFilters = this.globalFilters.concat(filters);
+  }
+  getGlobalPipes() {
+    return this.globalPipes;
+  }
+  getGlobalInterceptors() {
+    return this.globalInterceptors;
+  }
+  addGlobalInterceptor(interceptor) {
+    this.globalInterceptors.push(interceptor);
+  }
+  useGlobalInterceptors(...interceptors) {
+    this.globalInterceptors = this.globalInterceptors.concat(interceptors);
+  }
+  getGlobalGuards() {
+    return this.globalGuards;
+  }
+  addGlobalGuard(guard) {
+    this.globalGuards.push(guard);
+  }
+  useGlobalGuards(...guards) {
+    this.globalGuards = this.globalGuards.concat(guards);
+  }
+  addGlobalRequestInterceptor(wrapper) {
+    this.globalRequestInterceptors.push(wrapper);
+  }
+  getGlobalRequestInterceptors() {
+    return this.globalRequestInterceptors;
+  }
+  addGlobalRequestPipe(wrapper) {
+    this.globalRequestPipes.push(wrapper);
+  }
+  getGlobalRequestPipes() {
+    return this.globalRequestPipes;
+  }
+  addGlobalRequestFilter(wrapper) {
+    this.globalRequestFilters.push(wrapper);
+  }
+  getGlobalRequestFilters() {
+    return this.globalRequestFilters;
+  }
+  addGlobalRequestGuard(wrapper) {
+    this.globalRequestGuards.push(wrapper);
+  }
+  getGlobalRequestGuards() {
+    return this.globalRequestGuards;
+  }
+}
+export {
+  ApplicationConfig
+};

package/dist/application/context.js

@@ -0,0 +1,252 @@
+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/application/context.ts
+import { UnknownModuleException } from "../errors/exceptions/unknown-module.exception.js";
+import { callBeforeAppShutdownHook } from "../hooks/before-app-shutdown.hook.js";
+import { callModuleBootstrapHook } from "../hooks/on-app-bootstrap.hook.js";
+import { AbstractInstanceResolver } from "../injector/instance/resolver.js";
+import { callModuleDestroyHook } from "../hooks/on-module-destroy.hook.js";
+import { createContextId } from "../helpers/context-id-factory.helper.js";
+import { callAppShutdownHook } from "../hooks/on-app-shutdown.hook.js";
+import { callModuleInitHook } from "../hooks/on-module-init.hook.js";
+import { InstanceLinksHost } from "../injector/instance/links-host.js";
+import { ShutdownSignal } from "../enums/shutdown-signal.enum.js";
+import { ModuleCompiler } from "../injector/module/compiler.js";
+import { Logger } from "../services/logger.service.js";
+import { isEmpty } from "../helpers/shared.helper.js";
+import { Injector } from "../injector/injector.js";
+import { MESSAGES } from "../constants.js";
+
+class ApplicationContext extends AbstractInstanceResolver {
+  container;
+  config;
+  appOptions;
+  contextModule;
+  scope;
+  isInitialized = false;
+  injector;
+  logger = new Logger(ApplicationContext.name, {
+    timestamp: true
+  });
+  shouldFlushLogsOnOverride = false;
+  activeShutdownSignals = new Array;
+  moduleCompiler = new ModuleCompiler;
+  shutdownCleanupRef;
+  _instanceLinksHost;
+  _moduleRefsForHooksByDistance;
+  initializationPromise;
+  get instanceLinksHost() {
+    if (!this._instanceLinksHost) {
+      this._instanceLinksHost = new InstanceLinksHost(this.container);
+    }
+    return this._instanceLinksHost;
+  }
+  constructor(container, config, appOptions = {}, contextModule = null, scope = new Array) {
+    super();
+    this.container = container;
+    this.config = config;
+    this.appOptions = appOptions;
+    this.contextModule = contextModule;
+    this.scope = scope;
+    this.injector = new Injector;
+    if (!this.contextModule)
+      this.selectContextModule();
+    if (this.appOptions.preview)
+      this.printInPreviewModeWarning();
+  }
+  selectContextModule() {
+    const modules = this.container.getModules().values();
+    this.contextModule = modules.next().value;
+  }
+  select(moduleType, selectOptions) {
+    const modulesContainer = this.container.getModules();
+    const contextModuleCtor = this.contextModule.metatype;
+    const scope = this.scope.concat(contextModuleCtor);
+    const moduleTokenFactory = this.container.getModuleTokenFactory();
+    const { type, dynamicMetadata } = this.moduleCompiler.extractMetadata(moduleType);
+    const token = moduleTokenFactory.create(type, dynamicMetadata);
+    const selectedModule = modulesContainer.get(token);
+    if (!selectedModule)
+      throw new UnknownModuleException(type.name);
+    const options = typeof selectOptions?.abortOnError !== "undefined" ? { ...this.appOptions, ...selectOptions } : this.appOptions;
+    return new ApplicationContext(this.container, this.config, options, selectedModule, scope);
+  }
+  get(typeOrToken, options = { strict: false }) {
+    return !(options && options.strict) ? this.find(typeOrToken, options) : this.find(typeOrToken, { moduleId: this.contextModule?.id, each: options.each });
+  }
+  resolve(typeOrToken, contextId = createContextId(), options = { strict: false }) {
+    return this.resolvePerContext(typeOrToken, this.contextModule, contextId, options);
+  }
+  registerRequestByContextId(request, contextId) {
+    this.container.registerRequestProvider(request, contextId);
+  }
+  async init() {
+    if (this.isInitialized)
+      return this;
+    this.initializationPromise = this.initializationPromise = new Promise(async (resolve, reject) => {
+      try {
+        await this.callInitHook();
+        await this.callBootstrapHook();
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+    await this.initializationPromise;
+    this.isInitialized = true;
+    return this;
+  }
+  async close(signal) {
+    await this.initializationPromise;
+    await this.callDestroyHook();
+    await this.callBeforeShutdownHook(signal);
+    await this.dispose();
+    await this.callShutdownHook(signal);
+    this.unsubscribeFromProcessSignals();
+  }
+  useLogger(logger) {
+    Logger.overrideLogger(logger);
+    if (this.shouldFlushLogsOnOverride)
+      this.flushLogs();
+  }
+  useGlobalFilters(...filters) {
+    this.config.useGlobalFilters(...filters);
+    return this;
+  }
+  useGlobalPipes(...pipes) {
+    this.config.useGlobalPipes(...pipes);
+    return this;
+  }
+  useGlobalInterceptors(...interceptors) {
+    this.config.useGlobalInterceptors(...interceptors);
+    return this;
+  }
+  useGlobalGuards(...guards) {
+    this.config.useGlobalGuards(...guards);
+    return this;
+  }
+  flushLogs() {
+    Logger.flush();
+  }
+  flushLogsOnOverride() {
+    this.shouldFlushLogsOnOverride = true;
+  }
+  enableShutdownHooks(signals = []) {
+    if (isEmpty(signals)) {
+      const keys = Object.keys(ShutdownSignal);
+      signals = keys.map((key) => ShutdownSignal[key]);
+    } else {
+      signals = Array.from(new Set(signals));
+    }
+    signals = signals.map((signal) => signal.toString().toUpperCase().trim()).filter((signal) => !this.activeShutdownSignals.includes(signal));
+    this.listenToShutdownSignals(signals);
+    return this;
+  }
+  async dispose() {
+    return Promise.resolve();
+  }
+  listenToShutdownSignals(signals) {
+    let receivedSignal = false;
+    const cleanup = async (signal) => {
+      try {
+        if (receivedSignal)
+          return;
+        receivedSignal = true;
+        await this.initializationPromise;
+        await this.callDestroyHook();
+        await this.callBeforeShutdownHook(signal);
+        await this.dispose();
+        await this.callShutdownHook(signal);
+        signals.forEach((sig) => process.removeListener(sig, cleanup));
+        process.kill(process.pid, signal);
+      } catch (err) {
+        Logger.error(MESSAGES.ERROR_DURING_SHUTDOWN, err?.stack, ApplicationContext.name);
+        process.exit(1);
+      }
+    };
+    this.shutdownCleanupRef = cleanup;
+    signals.forEach((signal) => {
+      this.activeShutdownSignals.push(signal);
+      process.on(signal, cleanup);
+    });
+  }
+  unsubscribeFromProcessSignals() {
+    if (!this.shutdownCleanupRef)
+      return;
+    this.activeShutdownSignals.forEach((signal) => {
+      process.removeListener(signal, this.shutdownCleanupRef);
+    });
+  }
+  async callInitHook() {
+    const modulesSortedByDistance = this.getModulesToTriggerHooksOn();
+    for (const module of modulesSortedByDistance) {
+      await callModuleInitHook(module);
+    }
+  }
+  async callDestroyHook() {
+    const modulesSortedByDistance = [...this.getModulesToTriggerHooksOn()].reverse();
+    for (const module of modulesSortedByDistance) {
+      await callModuleDestroyHook(module);
+    }
+  }
+  async callBootstrapHook() {
+    const modulesSortedByDistance = this.getModulesToTriggerHooksOn();
+    for (const module of modulesSortedByDistance) {
+      await callModuleBootstrapHook(module);
+    }
+  }
+  async callShutdownHook(signal) {
+    const modulesSortedByDistance = [...this.getModulesToTriggerHooksOn()].reverse();
+    for (const module of modulesSortedByDistance) {
+      await callAppShutdownHook(module, signal);
+    }
+  }
+  async callBeforeShutdownHook(signal) {
+    const modulesSortedByDistance = [...this.getModulesToTriggerHooksOn()].reverse();
+    for (const module of modulesSortedByDistance) {
+      await callBeforeAppShutdownHook(module, signal);
+    }
+  }
+  assertNotInPreviewMode(methodName) {
+    if (this.appOptions.preview) {
+      const error = `Calling the "${methodName}" in the preview mode is not supported.`;
+      this.logger.error(error);
+      throw new Error(error);
+    }
+  }
+  getModulesToTriggerHooksOn() {
+    if (this._moduleRefsForHooksByDistance) {
+      return this._moduleRefsForHooksByDistance;
+    }
+    const modulesContainer = this.container.getModules();
+    const compareFn = (a, b) => b.distance - a.distance;
+    const modulesSortedByDistance = Array.from(modulesContainer.values()).sort(compareFn);
+    this._moduleRefsForHooksByDistance = this.appOptions?.preview ? modulesSortedByDistance.filter((moduleRef) => moduleRef.initOnPreview) : modulesSortedByDistance;
+    return this._moduleRefsForHooksByDistance;
+  }
+  printInPreviewModeWarning() {
+    this.logger.warn("------------------------------------------------");
+    this.logger.warn("Application is running in the PREVIEW mode!");
+    this.logger.warn("Providers will not be instantiated.");
+    this.logger.warn("------------------------------------------------");
+  }
+}
+export {
+  ApplicationContext
+};

package/dist/application/factory.js

@@ -0,0 +1,136 @@
+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/application/factory.ts
+import { isFunction, isNull } from "../helpers/shared.helper.js";
+import { rethrow } from "../helpers/rethrow.helper.js";
+import { UuidFactory, UuidFactoryMode } from "../helpers/uuid.helper.js";
+import { ApplicationConfig } from "../application/config.js";
+import { ApplicationContext } from "../application/context.js";
+import { ConsoleLogger } from "../services/console.service.js";
+import { Logger } from "../services/logger.service.js";
+import { NoopGraphInspector } from "../inspector/noop-graph-inspector.js";
+import { GraphInspector } from "../inspector/graph-inspector.js";
+import { Injector } from "../injector/injector.js";
+import { VenokContainer } from "../injector/container.js";
+import { InstanceLoader } from "../injector/instance/loader.js";
+import { MetadataScanner } from "../metadata-scanner.js";
+import { DependenciesScanner } from "../scanner.js";
+import { ExceptionsZone } from "../exceptions/zone/zone.js";
+import { MESSAGES } from "../constants.js";
+
+class VenokFactoryStatic {
+  logger = new Logger("VenokFactory", {
+    timestamp: true
+  });
+  abortOnError = true;
+  autoFlushLogs = false;
+  async createApplicationContext(moduleCls, options) {
+    try {
+      const nest = __require("@nestjs/common");
+      if (nest)
+        nest.Logger.overrideLogger(new ConsoleLogger);
+    } catch {}
+    const applicationConfig = new ApplicationConfig;
+    const container = new VenokContainer(applicationConfig);
+    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.createVenokInstance(new ApplicationContext(container, applicationConfig, options, root));
+    if (this.autoFlushLogs)
+      context.flushLogsOnOverride();
+    return context;
+  }
+  createVenokInstance(instance) {
+    return this.createProxy(instance);
+  }
+  setAbortOnError(options) {
+    this.abortOnError = !(options && options.abortOnError === false);
+  }
+  async initialize(module, container, graphInspector, config = new ApplicationConfig, options = {}) {
+    UuidFactory.mode = options.snapshot ? UuidFactoryMode.Deterministic : UuidFactoryMode.Random;
+    const injector = new Injector({ preview: options.preview });
+    const instanceLoader = new InstanceLoader(container, injector, graphInspector);
+    const metadataScanner = new MetadataScanner;
+    const dependenciesScanner = new DependenciesScanner(container, metadataScanner, graphInspector, config);
+    const teardown = !this.abortOnError ? rethrow : undefined;
+    try {
+      this.logger.log(MESSAGES.APPLICATION_START);
+      await 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();
+    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 (isFunction(receiver[prop]))
+        return this.createExceptionZone(receiver, prop);
+      return receiver[prop];
+    };
+  }
+  createExceptionZone(receiver, prop) {
+    const teardown = !this.abortOnError ? rethrow : undefined;
+    return (...args) => {
+      let result;
+      ExceptionsZone.run(() => {
+        result = receiver[prop](...args);
+      }, teardown);
+      return result;
+    };
+  }
+  registerLoggerConfiguration(options) {
+    if (!options)
+      return;
+    const { logger, bufferLogs, autoFlushLogs, forceConsole } = options;
+    if (!!logger && !isNull(logger))
+      Logger.overrideLogger(logger);
+    else if (forceConsole) {
+      const consoleLogger = new ConsoleLogger({ forceConsole: true });
+      Logger.overrideLogger(consoleLogger);
+    }
+    if (bufferLogs)
+      Logger.attachBuffer();
+    this.autoFlushLogs = autoFlushLogs ?? true;
+  }
+  createGraphInspector(appOptions, container) {
+    return appOptions?.snapshot ? new GraphInspector(container) : NoopGraphInspector;
+  }
+}
+var VenokFactory = new VenokFactoryStatic;
+export {
+  VenokFactoryStatic,
+  VenokFactory
+};

package/dist/constants.js

@@ -0,0 +1,100 @@
+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/constants.ts
+var MESSAGES = {
+  APPLICATION_START: `Starting Venok application...`,
+  APPLICATION_READY: `Venok application successfully started`,
+  UNKNOWN_EXCEPTION_MESSAGE: "Internal server error",
+  ERROR_DURING_SHUTDOWN: "Error happened during shutdown"
+};
+var FORBIDDEN_MESSAGE = "Forbidden resource";
+var MODULE_METADATA = {
+  IMPORTS: "imports",
+  PROVIDERS: "providers",
+  EXPORTS: "exports"
+};
+var PIPES_METADATA = "__pipes__";
+var GUARDS_METADATA = "__guards__";
+var INTERCEPTORS_METADATA = "__interceptors__";
+var EXCEPTION_FILTERS_METADATA = "__exceptionFilters__";
+var ENHANCER_KEY_TO_SUBTYPE_MAP = {
+  [GUARDS_METADATA]: "guard",
+  [INTERCEPTORS_METADATA]: "interceptor",
+  [PIPES_METADATA]: "pipe",
+  [EXCEPTION_FILTERS_METADATA]: "filter"
+};
+var APP_INTERCEPTOR = "APP_INTERCEPTOR";
+var APP_PIPE = "APP_PIPE";
+var APP_GUARD = "APP_GUARD";
+var APP_FILTER = "APP_FILTER";
+var ENHANCER_TOKEN_TO_SUBTYPE_MAP = {
+  [APP_GUARD]: "guard",
+  [APP_INTERCEPTOR]: "interceptor",
+  [APP_PIPE]: "pipe",
+  [APP_FILTER]: "filter"
+};
+var REQUEST = "REQUEST";
+var GLOBAL_MODULE_METADATA = "__module:global__";
+var PARAMTYPES_METADATA = "design:paramtypes";
+var SELF_DECLARED_DEPS_METADATA = "self:paramtypes";
+var OPTIONAL_DEPS_METADATA = "optional:paramtypes";
+var PROPERTY_DEPS_METADATA = "self:properties_metadata";
+var OPTIONAL_PROPERTY_DEPS_METADATA = "optional:properties_metadata";
+var SCOPE_OPTIONS_METADATA = "scope:options";
+var MODULE_PATH = "__module_path__";
+var ROUTE_ARGS_METADATA = "__routeArguments__";
+var CUSTOM_ROUTE_ARGS_METADATA = "__customRouteArgs__";
+var FILTER_CATCH_EXCEPTIONS = "__filterCatchExceptions__";
+var INJECTABLE_WATERMARK = "__injectable__";
+var CATCH_WATERMARK = "__catch__";
+var ENTRY_PROVIDER_WATERMARK = "__entryProvider__";
+var INQUIRER = "INQUIRER";
+var REQUEST_CONTEXT_ID = Symbol("REQUEST_CONTEXT_ID");
+export {
+  SELF_DECLARED_DEPS_METADATA,
+  SCOPE_OPTIONS_METADATA,
+  ROUTE_ARGS_METADATA,
+  REQUEST_CONTEXT_ID,
+  REQUEST,
+  PROPERTY_DEPS_METADATA,
+  PIPES_METADATA,
+  PARAMTYPES_METADATA,
+  OPTIONAL_PROPERTY_DEPS_METADATA,
+  OPTIONAL_DEPS_METADATA,
+  MODULE_PATH,
+  MODULE_METADATA,
+  MESSAGES,
+  INTERCEPTORS_METADATA,
+  INQUIRER,
+  INJECTABLE_WATERMARK,
+  GUARDS_METADATA,
+  GLOBAL_MODULE_METADATA,
+  FORBIDDEN_MESSAGE,
+  FILTER_CATCH_EXCEPTIONS,
+  EXCEPTION_FILTERS_METADATA,
+  ENTRY_PROVIDER_WATERMARK,
+  ENHANCER_TOKEN_TO_SUBTYPE_MAP,
+  ENHANCER_KEY_TO_SUBTYPE_MAP,
+  CUSTOM_ROUTE_ARGS_METADATA,
+  CATCH_WATERMARK,
+  APP_PIPE,
+  APP_INTERCEPTOR,
+  APP_GUARD,
+  APP_FILTER
+};

package/dist/context/context-id.factory.js

@@ -0,0 +1,58 @@
+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/context/context-id.factory.ts
+import { createContextId } from "../helpers/context-id-factory.helper.js";
+import { isObject } from "../helpers/shared.helper.js";
+import { REQUEST_CONTEXT_ID } from "../constants.js";
+
+class ContextIdFactory {
+  static strategy;
+  static create() {
+    return createContextId();
+  }
+  static getByRequest(request, propsToInspect = ["raw"]) {
+    if (!request)
+      return ContextIdFactory.create();
+    if (request[REQUEST_CONTEXT_ID])
+      return request[REQUEST_CONTEXT_ID];
+    for (const key of propsToInspect)
+      if (request[key]?.[REQUEST_CONTEXT_ID])
+        return request[key][REQUEST_CONTEXT_ID];
+    if (!this.strategy)
+      return ContextIdFactory.create();
+    const contextId = createContextId();
+    const resolverObjectOrFunction = this.strategy.attach(contextId, request);
+    if (this.isContextIdResolverWithPayload(resolverObjectOrFunction)) {
+      contextId.getParent = resolverObjectOrFunction.resolve;
+      contextId.payload = resolverObjectOrFunction.payload;
+    } else {
+      contextId.getParent = resolverObjectOrFunction;
+    }
+    return contextId;
+  }
+  static apply(strategy) {
+    this.strategy = strategy;
+  }
+  static isContextIdResolverWithPayload(resolverOrResolverFn) {
+    return isObject(resolverOrResolverFn);
+  }
+}
+export {
+  ContextIdFactory
+};