@venok/core 1.1.0 → 2.0.0

package/dist/index.js

@@ -0,0 +1,115 @@
+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/index.ts
+import"reflect-metadata";
+
+export * from "./application/config.js";
+export * from "./application/context.js";
+import { VenokFactory } from "./application/factory.js";
+
+export * from "./context/context.js";
+export * from "./context/context-id.factory.js";
+export * from "./context/creator.js";
+export * from "./context/execution-host.js";
+export * from "./context/proxy.js";
+export * from "./decorators/apply.decorator.js";
+export * from "./decorators/bind.decorator.js";
+export * from "./decorators/catch.decorator.js";
+export * from "./decorators/dependencies.decorator.js";
+export * from "./decorators/exception-filters.decorator.js";
+export * from "./decorators/global.decorator.js";
+export * from "./decorators/inject.decorator.js";
+export * from "./decorators/injectable.decorator.js";
+export * from "./decorators/module.decorator.js";
+export * from "./decorators/optional.decorator.js";
+export * from "./decorators/set-metadata.decorator.js";
+export * from "./decorators/use-guards.decorator.js";
+export * from "./decorators/use-pipes.decorator.js";
+export * from "./decorators/use-interceptors.decorator.js";
+export * from "./enums/scope.enum.js";
+export * from "./errors/exceptions/circular-dependency.exception.js";
+export * from "./errors/exceptions/invalid-class.exception.js";
+export * from "./errors/exceptions/invalid-class-module.exception.js";
+export * from "./errors/exceptions/invalid-class-scope.exception.js";
+export * from "./errors/exceptions/invalid-exception-filter.exception.js";
+export * from "./errors/exceptions/invalid-module.exception.js";
+export * from "./errors/exceptions/runtime.exception.js";
+export * from "./errors/exceptions/undefined-dependency.exception.js";
+export * from "./errors/exceptions/undefined-forwardref.exception.js";
+export * from "./errors/exceptions/undefined-module.exception.js";
+export * from "./errors/exceptions/unknown-dependencies.exception.js";
+export * from "./errors/exceptions/unknown-element.exception.js";
+export * from "./errors/exceptions/unknown-export.exception.js";
+export * from "./errors/exceptions/unknown-module.exception.js";
+export * from "./errors/messages.js";
+export * from "./filters/context.js";
+export * from "./guards/consumer.js";
+export * from "./guards/context-creator.js";
+export * from "./helpers/color.helper.js";
+export * from "./helpers/context.helper.js";
+export * from "./helpers/context-id-factory.helper.js";
+export * from "./helpers/create-param-decorator.helper.js";
+export * from "./helpers/filter-log-levels.util.js";
+export * from "./helpers/flatten.helper.js";
+export * from "./helpers/is-log-level.util.js";
+export * from "./helpers/is-log-level-enabled.util.js";
+export * from "./helpers/messages.helper.js";
+export * from "./helpers/metadata.helper.js";
+export * from "./helpers/noop.helper.js";
+export * from "./helpers/random-string-generator.helper.js";
+export * from "./helpers/rethrow.helper.js";
+export * from "./helpers/shared.helper.js";
+export * from "./helpers/silent.helper.js";
+export * from "./helpers/transient.helper.js";
+export * from "./helpers/uuid.helper.js";
+export * from "./helpers/validate-each.helper.js";
+export * from "./injector/injector.js";
+export * from "./injector/constants.js";
+export * from "./injector/container.js";
+export * from "./injector/instance/wrapper.js";
+export * from "./injector/internal-core-module/core-providers.js";
+export * from "./injector/module/lazy/loader.js";
+import { Module } from "./injector/module/module.js";
+
+export * from "./injector/module/ref.js";
+export * from "./injector/module/container.js";
+export * from "./injector/helpers/class-scope.helper.js";
+export * from "./injector/helpers/classifier.helper.js";
+export * from "./injector/helpers/is-durable.helper.js";
+export * from "./inspector/graph-inspector.js";
+export * from "./inspector/initialize-on-preview.allowlist.js";
+export * from "./inspector/partial-graph.host.js";
+export * from "./inspector/serialized-graph.js";
+export * from "./interceptors/consumer.js";
+export * from "./interceptors/context-creator.js";
+export * from "./interfaces/index.js";
+export * from "./pipes/consumer.js";
+export * from "./pipes/context-creator.js";
+export * from "./services/console.service.js";
+export * from "./services/logger.service.js";
+export * from "./services/reflector.service.js";
+export * from "./storage/handler-metadata.storage.js";
+export * from "./storage/meta-host.storage.js";
+export * from "./constants.js";
+export * from "./metadata-scanner.js";
+export * from "./scanner.js";
+export {
+  VenokFactory,
+  Module as CoreModule
+};

