@venok/core 1.0.1-canary.5 → 2.0.0

package/dist/context/context.js

@@ -0,0 +1,186 @@
+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.ts
+import { isObservable, lastValueFrom } from "rxjs";
+import { STATIC_CONTEXT } from "../injector/constants.js";
+import { HandlerMetadataStorage } from "../storage/handler-metadata.storage.js";
+import { ContextUtils } from "../helpers/context.helper.js";
+import { isEmpty } from "../helpers/shared.helper.js";
+import { InterceptorsConsumer } from "../interceptors/consumer.js";
+import { InterceptorsContextCreator } from "../interceptors/context-creator.js";
+import { GuardsConsumer } from "../guards/consumer.js";
+import { GuardsContextCreator } from "../guards/context-creator.js";
+import { PipesConsumer } from "../pipes/consumer.js";
+import { PipesContextCreator } from "../pipes/context-creator.js";
+import { VenokExceptionFilterContext } from "../filters/context.js";
+import { VenokProxy } from "../context/proxy.js";
+import { Reflector } from "../services/reflector.service.js";
+import { RuntimeException } from "../errors/exceptions/runtime.exception.js";
+import { CUSTOM_ROUTE_ARGS_METADATA, FORBIDDEN_MESSAGE } from "../constants.js";
+
+class VenokContextCreator {
+  guardsContextCreator;
+  guardsConsumer;
+  interceptorsContextCreator;
+  interceptorsConsumer;
+  modulesContainer;
+  pipesContextCreator;
+  pipesConsumer;
+  filtersContextCreator;
+  contextUtils = new ContextUtils;
+  venokProxy = new VenokProxy;
+  reflector = new Reflector;
+  handlerMetadataStorage = new HandlerMetadataStorage;
+  container;
+  constructor(guardsContextCreator, guardsConsumer, interceptorsContextCreator, interceptorsConsumer, modulesContainer, pipesContextCreator, pipesConsumer, filtersContextCreator) {
+    this.guardsContextCreator = guardsContextCreator;
+    this.guardsConsumer = guardsConsumer;
+    this.interceptorsContextCreator = interceptorsContextCreator;
+    this.interceptorsConsumer = interceptorsConsumer;
+    this.modulesContainer = modulesContainer;
+    this.pipesContextCreator = pipesContextCreator;
+    this.pipesConsumer = pipesConsumer;
+    this.filtersContextCreator = filtersContextCreator;
+  }
+  static fromContainer(container, contextClass = VenokContextCreator, filtersContextClass = VenokExceptionFilterContext) {
+    const guardsContextCreator = new GuardsContextCreator(container, container.applicationConfig);
+    const guardsConsumer = new GuardsConsumer;
+    const interceptorsContextCreator = new InterceptorsContextCreator(container, container.applicationConfig);
+    const interceptorsConsumer = new InterceptorsConsumer;
+    const pipesContextCreator = new PipesContextCreator(container, container.applicationConfig);
+    const pipesConsumer = new PipesConsumer;
+    const filtersContextCreator = new filtersContextClass(container, container.applicationConfig);
+    const venokContextCreator = new contextClass(guardsContextCreator, guardsConsumer, interceptorsContextCreator, interceptorsConsumer, container.getModules(), pipesContextCreator, pipesConsumer, filtersContextCreator);
+    venokContextCreator.container = container;
+    return venokContextCreator;
+  }
+  create(instance, callback, methodName, metadataKey, paramsFactory, contextId = STATIC_CONTEXT, inquirerId, options = {
+    interceptors: true,
+    guards: true,
+    filters: true,
+    callback: undefined
+  }, contextType = "native") {
+    const module = this.getContextModuleKey(instance.constructor);
+    const { argsLength, paramtypes, getParamsMetadata } = this.getMetadata(instance, methodName, metadataKey, paramsFactory, contextType);
+    const pipes = this.pipesContextCreator.create(instance, callback, module, contextId, inquirerId);
+    const guards = this.guardsContextCreator.create(instance, callback, module, contextId, inquirerId);
+    const exceptionFilter = this.filtersContextCreator.create(instance, callback, module, contextId, inquirerId);
+    const interceptors = options.interceptors ? this.interceptorsContextCreator.create(instance, callback, module, contextId, inquirerId) : [];
+    const paramsMetadata = getParamsMetadata(module, contextId, inquirerId);
+    const paramsOptions = paramsMetadata ? this.contextUtils.mergeParamsMetatypes(paramsMetadata, paramtypes) : [];
+    const fnCanActivate = options.guards ? this.createGuardsFn(guards, instance, callback, contextType) : null;
+    const fnApplyPipes = this.createPipesFn(pipes, paramsOptions, contextType);
+    const handler = (initialArgs, ...args) => async () => {
+      if (fnApplyPipes) {
+        await fnApplyPipes(initialArgs, ...args);
+        return callback.apply(instance, initialArgs);
+      }
+      return callback.apply(instance, args);
+    };
+    const target = async (...args) => {
+      const initialArgs = this.contextUtils.createNullArray(argsLength);
+      fnCanActivate && await fnCanActivate(args);
+      const result = await this.interceptorsConsumer.intercept(interceptors, args, instance, callback, handler(initialArgs, ...args), contextType);
+      const done = await this.transformToResult(result);
+      if (options.callback)
+        await options.callback(done, ...args);
+      return done;
+    };
+    return options.filters ? this.venokProxy.createProxy(target, exceptionFilter, contextType) : target;
+  }
+  getMetadata(instance, methodName, metadataKey, paramsFactory, contextType) {
+    const cacheMetadata = this.handlerMetadataStorage.get(instance, methodName);
+    if (cacheMetadata)
+      return cacheMetadata;
+    const metadata = this.contextUtils.reflectCallbackMetadata(instance, methodName, metadataKey || "") || {};
+    const keys = Object.keys(metadata);
+    const argsLength = this.contextUtils.getArgumentsLength(keys, metadata);
+    const paramtypes = this.contextUtils.reflectCallbackParamtypes(instance, methodName);
+    const contextFactory = this.contextUtils.getContextFactory(contextType, instance, instance[methodName]);
+    const getParamsMetadata = (moduleKey, contextId = STATIC_CONTEXT, inquirerId) => paramsFactory ? this.exchangeKeysForValues(keys, metadata, moduleKey, paramsFactory, contextId, inquirerId, contextFactory) : null;
+    const handlerMetadata = {
+      argsLength,
+      paramtypes,
+      getParamsMetadata
+    };
+    this.handlerMetadataStorage.set(instance, methodName, handlerMetadata);
+    return handlerMetadata;
+  }
+  getContextModuleKey(moduleCtor) {
+    const emptyModuleKey = "";
+    if (!moduleCtor)
+      return emptyModuleKey;
+    const moduleContainerEntries = this.modulesContainer.entries();
+    for (const [key, moduleRef] of moduleContainerEntries) {
+      if (moduleRef.hasProvider && moduleRef.hasProvider(moduleCtor))
+        return key;
+    }
+    return emptyModuleKey;
+  }
+  exchangeKeysForValues(keys, metadata, moduleContext, paramsFactory, contextId = STATIC_CONTEXT, inquirerId, contextFactory = this.contextUtils.getContextFactory("native")) {
+    this.pipesContextCreator.setModuleContext(moduleContext);
+    return keys.map((key) => {
+      const { index, data, pipes: pipesCollection } = metadata[key];
+      const pipes = this.pipesContextCreator.createConcreteContext(pipesCollection, contextId, inquirerId);
+      const type = this.contextUtils.mapParamType(key);
+      if (key.includes(CUSTOM_ROUTE_ARGS_METADATA)) {
+        const { factory } = metadata[key];
+        const customExtractValue = this.contextUtils.getCustomFactory(factory, data, contextFactory);
+        return { index, extractValue: customExtractValue, type, data, pipes };
+      }
+      const extractValue = (...args) => paramsFactory.exchangeKeyForValue(+type, data, args);
+      return { index, extractValue, type, data, pipes };
+    });
+  }
+  createPipesFn(pipes, paramsOptions, contextType) {
+    const pipesFn = async (args, ...params) => {
+      const resolveParamValue = async (param) => {
+        const { index, extractValue, type, data, metatype, pipes: paramPipes } = param;
+        const value = extractValue(...params);
+        args[index] = await this.getParamValue(value, {
+          metatype,
+          type,
+          data,
+          contextType
+        }, pipes.concat(paramPipes));
+      };
+      await Promise.all(paramsOptions.map(resolveParamValue));
+    };
+    return paramsOptions.length ? pipesFn : null;
+  }
+  async getParamValue(value, metadata, pipes) {
+    return isEmpty(pipes) ? value : this.pipesConsumer.apply(value, metadata, pipes);
+  }
+  async transformToResult(resultOrDeferred) {
+    if (isObservable(resultOrDeferred))
+      return lastValueFrom(resultOrDeferred);
+    return resultOrDeferred;
+  }
+  createGuardsFn(guards, instance, callback, contextType) {
+    const canActivateFn = async (args) => {
+      const canActivate = await this.guardsConsumer.tryActivate(guards, args, instance, callback, contextType);
+      if (!canActivate)
+        throw new RuntimeException(FORBIDDEN_MESSAGE);
+    };
+    return guards.length ? canActivateFn : null;
+  }
+}
+export {
+  VenokContextCreator
+};

