@venok/core 1.1.0 → 2.0.1-next.1

package/dist/errors/exceptions/unknown-export.exception.js

@@ -0,0 +1,30 @@
+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/errors/exceptions/unknown-export.exception.ts
+import { RuntimeException } from "../../errors/exceptions/runtime.exception.js";
+import { UNKNOWN_EXPORT_MESSAGE } from "../../errors/messages.js";
+
+class UnknownExportException extends RuntimeException {
+  constructor(token, moduleName) {
+    super(UNKNOWN_EXPORT_MESSAGE(token, moduleName));
+  }
+}
+export {
+  UnknownExportException
+};

package/dist/errors/exceptions/unknown-module.exception.js

@@ -0,0 +1,29 @@
+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/errors/exceptions/unknown-module.exception.ts
+import { RuntimeException } from "../../errors/exceptions/runtime.exception.js";
+
+class UnknownModuleException extends RuntimeException {
+  constructor(moduleName) {
+    super(`Venok could not select the given module (${moduleName ? `"${moduleName}"` : "it"} does not exist in current context).`);
+  }
+}
+export {
+  UnknownModuleException
+};

package/dist/errors/messages.js

@@ -0,0 +1,134 @@
+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/errors/messages.ts
+import { isNull, isSymbol } from "../helpers/shared.helper.js";
+var getInstanceName = (instance) => {
+  if (instance?.forwardRef)
+    return instance.forwardRef()?.name;
+  if (instance?.module)
+    return instance.module?.name;
+  return instance?.name;
+};
+var getDependencyName = (dependency, fallbackValue, disambiguated = true) => getInstanceName(dependency) || isSymbol(dependency) && dependency.toString() || (dependency ? disambiguated ? `"${dependency}"` : dependency : undefined) || fallbackValue;
+var getModuleName = (module) => module && getInstanceName(module.metatype) || "current";
+var stringifyScope = (scope) => (scope || []).map(getInstanceName).join(" -> ");
+var UNKNOWN_DEPENDENCIES_MESSAGE = (type, unknownDependencyContext, module) => {
+  const { index, name = "dependency", dependencies, key } = unknownDependencyContext;
+  const moduleName = getModuleName(module);
+  const dependencyName = getDependencyName(name, "dependency");
+  const isImportTypeIssue = !isNull(index) && dependencies && (dependencies[index] === undefined || dependencies[index] === Object || typeof dependencies[index] === "function" && dependencies[index].name === "Object");
+  let potentialSolutions;
+  if (isImportTypeIssue) {
+    potentialSolutions = `
+
+Potential solutions:
+- The dependency at index [${index}] appears to be undefined at runtime
+- This commonly occurs when using 'import type' instead of 'import' for injectable classes
+- Check your imports and change:
+  ❌ import type { SomeService } from './some.service';
+  ✅ import { SomeService } from './some.service';
+- Ensure the imported class is decorated with @Injectable() or is a valid provider
+- If using dynamic imports, ensure the class is available at runtime, not just for type checking`;
+  } else {
+    potentialSolutions = moduleName !== "current" ? `
+
+Potential solutions:
+- Is ${moduleName} a valid Venok module?
+- If ${dependencyName} is a provider, is it part of the current ${moduleName}?
+- If ${dependencyName} is exported from a separate @Module, is that module imported within ${moduleName}?
+  @Module({
+    imports: [ /* the Module containing ${dependencyName} */ ]
+  })` : `
+
+Potential solutions:
+- If ${dependencyName} is a provider, is it part of the current Module?
+- If ${dependencyName} is exported from a separate @Module, is that module imported within Module?
+  @Module({
+    imports: [ /* the Module containing ${dependencyName} */ ]
+  })`;
+  }
+  let message = `Venok can't resolve dependencies of the ${type.toString()}`;
+  if (isNull(index) && key) {
+    message += `. Please make sure that the "${key.toString()}" property is available in the current context.${potentialSolutions}`;
+    return message;
+  }
+  const dependenciesName = (dependencies || []).map((dependencyName2) => getDependencyName(dependencyName2, "+", false));
+  dependenciesName[index] = "?";
+  message += ` (`;
+  message += dependenciesName.join(", ");
+  message += `). Please make sure that the argument ${isImportTypeIssue ? "dependency" : dependencyName} at index [${index}] is available in the ${isImportTypeIssue ? "current" : moduleName} context.`;
+  message += potentialSolutions;
+  return message;
+};
+var UNDEFINED_FORWARDREF_MESSAGE = (scope) => `Venok cannot create the module instance. Often, this is because of a circular dependency between modules. Use forwardRef() to avoid it.
+
+Scope [${stringifyScope(scope)}]
+`;
+var INVALID_MODULE_MESSAGE = (parentModule, index, scope) => {
+  const parentModuleName = parentModule?.name || "module";
+  return `Venok cannot create the ${parentModuleName} instance.
+Received an unexpected value at index [${index}] of the ${parentModuleName} "imports" array.
+
+Scope [${stringifyScope(scope)}]`;
+};
+var USING_INVALID_CLASS_AS_A_MODULE_MESSAGE = (metatypeUsedAsAModule, scope) => {
+  const metatypeNameQuote = `"${getInstanceName(metatypeUsedAsAModule)}"` || "that class";
+  return `Classes annotated with @Injectable(), @Catch(), and @Controller() decorators must not appear in the "imports" array of a module.
+Please remove ${metatypeNameQuote} (including forwarded occurrences, if any) from all of the "imports" arrays.
+
+Scope [${stringifyScope(scope)}]
+`;
+};
+var UNDEFINED_MODULE_MESSAGE = (parentModule, index, scope) => {
+  const parentModuleName = parentModule?.name || "module";
+  return `Venok cannot create the ${parentModuleName} instance.
+The module at index [${index}] of the ${parentModuleName} "imports" array is undefined.
+
+Potential causes:
+- A circular dependency between modules. Use forwardRef() to avoid it.
+- The module at index [${index}] is of type "undefined". Check your import statements and the type of the module.
+
+Scope [${stringifyScope(scope)}]`;
+};
+var UNKNOWN_EXPORT_MESSAGE = (token = "item", module) => {
+  token = isSymbol(token) ? token.toString() : token;
+  return `Venok cannot export a provider/module that is not a part of the currently processed module (${module}). Please verify whether the exported ${token} is available in this particular context.
+
+Possible Solutions:
+- Is ${token} part of the relevant providers/imports within ${module}?
+`;
+};
+var INVALID_CLASS_MESSAGE = (text, value) => `ModuleRef cannot instantiate class (${value} is not constructable).`;
+var INVALID_CLASS_SCOPE_MESSAGE = (text, name) => `${name || "This class"} is marked as a scoped provider. Request and transient-scoped providers can't be used in combination with "get()" method. Please, use "resolve()" instead.`;
+var UNHANDLED_RUNTIME_EXCEPTION = `Unhandled Runtime Exception.`;
+var INVALID_EXCEPTION_FILTER = `Invalid exception filters (@UseFilters()).`;
+var MICROSERVICES_PACKAGE_NOT_FOUND_EXCEPTION = `Unable to load @Venok/microservices package. (Please make sure that it's already installed.)`;
+export {
+  USING_INVALID_CLASS_AS_A_MODULE_MESSAGE,
+  UNKNOWN_EXPORT_MESSAGE,
+  UNKNOWN_DEPENDENCIES_MESSAGE,
+  UNHANDLED_RUNTIME_EXCEPTION,
+  UNDEFINED_MODULE_MESSAGE,
+  UNDEFINED_FORWARDREF_MESSAGE,
+  MICROSERVICES_PACKAGE_NOT_FOUND_EXCEPTION,
+  INVALID_MODULE_MESSAGE,
+  INVALID_EXCEPTION_FILTER,
+  INVALID_CLASS_SCOPE_MESSAGE,
+  INVALID_CLASS_MESSAGE
+};