package/dist/injector/constants.js

@@ -0,0 +1,28 @@
+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/constants.ts
+var STATIC_CONTEXT_ID = 1;
+var STATIC_CONTEXT = Object.freeze({
+  id: STATIC_CONTEXT_ID
+});
+var PROVIDER_ID_KEY = Symbol.for("PROVIDER_KEY");
+export {
+  STATIC_CONTEXT,
+  PROVIDER_ID_KEY
+};

package/dist/injector/container.js

@@ -0,0 +1,229 @@
+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/container.ts
+import { GLOBAL_MODULE_METADATA, REQUEST, REQUEST_CONTEXT_ID } from "../constants.js";
+import { Module } from "../injector/module/module.js";
+import { ModuleCompiler } from "../injector/module/compiler.js";
+import { ModulesContainer } from "../injector/module/container.js";
+import { TokenFactory } from "../injector/module/token-factory.js";
+import { InternalCoreModule } from "../injector/internal-core-module/internal-core-module.js";
+import { InitializeOnPreviewAllowlist } from "../inspector/initialize-on-preview.allowlist.js";
+import { ContextIdFactory } from "../context/context-id.factory.js";
+import { MetaHostStorage } from "../storage/meta-host.storage.js";
+import { SerializedGraph } from "../inspector/serialized-graph.js";
+import { ApplicationConfig } from "../application/config.js";
+import { CircularDependencyException } from "../errors/exceptions/circular-dependency.exception.js";
+import { UndefinedForwardRefException } from "../errors/exceptions/undefined-forwardref.exception.js";
+import { UnknownModuleException } from "../errors/exceptions/unknown-module.exception.js";
+
+class VenokContainer {
+  _applicationConfig;
+  globalModules = new Set;
+  moduleTokenFactory = new TokenFactory;
+  moduleCompiler = new ModuleCompiler(this.moduleTokenFactory);
+  modules = new ModulesContainer;
+  dynamicModulesMetadata = new Map;
+  _serializedGraph = new SerializedGraph;
+  internalCoreModule;
+  constructor(_applicationConfig = new ApplicationConfig) {
+    this._applicationConfig = _applicationConfig;
+  }
+  get serializedGraph() {
+    return this._serializedGraph;
+  }
+  get applicationConfig() {
+    return this._applicationConfig;
+  }
+  async addModule(metatype, scope) {
+    if (!metatype) {
+      throw new UndefinedForwardRefException(scope);
+    }
+    const { type, dynamicMetadata, token } = await this.moduleCompiler.compile(metatype);
+    if (this.modules.has(token)) {
+      return {
+        moduleRef: this.modules.get(token),
+        inserted: true
+      };
+    }
+    return {
+      moduleRef: await this.setModule({
+        token,
+        type,
+        dynamicMetadata
+      }, scope),
+      inserted: true
+    };
+  }
+  async replaceModule(metatypeToReplace, newMetatype, scope) {
+    if (!metatypeToReplace || !newMetatype) {
+      throw new UndefinedForwardRefException(scope);
+    }
+    const { token } = await this.moduleCompiler.compile(metatypeToReplace);
+    const { type, dynamicMetadata } = await this.moduleCompiler.compile(newMetatype);
+    return {
+      moduleRef: await this.setModule({
+        token,
+        type,
+        dynamicMetadata
+      }, scope),
+      inserted: false
+    };
+  }
+  async setModule({ token, dynamicMetadata, type }, scope) {
+    const moduleRef = new Module(type, this);
+    moduleRef.token = token;
+    moduleRef.initOnPreview = this.shouldInitOnPreview(type);
+    this.modules.set(token, moduleRef);
+    const updatedScope = scope.concat(type);
+    await this.addDynamicMetadata(token, dynamicMetadata, updatedScope);
+    if (this.isGlobalModule(type, dynamicMetadata)) {
+      moduleRef.isGlobal = true;
+      moduleRef.distance = Number.MAX_VALUE;
+      this.addGlobalModule(moduleRef);
+    }
+    return moduleRef;
+  }
+  async addDynamicMetadata(token, dynamicModuleMetadata, scope) {
+    if (!dynamicModuleMetadata) {
+      return;
+    }
+    this.dynamicModulesMetadata.set(token, dynamicModuleMetadata);
+    const { imports } = dynamicModuleMetadata;
+    await this.addDynamicModules(imports, scope);
+  }
+  async addDynamicModules(modules, scope) {
+    if (!modules) {
+      return;
+    }
+    await Promise.all(modules.map((module) => this.addModule(module, scope)));
+  }
+  isGlobalModule(metatype, dynamicMetadata) {
+    if (dynamicMetadata && dynamicMetadata.global) {
+      return true;
+    }
+    return !!Reflect.getMetadata(GLOBAL_MODULE_METADATA, metatype);
+  }
+  addGlobalModule(module) {
+    this.globalModules.add(module);
+  }
+  getModules() {
+    return this.modules;
+  }
+  getModuleCompiler() {
+    return this.moduleCompiler;
+  }
+  getModuleByKey(moduleKey) {
+    return this.modules.get(moduleKey);
+  }
+  getInternalCoreModuleRef() {
+    return this.internalCoreModule;
+  }
+  async addImport(relatedModule, token) {
+    if (!this.modules.has(token)) {
+      return;
+    }
+    const moduleRef = this.modules.get(token);
+    const { token: relatedModuleToken } = await this.moduleCompiler.compile(relatedModule);
+    const related = this.modules.get(relatedModuleToken);
+    moduleRef.addImport(related);
+  }
+  addProvider(provider, token, enhancerSubtype) {
+    const moduleRef = this.modules.get(token);
+    if (!provider) {
+      throw new CircularDependencyException(moduleRef?.metatype.name);
+    }
+    if (!moduleRef) {
+      throw new UnknownModuleException;
+    }
+    const providerKey = moduleRef.addProvider(provider, enhancerSubtype);
+    const providerRef = moduleRef.getProviderByKey(providerKey);
+    MetaHostStorage.inspectProvider(this.modules, providerRef);
+    return providerKey;
+  }
+  addInjectable(injectable, token, enhancerSubtype, host) {
+    if (!this.modules.has(token)) {
+      throw new UnknownModuleException;
+    }
+    const moduleRef = this.modules.get(token);
+    return moduleRef.addInjectable(injectable, enhancerSubtype, host);
+  }
+  addExportedProviderOrModule(provider, token) {
+    if (!this.modules.has(token)) {
+      throw new UnknownModuleException;
+    }
+    const moduleRef = this.modules.get(token);
+    moduleRef.addExportedProviderOrModule(provider);
+  }
+  clear() {
+    this.modules.clear();
+  }
+  replace(toReplace, options) {
+    this.modules.forEach((moduleRef) => moduleRef.replace(toReplace, options));
+  }
+  bindGlobalScope() {
+    this.modules.forEach((moduleRef) => this.bindGlobalsToImports(moduleRef));
+  }
+  bindGlobalsToImports(moduleRef) {
+    this.globalModules.forEach((globalModule) => this.bindGlobalModuleToModule(moduleRef, globalModule));
+  }
+  bindGlobalModuleToModule(target, globalModule) {
+    if (target === globalModule || target === this.internalCoreModule) {
+      return;
+    }
+    target.addImport(globalModule);
+  }
+  getDynamicMetadataByToken(token, metadataKey) {
+    const metadata = this.dynamicModulesMetadata.get(token);
+    return metadataKey ? metadata?.[metadataKey] ?? [] : metadata;
+  }
+  registerCoreModuleRef(moduleRef) {
+    this.internalCoreModule = moduleRef;
+    this.modules.set(InternalCoreModule.name, moduleRef);
+  }
+  getModuleTokenFactory() {
+    return this.moduleTokenFactory;
+  }
+  getContextId(request, isTreeDurable) {
+    const contextId = ContextIdFactory.getByRequest(request);
+    if (!request[REQUEST_CONTEXT_ID]) {
+      Object.defineProperty(request, REQUEST_CONTEXT_ID, {
+        value: contextId,
+        enumerable: false,
+        writable: false,
+        configurable: false
+      });
+      const requestProviderValue = isTreeDurable ? contextId.payload : request;
+      this.registerRequestProvider(requestProviderValue, contextId);
+    }
+    return contextId;
+  }
+  registerRequestProvider(request, contextId) {
+    const wrapper = this.internalCoreModule.getProviderByKey(REQUEST);
+    wrapper.setInstanceByContextId(contextId, {
+      instance: request,
+      isResolved: true
+    });
+  }
+  shouldInitOnPreview(type) {
+    return InitializeOnPreviewAllowlist.has(type);
+  }
+}
+export {
+  VenokContainer
+};

