@catbee/utils 1.1.0 → 2.0.0-next.1

package/decorators/index.mjs

@@ -0,0 +1,2010 @@
+/*
+ * The MIT License
+ * 
+ * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { getLogger } from '@catbee/utils/logger';
+import { createFinalErrorResponse } from '@catbee/utils/response';
+import { HttpStatusCodes } from '@catbee/utils/http-status-codes';
+import { TTLCache } from '@catbee/utils/cache';
+import { BadRequestException } from '@catbee/utils/exception';
+import { optionalRequire } from '@catbee/utils/async';
+import { DependencyErrors } from '@catbee/utils/server';
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/reflect-metadata/Reflect.js
+var require_Reflect = __commonJS({
+  "node_modules/reflect-metadata/Reflect.js"() {
+    var Reflect2;
+    (function(Reflect3) {
+      (function(factory) {
+        var root = typeof globalThis === "object" ? globalThis : typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
+        var exporter = makeExporter(Reflect3);
+        if (typeof root.Reflect !== "undefined") {
+          exporter = makeExporter(root.Reflect, exporter);
+        }
+        factory(exporter, root);
+        if (typeof root.Reflect === "undefined") {
+          root.Reflect = Reflect3;
+        }
+        function makeExporter(target, previous) {
+          return function(key, value) {
+            Object.defineProperty(target, key, {
+              configurable: true,
+              writable: true,
+              value
+            });
+            if (previous) previous(key, value);
+          };
+        }
+        __name(makeExporter, "makeExporter");
+        function functionThis() {
+          try {
+            return Function("return this;")();
+          } catch (_) {
+          }
+        }
+        __name(functionThis, "functionThis");
+        function indirectEvalThis() {
+          try {
+            return (0, eval)("(function() { return this; })()");
+          } catch (_) {
+          }
+        }
+        __name(indirectEvalThis, "indirectEvalThis");
+        function sloppyModeThis() {
+          return functionThis() || indirectEvalThis();
+        }
+        __name(sloppyModeThis, "sloppyModeThis");
+      })(function(exporter, root) {
+        var hasOwn = Object.prototype.hasOwnProperty;
+        var supportsSymbol = typeof Symbol === "function";
+        var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
+        var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
+        var supportsCreate = typeof Object.create === "function";
+        var supportsProto = {
+          __proto__: []
+        } instanceof Array;
+        var downLevel = !supportsCreate && !supportsProto;
+        var HashMap = {
+          // create an object in dictionary mode (a.k.a. "slow" mode in v8)
+          create: supportsCreate ? function() {
+            return MakeDictionary(/* @__PURE__ */ Object.create(null));
+          } : supportsProto ? function() {
+            return MakeDictionary({
+              __proto__: null
+            });
+          } : function() {
+            return MakeDictionary({});
+          },
+          has: downLevel ? function(map, key) {
+            return hasOwn.call(map, key);
+          } : function(map, key) {
+            return key in map;
+          },
+          get: downLevel ? function(map, key) {
+            return hasOwn.call(map, key) ? map[key] : void 0;
+          } : function(map, key) {
+            return map[key];
+          }
+        };
+        var functionPrototype = Object.getPrototypeOf(Function);
+        var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
+        var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
+        var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
+        var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : void 0;
+        var metadataRegistry = GetOrCreateMetadataRegistry();
+        var metadataProvider = CreateMetadataProvider(metadataRegistry);
+        function decorate(decorators, target, propertyKey, attributes) {
+          if (!IsUndefined(propertyKey)) {
+            if (!IsArray(decorators)) throw new TypeError();
+            if (!IsObject(target)) throw new TypeError();
+            if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes)) throw new TypeError();
+            if (IsNull(attributes)) attributes = void 0;
+            propertyKey = ToPropertyKey(propertyKey);
+            return DecorateProperty(decorators, target, propertyKey, attributes);
+          } else {
+            if (!IsArray(decorators)) throw new TypeError();
+            if (!IsConstructor(target)) throw new TypeError();
+            return DecorateConstructor(decorators, target);
+          }
+        }
+        __name(decorate, "decorate");
+        exporter("decorate", decorate);
+        function metadata(metadataKey, metadataValue) {
+          function decorator(target, propertyKey) {
+            if (!IsObject(target)) throw new TypeError();
+            if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey)) throw new TypeError();
+            OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+          }
+          __name(decorator, "decorator");
+          return decorator;
+        }
+        __name(metadata, "metadata");
+        exporter("metadata", metadata);
+        function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
+          if (!IsObject(target)) throw new TypeError();
+          if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+        }
+        __name(defineMetadata, "defineMetadata");
+        exporter("defineMetadata", defineMetadata);
+        function hasMetadata(metadataKey, target, propertyKey) {
+          if (!IsObject(target)) throw new TypeError();
+          if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryHasMetadata(metadataKey, target, propertyKey);
+        }
+        __name(hasMetadata, "hasMetadata");
+        exporter("hasMetadata", hasMetadata);
+        function hasOwnMetadata(metadataKey, target, propertyKey) {
+          if (!IsObject(target)) throw new TypeError();
+          if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
+        }
+        __name(hasOwnMetadata, "hasOwnMetadata");
+        exporter("hasOwnMetadata", hasOwnMetadata);
+        function getMetadata(metadataKey, target, propertyKey) {
+          if (!IsObject(target)) throw new TypeError();
+          if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryGetMetadata(metadataKey, target, propertyKey);
+        }
+        __name(getMetadata, "getMetadata");
+        exporter("getMetadata", getMetadata);
+        function getOwnMetadata(metadataKey, target, propertyKey) {
+          if (!IsObject(target)) throw new TypeError();
+          if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
+        }
+        __name(getOwnMetadata, "getOwnMetadata");
+        exporter("getOwnMetadata", getOwnMetadata);
+        function getMetadataKeys(target, propertyKey) {
+          if (!IsObject(target)) throw new TypeError();
+          if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryMetadataKeys(target, propertyKey);
+        }
+        __name(getMetadataKeys, "getMetadataKeys");
+        exporter("getMetadataKeys", getMetadataKeys);
+        function getOwnMetadataKeys(target, propertyKey) {
+          if (!IsObject(target)) throw new TypeError();
+          if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+          return OrdinaryOwnMetadataKeys(target, propertyKey);
+        }
+        __name(getOwnMetadataKeys, "getOwnMetadataKeys");
+        exporter("getOwnMetadataKeys", getOwnMetadataKeys);
+        function deleteMetadata(metadataKey, target, propertyKey) {
+          if (!IsObject(target)) throw new TypeError();
+          if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+          if (!IsObject(target)) throw new TypeError();
+          if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+          var provider = GetMetadataProvider(
+            target,
+            propertyKey,
+            /*Create*/
+            false
+          );
+          if (IsUndefined(provider)) return false;
+          return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
+        }
+        __name(deleteMetadata, "deleteMetadata");
+        exporter("deleteMetadata", deleteMetadata);
+        function DecorateConstructor(decorators, target) {
+          for (var i = decorators.length - 1; i >= 0; --i) {
+            var decorator = decorators[i];
+            var decorated = decorator(target);
+            if (!IsUndefined(decorated) && !IsNull(decorated)) {
+              if (!IsConstructor(decorated)) throw new TypeError();
+              target = decorated;
+            }
+          }
+          return target;
+        }
+        __name(DecorateConstructor, "DecorateConstructor");
+        function DecorateProperty(decorators, target, propertyKey, descriptor) {
+          for (var i = decorators.length - 1; i >= 0; --i) {
+            var decorator = decorators[i];
+            var decorated = decorator(target, propertyKey, descriptor);
+            if (!IsUndefined(decorated) && !IsNull(decorated)) {
+              if (!IsObject(decorated)) throw new TypeError();
+              descriptor = decorated;
+            }
+          }
+          return descriptor;
+        }
+        __name(DecorateProperty, "DecorateProperty");
+        function OrdinaryHasMetadata(MetadataKey, O, P) {
+          var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+          if (hasOwn2) return true;
+          var parent = OrdinaryGetPrototypeOf(O);
+          if (!IsNull(parent)) return OrdinaryHasMetadata(MetadataKey, parent, P);
+          return false;
+        }
+        __name(OrdinaryHasMetadata, "OrdinaryHasMetadata");
+        function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
+          var provider = GetMetadataProvider(
+            O,
+            P,
+            /*Create*/
+            false
+          );
+          if (IsUndefined(provider)) return false;
+          return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
+        }
+        __name(OrdinaryHasOwnMetadata, "OrdinaryHasOwnMetadata");
+        function OrdinaryGetMetadata(MetadataKey, O, P) {
+          var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+          if (hasOwn2) return OrdinaryGetOwnMetadata(MetadataKey, O, P);
+          var parent = OrdinaryGetPrototypeOf(O);
+          if (!IsNull(parent)) return OrdinaryGetMetadata(MetadataKey, parent, P);
+          return void 0;
+        }
+        __name(OrdinaryGetMetadata, "OrdinaryGetMetadata");
+        function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
+          var provider = GetMetadataProvider(
+            O,
+            P,
+            /*Create*/
+            false
+          );
+          if (IsUndefined(provider)) return;
+          return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
+        }
+        __name(OrdinaryGetOwnMetadata, "OrdinaryGetOwnMetadata");
+        function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
+          var provider = GetMetadataProvider(
+            O,
+            P,
+            /*Create*/
+            true
+          );
+          provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
+        }
+        __name(OrdinaryDefineOwnMetadata, "OrdinaryDefineOwnMetadata");
+        function OrdinaryMetadataKeys(O, P) {
+          var ownKeys = OrdinaryOwnMetadataKeys(O, P);
+          var parent = OrdinaryGetPrototypeOf(O);
+          if (parent === null) return ownKeys;
+          var parentKeys = OrdinaryMetadataKeys(parent, P);
+          if (parentKeys.length <= 0) return ownKeys;
+          if (ownKeys.length <= 0) return parentKeys;
+          var set = new _Set();
+          var keys = [];
+          for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {
+            var key = ownKeys_1[_i];
+            var hasKey = set.has(key);
+            if (!hasKey) {
+              set.add(key);
+              keys.push(key);
+            }
+          }
+          for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {
+            var key = parentKeys_1[_a];
+            var hasKey = set.has(key);
+            if (!hasKey) {
+              set.add(key);
+              keys.push(key);
+            }
+          }
+          return keys;
+        }
+        __name(OrdinaryMetadataKeys, "OrdinaryMetadataKeys");
+        function OrdinaryOwnMetadataKeys(O, P) {
+          var provider = GetMetadataProvider(
+            O,
+            P,
+            /*create*/
+            false
+          );
+          if (!provider) {
+            return [];
+          }
+          return provider.OrdinaryOwnMetadataKeys(O, P);
+        }
+        __name(OrdinaryOwnMetadataKeys, "OrdinaryOwnMetadataKeys");
+        function Type(x) {
+          if (x === null) return 1;
+          switch (typeof x) {
+            case "undefined":
+              return 0;
+            case "boolean":
+              return 2;
+            case "string":
+              return 3;
+            case "symbol":
+              return 4;
+            case "number":
+              return 5;
+            case "object":
+              return x === null ? 1 : 6;
+            default:
+              return 6;
+          }
+        }
+        __name(Type, "Type");
+        function IsUndefined(x) {
+          return x === void 0;
+        }
+        __name(IsUndefined, "IsUndefined");
+        function IsNull(x) {
+          return x === null;
+        }
+        __name(IsNull, "IsNull");
+        function IsSymbol(x) {
+          return typeof x === "symbol";
+        }
+        __name(IsSymbol, "IsSymbol");
+        function IsObject(x) {
+          return typeof x === "object" ? x !== null : typeof x === "function";
+        }
+        __name(IsObject, "IsObject");
+        function ToPrimitive(input, PreferredType) {
+          switch (Type(input)) {
+            case 0:
+              return input;
+            case 1:
+              return input;
+            case 2:
+              return input;
+            case 3:
+              return input;
+            case 4:
+              return input;
+            case 5:
+              return input;
+          }
+          var hint = PreferredType === 3 ? "string" : PreferredType === 5 ? "number" : "default";
+          var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
+          if (exoticToPrim !== void 0) {
+            var result = exoticToPrim.call(input, hint);
+            if (IsObject(result)) throw new TypeError();
+            return result;
+          }
+          return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
+        }
+        __name(ToPrimitive, "ToPrimitive");
+        function OrdinaryToPrimitive(O, hint) {
+          if (hint === "string") {
+            var toString_1 = O.toString;
+            if (IsCallable(toString_1)) {
+              var result = toString_1.call(O);
+              if (!IsObject(result)) return result;
+            }
+            var valueOf = O.valueOf;
+            if (IsCallable(valueOf)) {
+              var result = valueOf.call(O);
+              if (!IsObject(result)) return result;
+            }
+          } else {
+            var valueOf = O.valueOf;
+            if (IsCallable(valueOf)) {
+              var result = valueOf.call(O);
+              if (!IsObject(result)) return result;
+            }
+            var toString_2 = O.toString;
+            if (IsCallable(toString_2)) {
+              var result = toString_2.call(O);
+              if (!IsObject(result)) return result;
+            }
+          }
+          throw new TypeError();
+        }
+        __name(OrdinaryToPrimitive, "OrdinaryToPrimitive");
+        function ToBoolean(argument) {
+          return !!argument;
+        }
+        __name(ToBoolean, "ToBoolean");
+        function ToString(argument) {
+          return "" + argument;
+        }
+        __name(ToString, "ToString");
+        function ToPropertyKey(argument) {
+          var key = ToPrimitive(
+            argument,
+            3
+            /* String */
+          );
+          if (IsSymbol(key)) return key;
+          return ToString(key);
+        }
+        __name(ToPropertyKey, "ToPropertyKey");
+        function IsArray(argument) {
+          return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
+        }
+        __name(IsArray, "IsArray");
+        function IsCallable(argument) {
+          return typeof argument === "function";
+        }
+        __name(IsCallable, "IsCallable");
+        function IsConstructor(argument) {
+          return typeof argument === "function";
+        }
+        __name(IsConstructor, "IsConstructor");
+        function IsPropertyKey(argument) {
+          switch (Type(argument)) {
+            case 3:
+              return true;
+            case 4:
+              return true;
+            default:
+              return false;
+          }
+        }
+        __name(IsPropertyKey, "IsPropertyKey");
+        function SameValueZero(x, y) {
+          return x === y || x !== x && y !== y;
+        }
+        __name(SameValueZero, "SameValueZero");
+        function GetMethod(V, P) {
+          var func = V[P];
+          if (func === void 0 || func === null) return void 0;
+          if (!IsCallable(func)) throw new TypeError();
+          return func;
+        }
+        __name(GetMethod, "GetMethod");
+        function GetIterator(obj) {
+          var method = GetMethod(obj, iteratorSymbol);
+          if (!IsCallable(method)) throw new TypeError();
+          var iterator = method.call(obj);
+          if (!IsObject(iterator)) throw new TypeError();
+          return iterator;
+        }
+        __name(GetIterator, "GetIterator");
+        function IteratorValue(iterResult) {
+          return iterResult.value;
+        }
+        __name(IteratorValue, "IteratorValue");
+        function IteratorStep(iterator) {
+          var result = iterator.next();
+          return result.done ? false : result;
+        }
+        __name(IteratorStep, "IteratorStep");
+        function IteratorClose(iterator) {
+          var f = iterator["return"];
+          if (f) f.call(iterator);
+        }
+        __name(IteratorClose, "IteratorClose");
+        function OrdinaryGetPrototypeOf(O) {
+          var proto = Object.getPrototypeOf(O);
+          if (typeof O !== "function" || O === functionPrototype) return proto;
+          if (proto !== functionPrototype) return proto;
+          var prototype = O.prototype;
+          var prototypeProto = prototype && Object.getPrototypeOf(prototype);
+          if (prototypeProto == null || prototypeProto === Object.prototype) return proto;
+          var constructor = prototypeProto.constructor;
+          if (typeof constructor !== "function") return proto;
+          if (constructor === O) return proto;
+          return constructor;
+        }
+        __name(OrdinaryGetPrototypeOf, "OrdinaryGetPrototypeOf");
+        function CreateMetadataRegistry() {
+          var fallback;
+          if (!IsUndefined(registrySymbol) && typeof root.Reflect !== "undefined" && !(registrySymbol in root.Reflect) && typeof root.Reflect.defineMetadata === "function") {
+            fallback = CreateFallbackProvider(root.Reflect);
+          }
+          var first;
+          var second;
+          var rest;
+          var targetProviderMap = new _WeakMap();
+          var registry = {
+            registerProvider,
+            getProvider,
+            setProvider
+          };
+          return registry;
+          function registerProvider(provider) {
+            if (!Object.isExtensible(registry)) {
+              throw new Error("Cannot add provider to a frozen registry.");
+            }
+            switch (true) {
+              case fallback === provider:
+                break;
+              case IsUndefined(first):
+                first = provider;
+                break;
+              case first === provider:
+                break;
+              case IsUndefined(second):
+                second = provider;
+                break;
+              case second === provider:
+                break;
+              default:
+                if (rest === void 0) rest = new _Set();
+                rest.add(provider);
+                break;
+            }
+          }
+          function getProviderNoCache(O, P) {
+            if (!IsUndefined(first)) {
+              if (first.isProviderFor(O, P)) return first;
+              if (!IsUndefined(second)) {
+                if (second.isProviderFor(O, P)) return first;
+                if (!IsUndefined(rest)) {
+                  var iterator = GetIterator(rest);
+                  while (true) {
+                    var next = IteratorStep(iterator);
+                    if (!next) {
+                      return void 0;
+                    }
+                    var provider = IteratorValue(next);
+                    if (provider.isProviderFor(O, P)) {
+                      IteratorClose(iterator);
+                      return provider;
+                    }
+                  }
+                }
+              }
+            }
+            if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) {
+              return fallback;
+            }
+            return void 0;
+          }
+          function getProvider(O, P) {
+            var providerMap = targetProviderMap.get(O);
+            var provider;
+            if (!IsUndefined(providerMap)) {
+              provider = providerMap.get(P);
+            }
+            if (!IsUndefined(provider)) {
+              return provider;
+            }
+            provider = getProviderNoCache(O, P);
+            if (!IsUndefined(provider)) {
+              if (IsUndefined(providerMap)) {
+                providerMap = new _Map();
+                targetProviderMap.set(O, providerMap);
+              }
+              providerMap.set(P, provider);
+            }
+            return provider;
+          }
+          function hasProvider(provider) {
+            if (IsUndefined(provider)) throw new TypeError();
+            return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);
+          }
+          function setProvider(O, P, provider) {
+            if (!hasProvider(provider)) {
+              throw new Error("Metadata provider not registered.");
+            }
+            var existingProvider = getProvider(O, P);
+            if (existingProvider !== provider) {
+              if (!IsUndefined(existingProvider)) {
+                return false;
+              }
+              var providerMap = targetProviderMap.get(O);
+              if (IsUndefined(providerMap)) {
+                providerMap = new _Map();
+                targetProviderMap.set(O, providerMap);
+              }
+              providerMap.set(P, provider);
+            }
+            return true;
+          }
+        }
+        __name(CreateMetadataRegistry, "CreateMetadataRegistry");
+        function GetOrCreateMetadataRegistry() {
+          var metadataRegistry2;
+          if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+            metadataRegistry2 = root.Reflect[registrySymbol];
+          }
+          if (IsUndefined(metadataRegistry2)) {
+            metadataRegistry2 = CreateMetadataRegistry();
+          }
+          if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+            Object.defineProperty(root.Reflect, registrySymbol, {
+              enumerable: false,
+              configurable: false,
+              writable: false,
+              value: metadataRegistry2
+            });
+          }
+          return metadataRegistry2;
+        }
+        __name(GetOrCreateMetadataRegistry, "GetOrCreateMetadataRegistry");
+        function CreateMetadataProvider(registry) {
+          var metadata2 = new _WeakMap();
+          var provider = {
+            isProviderFor: /* @__PURE__ */ __name(function(O, P) {
+              var targetMetadata = metadata2.get(O);
+              if (IsUndefined(targetMetadata)) return false;
+              return targetMetadata.has(P);
+            }, "isProviderFor"),
+            OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata2,
+            OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata2,
+            OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata2,
+            OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys2,
+            OrdinaryDeleteMetadata
+          };
+          metadataRegistry.registerProvider(provider);
+          return provider;
+          function GetOrCreateMetadataMap(O, P, Create) {
+            var targetMetadata = metadata2.get(O);
+            var createdTargetMetadata = false;
+            if (IsUndefined(targetMetadata)) {
+              if (!Create) return void 0;
+              targetMetadata = new _Map();
+              metadata2.set(O, targetMetadata);
+              createdTargetMetadata = true;
+            }
+            var metadataMap = targetMetadata.get(P);
+            if (IsUndefined(metadataMap)) {
+              if (!Create) return void 0;
+              metadataMap = new _Map();
+              targetMetadata.set(P, metadataMap);
+              if (!registry.setProvider(O, P, provider)) {
+                targetMetadata.delete(P);
+                if (createdTargetMetadata) {
+                  metadata2.delete(O);
+                }
+                throw new Error("Wrong provider for target.");
+              }
+            }
+            return metadataMap;
+          }
+          function OrdinaryHasOwnMetadata2(MetadataKey, O, P) {
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              false
+            );
+            if (IsUndefined(metadataMap)) return false;
+            return ToBoolean(metadataMap.has(MetadataKey));
+          }
+          function OrdinaryGetOwnMetadata2(MetadataKey, O, P) {
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              false
+            );
+            if (IsUndefined(metadataMap)) return void 0;
+            return metadataMap.get(MetadataKey);
+          }
+          function OrdinaryDefineOwnMetadata2(MetadataKey, MetadataValue, O, P) {
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              true
+            );
+            metadataMap.set(MetadataKey, MetadataValue);
+          }
+          function OrdinaryOwnMetadataKeys2(O, P) {
+            var keys = [];
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              false
+            );
+            if (IsUndefined(metadataMap)) return keys;
+            var keysObj = metadataMap.keys();
+            var iterator = GetIterator(keysObj);
+            var k = 0;
+            while (true) {
+              var next = IteratorStep(iterator);
+              if (!next) {
+                keys.length = k;
+                return keys;
+              }
+              var nextValue = IteratorValue(next);
+              try {
+                keys[k] = nextValue;
+              } catch (e) {
+                try {
+                  IteratorClose(iterator);
+                } finally {
+                  throw e;
+                }
+              }
+              k++;
+            }
+          }
+          function OrdinaryDeleteMetadata(MetadataKey, O, P) {
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              false
+            );
+            if (IsUndefined(metadataMap)) return false;
+            if (!metadataMap.delete(MetadataKey)) return false;
+            if (metadataMap.size === 0) {
+              var targetMetadata = metadata2.get(O);
+              if (!IsUndefined(targetMetadata)) {
+                targetMetadata.delete(P);
+                if (targetMetadata.size === 0) {
+                  metadata2.delete(targetMetadata);
+                }
+              }
+            }
+            return true;
+          }
+        }
+        __name(CreateMetadataProvider, "CreateMetadataProvider");
+        function CreateFallbackProvider(reflect) {
+          var defineMetadata2 = reflect.defineMetadata, hasOwnMetadata2 = reflect.hasOwnMetadata, getOwnMetadata2 = reflect.getOwnMetadata, getOwnMetadataKeys2 = reflect.getOwnMetadataKeys, deleteMetadata2 = reflect.deleteMetadata;
+          var metadataOwner = new _WeakMap();
+          var provider = {
+            isProviderFor: /* @__PURE__ */ __name(function(O, P) {
+              var metadataPropertySet = metadataOwner.get(O);
+              if (!IsUndefined(metadataPropertySet) && metadataPropertySet.has(P)) {
+                return true;
+              }
+              if (getOwnMetadataKeys2(O, P).length) {
+                if (IsUndefined(metadataPropertySet)) {
+                  metadataPropertySet = new _Set();
+                  metadataOwner.set(O, metadataPropertySet);
+                }
+                metadataPropertySet.add(P);
+                return true;
+              }
+              return false;
+            }, "isProviderFor"),
+            OrdinaryDefineOwnMetadata: defineMetadata2,
+            OrdinaryHasOwnMetadata: hasOwnMetadata2,
+            OrdinaryGetOwnMetadata: getOwnMetadata2,
+            OrdinaryOwnMetadataKeys: getOwnMetadataKeys2,
+            OrdinaryDeleteMetadata: deleteMetadata2
+          };
+          return provider;
+        }
+        __name(CreateFallbackProvider, "CreateFallbackProvider");
+        function GetMetadataProvider(O, P, Create) {
+          var registeredProvider = metadataRegistry.getProvider(O, P);
+          if (!IsUndefined(registeredProvider)) {
+            return registeredProvider;
+          }
+          if (Create) {
+            if (metadataRegistry.setProvider(O, P, metadataProvider)) {
+              return metadataProvider;
+            }
+            throw new Error("Illegal state.");
+          }
+          return void 0;
+        }
+        __name(GetMetadataProvider, "GetMetadataProvider");
+        function CreateMapPolyfill() {
+          var cacheSentinel = {};
+          var arraySentinel = [];
+          var MapIterator = (
+            /** @class */
+            (function() {
+              function MapIterator2(keys, values, selector) {
+                this._index = 0;
+                this._keys = keys;
+                this._values = values;
+                this._selector = selector;
+              }
+              __name(MapIterator2, "MapIterator");
+              MapIterator2.prototype["@@iterator"] = function() {
+                return this;
+              };
+              MapIterator2.prototype[iteratorSymbol] = function() {
+                return this;
+              };
+              MapIterator2.prototype.next = function() {
+                var index = this._index;
+                if (index >= 0 && index < this._keys.length) {
+                  var result = this._selector(this._keys[index], this._values[index]);
+                  if (index + 1 >= this._keys.length) {
+                    this._index = -1;
+                    this._keys = arraySentinel;
+                    this._values = arraySentinel;
+                  } else {
+                    this._index++;
+                  }
+                  return {
+                    value: result,
+                    done: false
+                  };
+                }
+                return {
+                  value: void 0,
+                  done: true
+                };
+              };
+              MapIterator2.prototype.throw = function(error) {
+                if (this._index >= 0) {
+                  this._index = -1;
+                  this._keys = arraySentinel;
+                  this._values = arraySentinel;
+                }
+                throw error;
+              };
+              MapIterator2.prototype.return = function(value) {
+                if (this._index >= 0) {
+                  this._index = -1;
+                  this._keys = arraySentinel;
+                  this._values = arraySentinel;
+                }
+                return {
+                  value,
+                  done: true
+                };
+              };
+              return MapIterator2;
+            })()
+          );
+          var Map1 = (
+            /** @class */
+            (function() {
+              function Map12() {
+                this._keys = [];
+                this._values = [];
+                this._cacheKey = cacheSentinel;
+                this._cacheIndex = -2;
+              }
+              __name(Map12, "Map1");
+              Object.defineProperty(Map12.prototype, "size", {
+                get: /* @__PURE__ */ __name(function() {
+                  return this._keys.length;
+                }, "get"),
+                enumerable: true,
+                configurable: true
+              });
+              Map12.prototype.has = function(key) {
+                return this._find(
+                  key,
+                  /*insert*/
+                  false
+                ) >= 0;
+              };
+              Map12.prototype.get = function(key) {
+                var index = this._find(
+                  key,
+                  /*insert*/
+                  false
+                );
+                return index >= 0 ? this._values[index] : void 0;
+              };
+              Map12.prototype.set = function(key, value) {
+                var index = this._find(
+                  key,
+                  /*insert*/
+                  true
+                );
+                this._values[index] = value;
+                return this;
+              };
+              Map12.prototype.delete = function(key) {
+                var index = this._find(
+                  key,
+                  /*insert*/
+                  false
+                );
+                if (index >= 0) {
+                  var size = this._keys.length;
+                  for (var i = index + 1; i < size; i++) {
+                    this._keys[i - 1] = this._keys[i];
+                    this._values[i - 1] = this._values[i];
+                  }
+                  this._keys.length--;
+                  this._values.length--;
+                  if (SameValueZero(key, this._cacheKey)) {
+                    this._cacheKey = cacheSentinel;
+                    this._cacheIndex = -2;
+                  }
+                  return true;
+                }
+                return false;
+              };
+              Map12.prototype.clear = function() {
+                this._keys.length = 0;
+                this._values.length = 0;
+                this._cacheKey = cacheSentinel;
+                this._cacheIndex = -2;
+              };
+              Map12.prototype.keys = function() {
+                return new MapIterator(this._keys, this._values, getKey);
+              };
+              Map12.prototype.values = function() {
+                return new MapIterator(this._keys, this._values, getValue);
+              };
+              Map12.prototype.entries = function() {
+                return new MapIterator(this._keys, this._values, getEntry);
+              };
+              Map12.prototype["@@iterator"] = function() {
+                return this.entries();
+              };
+              Map12.prototype[iteratorSymbol] = function() {
+                return this.entries();
+              };
+              Map12.prototype._find = function(key, insert) {
+                if (!SameValueZero(this._cacheKey, key)) {
+                  this._cacheIndex = -1;
+                  for (var i = 0; i < this._keys.length; i++) {
+                    if (SameValueZero(this._keys[i], key)) {
+                      this._cacheIndex = i;
+                      break;
+                    }
+                  }
+                }
+                if (this._cacheIndex < 0 && insert) {
+                  this._cacheIndex = this._keys.length;
+                  this._keys.push(key);
+                  this._values.push(void 0);
+                }
+                return this._cacheIndex;
+              };
+              return Map12;
+            })()
+          );
+          return Map1;
+          function getKey(key, _) {
+            return key;
+          }
+          function getValue(_, value) {
+            return value;
+          }
+          function getEntry(key, value) {
+            return [
+              key,
+              value
+            ];
+          }
+        }
+        __name(CreateMapPolyfill, "CreateMapPolyfill");
+        function CreateSetPolyfill() {
+          var Set1 = (
+            /** @class */
+            (function() {
+              function Set12() {
+                this._map = new _Map();
+              }
+              __name(Set12, "Set1");
+              Object.defineProperty(Set12.prototype, "size", {
+                get: /* @__PURE__ */ __name(function() {
+                  return this._map.size;
+                }, "get"),
+                enumerable: true,
+                configurable: true
+              });
+              Set12.prototype.has = function(value) {
+                return this._map.has(value);
+              };
+              Set12.prototype.add = function(value) {
+                return this._map.set(value, value), this;
+              };
+              Set12.prototype.delete = function(value) {
+                return this._map.delete(value);
+              };
+              Set12.prototype.clear = function() {
+                this._map.clear();
+              };
+              Set12.prototype.keys = function() {
+                return this._map.keys();
+              };
+              Set12.prototype.values = function() {
+                return this._map.keys();
+              };
+              Set12.prototype.entries = function() {
+                return this._map.entries();
+              };
+              Set12.prototype["@@iterator"] = function() {
+                return this.keys();
+              };
+              Set12.prototype[iteratorSymbol] = function() {
+                return this.keys();
+              };
+              return Set12;
+            })()
+          );
+          return Set1;
+        }
+        __name(CreateSetPolyfill, "CreateSetPolyfill");
+        function CreateWeakMapPolyfill() {
+          var UUID_SIZE = 16;
+          var keys = HashMap.create();
+          var rootKey = CreateUniqueKey();
+          return (
+            /** @class */
+            (function() {
+              function WeakMap1() {
+                this._key = CreateUniqueKey();
+              }
+              __name(WeakMap1, "WeakMap1");
+              WeakMap1.prototype.has = function(target) {
+                var table = GetOrCreateWeakMapTable(
+                  target,
+                  /*create*/
+                  false
+                );
+                return table !== void 0 ? HashMap.has(table, this._key) : false;
+              };
+              WeakMap1.prototype.get = function(target) {
+                var table = GetOrCreateWeakMapTable(
+                  target,
+                  /*create*/
+                  false
+                );
+                return table !== void 0 ? HashMap.get(table, this._key) : void 0;
+              };
+              WeakMap1.prototype.set = function(target, value) {
+                var table = GetOrCreateWeakMapTable(
+                  target,
+                  /*create*/
+                  true
+                );
+                table[this._key] = value;
+                return this;
+              };
+              WeakMap1.prototype.delete = function(target) {
+                var table = GetOrCreateWeakMapTable(
+                  target,
+                  /*create*/
+                  false
+                );
+                return table !== void 0 ? delete table[this._key] : false;
+              };
+              WeakMap1.prototype.clear = function() {
+                this._key = CreateUniqueKey();
+              };
+              return WeakMap1;
+            })()
+          );
+          function CreateUniqueKey() {
+            var key;
+            do
+              key = "@@WeakMap@@" + CreateUUID();
+            while (HashMap.has(keys, key));
+            keys[key] = true;
+            return key;
+          }
+          function GetOrCreateWeakMapTable(target, create) {
+            if (!hasOwn.call(target, rootKey)) {
+              if (!create) return void 0;
+              Object.defineProperty(target, rootKey, {
+                value: HashMap.create()
+              });
+            }
+            return target[rootKey];
+          }
+          function FillRandomBytes(buffer, size) {
+            for (var i = 0; i < size; ++i) buffer[i] = Math.random() * 255 | 0;
+            return buffer;
+          }
+          function GenRandomBytes(size) {
+            if (typeof Uint8Array === "function") {
+              var array = new Uint8Array(size);
+              if (typeof crypto !== "undefined") {
+                crypto.getRandomValues(array);
+              } else if (typeof msCrypto !== "undefined") {
+                msCrypto.getRandomValues(array);
+              } else {
+                FillRandomBytes(array, size);
+              }
+              return array;
+            }
+            return FillRandomBytes(new Array(size), size);
+          }
+          function CreateUUID() {
+            var data = GenRandomBytes(UUID_SIZE);
+            data[6] = data[6] & 79 | 64;
+            data[8] = data[8] & 191 | 128;
+            var result = "";
+            for (var offset = 0; offset < UUID_SIZE; ++offset) {
+              var byte = data[offset];
+              if (offset === 4 || offset === 6 || offset === 8) result += "-";
+              if (byte < 16) result += "0";
+              result += byte.toString(16).toLowerCase();
+            }
+            return result;
+          }
+        }
+        __name(CreateWeakMapPolyfill, "CreateWeakMapPolyfill");
+        function MakeDictionary(obj) {
+          obj.__ = void 0;
+          delete obj.__;
+          return obj;
+        }
+        __name(MakeDictionary, "MakeDictionary");
+      });
+    })(Reflect2 || (Reflect2 = {}));
+  }
+});
+
+// src/decorators/decorators.utils.ts
+__toESM(require_Reflect());
+var ROUTES_KEY = Symbol("routes");
+var MIDDLEWARE_KEY = Symbol("middlewares");
+var PARAMS_KEY = Symbol("params");
+var HTTP_CODE_KEY = Symbol("httpCode");
+var HEADER_KEY = Symbol("headers");
+var BEFORE_KEY = Symbol("before");
+var AFTER_KEY = Symbol("after");
+var ROLES_KEY = Symbol("roles");
+var REDIRECT_KEY = Symbol("redirect");
+var CACHE_KEY = Symbol("cache");
+var RATE_LIMIT_KEY = Symbol("rateLimit");
+var CONTENT_TYPE_KEY = Symbol("contentType");
+var VERSION_KEY = Symbol("version");
+var TIMEOUT_KEY = Symbol("timeout");
+var LOG_KEY = Symbol("log");
+var RateLimiterCache = class RateLimiterCache2 {
+  static {
+    __name(this, "RateLimiterCache");
+  }
+  rateLimit;
+  cache;
+  constructor(maxSize = 100, ttlMs = 5 * 60 * 1e3) {
+    this.cache = new TTLCache({
+      maxSize,
+      ttlMs
+    });
+    const rateLimitModule = optionalRequire("express-rate-limit");
+    if (rateLimitModule) this.rateLimit = rateLimitModule.rateLimit;
+  }
+  generateKey(options) {
+    return `${options.max}:${options.windowMs}:${options.standardHeaders}:${options.legacyHeaders}`;
+  }
+  get(options) {
+    const key = this.generateKey(options);
+    const cached = this.cache.get(key);
+    if (cached) {
+      return cached.limiter;
+    }
+    if (!this.rateLimit) {
+      throw new Error(DependencyErrors["express-rate-limit"]);
+    }
+    const limiter = this.rateLimit({
+      ...options,
+      handler: /* @__PURE__ */ __name((req, res) => {
+        const errorResponse = createFinalErrorResponse(req, HttpStatusCodes.TOO_MANY_REQUESTS, "Too Many Requests");
+        res.status(HttpStatusCodes.TOO_MANY_REQUESTS).json(errorResponse);
+      }, "handler")
+    });
+    this.cache.set(key, {
+      limiter,
+      config: key
+    });
+    return limiter;
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size();
+  }
+  destroy() {
+    this.cache.destroy();
+  }
+};
+var rateLimiterCache = new RateLimiterCache();
+var DIContainer = class {
+  static {
+    __name(this, "DIContainer");
+  }
+  instances = /* @__PURE__ */ new Map();
+  constructing = /* @__PURE__ */ new Map();
+  propertyInjections = /* @__PURE__ */ new Map();
+  register(target) {
+    if (!this.instances.has(target) && !this.constructing.has(target)) ;
+  }
+  /**
+  * Register a property injection to be resolved when the target class is instantiated
+  */
+  registerPropertyInjection(target, propertyKey, injectClass) {
+    const targetClass = target.constructor;
+    if (!this.propertyInjections.has(targetClass)) {
+      this.propertyInjections.set(targetClass, []);
+    }
+    this.propertyInjections.get(targetClass).push({
+      targetClass: injectClass,
+      propertyKey
+    });
+  }
+  get(target) {
+    if (this.instances.has(target)) {
+      return this.instances.get(target);
+    }
+    if (this.constructing.has(target)) {
+      return this.constructing.get(target);
+    }
+    let proxy = {};
+    this.constructing.set(target, proxy);
+    const paramTypes = Reflect.getMetadata("design:paramtypes", target) || [];
+    const dependencies = paramTypes.map((dep) => this.get(dep));
+    const instance = new target(...dependencies);
+    this.applyPropertyInjections(target, instance);
+    Object.assign(proxy, instance);
+    this.instances.set(target, proxy);
+    this.constructing.delete(target);
+    Object.setPrototypeOf(proxy, target.prototype);
+    return proxy;
+  }
+  applyPropertyInjections(targetClass, instance) {
+    const injections = this.propertyInjections.get(targetClass) || [];
+    for (const injection of injections) {
+      const dependency = this.get(injection.targetClass);
+      instance[injection.propertyKey] = dependency;
+    }
+  }
+  clear() {
+    this.instances.clear();
+    this.constructing.clear();
+    this.propertyInjections.clear();
+  }
+};
+var diContainer = new DIContainer();
+function normalizeHeaderValue(value) {
+  if (typeof value === "undefined") return void 0;
+  if (typeof value === "string") return value;
+  if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+    return value;
+  }
+  return String(value);
+}
+__name(normalizeHeaderValue, "normalizeHeaderValue");
+function Injectable() {
+  return (target) => {
+    Reflect.defineMetadata("injectable", true, target);
+    diContainer.register(target);
+  };
+}
+__name(Injectable, "Injectable");
+function Inject(targetClass) {
+  return (target, propertyKey) => {
+    diContainer.registerPropertyInjection(target, propertyKey, targetClass);
+    Object.defineProperty(target, propertyKey, {
+      configurable: true,
+      get: /* @__PURE__ */ __name(function() {
+        const value = Object.getOwnPropertyDescriptor(this, propertyKey)?.value;
+        if (value !== void 0) return value;
+        const injectedValue = diContainer.get(targetClass);
+        Object.defineProperty(this, propertyKey, {
+          value: injectedValue,
+          writable: true,
+          configurable: true
+        });
+        return injectedValue;
+      }, "get"),
+      set: /* @__PURE__ */ __name(function(value) {
+        Object.defineProperty(this, propertyKey, {
+          value,
+          writable: true,
+          configurable: true
+        });
+      }, "set")
+    });
+  };
+}
+__name(Inject, "Inject");
+function inject(targetClass) {
+  return diContainer.get(targetClass);
+}
+__name(inject, "inject");
+function createRouteDecorator(method) {
+  return (path) => {
+    return (target, propertyKey, _descriptor) => {
+      const routes = Reflect.getMetadata(ROUTES_KEY, target.constructor) || [];
+      routes.push({
+        path,
+        method,
+        handlerName: propertyKey
+      });
+      Reflect.defineMetadata(ROUTES_KEY, routes, target.constructor);
+    };
+  };
+}
+__name(createRouteDecorator, "createRouteDecorator");
+var Get = createRouteDecorator("get");
+var Post = createRouteDecorator("post");
+var Put = createRouteDecorator("put");
+var Patch = createRouteDecorator("patch");
+var Delete = createRouteDecorator("delete");
+var Options = createRouteDecorator("options");
+var Head = createRouteDecorator("head");
+var Trace = createRouteDecorator("trace");
+var Connect = createRouteDecorator("connect");
+function Controller(basePath) {
+  return (target) => {
+    Reflect.defineMetadata("basePath", basePath, target);
+  };
+}
+__name(Controller, "Controller");
+function Use(...middlewares) {
+  return (target, propertyKey, _descriptor) => {
+    if (propertyKey === void 0) {
+      const existing = Reflect.getMetadata(MIDDLEWARE_KEY, target) || [];
+      Reflect.defineMetadata(MIDDLEWARE_KEY, [
+        ...existing,
+        ...middlewares
+      ], target);
+    } else {
+      const existing = Reflect.getMetadata(MIDDLEWARE_KEY, target, propertyKey) || [];
+      Reflect.defineMetadata(MIDDLEWARE_KEY, [
+        ...existing,
+        ...middlewares
+      ], target, propertyKey);
+    }
+  };
+}
+__name(Use, "Use");
+function defineParamMetadata(target, propertyKey, parameterIndex, type, key) {
+  const params = Reflect.getMetadata(PARAMS_KEY, target, propertyKey) || [];
+  params.push({
+    index: parameterIndex,
+    type,
+    key
+  });
+  params.sort((a, b) => a.index - b.index);
+  Reflect.defineMetadata(PARAMS_KEY, params, target, propertyKey);
+}
+__name(defineParamMetadata, "defineParamMetadata");
+function createParamDecorator(type, key) {
+  return (paramKey) => {
+    return (target, propertyKey, parameterIndex) => {
+      defineParamMetadata(target, propertyKey, parameterIndex, type, paramKey ?? key);
+    };
+  };
+}
+__name(createParamDecorator, "createParamDecorator");
+function createParamDecoratorWithoutParam(type) {
+  return () => {
+    return (target, propertyKey, parameterIndex) => {
+      defineParamMetadata(target, propertyKey, parameterIndex, type, void 0);
+    };
+  };
+}
+__name(createParamDecoratorWithoutParam, "createParamDecoratorWithoutParam");
+function createApiUrlParamDecorator(type, key) {
+  return (paramKey, options) => {
+    return (target, propertyKey, parameterIndex) => {
+      const params = Reflect.getMetadata(PARAMS_KEY, target, propertyKey) || [];
+      let paramOptions = void 0;
+      if (typeof options === "object") {
+        paramOptions = {};
+        paramOptions.type = "string";
+        paramOptions.dataType = "single";
+        paramOptions.delimiter = ",";
+        paramOptions.required = false;
+        paramOptions.throwError = true;
+        paramOptions = {
+          ...paramOptions,
+          ...options
+        };
+      }
+      params.push({
+        index: parameterIndex,
+        type,
+        key: paramKey || key,
+        options: paramOptions
+      });
+      params.sort((a, b) => a.index - b.index);
+      Reflect.defineMetadata(PARAMS_KEY, params, target, propertyKey);
+    };
+  };
+}
+__name(createApiUrlParamDecorator, "createApiUrlParamDecorator");
+var Query = createApiUrlParamDecorator("query");
+var Param = createApiUrlParamDecorator("param");
+var Body = createParamDecorator("body");
+var ReqLogger = createParamDecoratorWithoutParam("logger");
+var ReqId = createParamDecoratorWithoutParam("reqId");
+var ReqHeader = createParamDecorator("reqHeader");
+var ReqCookie = createParamDecorator("cookie");
+var Req = createParamDecoratorWithoutParam("req");
+var Res = createParamDecoratorWithoutParam("res");
+function HttpCode(status) {
+  return (target, propertyKey, _descriptor) => {
+    Reflect.defineMetadata(HTTP_CODE_KEY, status, target, propertyKey);
+  };
+}
+__name(HttpCode, "HttpCode");
+function Header(name, value) {
+  return Headers(name, value);
+}
+__name(Header, "Header");
+function Headers(headers, value) {
+  return (target, propertyKey) => {
+    if (propertyKey === void 0) {
+      const existing = Reflect.getMetadata(HEADER_KEY, target) || {};
+      const newHeaders = typeof headers === "string" ? {
+        [headers]: value
+      } : headers;
+      Reflect.defineMetadata(HEADER_KEY, {
+        ...existing,
+        ...newHeaders
+      }, target);
+    } else {
+      const existing = Reflect.getMetadata(HEADER_KEY, target, propertyKey) || {};
+      const newHeaders = typeof headers === "string" ? {
+        [headers]: value
+      } : headers;
+      Reflect.defineMetadata(HEADER_KEY, {
+        ...existing,
+        ...newHeaders
+      }, target, propertyKey);
+    }
+  };
+}
+__name(Headers, "Headers");
+function Before(fn) {
+  return (target, propertyKey, _descriptor) => {
+    if (propertyKey === void 0) {
+      const hooks = Reflect.getMetadata(BEFORE_KEY, target) || [];
+      hooks.push(fn);
+      Reflect.defineMetadata(BEFORE_KEY, hooks, target);
+    } else {
+      const hooks = Reflect.getMetadata(BEFORE_KEY, target, propertyKey) || [];
+      hooks.push(fn);
+      Reflect.defineMetadata(BEFORE_KEY, hooks, target, propertyKey);
+    }
+  };
+}
+__name(Before, "Before");
+function After(fn) {
+  return (target, propertyKey, _descriptor) => {
+    if (propertyKey === void 0) {
+      const hooks = Reflect.getMetadata(AFTER_KEY, target) || [];
+      hooks.push(fn);
+      Reflect.defineMetadata(AFTER_KEY, hooks, target);
+    } else {
+      const hooks = Reflect.getMetadata(AFTER_KEY, target, propertyKey) || [];
+      hooks.push(fn);
+      Reflect.defineMetadata(AFTER_KEY, hooks, target, propertyKey);
+    }
+  };
+}
+__name(After, "After");
+function Roles(...roles) {
+  return (target, propertyKey, _descriptor) => {
+    if (propertyKey === void 0) {
+      Reflect.defineMetadata(ROLES_KEY, roles, target);
+    } else {
+      Reflect.defineMetadata(ROLES_KEY, roles, target, propertyKey);
+    }
+  };
+}
+__name(Roles, "Roles");
+function Redirect(url, statusCode = 302) {
+  return (target, propertyKey, descriptor) => {
+    Reflect.defineMetadata(REDIRECT_KEY, {
+      url,
+      statusCode
+    }, target, propertyKey);
+    return descriptor;
+  };
+}
+__name(Redirect, "Redirect");
+function Cache(ttlSeconds) {
+  return (target, propertyKey, _descriptor) => {
+    if (propertyKey === void 0) {
+      Reflect.defineMetadata(CACHE_KEY, {
+        ttlSeconds
+      }, target);
+    } else {
+      Reflect.defineMetadata(CACHE_KEY, {
+        ttlSeconds
+      }, target, propertyKey);
+    }
+  };
+}
+__name(Cache, "Cache");
+function RateLimit(options) {
+  const opts = {
+    standardHeaders: true,
+    legacyHeaders: false,
+    ...options
+  };
+  return (target, propertyKey, _descriptor) => {
+    if (propertyKey === void 0) {
+      Reflect.defineMetadata(RATE_LIMIT_KEY, opts, target);
+    } else {
+      Reflect.defineMetadata(RATE_LIMIT_KEY, opts, target, propertyKey);
+    }
+  };
+}
+__name(RateLimit, "RateLimit");
+function ContentType(type) {
+  return (target, propertyKey, _descriptor) => {
+    if (propertyKey === void 0) {
+      Reflect.defineMetadata(CONTENT_TYPE_KEY, {
+        type
+      }, target);
+    } else {
+      Reflect.defineMetadata(CONTENT_TYPE_KEY, {
+        type
+      }, target, propertyKey);
+    }
+  };
+}
+__name(ContentType, "ContentType");
+function Version(version, options) {
+  const opts = {
+    addPrefix: true,
+    addHeader: true,
+    headerName: "X-API-Version",
+    ...options
+  };
+  return (target, propertyKey, _descriptor) => {
+    if (propertyKey === void 0) {
+      Reflect.defineMetadata(VERSION_KEY, {
+        version,
+        options: opts
+      }, target);
+    } else {
+      Reflect.defineMetadata(VERSION_KEY, {
+        version,
+        options: opts
+      }, target, propertyKey);
+    }
+  };
+}
+__name(Version, "Version");
+function Timeout(ms) {
+  return (target, propertyKey, _descriptor) => {
+    if (propertyKey === void 0) {
+      Reflect.defineMetadata(TIMEOUT_KEY, {
+        ms
+      }, target);
+    } else {
+      Reflect.defineMetadata(TIMEOUT_KEY, {
+        ms
+      }, target, propertyKey);
+    }
+  };
+}
+__name(Timeout, "Timeout");
+function Log(options) {
+  return (target, propertyKey, _descriptor) => {
+    const config = {
+      logEntry: true,
+      logExit: true,
+      logBody: false,
+      logParams: false,
+      logResponse: false,
+      ...options
+    };
+    if (propertyKey === void 0) {
+      Reflect.defineMetadata(LOG_KEY, config, target);
+    } else {
+      Reflect.defineMetadata(LOG_KEY, config, target, propertyKey);
+    }
+  };
+}
+__name(Log, "Log");
+function registerControllers(router, controllers) {
+  controllers.forEach((ControllerClass) => {
+    if (!Reflect.getMetadata("injectable", ControllerClass)) {
+      Reflect.defineMetadata("injectable", true, ControllerClass);
+      diContainer.register(ControllerClass);
+    }
+    const instance = diContainer.get(ControllerClass);
+    let basePath = Reflect.getMetadata("basePath", ControllerClass) || "";
+    const routes = Reflect.getMetadata(ROUTES_KEY, ControllerClass) || [];
+    const controllerRateLimit = Reflect.getMetadata(RATE_LIMIT_KEY, ControllerClass);
+    const controllerCache = Reflect.getMetadata(CACHE_KEY, ControllerClass);
+    const controllerTimeout = Reflect.getMetadata(TIMEOUT_KEY, ControllerClass);
+    const controllerVersion = Reflect.getMetadata(VERSION_KEY, ControllerClass);
+    const controllerRoles = Reflect.getMetadata(ROLES_KEY, ControllerClass);
+    const controllerLogConfig = Reflect.getMetadata(LOG_KEY, ControllerClass);
+    const controllerHeaders = Reflect.getMetadata(HEADER_KEY, ControllerClass) || {};
+    const controllerMiddlewares = Reflect.getMetadata(MIDDLEWARE_KEY, ControllerClass) || [];
+    const controllerBeforeHooks = Reflect.getMetadata(BEFORE_KEY, ControllerClass) || [];
+    const controllerAfterHooks = Reflect.getMetadata(AFTER_KEY, ControllerClass) || [];
+    const controllerContentType = Reflect.getMetadata(CONTENT_TYPE_KEY, ControllerClass);
+    if (controllerVersion?.options?.addPrefix) {
+      basePath = `/${controllerVersion.version}${basePath || ""}`;
+    }
+    routes.forEach(({ path, method, handlerName }) => {
+      const methodMiddlewares = Reflect.getMetadata(MIDDLEWARE_KEY, instance, handlerName) || [];
+      const params = Reflect.getMetadata(PARAMS_KEY, instance, handlerName) || [];
+      const httpCode = Reflect.getMetadata(HTTP_CODE_KEY, instance, handlerName);
+      const methodHeaders = Reflect.getMetadata(HEADER_KEY, instance, handlerName) || {};
+      const headers = {
+        ...controllerHeaders,
+        ...methodHeaders
+      };
+      const middlewares = [
+        ...controllerMiddlewares,
+        ...methodMiddlewares
+      ];
+      const methodBeforeHooks = Reflect.getMetadata(BEFORE_KEY, instance, handlerName) || [];
+      const methodAfterHooks = Reflect.getMetadata(AFTER_KEY, instance, handlerName) || [];
+      const beforeHooks = [
+        ...controllerBeforeHooks,
+        ...methodBeforeHooks
+      ];
+      const afterHooks = [
+        ...methodAfterHooks,
+        ...controllerAfterHooks
+      ];
+      const redirect = Reflect.getMetadata(REDIRECT_KEY, instance, handlerName);
+      const methodContentType = Reflect.getMetadata(CONTENT_TYPE_KEY, instance, handlerName);
+      const contentType = methodContentType || controllerContentType;
+      const roles = Reflect.getMetadata(ROLES_KEY, instance, handlerName) || controllerRoles || [];
+      const cache = Reflect.getMetadata(CACHE_KEY, instance, handlerName) || controllerCache;
+      const rateLimitOptions = Reflect.getMetadata(RATE_LIMIT_KEY, instance, handlerName) || controllerRateLimit;
+      const methodVersion = Reflect.getMetadata(VERSION_KEY, instance, handlerName);
+      const version = methodVersion || controllerVersion;
+      const timeout = Reflect.getMetadata(TIMEOUT_KEY, instance, handlerName) || controllerTimeout;
+      const logConfig = Reflect.getMetadata(LOG_KEY, instance, handlerName) || controllerLogConfig;
+      let rateLimiter = null;
+      if (rateLimitOptions) {
+        try {
+          rateLimiter = rateLimiterCache.get(rateLimitOptions);
+        } catch (err) {
+          getLogger().warn({
+            err
+          }, "express-rate-limit not available, skipping rate limiting for this route");
+        }
+      }
+      let finalPath = path;
+      if (methodVersion?.options?.addPrefix && methodVersion.version !== controllerVersion?.version) {
+        finalPath = `/${methodVersion.version}${path}`;
+      }
+      const handler = /* @__PURE__ */ __name(async (req, res, next) => {
+        req["startTime"] = Date.now();
+        let timeoutId;
+        let timedOut = false;
+        try {
+          if (timeout) {
+            timeoutId = setTimeout(() => {
+              if (!res.headersSent && !timedOut) {
+                timedOut = true;
+                const errorResponse = createFinalErrorResponse(req, HttpStatusCodes.REQUEST_TIMEOUT, "Request timed out");
+                res.status(HttpStatusCodes.REQUEST_TIMEOUT).json(errorResponse);
+              }
+            }, timeout.ms);
+          }
+          if (timedOut) return;
+          if (rateLimiter) {
+            await new Promise((resolve, reject) => {
+              rateLimiter(req, res, (err) => {
+                if (err) reject(err);
+                else resolve();
+              });
+            });
+          }
+          if (!res.headersSent && contentType) {
+            res.setHeader("Content-Type", contentType.type);
+          }
+          if (version?.options?.addHeader && version?.options?.headerName && version?.version) {
+            if (!res.headersSent) {
+              res.setHeader(version.options.headerName, version.version);
+            }
+          }
+          if (cache && !res.headersSent) {
+            res.setHeader("Cache-Control", `public, max-age=${cache.ttlSeconds}`);
+          }
+          if (logConfig?.logEntry) {
+            const logger = getLogger();
+            const logData = {
+              method: req.method,
+              url: req.originalUrl || req.url,
+              userAgent: req.get("User-Agent")
+            };
+            if (logConfig.logParams) {
+              logData.params = req.params;
+              logData.query = req.query;
+            }
+            if (logConfig.logBody) logData.body = req.body;
+            logger.info({
+              entry: logData
+            }, "Route Entry:");
+          }
+          if (roles.length && !req?.user?.roles?.some((role) => roles.includes(role))) {
+            const errorResponse = createFinalErrorResponse(req, HttpStatusCodes.FORBIDDEN, "Forbidden Insufficient Roles");
+            res.status(HttpStatusCodes.FORBIDDEN).json(errorResponse);
+            if (timeoutId) {
+              clearTimeout(timeoutId);
+            }
+            return;
+          }
+          if (redirect?.url) {
+            if (timeoutId) {
+              clearTimeout(timeoutId);
+            }
+            return res.redirect(redirect.statusCode, redirect.url);
+          }
+          for (const fn of beforeHooks) await fn(req, res);
+          const args = [];
+          if (params.length) {
+            params.forEach(({ index, type, key, options }) => {
+              let rawValue;
+              switch (type) {
+                case "query":
+                  rawValue = key ? req.query[key] : req.query;
+                  args[index] = options ? applyParamOptions(rawValue, options, key) : rawValue;
+                  break;
+                case "param":
+                  rawValue = key ? req.params[key] : req.params;
+                  args[index] = options ? applyParamOptions(rawValue, options, key) : rawValue;
+                  break;
+                case "body":
+                  args[index] = key ? req.body?.[key] : req.body;
+                  break;
+                case "req":
+                  args[index] = req;
+                  break;
+                case "res":
+                  args[index] = res;
+                  break;
+                case "logger":
+                  args[index] = getLogger();
+                  break;
+                case "reqHeader":
+                  args[index] = key ? req.headers[key.toLowerCase()] : req.headers;
+                  break;
+                case "reqId":
+                  args[index] = req.headers["x-request-id"] || req?.id || void 0;
+                  break;
+                case "cookie":
+                  args[index] = key ? req.cookies?.[key] : req.cookies;
+                  break;
+              }
+            });
+          }
+          const result = instance[handlerName](...args);
+          const awaited = result instanceof Promise ? await result : result;
+          if (timeoutId) {
+            clearTimeout(timeoutId);
+          }
+          if (timedOut) return;
+          if (redirect && awaited && typeof awaited === "object" && "url" in awaited) {
+            const redirectUrl = awaited.url;
+            const redirectStatus = awaited.statusCode || redirect.statusCode;
+            return res.redirect(redirectStatus, redirectUrl);
+          }
+          if (!res.headersSent && typeof awaited !== "undefined") {
+            if (httpCode) res.status(httpCode);
+            for (const [k, v] of Object.entries(headers)) {
+              const normalized = normalizeHeaderValue(v);
+              if (typeof normalized !== "undefined") {
+                res.set(k, normalized);
+              }
+            }
+            res.json(awaited);
+          }
+          if (logConfig?.logExit) {
+            const logger = getLogger();
+            const logData = {
+              method: req.method,
+              url: req.originalUrl || req.url,
+              statusCode: res.statusCode,
+              duration: `${Date.now() - req.startTime}ms`
+            };
+            if (logConfig.logResponse) logData.response = awaited;
+            logger.info({
+              exit: logData
+            }, "Route Exit:");
+          }
+          for (const fn of afterHooks) await fn(req, res, awaited);
+        } catch (err) {
+          if (timeoutId) {
+            clearTimeout(timeoutId);
+          }
+          next(err);
+        }
+      }, "handler");
+      router[method](basePath + finalPath, ...middlewares, handler);
+    });
+  });
+}
+__name(registerControllers, "registerControllers");
+function applyParamOptions(rawValue, options, key) {
+  if (!options) return rawValue;
+  let value = rawValue;
+  const paramName = key ? `: ${key}` : "";
+  if (value === void 0 || value === null || value === "") {
+    if ("default" in options) {
+      value = options.default;
+    }
+  }
+  if (options.required && (value === void 0 || value === null || value === "")) {
+    throw new BadRequestException(`Required parameter missing${paramName}`);
+  }
+  if (value !== void 0 && value !== null) {
+    if (options.dataType === "array") {
+      const delimiter = options.delimiter || ",";
+      if (typeof value === "string") {
+        value = value.split(delimiter).map((v) => v.trim());
+      } else if (!Array.isArray(value)) {
+        value = [
+          value
+        ];
+      }
+      if (options.type === "string" && options.pattern) {
+        const hasInvalidPattern = value.some((v) => !options.pattern.test(v));
+        if (hasInvalidPattern) {
+          throw new BadRequestException(`Parameter '${key}' array contains values that do not match pattern: ${options.patternName || options.pattern}`);
+        }
+      }
+      if (options.type === "number" && options.pattern) {
+        const hasInvalidPattern = value.some((v) => !options.pattern.test(String(v)));
+        if (hasInvalidPattern) {
+          throw new BadRequestException(`Parameter '${key}' array contains values that do not match pattern: ${options.patternName || options.pattern}`);
+        }
+      }
+      if (options.type === "number" && options.throwError !== false) {
+        const hasInvalidNumber = value.some((v) => Number.isNaN(Number(v)));
+        if (hasInvalidNumber) {
+          throw new BadRequestException(`Type error: expected number array${paramName}`);
+        }
+        if (options.min !== void 0) {
+          const hasBelowMin = value.some((v) => Number(v) < options.min);
+          if (hasBelowMin) {
+            throw new BadRequestException(`Validation error: number array values must be >= ${options.min}${paramName}`);
+          }
+        }
+        if (options.max !== void 0) {
+          const hasAboveMax = value.some((v) => Number(v) > options.max);
+          if (hasAboveMax) {
+            throw new BadRequestException(`Validation error: number array values must be <= ${options.max}${paramName}`);
+          }
+        }
+      }
+      if (options.type === "boolean" && options.throwError !== false) {
+        const hasInvalidBoolean = value.some((v) => !isValidBooleanInput(v));
+        if (hasInvalidBoolean) {
+          throw new BadRequestException(`Type error: expected boolean array${paramName}`);
+        }
+      }
+      if (options.type) {
+        value = value.map((v) => convertType(v, options.type || "string"));
+      }
+    } else if (options.dataType === "object") {
+      if (typeof value === "string") {
+        try {
+          value = JSON.parse(value);
+        } catch (_e) {
+          if (options.throwError !== false) {
+            throw new BadRequestException(`Invalid JSON object${paramName}`);
+          }
+        }
+      }
+    } else if (options.type) {
+      const originalValue = value;
+      value = convertType(value, options.type);
+      if (options.throwError === false) {
+        if (options.type === "number" && typeof value === "number") {
+          if (options.min !== void 0 && value < options.min) {
+            value = void 0;
+          }
+          if (options.max !== void 0 && value > options.max) {
+            value = void 0;
+          }
+        }
+      }
+      const paramNotMatchMsg = `Parameter '${key}' does not match pattern: ${options.patternName || options.pattern}`;
+      if (options.type === "string" && options.pattern && typeof value === "string" && !options.pattern.test(value)) {
+        throw new BadRequestException(paramNotMatchMsg);
+      } else if (options.type === "number" && options.pattern && typeof value === "number" && !options.pattern.test(String(value))) {
+        throw new BadRequestException(paramNotMatchMsg);
+      }
+      if (options.throwError !== false) {
+        if (options.type === "number" && typeof value === "number" && Number.isNaN(value)) {
+          throw new BadRequestException(`Type error: expected number${paramName}`);
+        }
+        if (options.type === "number" && typeof value === "number") {
+          if (options.min !== void 0 && value < options.min) {
+            throw new BadRequestException(`Validation error: number must be >= ${options.min}${paramName}`);
+          }
+          if (options.max !== void 0 && value > options.max) {
+            throw new BadRequestException(`Validation error: number must be <= ${options.max}${paramName}`);
+          }
+        }
+        if (options.type === "boolean" && !isValidBooleanInput(originalValue)) {
+          throw new BadRequestException(`Type error: expected boolean${paramName}`);
+        }
+      }
+    }
+  }
+  if (options.transform && typeof options.transform === "function") {
+    value = options.transform(value);
+  }
+  if (options.validate && typeof options.validate === "function") {
+    if (!options.validate(value)) {
+      if (options.throwError !== false) {
+        throw new BadRequestException(`Parameter validation failed${paramName}`);
+      }
+      return void 0;
+    }
+  }
+  return value;
+}
+__name(applyParamOptions, "applyParamOptions");
+function isValidBooleanInput(value) {
+  if (typeof value === "boolean") return true;
+  if (typeof value === "number") return value === 0 || value === 1;
+  if (typeof value === "string") {
+    const normalizedValue = value.toLowerCase().trim();
+    return [
+      "true",
+      "false",
+      "0",
+      "1",
+      "yes",
+      "no"
+    ].includes(normalizedValue);
+  }
+  return false;
+}
+__name(isValidBooleanInput, "isValidBooleanInput");
+function convertType(value, type) {
+  if (value === void 0 || value === null) {
+    return value;
+  }
+  switch (type) {
+    case "number":
+      return Number(value);
+    case "boolean":
+      if (typeof value === "string") {
+        const normalizedValue = value.toLowerCase().trim();
+        return normalizedValue === "true" || normalizedValue === "1" || normalizedValue === "yes";
+      }
+      return value === true || value === 1;
+    case "string":
+    default:
+      return String(value);
+  }
+}
+__name(convertType, "convertType");
+/*! Bundled license information:
+
+reflect-metadata/Reflect.js:
+  (*! *****************************************************************************
+  Copyright (C) Microsoft. All rights reserved.
+  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of the
+  License at http://www.apache.org/licenses/LICENSE-2.0
+  
+  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+  MERCHANTABLITY OR NON-INFRINGEMENT.
+  
+  See the Apache Version 2.0 License for specific language governing permissions
+  and limitations under the License.
+  ***************************************************************************** *)
+*/
+
+export { After, Before, Body, Cache, Connect, ContentType, Controller, DIContainer, Delete, Get, Head, Header, Headers, HttpCode, Inject, Injectable, Log, Options, Param, Patch, Post, Put, Query, RateLimit, Redirect, Req, ReqCookie, ReqHeader, ReqId, ReqLogger, Res, Roles, Timeout, Trace, Use, Version, createParamDecorator, createParamDecoratorWithoutParam, inject, registerControllers };