package/dist/context/creator.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/context/creator.ts
+import { STATIC_CONTEXT } from "../injector/constants.js";
+
+class ContextCreator {
+  createContext(instance, callback, metadataKey, contextId = STATIC_CONTEXT, inquirerId) {
+    const globalMetadata = this.getGlobalMetadata && this.getGlobalMetadata(contextId, inquirerId);
+    const classMetadata = this.reflectClassMetadata(instance, metadataKey);
+    const methodMetadata = this.reflectMethodMetadata(callback, metadataKey);
+    return [
+      ...this.createConcreteContext(globalMetadata || [], contextId, inquirerId),
+      ...this.createConcreteContext(classMetadata, contextId, inquirerId),
+      ...this.createConcreteContext(methodMetadata, contextId, inquirerId)
+    ];
+  }
+  reflectClassMetadata(instance, metadataKey) {
+    const prototype = Object.getPrototypeOf(instance);
+    return Reflect.getMetadata(metadataKey, prototype.constructor);
+  }
+  reflectMethodMetadata(callback, metadataKey) {
+    return Reflect.getMetadata(metadataKey, callback);
+  }
+  getContextId(contextId, instanceWrapper) {
+    return contextId.getParent ? contextId.getParent({
+      token: instanceWrapper.token,
+      isTreeDurable: instanceWrapper.isDependencyTreeDurable()
+    }) : contextId;
+  }
+}
+export {
+  ContextCreator
+};