package/dist/exceptions/handler.js

@@ -0,0 +1,53 @@
+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/exceptions/handler.ts
+import { InvalidExceptionFilterException } from "../errors/exceptions/invalid-exception-filter.exception.js";
+import { isEmpty } from "../helpers/shared.helper.js";
+
+class VenokExceptionsHandler {
+  exceptionsFilter;
+  filters = [];
+  constructor(exceptionsFilter) {
+    this.exceptionsFilter = exceptionsFilter;
+  }
+  next(exception, host) {
+    const result = this.invokeCustomFilters(exception, host);
+    if (result)
+      return result;
+    return this.exceptionsFilter.catch(exception, host);
+  }
+  setCustomFilters(filters) {
+    if (!Array.isArray(filters))
+      throw new InvalidExceptionFilterException;
+    this.filters = filters;
+  }
+  invokeCustomFilters(exception, host) {
+    if (isEmpty(this.filters))
+      return false;
+    const filter = this.selectExceptionFilterMetadata(this.filters, exception);
+    filter && filter.func(exception, host);
+    return !!filter;
+  }
+  selectExceptionFilterMetadata(filters, exception) {
+    return filters.find(({ exceptionMetatypes }) => !exceptionMetatypes.length || exceptionMetatypes.some((ExceptionMetaType) => exception instanceof ExceptionMetaType));
+  }
+}
+export {
+  VenokExceptionsHandler
+};