package/dist/injector/helpers/barrier.js

@@ -0,0 +1,48 @@
+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/helpers/barrier.ts
+class Barrier {
+  currentCount;
+  targetCount;
+  promise;
+  resolve;
+  constructor(targetCount) {
+    this.currentCount = 0;
+    this.targetCount = targetCount;
+    this.promise = new Promise((resolve) => {
+      this.resolve = resolve;
+    });
+  }
+  signal() {
+    this.currentCount += 1;
+    if (this.currentCount === this.targetCount) {
+      this.resolve();
+    }
+  }
+  async wait() {
+    return this.promise;
+  }
+  async signalAndWait() {
+    this.signal();
+    return this.wait();
+  }
+}
+export {
+  Barrier
+};

package/dist/injector/helpers/class-scope.helper.js

@@ -0,0 +1,27 @@
+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/helpers/class-scope.helper.ts
+import { SCOPE_OPTIONS_METADATA } from "../../constants.js";
+function getClassScope(provider) {
+  const metadata = Reflect.getMetadata(SCOPE_OPTIONS_METADATA, provider);
+  return metadata && metadata.scope;
+}
+export {
+  getClassScope
+};

package/dist/injector/helpers/classifier.helper.js

@@ -0,0 +1,35 @@
+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/helpers/classifier.helper.ts
+import { isUndefined } from "../../helpers/shared.helper.js";
+function isClassProvider(provider) {
+  return Boolean(provider?.useClass);
+}
+function isValueProvider(provider) {
+  const providerValue = provider?.useValue;
+  return !isUndefined(providerValue);
+}
+function isFactoryProvider(provider) {
+  return Boolean(provider.useFactory);
+}
+export {
+  isValueProvider,
+  isFactoryProvider,
+  isClassProvider
+};

package/dist/injector/helpers/is-durable.helper.js

@@ -0,0 +1,27 @@
+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/helpers/is-durable.helper.ts
+import { SCOPE_OPTIONS_METADATA } from "../../constants.js";
+function isDurable(provider) {
+  const metadata = Reflect.getMetadata(SCOPE_OPTIONS_METADATA, provider);
+  return metadata && metadata.durable;
+}
+export {
+  isDurable
+};