package/dist/context/execution-host.js

@@ -0,0 +1,51 @@
+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/execution-host.ts
+class ExecutionContextHost {
+  args;
+  constructorRef;
+  handler;
+  contextType = "native";
+  constructor(args, constructorRef = null, handler = null) {
+    this.args = args;
+    this.constructorRef = constructorRef;
+    this.handler = handler;
+  }
+  setType(type) {
+    type && (this.contextType = type);
+  }
+  getType() {
+    return this.contextType;
+  }
+  getClass() {
+    return this.constructorRef;
+  }
+  getHandler() {
+    return this.handler;
+  }
+  getArgs() {
+    return this.args;
+  }
+  getArgByIndex(index) {
+    return this.args[index];
+  }
+}
+export {
+  ExecutionContextHost
+};

package/dist/context/proxy.js

@@ -0,0 +1,55 @@
+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/proxy.ts
+import { catchError, isObservable } from "rxjs";
+import { ExecutionContextHost } from "../context/execution-host.js";
+
+class VenokProxy {
+  createProxy(targetCallback, exceptionsHandler, type = "native") {
+    return async (...args) => {
+      try {
+        const result = await targetCallback(...args);
+        return !isObservable(result) ? result : result.pipe(catchError((error) => this.handleError(exceptionsHandler, args, error, type)));
+      } catch (error) {
+        return this.handleError(exceptionsHandler, args, error, type);
+      }
+    };
+  }
+  handleError(exceptionsHandler, args, error, type = "native") {
+    const host = new ExecutionContextHost(args);
+    host.setType(type);
+    exceptionsHandler.next(error, host);
+    return args;
+  }
+  createExceptionLayerProxy(targetCallback, exceptionsHandler, type) {
+    return async (err, req, res, next) => {
+      try {
+        await targetCallback(err, req, res, next);
+      } catch (e) {
+        const host = new ExecutionContextHost([req, res, next]);
+        host.setType(type);
+        exceptionsHandler.next(e, host);
+        return res;
+      }
+    };
+  }
+}
+export {
+  VenokProxy
+};