package/dist/exceptions/zone/handler.js

@@ -0,0 +1,30 @@
+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/exceptions/zone/handler.ts
+import { Logger } from "../../services/logger.service.js";
+
+class ExceptionHandler {
+  static logger = new Logger(ExceptionHandler.name);
+  handle(exception) {
+    return ExceptionHandler.logger.error(exception);
+  }
+}
+export {
+  ExceptionHandler
+};

package/dist/exceptions/zone/zone.js

@@ -0,0 +1,49 @@
+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/exceptions/zone/zone.ts
+import { ExceptionHandler } from "../../exceptions/zone/handler.js";
+import { Logger } from "../../services/logger.service.js";
+var DEFAULT_TEARDOWN = () => process.exit(1);
+
+class ExceptionsZone {
+  static exceptionHandler = new ExceptionHandler;
+  static run(callback, teardown = DEFAULT_TEARDOWN, autoFlushLogs) {
+    try {
+      callback();
+    } catch (e) {
+      this.exceptionHandler.handle(e);
+      if (autoFlushLogs)
+        Logger.flush();
+      teardown(e);
+    }
+  }
+  static async asyncRun(callback, teardown = DEFAULT_TEARDOWN, autoFlushLogs) {
+    try {
+      await callback();
+    } catch (e) {
+      this.exceptionHandler.handle(e);
+      if (autoFlushLogs)
+        Logger.flush();
+      teardown(e);
+    }
+  }
+}
+export {
+  ExceptionsZone
+};

package/dist/filters/context-creator.js

@@ -0,0 +1,65 @@
+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/filters/context-creator.ts
+import { STATIC_CONTEXT } from "../injector/constants.js";
+import { isEmpty, isFunction } from "../helpers/shared.helper.js";
+import { ContextCreator } from "../context/creator.js";
+import { FILTER_CATCH_EXCEPTIONS } from "../constants.js";
+
+class ExceptionFilterContextCreator extends ContextCreator {
+  container;
+  moduleContext;
+  constructor(container) {
+    super();
+    this.container = container;
+  }
+  createConcreteContext(metadata, contextId = STATIC_CONTEXT, inquirerId) {
+    if (isEmpty(metadata))
+      return [];
+    return metadata.filter((instance) => instance && (isFunction(instance.catch) || instance.name)).map((filter) => this.getFilterInstance(filter, contextId, inquirerId)).filter(Boolean).map((instance) => ({
+      func: instance.catch.bind(instance),
+      exceptionMetatypes: this.reflectCatchExceptions(instance)
+    }));
+  }
+  getFilterInstance(filter, contextId = STATIC_CONTEXT, inquirerId) {
+    if ("catch" in filter)
+      return filter;
+    const instanceWrapper = this.getInstanceByMetatype(filter);
+    if (!instanceWrapper)
+      return null;
+    const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
+    return instanceHost && instanceHost.instance;
+  }
+  getInstanceByMetatype(metatype) {
+    if (!this.moduleContext)
+      return;
+    const collection = this.container.getModules();
+    const moduleRef = collection.get(this.moduleContext);
+    if (!moduleRef)
+      return;
+    return moduleRef.injectables.get(metatype);
+  }
+  reflectCatchExceptions(instance) {
+    const prototype = Object.getPrototypeOf(instance);
+    return Reflect.getMetadata(FILTER_CATCH_EXCEPTIONS, prototype.constructor) || [];
+  }
+}
+export {
+  ExceptionFilterContextCreator
+};