package/dist/decorators/apply.decorator.js

@@ -0,0 +1,33 @@
+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/decorators/apply.decorator.ts
+function applyDecorators(...decorators) {
+  return (target, propertyKey, descriptor) => {
+    for (const decorator of decorators) {
+      if (target instanceof Function && !descriptor) {
+        decorator(target);
+        continue;
+      }
+      decorator(target, propertyKey, descriptor);
+    }
+  };
+}
+export {
+  applyDecorators
+};

package/dist/decorators/bind.decorator.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/decorators/bind.decorator.ts
+function Bind(...decorators) {
+  return (target, key, descriptor) => {
+    decorators.forEach((fn, index) => fn(target, key, index));
+    return descriptor;
+  };
+}
+export {
+  Bind
+};

package/dist/decorators/catch.decorator.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/decorators/catch.decorator.ts
+import { CATCH_WATERMARK, FILTER_CATCH_EXCEPTIONS } from "../constants.js";
+function Catch(...exceptions) {
+  return (target) => {
+    Reflect.defineMetadata(CATCH_WATERMARK, true, target);
+    Reflect.defineMetadata(FILTER_CATCH_EXCEPTIONS, exceptions, target);
+  };
+}
+export {
+  Catch
+};

package/dist/decorators/dependencies.decorator.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/decorators/dependencies.decorator.ts
+import { flatten } from "../helpers/flatten.helper.js";
+import { PARAMTYPES_METADATA } from "../constants.js";
+var Dependencies = (...dependencies) => {
+  const flattenDeps = flatten(dependencies);
+  return (target) => {
+    Reflect.defineMetadata(PARAMTYPES_METADATA, flattenDeps, target);
+  };
+};
+export {
+  Dependencies
+};

package/dist/decorators/exception-filters.decorator.js

@@ -0,0 +1,40 @@
+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/decorators/exception-filters.decorator.ts
+import { extendArrayMetadata } from "../helpers/metadata.helper.js";
+import { isFunction } from "../helpers/shared.helper.js";
+import { validateEach } from "../helpers/validate-each.helper.js";
+import { EXCEPTION_FILTERS_METADATA } from "../constants.js";
+var UseFilters = (...filters) => addExceptionFiltersMetadata(...filters);
+function addExceptionFiltersMetadata(...filters) {
+  return (target, key, descriptor) => {
+    const isFilterValid = (filter) => filter && (isFunction(filter) || isFunction(filter.catch));
+    if (descriptor) {
+      validateEach(target.constructor, filters, isFilterValid, "@UseFilters", "filter");
+      extendArrayMetadata(EXCEPTION_FILTERS_METADATA, filters, descriptor.value);
+      return descriptor;
+    }
+    validateEach(target, filters, isFilterValid, "@UseFilters", "filter");
+    extendArrayMetadata(EXCEPTION_FILTERS_METADATA, filters, target);
+    return target;
+  };
+}
+export {
+  UseFilters
+};

package/dist/decorators/global.decorator.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/decorators/global.decorator.ts
+import { GLOBAL_MODULE_METADATA } from "../constants.js";
+function Global() {
+  return (target) => {
+    Reflect.defineMetadata(GLOBAL_MODULE_METADATA, true, target);
+  };
+}
+export {
+  Global
+};

package/dist/decorators/inject.decorator.js

@@ -0,0 +1,42 @@
+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/decorators/inject.decorator.ts
+import { isUndefined } from "../helpers/shared.helper.js";
+import { PARAMTYPES_METADATA, PROPERTY_DEPS_METADATA, SELF_DECLARED_DEPS_METADATA } from "../constants.js";
+function Inject(token) {
+  const injectCallHasArguments = arguments.length > 0;
+  return (target, key, index) => {
+    let type = token || Reflect.getMetadata("design:type", target, key);
+    if (!type && !injectCallHasArguments) {
+      type = Reflect.getMetadata(PARAMTYPES_METADATA, target, key)?.[index];
+    }
+    if (!isUndefined(index)) {
+      let dependencies = Reflect.getMetadata(SELF_DECLARED_DEPS_METADATA, target) || [];
+      dependencies = [...dependencies, { index, param: type }];
+      Reflect.defineMetadata(SELF_DECLARED_DEPS_METADATA, dependencies, target);
+      return;
+    }
+    let properties = Reflect.getMetadata(PROPERTY_DEPS_METADATA, target.constructor) || [];
+    properties = [...properties, { key, type }];
+    Reflect.defineMetadata(PROPERTY_DEPS_METADATA, properties, target.constructor);
+  };
+}
+export {
+  Inject
+};

package/dist/decorators/injectable.decorator.js

@@ -0,0 +1,38 @@
+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/decorators/injectable.decorator.ts
+import { uid } from "uid";
+import { INJECTABLE_WATERMARK, SCOPE_OPTIONS_METADATA } from "../constants.js";
+function Injectable(options) {
+  return (target) => {
+    Reflect.defineMetadata(INJECTABLE_WATERMARK, true, target);
+    Reflect.defineMetadata(SCOPE_OPTIONS_METADATA, options, target);
+  };
+}
+function mixin(mixinClass) {
+  Object.defineProperty(mixinClass, "name", {
+    value: uid(21)
+  });
+  Injectable()(mixinClass);
+  return mixinClass;
+}
+export {
+  mixin,
+  Injectable
+};

package/dist/decorators/module.decorator.js

@@ -0,0 +1,42 @@
+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/decorators/module.decorator.ts
+import { MODULE_METADATA as metadataConstants } from "../constants.js";
+var reservedMetadataKeys = [metadataConstants.IMPORTS, metadataConstants.EXPORTS, metadataConstants.PROVIDERS];
+function Module(metadata) {
+  return (target) => {
+    const allProviders = [...metadata.providers || []];
+    for (const property in metadata) {
+      if (Object.prototype.hasOwnProperty.call(metadata, property)) {
+        if (reservedMetadataKeys.includes(property) && property !== metadataConstants.PROVIDERS) {
+          Reflect.defineMetadata(property, metadata[property], target);
+        } else if (!reservedMetadataKeys.includes(property)) {
+          const customProviders = metadata[property];
+          if (Array.isArray(customProviders))
+            allProviders.push(...customProviders);
+        }
+      }
+    }
+    if (allProviders.length > 0)
+      Reflect.defineMetadata(metadataConstants.PROVIDERS, allProviders, target);
+  };
+}
+export {
+  Module
+};