package/dist/filters/context.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/filters/context.ts
+import { STATIC_CONTEXT } from "../injector/constants.js";
+import { ExceptionFilterContextCreator } from "../filters/context-creator.js";
+import { VenokExceptionFilter } from "../filters/filter.js";
+import { VenokExceptionsHandler } from "../exceptions/handler.js";
+import { isEmpty } from "../helpers/shared.helper.js";
+import { EXCEPTION_FILTERS_METADATA } from "../constants.js";
+
+class VenokExceptionFilterContext extends ExceptionFilterContextCreator {
+  config;
+  constructor(container, config) {
+    super(container);
+    this.config = config;
+  }
+  create(instance, callback, module, contextId = STATIC_CONTEXT, inquirerId) {
+    this.moduleContext = module;
+    const exceptionHandler = new VenokExceptionsHandler(this.getExceptionFilter());
+    const filters = this.createContext(instance, callback, EXCEPTION_FILTERS_METADATA, contextId, inquirerId);
+    if (isEmpty(filters))
+      return exceptionHandler;
+    exceptionHandler.setCustomFilters(filters.reverse());
+    return exceptionHandler;
+  }
+  getExceptionFilter() {
+    return new VenokExceptionFilter;
+  }
+  getGlobalMetadata(contextId = STATIC_CONTEXT, inquirerId) {
+    if (!this.config)
+      return [];
+    const globalFilters = this.config.getGlobalFilters();
+    if (contextId === STATIC_CONTEXT && !inquirerId)
+      return globalFilters;
+    const scopedFilterWrappers = this.config.getGlobalRequestFilters();
+    const scopedFilters = scopedFilterWrappers.map((wrapper) => wrapper.getInstanceByContextId(contextId, inquirerId)).filter((host) => !!host).map((host) => host.instance);
+    return globalFilters.concat(scopedFilters);
+  }
+}
+export {
+  VenokExceptionFilterContext
+};

package/dist/filters/filter.js

@@ -0,0 +1,36 @@
+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/filters/filter.ts
+import { Logger } from "../services/logger.service.js";
+import { RuntimeException } from "../errors/exceptions/runtime.exception.js";
+
+class VenokExceptionFilter {
+  static logger = new Logger("ExternalExceptionsHandler");
+  catch(exception, host) {
+    if (exception instanceof RuntimeException) {
+      VenokExceptionFilter.logger.error(exception.what(), exception.stack);
+    }
+    if (exception instanceof Error)
+      VenokExceptionFilter.logger.error(exception.message, exception.stack);
+    throw exception;
+  }
+}
+export {
+  VenokExceptionFilter
+};

package/dist/guards/consumer.js

@@ -0,0 +1,54 @@
+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/guards/consumer.ts
+import { lastValueFrom, Observable } from "rxjs";
+import { ExecutionContextHost } from "../context/execution-host.js";
+import { isEmpty } from "../helpers/shared.helper.js";
+
+class GuardsConsumer {
+  async tryActivate(guards, args, instance, callback, type) {
+    if (!guards || isEmpty(guards))
+      return true;
+    const context = this.createContext(args, instance, callback);
+    context.setType(type);
+    for (const guard of guards) {
+      const result = guard.canActivate(context);
+      if (typeof result === "boolean") {
+        if (!result)
+          return false;
+        continue;
+      }
+      if (await this.pickResult(result))
+        continue;
+      return false;
+    }
+    return true;
+  }
+  createContext(args, instance, callback) {
+    return new ExecutionContextHost(args, instance.constructor, callback);
+  }
+  async pickResult(result) {
+    if (result instanceof Observable)
+      return lastValueFrom(result);
+    return result;
+  }
+}
+export {
+  GuardsConsumer
+};

package/dist/guards/context-creator.js

@@ -0,0 +1,76 @@
+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/guards/context-creator.ts
+import { STATIC_CONTEXT } from "../injector/constants.js";
+import { ContextCreator } from "../context/creator.js";
+import { isEmpty, isFunction } from "../helpers/shared.helper.js";
+import { GUARDS_METADATA } from "../constants.js";
+
+class GuardsContextCreator extends ContextCreator {
+  container;
+  config;
+  moduleContext;
+  constructor(container, config) {
+    super();
+    this.container = container;
+    this.config = config;
+  }
+  create(instance, callback, module, contextId = STATIC_CONTEXT, inquirerId) {
+    this.moduleContext = module;
+    return this.createContext(instance, callback, GUARDS_METADATA, contextId, inquirerId);
+  }
+  createConcreteContext(metadata, contextId = STATIC_CONTEXT, inquirerId) {
+    if (isEmpty(metadata))
+      return [];
+    return metadata.filter((guard) => guard && (guard.name || guard.canActivate)).map((guard) => this.getGuardInstance(guard, contextId, inquirerId)).filter((guard) => guard && isFunction(guard.canActivate));
+  }
+  getGuardInstance(metatype, contextId = STATIC_CONTEXT, inquirerId) {
+    const isObject = metatype.canActivate;
+    if (isObject)
+      return metatype;
+    const instanceWrapper = this.getInstanceByMetatype(metatype);
+    if (!instanceWrapper)
+      return null;
+    const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
+    return instanceHost && instanceHost.instance;
+  }
+  getInstanceByMetatype(metatype) {
+    if (!this.moduleContext)
+      return;
+    const collection = this.container.getModules();
+    const moduleRef = collection.get(this.moduleContext);
+    if (!moduleRef)
+      return;
+    const injectables = moduleRef.injectables;
+    return injectables.get(metatype);
+  }
+  getGlobalMetadata(contextId = STATIC_CONTEXT, inquirerId) {
+    if (!this.config)
+      return [];
+    const globalGuards = this.config.getGlobalGuards();
+    if (contextId === STATIC_CONTEXT && !inquirerId)
+      return globalGuards;
+    const scopedGuardWrappers = this.config.getGlobalRequestGuards();
+    const scopedGuards = scopedGuardWrappers.map((wrapper) => wrapper.getInstanceByContextId(this.getContextId(contextId, wrapper), inquirerId)).filter((host) => !!host).map((host) => host.instance);
+    return globalGuards.concat(scopedGuards);
+  }
+}
+export {
+  GuardsContextCreator
+};

package/dist/helpers/color.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/helpers/color.helper.ts
+var isColorAllowed = () => !process.env.NO_COLOR;
+var colorIfAllowed = (colorFn) => (text) => isColorAllowed() ? colorFn(text) : text;
+var colors = {
+  bold: colorIfAllowed((text) => `\x1B[1m${text}\x1B[0m`),
+  green: colorIfAllowed((text) => `\x1B[32m${text}\x1B[39m`),
+  yellow: colorIfAllowed((text) => `\x1B[33m${text}\x1B[39m`),
+  red: colorIfAllowed((text) => `\x1B[31m${text}\x1B[39m`),
+  magentaBright: colorIfAllowed((text) => `\x1B[95m${text}\x1B[39m`),
+  cyanBright: colorIfAllowed((text) => `\x1B[96m${text}\x1B[39m`)
+};
+var yellow = colorIfAllowed((text) => `\x1B[38;5;3m${text}\x1B[39m`);
+export {
+  yellow,
+  isColorAllowed,
+  colors
+};