@dangao/bun-server 1.7.1 → 1.8.0

package/dist/index.js

@@ -3,6 +3,7 @@ var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __toESM = (mod, isNodeMode, target) => {
   target = mod != null ? __create(__getProtoOf(mod)) : {};
@@ -15,6 +16,20 @@ var __toESM = (mod, isNodeMode, target) => {
       });
   return to;
 };
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -136,10 +151,19 @@ function getTypeReference(constructor, parameterIndex) {
   }
   return;
 }
-var DEPENDENCY_METADATA_KEY, INJECTABLE_METADATA_KEY, typeReferenceMap;
+function Global() {
+  return (target) => {
+    Reflect.defineMetadata(GLOBAL_MODULE_METADATA_KEY, true, target);
+  };
+}
+function isGlobalModule(target) {
+  return Reflect.getMetadata(GLOBAL_MODULE_METADATA_KEY, target) === true;
+}
+var DEPENDENCY_METADATA_KEY, INJECTABLE_METADATA_KEY, GLOBAL_MODULE_METADATA_KEY, typeReferenceMap;
 var init_decorators = __esm(() => {
   DEPENDENCY_METADATA_KEY = Symbol("dependency:metadata");
   INJECTABLE_METADATA_KEY = Symbol("injectable");
+  GLOBAL_MODULE_METADATA_KEY = Symbol("@dangao/bun-server:global-module");
   typeReferenceMap = new WeakMap;
 });
 
@@ -1437,6 +1461,31 @@ var init_errors = __esm(() => {
       this.name = "ValidationError";
       this.issues = issues;
     }
+    getFlattened() {
+      const flatten = (issues, prefix = "") => {
+        const result = [];
+        for (const issue of issues) {
+          const propertyPath = prefix ? `${prefix}.${issue.property ?? ""}` : issue.property ?? "";
+          if (issue.children && issue.children.length > 0) {
+            result.push(...flatten(issue.children, propertyPath));
+          } else {
+            result.push({
+              ...issue,
+              property: propertyPath || undefined
+            });
+          }
+        }
+        return result;
+      };
+      return flatten(this.issues);
+    }
+    toJSON() {
+      return {
+        name: this.name,
+        message: this.message,
+        issues: this.issues
+      };
+    }
   };
 });
 
@@ -1488,11 +1537,614 @@ var init_validator = __esm(() => {
   init_errors();
 });
 
+// src/validation/rules/object.ts
+function IsObject(options = {}) {
+  return {
+    name: "isObject",
+    message: options.message ?? "\u5FC5\u987B\u662F\u5BF9\u8C61",
+    validate: (value) => typeof value === "object" && value !== null && !Array.isArray(value)
+  };
+}
+function IsNotEmpty(options = {}) {
+  return {
+    name: "isNotEmpty",
+    message: options.message ?? "\u4E0D\u80FD\u4E3A\u7A7A",
+    validate: (value) => {
+      if (value === null || value === undefined) {
+        return false;
+      }
+      if (typeof value === "string") {
+        return value.trim().length > 0;
+      }
+      if (Array.isArray(value)) {
+        return value.length > 0;
+      }
+      if (typeof value === "object") {
+        return Object.keys(value).length > 0;
+      }
+      return true;
+    }
+  };
+}
+function IsNotEmptyObject(options = {}) {
+  return {
+    name: "isNotEmptyObject",
+    message: options.message ?? "\u5FC5\u987B\u662F\u975E\u7A7A\u5BF9\u8C61",
+    validate: (value) => {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+      }
+      return Object.keys(value).length > 0;
+    }
+  };
+}
+function ValidateNested(options = {}) {
+  return {
+    name: "validateNested",
+    message: options.message ?? "\u5D4C\u5957\u5BF9\u8C61\u9A8C\u8BC1\u5931\u8D25",
+    nested: true,
+    each: options.each ?? false,
+    validate: (value) => {
+      if (options.each) {
+        return Array.isArray(value);
+      }
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
+  };
+}
+
+// src/validation/rules/array.ts
+function IsArray(options = {}) {
+  return {
+    name: "isArray",
+    message: options.message ?? "\u5FC5\u987B\u662F\u6570\u7EC4",
+    validate: (value) => Array.isArray(value)
+  };
+}
+function ArrayMinSize(min, options = {}) {
+  return {
+    name: "arrayMinSize",
+    message: options.message ?? `\u6570\u7EC4\u957F\u5EA6\u4E0D\u80FD\u5C0F\u4E8E ${min}`,
+    validate: (value) => Array.isArray(value) && value.length >= min
+  };
+}
+function ArrayMaxSize(max, options = {}) {
+  return {
+    name: "arrayMaxSize",
+    message: options.message ?? `\u6570\u7EC4\u957F\u5EA6\u4E0D\u80FD\u5927\u4E8E ${max}`,
+    validate: (value) => Array.isArray(value) && value.length <= max
+  };
+}
+function ArrayUnique(options = {}) {
+  return {
+    name: "arrayUnique",
+    message: options.message ?? "\u6570\u7EC4\u5143\u7D20\u5FC5\u987B\u552F\u4E00",
+    validate: (value) => {
+      if (!Array.isArray(value)) {
+        return false;
+      }
+      const seen = new Set;
+      for (const item of value) {
+        const key = typeof item === "object" ? JSON.stringify(item) : item;
+        if (seen.has(key)) {
+          return false;
+        }
+        seen.add(key);
+      }
+      return true;
+    }
+  };
+}
+function ArrayContains(values, options = {}) {
+  return {
+    name: "arrayContains",
+    message: options.message ?? `\u6570\u7EC4\u5FC5\u987B\u5305\u542B ${values.join(", ")}`,
+    validate: (value) => {
+      if (!Array.isArray(value)) {
+        return false;
+      }
+      return values.every((v) => {
+        if (typeof v === "object") {
+          const vStr = JSON.stringify(v);
+          return value.some((item) => JSON.stringify(item) === vStr);
+        }
+        return value.includes(v);
+      });
+    }
+  };
+}
+function ArrayNotContains(values, options = {}) {
+  return {
+    name: "arrayNotContains",
+    message: options.message ?? `\u6570\u7EC4\u4E0D\u80FD\u5305\u542B ${values.join(", ")}`,
+    validate: (value) => {
+      if (!Array.isArray(value)) {
+        return false;
+      }
+      return values.every((v) => {
+        if (typeof v === "object") {
+          const vStr = JSON.stringify(v);
+          return !value.some((item) => JSON.stringify(item) === vStr);
+        }
+        return !value.includes(v);
+      });
+    }
+  };
+}
+function ArrayNotEmpty(options = {}) {
+  return {
+    name: "arrayNotEmpty",
+    message: options.message ?? "\u6570\u7EC4\u4E0D\u80FD\u4E3A\u7A7A",
+    validate: (value) => Array.isArray(value) && value.length > 0
+  };
+}
+
+// src/validation/rules/common.ts
+function IsBoolean(options = {}) {
+  return {
+    name: "isBoolean",
+    message: options.message ?? "\u5FC5\u987B\u662F\u5E03\u5C14\u503C",
+    validate: (value) => typeof value === "boolean"
+  };
+}
+function IsInt(options = {}) {
+  return {
+    name: "isInt",
+    message: options.message ?? "\u5FC5\u987B\u662F\u6574\u6570",
+    validate: (value) => typeof value === "number" && Number.isInteger(value)
+  };
+}
+function IsPositive(options = {}) {
+  return {
+    name: "isPositive",
+    message: options.message ?? "\u5FC5\u987B\u662F\u6B63\u6570",
+    validate: (value) => typeof value === "number" && value > 0
+  };
+}
+function IsNegative(options = {}) {
+  return {
+    name: "isNegative",
+    message: options.message ?? "\u5FC5\u987B\u662F\u8D1F\u6570",
+    validate: (value) => typeof value === "number" && value < 0
+  };
+}
+function Min(min, options = {}) {
+  return {
+    name: "min",
+    message: options.message ?? `\u4E0D\u80FD\u5C0F\u4E8E ${min}`,
+    validate: (value) => typeof value === "number" && value >= min
+  };
+}
+function Max(max, options = {}) {
+  return {
+    name: "max",
+    message: options.message ?? `\u4E0D\u80FD\u5927\u4E8E ${max}`,
+    validate: (value) => typeof value === "number" && value <= max
+  };
+}
+function IsDate(options = {}) {
+  return {
+    name: "isDate",
+    message: options.message ?? "\u5FC5\u987B\u662F\u6709\u6548\u7684\u65E5\u671F",
+    validate: (value) => {
+      if (value instanceof Date) {
+        return !Number.isNaN(value.getTime());
+      }
+      if (typeof value === "string" || typeof value === "number") {
+        const date = new Date(value);
+        return !Number.isNaN(date.getTime());
+      }
+      return false;
+    }
+  };
+}
+function IsUUID(version = "all", options = {}) {
+  return {
+    name: "isUUID",
+    message: options.message ?? `\u5FC5\u987B\u662F\u6709\u6548\u7684 UUID${version !== "all" ? ` (v${version})` : ""}`,
+    validate: (value) => typeof value === "string" && UUID_PATTERNS[version].test(value)
+  };
+}
+function Length(min, max, options = {}) {
+  const maxMsg = max !== undefined ? ` \u4E14\u4E0D\u80FD\u5927\u4E8E ${max}` : "";
+  return {
+    name: "length",
+    message: options.message ?? `\u957F\u5EA6\u4E0D\u80FD\u5C0F\u4E8E ${min}${maxMsg}`,
+    validate: (value) => {
+      if (typeof value !== "string") {
+        return false;
+      }
+      if (value.length < min) {
+        return false;
+      }
+      if (max !== undefined && value.length > max) {
+        return false;
+      }
+      return true;
+    }
+  };
+}
+function MaxLength(max, options = {}) {
+  return {
+    name: "maxLength",
+    message: options.message ?? `\u957F\u5EA6\u4E0D\u80FD\u5927\u4E8E ${max}`,
+    validate: (value) => typeof value === "string" && value.length <= max
+  };
+}
+function Matches(pattern, options = {}) {
+  return {
+    name: "matches",
+    message: options.message ?? `\u5FC5\u987B\u5339\u914D\u683C\u5F0F ${pattern.toString()}`,
+    validate: (value) => typeof value === "string" && pattern.test(value)
+  };
+}
+function IsIn(values, options = {}) {
+  return {
+    name: "isIn",
+    message: options.message ?? `\u5FC5\u987B\u662F\u4EE5\u4E0B\u503C\u4E4B\u4E00: ${values.join(", ")}`,
+    validate: (value) => values.includes(value)
+  };
+}
+function IsNotIn(values, options = {}) {
+  return {
+    name: "isNotIn",
+    message: options.message ?? `\u4E0D\u80FD\u662F\u4EE5\u4E0B\u503C\u4E4B\u4E00: ${values.join(", ")}`,
+    validate: (value) => !values.includes(value)
+  };
+}
+function IsUrl(options = {}) {
+  return {
+    name: "isUrl",
+    message: options.message ?? "\u5FC5\u987B\u662F\u6709\u6548\u7684 URL",
+    validate: (value) => {
+      if (typeof value !== "string") {
+        return false;
+      }
+      try {
+        new URL(value);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+function IsJSON(options = {}) {
+  return {
+    name: "isJSON",
+    message: options.message ?? "\u5FC5\u987B\u662F\u6709\u6548\u7684 JSON \u5B57\u7B26\u4E32",
+    validate: (value) => {
+      if (typeof value !== "string") {
+        return false;
+      }
+      try {
+        JSON.parse(value);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+function Equals(comparison, options = {}) {
+  return {
+    name: "equals",
+    message: options.message ?? `\u5FC5\u987B\u7B49\u4E8E ${comparison}`,
+    validate: (value) => value === comparison
+  };
+}
+function NotEquals(comparison, options = {}) {
+  return {
+    name: "notEquals",
+    message: options.message ?? `\u4E0D\u80FD\u7B49\u4E8E ${comparison}`,
+    validate: (value) => value !== comparison
+  };
+}
+function IsDefined(options = {}) {
+  return {
+    name: "isDefined",
+    message: options.message ?? "\u5FC5\u987B\u5B9A\u4E49",
+    validate: (value) => value !== null && value !== undefined
+  };
+}
+function IsAlphanumeric(options = {}) {
+  return {
+    name: "isAlphanumeric",
+    message: options.message ?? "\u53EA\u80FD\u5305\u542B\u5B57\u6BCD\u548C\u6570\u5B57",
+    validate: (value) => typeof value === "string" && /^[a-zA-Z0-9]+$/.test(value)
+  };
+}
+function IsAlpha(options = {}) {
+  return {
+    name: "isAlpha",
+    message: options.message ?? "\u53EA\u80FD\u5305\u542B\u5B57\u6BCD",
+    validate: (value) => typeof value === "string" && /^[a-zA-Z]+$/.test(value)
+  };
+}
+function IsNumberString(options = {}) {
+  return {
+    name: "isNumberString",
+    message: options.message ?? "\u53EA\u80FD\u5305\u542B\u6570\u5B57",
+    validate: (value) => typeof value === "string" && /^[0-9]+$/.test(value)
+  };
+}
+var UUID_PATTERNS;
+var init_common = __esm(() => {
+  UUID_PATTERNS = {
+    "3": /^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    "4": /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    "5": /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    all: /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+  };
+});
+
+// src/validation/rules/conditional.ts
+function ValidateIf(condition, options = {}) {
+  return {
+    name: "validateIf",
+    message: options.message ?? "",
+    condition,
+    validate: () => true
+  };
+}
+function Transform(transformFn, options = {}) {
+  return {
+    name: "transform",
+    message: options.message ?? "",
+    transform: transformFn,
+    validate: () => true
+  };
+}
+
+// src/validation/custom-validator.ts
+function createCustomValidator(name, validate, defaultMessage) {
+  return (...args) => (options = {}) => {
+    const message = options.message ?? (typeof defaultMessage === "function" ? defaultMessage(...args) : defaultMessage);
+    return {
+      name,
+      message,
+      validate: (value) => validate(value, ...args)
+    };
+  };
+}
+function createSimpleValidator(name, validate, defaultMessage) {
+  return (options = {}) => ({
+    name,
+    message: options.message ?? defaultMessage,
+    validate
+  });
+}
+function createRegexValidator(name, pattern, defaultMessage) {
+  return createSimpleValidator(name, (value) => typeof value === "string" && pattern.test(value), defaultMessage);
+}
+var IsPhoneNumber, IsIdCard, IsIPv4, IsPort, IsPostalCode, IsCreditCard, IsHexColor, IsMacAddress, IsSemVer, IsDivisibleBy, IsBetween, Contains, NotContains;
+var init_custom_validator = __esm(() => {
+  IsPhoneNumber = createSimpleValidator("isPhoneNumber", (value) => typeof value === "string" && /^1[3-9]\d{9}$/.test(value), "\u5FC5\u987B\u662F\u6709\u6548\u7684\u624B\u673A\u53F7\u7801");
+  IsIdCard = createSimpleValidator("isIdCard", (value) => {
+    if (typeof value !== "string")
+      return false;
+    const pattern15 = /^[1-9]\d{5}\d{2}((0[1-9])|(1[0-2]))(([0-2]\d)|30|31)\d{3}$/;
+    const pattern18 = /^[1-9]\d{5}(18|19|20)\d{2}((0[1-9])|(1[0-2]))(([0-2]\d)|30|31)\d{3}[0-9Xx]$/;
+    return pattern15.test(value) || pattern18.test(value);
+  }, "\u5FC5\u987B\u662F\u6709\u6548\u7684\u8EAB\u4EFD\u8BC1\u53F7\u7801");
+  IsIPv4 = createSimpleValidator("isIPv4", (value) => {
+    if (typeof value !== "string")
+      return false;
+    const parts = value.split(".");
+    if (parts.length !== 4)
+      return false;
+    return parts.every((part) => {
+      const num = parseInt(part, 10);
+      return !Number.isNaN(num) && num >= 0 && num <= 255 && String(num) === part;
+    });
+  }, "\u5FC5\u987B\u662F\u6709\u6548\u7684 IPv4 \u5730\u5740");
+  IsPort = createSimpleValidator("isPort", (value) => {
+    if (typeof value === "string") {
+      const num = parseInt(value, 10);
+      return !Number.isNaN(num) && num >= 0 && num <= 65535;
+    }
+    if (typeof value === "number") {
+      return Number.isInteger(value) && value >= 0 && value <= 65535;
+    }
+    return false;
+  }, "\u5FC5\u987B\u662F\u6709\u6548\u7684\u7AEF\u53E3\u53F7 (0-65535)");
+  IsPostalCode = createSimpleValidator("isPostalCode", (value) => typeof value === "string" && /^[1-9]\d{5}$/.test(value), "\u5FC5\u987B\u662F\u6709\u6548\u7684\u90AE\u653F\u7F16\u7801");
+  IsCreditCard = createSimpleValidator("isCreditCard", (value) => {
+    if (typeof value !== "string")
+      return false;
+    const sanitized = value.replace(/[\s-]/g, "");
+    if (!/^\d{13,19}$/.test(sanitized))
+      return false;
+    let sum = 0;
+    let isEven = false;
+    for (let i = sanitized.length - 1;i >= 0; i--) {
+      let digit = parseInt(sanitized[i], 10);
+      if (isEven) {
+        digit *= 2;
+        if (digit > 9)
+          digit -= 9;
+      }
+      sum += digit;
+      isEven = !isEven;
+    }
+    return sum % 10 === 0;
+  }, "\u5FC5\u987B\u662F\u6709\u6548\u7684\u4FE1\u7528\u5361\u53F7");
+  IsHexColor = createSimpleValidator("isHexColor", (value) => typeof value === "string" && /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/.test(value), "\u5FC5\u987B\u662F\u6709\u6548\u7684\u5341\u516D\u8FDB\u5236\u989C\u8272\u503C");
+  IsMacAddress = createSimpleValidator("isMacAddress", (value) => typeof value === "string" && /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/.test(value), "\u5FC5\u987B\u662F\u6709\u6548\u7684 MAC \u5730\u5740");
+  IsSemVer = createSimpleValidator("isSemVer", (value) => typeof value === "string" && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/.test(value), "\u5FC5\u987B\u662F\u6709\u6548\u7684\u8BED\u4E49\u5316\u7248\u672C\u53F7");
+  IsDivisibleBy = createCustomValidator("isDivisibleBy", (value, divisor) => typeof value === "number" && !Number.isNaN(value) && value % divisor === 0, (divisor) => `\u5FC5\u987B\u80FD\u88AB ${divisor} \u6574\u9664`);
+  IsBetween = createCustomValidator("isBetween", (value, min, max) => typeof value === "number" && value >= min && value <= max, (min, max) => `\u5FC5\u987B\u5728 ${min} \u548C ${max} \u4E4B\u95F4`);
+  Contains = createCustomValidator("contains", (value, substring) => typeof value === "string" && value.includes(substring), (substring) => `\u5FC5\u987B\u5305\u542B "${substring}"`);
+  NotContains = createCustomValidator("notContains", (value, substring) => typeof value === "string" && !value.includes(substring), (substring) => `\u4E0D\u80FD\u5305\u542B "${substring}"`);
+});
+
+// src/validation/class-validator.ts
+import"reflect-metadata";
+function ValidateClass() {
+  return (target) => {
+    Reflect.defineMetadata(VALIDATE_CLASS_METADATA_KEY, true, target);
+  };
+}
+function Property(...rules) {
+  return (target, propertyKey) => {
+    if (typeof propertyKey === "symbol") {
+      throw new Error("@Property decorator does not support symbol property keys");
+    }
+    const existingMetadata = Reflect.getMetadata(CLASS_VALIDATION_METADATA_KEY, target.constructor) ?? [];
+    let propertyMetadata = existingMetadata.find((m) => m.property === propertyKey);
+    if (!propertyMetadata) {
+      propertyMetadata = { property: propertyKey, rules: [] };
+      existingMetadata.push(propertyMetadata);
+    }
+    propertyMetadata.rules.push(...rules);
+    Reflect.defineMetadata(CLASS_VALIDATION_METADATA_KEY, existingMetadata, target.constructor);
+  };
+}
+function getClassValidationMetadata(target) {
+  return Reflect.getMetadata(CLASS_VALIDATION_METADATA_KEY, target) ?? [];
+}
+function isValidateClass(target) {
+  return Reflect.getMetadata(VALIDATE_CLASS_METADATA_KEY, target) === true;
+}
+function validateValue(value, rules, property, fullObject) {
+  const issues = [];
+  let currentValue = value;
+  let shouldSkip2 = false;
+  for (const rule of rules) {
+    if (rule.condition && !rule.condition(currentValue, fullObject)) {
+      shouldSkip2 = true;
+      break;
+    }
+    if (rule.optional && (currentValue === undefined || currentValue === null)) {
+      shouldSkip2 = true;
+      break;
+    }
+    if (rule.transform) {
+      currentValue = rule.transform(currentValue);
+    }
+    if (rule.nested) {
+      if (rule.each && Array.isArray(currentValue)) {
+        for (let i = 0;i < currentValue.length; i++) {
+          const item = currentValue[i];
+          if (typeof item === "object" && item !== null && rule.nestedType) {
+            const nestedIssues = validateObjectInternal(item, rule.nestedType, `${property}[${i}]`);
+            issues.push(...nestedIssues);
+          }
+        }
+      } else if (typeof currentValue === "object" && currentValue !== null && rule.nestedType) {
+        const nestedIssues = validateObjectInternal(currentValue, rule.nestedType, property);
+        issues.push(...nestedIssues);
+      }
+      continue;
+    }
+    const passed = rule.validate(currentValue, fullObject);
+    if (!passed) {
+      issues.push({
+        property,
+        rule: rule.name,
+        message: rule.message,
+        value: currentValue
+      });
+    }
+  }
+  return shouldSkip2 ? [] : issues;
+}
+function validateObjectInternal(obj, targetClass, prefix = "") {
+  const metadata = getClassValidationMetadata(targetClass);
+  const issues = [];
+  if (typeof obj !== "object" || obj === null) {
+    issues.push({
+      property: prefix || "root",
+      rule: "isObject",
+      message: "\u5FC5\u987B\u662F\u5BF9\u8C61",
+      value: obj
+    });
+    return issues;
+  }
+  const objRecord = obj;
+  for (const meta of metadata) {
+    const propertyPath = prefix ? `${prefix}.${meta.property}` : meta.property;
+    const value = objRecord[meta.property];
+    const propertyIssues = validateValue(value, meta.rules, propertyPath, obj);
+    issues.push(...propertyIssues);
+  }
+  return issues;
+}
+function validateObject(obj, targetClass, options = {}) {
+  const issues = validateObjectInternal(obj, targetClass);
+  if (options.stopAtFirstError && issues.length > 0) {
+    throw new ValidationError("Validation failed", [issues[0]]);
+  }
+  if (issues.length > 0) {
+    throw new ValidationError("Validation failed", issues);
+  }
+}
+function validateObjectSync(obj, targetClass, options = {}) {
+  const issues = validateObjectInternal(obj, targetClass);
+  if (options.stopAtFirstError && issues.length > 0) {
+    return { valid: false, issues: [issues[0]] };
+  }
+  return { valid: issues.length === 0, issues };
+}
+function NestedProperty(nestedClass) {
+  return (target, propertyKey) => {
+    if (typeof propertyKey === "symbol") {
+      throw new Error("@NestedProperty decorator does not support symbol property keys");
+    }
+    const existingMetadata = Reflect.getMetadata(CLASS_VALIDATION_METADATA_KEY, target.constructor) ?? [];
+    let propertyMetadata = existingMetadata.find((m) => m.property === propertyKey);
+    if (!propertyMetadata) {
+      propertyMetadata = { property: propertyKey, rules: [] };
+      existingMetadata.push(propertyMetadata);
+    }
+    propertyMetadata.rules.push({
+      name: "validateNested",
+      message: "\u5D4C\u5957\u5BF9\u8C61\u9A8C\u8BC1\u5931\u8D25",
+      nested: true,
+      nestedType: nestedClass,
+      validate: (value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    });
+    Reflect.defineMetadata(CLASS_VALIDATION_METADATA_KEY, existingMetadata, target.constructor);
+  };
+}
+function ArrayNestedProperty(nestedClass) {
+  return (target, propertyKey) => {
+    if (typeof propertyKey === "symbol") {
+      throw new Error("@ArrayNestedProperty decorator does not support symbol property keys");
+    }
+    const existingMetadata = Reflect.getMetadata(CLASS_VALIDATION_METADATA_KEY, target.constructor) ?? [];
+    let propertyMetadata = existingMetadata.find((m) => m.property === propertyKey);
+    if (!propertyMetadata) {
+      propertyMetadata = { property: propertyKey, rules: [] };
+      existingMetadata.push(propertyMetadata);
+    }
+    propertyMetadata.rules.push({
+      name: "validateNestedArray",
+      message: "\u6570\u7EC4\u5143\u7D20\u9A8C\u8BC1\u5931\u8D25",
+      nested: true,
+      nestedType: nestedClass,
+      each: true,
+      validate: (value) => Array.isArray(value)
+    });
+    Reflect.defineMetadata(CLASS_VALIDATION_METADATA_KEY, existingMetadata, target.constructor);
+  };
+}
+var CLASS_VALIDATION_METADATA_KEY, PROPERTY_VALIDATION_METADATA_KEY, VALIDATE_CLASS_METADATA_KEY;
+var init_class_validator = __esm(() => {
+  init_errors();
+  CLASS_VALIDATION_METADATA_KEY = Symbol("validation:class");
+  PROPERTY_VALIDATION_METADATA_KEY = Symbol("validation:property");
+  VALIDATE_CLASS_METADATA_KEY = Symbol("validation:validateClass");
+});
+
 // src/validation/index.ts
 var init_validation = __esm(() => {
   init_decorators5();
   init_validator();
   init_errors();
+  init_common();
+  init_custom_validator();
+  init_class_validator();
 });
 
 // src/error/error-codes.ts
@@ -2571,6 +3223,12 @@ var init_interceptor = __esm(() => {
 });
 
 // src/controller/controller.ts
+var exports_controller = {};
+__export(exports_controller, {
+  ControllerRegistry: () => ControllerRegistry,
+  Controller: () => Controller,
+  CONTROLLER_METADATA_KEY: () => CONTROLLER_METADATA_KEY
+});
 import"reflect-metadata";
 function Controller(path = "") {
   return function(target) {
@@ -3632,12 +4290,14 @@ init_controller();
 init_container();
 init_types();
 init_module();
+init_decorators();
 
 class ModuleRegistry {
   static instance;
   moduleRefs = new Map;
   processing = new Set;
   rootContainer;
+  globalModules = new Set;
   static getInstance() {
     if (!ModuleRegistry.instance) {
       ModuleRegistry.instance = new ModuleRegistry;
@@ -3656,8 +4316,12 @@ class ModuleRegistry {
   clear() {
     this.moduleRefs.clear();
     this.processing.clear();
+    this.globalModules.clear();
     this.rootContainer = undefined;
   }
+  getGlobalModules() {
+    return Array.from(this.globalModules);
+  }
   processModule(moduleClass, parentContainer) {
     if (this.processing.has(moduleClass)) {
       throw new Error(`Circular module dependency detected for ${moduleClass.name}`);
@@ -3680,6 +4344,7 @@ class ModuleRegistry {
       throw new Error("ModuleRegistry is not initialized with a root container");
     }
     const metadata = getModuleMetadata(moduleClass);
+    const isGlobal = isGlobalModule(moduleClass);
     const container = new Container({ parent: this.rootContainer });
     this.registerProviders(container, metadata.providers);
     ref = {
@@ -3689,12 +4354,25 @@ class ModuleRegistry {
       controllersRegistered: false,
       attachedParents: new Set,
       extensions: metadata.extensions ?? [],
-      middlewares: metadata.middlewares ?? []
+      middlewares: metadata.middlewares ?? [],
+      isGlobal
     };
     this.registerControllers(ref);
     this.moduleRefs.set(moduleClass, ref);
+    if (isGlobal) {
+      this.globalModules.add(moduleClass);
+      this.registerGlobalExports(ref);
+    }
     return ref;
   }
+  registerGlobalExports(moduleRef) {
+    if (!this.rootContainer) {
+      return;
+    }
+    for (const exportedToken of moduleRef.metadata.exports) {
+      this.registerExport(this.rootContainer, moduleRef, exportedToken);
+    }
+  }
   registerProviders(container, providers) {
     for (const provider of providers) {
       if (typeof provider === "function") {
@@ -5476,6 +6154,232 @@ function checkRoles(target, propertyKey, userRoles = []) {
   return config.roles.some((role) => userRoles.includes(role));
 }
 
+// src/security/guards/decorators.ts
+import"reflect-metadata";
+
+// src/security/guards/types.ts
+var GUARDS_METADATA_KEY = Symbol("@dangao/bun-server:guards");
+var GUARD_REGISTRY_TOKEN = Symbol("@dangao/bun-server:guard-registry");
+var ROLES_METADATA_KEY = Symbol("@dangao/bun-server:roles");
+
+// src/security/guards/decorators.ts
+function UseGuards(...guards) {
+  return (target, propertyKey, descriptor) => {
+    if (propertyKey !== undefined) {
+      const existingGuards = Reflect.getMetadata(GUARDS_METADATA_KEY, target, propertyKey) || [];
+      Reflect.defineMetadata(GUARDS_METADATA_KEY, [...existingGuards, ...guards], target, propertyKey);
+    } else {
+      const existingGuards = Reflect.getMetadata(GUARDS_METADATA_KEY, target) || [];
+      Reflect.defineMetadata(GUARDS_METADATA_KEY, [...existingGuards, ...guards], target);
+    }
+  };
+}
+function Roles(...roles) {
+  return (target, propertyKey, descriptor) => {
+    if (propertyKey !== undefined) {
+      Reflect.defineMetadata(ROLES_METADATA_KEY, roles, target, propertyKey);
+    } else {
+      Reflect.defineMetadata(ROLES_METADATA_KEY, roles, target);
+    }
+  };
+}
+function getGuardsMetadata(target, propertyKey) {
+  if (target === null || target === undefined) {
+    return [];
+  }
+  if (typeof target !== "object" && typeof target !== "function") {
+    return [];
+  }
+  if (propertyKey !== undefined) {
+    return Reflect.getMetadata(GUARDS_METADATA_KEY, target, propertyKey) || [];
+  }
+  return Reflect.getMetadata(GUARDS_METADATA_KEY, target) || [];
+}
+function getRolesMetadata(target, propertyKey) {
+  if (propertyKey !== undefined) {
+    return Reflect.getMetadata(ROLES_METADATA_KEY, target, propertyKey) || [];
+  }
+  return Reflect.getMetadata(ROLES_METADATA_KEY, target) || [];
+}
+
+// src/security/guards/guard-registry.ts
+init_http_exception();
+init_error_codes();
+
+class GuardRegistry {
+  globalGuards = [];
+  guardInstances = new Map;
+  addGlobalGuards(...guards) {
+    this.globalGuards.push(...guards);
+  }
+  getGlobalGuards() {
+    return [...this.globalGuards];
+  }
+  clearGlobalGuards() {
+    this.globalGuards = [];
+    this.guardInstances.clear();
+  }
+  resolveGuard(guard, container) {
+    if (typeof guard !== "function") {
+      return guard;
+    }
+    const cached = this.guardInstances.get(guard);
+    if (cached) {
+      return cached;
+    }
+    try {
+      if (container.isRegistered(guard)) {
+        const instance2 = container.resolve(guard);
+        this.guardInstances.set(guard, instance2);
+        return instance2;
+      }
+    } catch {}
+    const GuardClass = guard;
+    const instance = new GuardClass;
+    this.guardInstances.set(guard, instance);
+    return instance;
+  }
+  getControllerGuards(controllerClass) {
+    return getGuardsMetadata(controllerClass);
+  }
+  getMethodGuards(controllerClass, methodName) {
+    return getGuardsMetadata(controllerClass.prototype, methodName);
+  }
+  collectGuards(controllerClass, methodName) {
+    const globalGuards = this.getGlobalGuards();
+    const controllerGuards = this.getControllerGuards(controllerClass);
+    const methodGuards = this.getMethodGuards(controllerClass, methodName);
+    return [...globalGuards, ...controllerGuards, ...methodGuards];
+  }
+  async executeGuards(context, container) {
+    const controllerClass = context.getClass();
+    const methodName = context.getMethodName();
+    const guards = this.collectGuards(controllerClass, methodName);
+    if (guards.length === 0) {
+      return true;
+    }
+    for (const guard of guards) {
+      const guardInstance = this.resolveGuard(guard, container);
+      const result = await guardInstance.canActivate(context);
+      if (!result) {
+        const guardName = typeof guard === "function" ? guard.name : guard.constructor.name;
+        throw new ForbiddenException(`Access denied by guard: ${guardName}`, { guard: guardName }, "AUTH_INSUFFICIENT_PERMISSIONS" /* AUTH_INSUFFICIENT_PERMISSIONS */);
+      }
+    }
+    return true;
+  }
+}
+
+// src/security/guards/execution-context.ts
+import"reflect-metadata";
+
+class HttpArgumentsHostImpl {
+  ctx;
+  responseBuilder;
+  constructor(ctx, responseBuilder) {
+    this.ctx = ctx;
+    this.responseBuilder = responseBuilder;
+  }
+  getRequest() {
+    return this.ctx;
+  }
+  getResponse() {
+    return this.responseBuilder;
+  }
+}
+
+class WsArgumentsHostImpl {
+  client;
+  data;
+  constructor(client, data) {
+    this.client = client;
+    this.data = data;
+  }
+  getClient() {
+    return this.client;
+  }
+  getData() {
+    return this.data;
+  }
+}
+
+class ExecutionContextImpl {
+  ctx;
+  controllerClass;
+  methodName;
+  handler;
+  args;
+  httpHost;
+  wsHost;
+  constructor(ctx, controllerClass, methodName, handler, args = [], responseBuilder) {
+    this.ctx = ctx;
+    this.controllerClass = controllerClass;
+    this.methodName = methodName;
+    this.handler = handler;
+    this.args = args;
+    this.httpHost = new HttpArgumentsHostImpl(ctx, responseBuilder);
+  }
+  setWsContext(client, data) {
+    this.wsHost = new WsArgumentsHostImpl(client, data);
+  }
+  switchToHttp() {
+    return this.httpHost;
+  }
+  switchToWs() {
+    if (!this.wsHost) {
+      throw new Error("WebSocket context is not available");
+    }
+    return this.wsHost;
+  }
+  getClass() {
+    return this.controllerClass;
+  }
+  getHandler() {
+    return this.handler;
+  }
+  getMethodName() {
+    return this.methodName;
+  }
+  getMetadata(key) {
+    const methodMetadata = Reflect.getMetadata(key, this.controllerClass.prototype, this.methodName);
+    if (methodMetadata !== undefined) {
+      return methodMetadata;
+    }
+    return Reflect.getMetadata(key, this.controllerClass);
+  }
+  getArgs() {
+    return this.args;
+  }
+}
+
+// src/security/guards/reflector.ts
+import"reflect-metadata";
+
+class Reflector {
+  get(metadataKey, target) {
+    return Reflect.getMetadata(metadataKey, target);
+  }
+  getFromClass(metadataKey, target) {
+    return Reflect.getMetadata(metadataKey, target);
+  }
+  getFromMethod(metadataKey, target, propertyKey) {
+    return Reflect.getMetadata(metadataKey, target, propertyKey);
+  }
+  getAllAndMerge(metadataKey, target, propertyKey) {
+    const classMetadata = this.getFromClass(metadataKey, target) || [];
+    const methodMetadata = this.getFromMethod(metadataKey, target.prototype, propertyKey) || [];
+    return [...classMetadata, ...methodMetadata];
+  }
+  getAllAndOverride(metadataKey, target, propertyKey) {
+    const methodMetadata = this.getFromMethod(metadataKey, target.prototype, propertyKey);
+    if (methodMetadata !== undefined) {
+      return methodMetadata;
+    }
+    return this.getFromClass(metadataKey, target);
+  }
+}
+var REFLECTOR_TOKEN = Symbol("@dangao/bun-server:reflector");
+
 // src/security/filter.ts
 function createSecurityFilter(config) {
   const {
@@ -5483,8 +6387,24 @@ function createSecurityFilter(config) {
     accessDecisionManager = new RoleBasedAccessDecisionManager,
     excludePaths = [],
     defaultAuthRequired = true,
-    extractToken
+    extractToken,
+    container: initialContainer,
+    guardRegistry
   } = config;
+  const registry = guardRegistry || new GuardRegistry;
+  let cachedContainer = initialContainer || null;
+  const getContainer = () => {
+    if (cachedContainer) {
+      return cachedContainer;
+    }
+    try {
+      const { ControllerRegistry: ControllerRegistry2 } = (init_controller(), __toCommonJS(exports_controller));
+      cachedContainer = ControllerRegistry2.getInstance().getContainer();
+      return cachedContainer;
+    } catch {
+      return null;
+    }
+  };
   return async (ctx, next) => {
     return SecurityContextHolder.runWithContext(async () => {
       const path = ctx.path || ctx.request.url.split("?")[0].replace(/^https?:\/\/[^/]+/, "");
@@ -5505,11 +6425,23 @@ function createSecurityFilter(config) {
             securityContext.setAuthentication(authentication);
           }
         }
+        ctx.security = securityContext;
+        ctx.auth = {
+          isAuthenticated: securityContext.isAuthenticated(),
+          user: securityContext.getPrincipal(),
+          payload: securityContext.authentication?.details
+        };
         const handler = ctx.routeHandler;
         if (handler) {
           const controllerClass = handler.controller;
           const controllerTarget = controllerClass && controllerClass.prototype || controllerClass;
           const method = handler.method;
+          const container = getContainer();
+          if (container && typeof controllerClass === "function") {
+            const methodHandler = controllerTarget[method];
+            const executionContext = new ExecutionContextImpl(ctx, controllerClass, method, methodHandler || (() => {}));
+            await registry.executeGuards(executionContext, container);
+          }
           if (requiresAuth(controllerTarget, method)) {
             const authentication = securityContext.authentication;
             if (!authentication || !authentication.authenticated) {
@@ -5527,12 +6459,6 @@ function createSecurityFilter(config) {
         } else if (defaultAuthRequired && !securityContext.isAuthenticated()) {
           throw new UnauthorizedException("Authentication required", undefined, "AUTH_REQUIRED" /* AUTH_REQUIRED */);
         }
-        ctx.security = securityContext;
-        ctx.auth = {
-          isAuthenticated: securityContext.isAuthenticated(),
-          user: securityContext.getPrincipal(),
-          payload: securityContext.authentication?.details
-        };
         return await next();
       } finally {
         SecurityContextHolder.clearContext();
@@ -5540,6 +6466,22 @@ function createSecurityFilter(config) {
     });
   };
 }
+function getGuardRegistry(container) {
+  if (container.isRegistered(GUARD_REGISTRY_TOKEN)) {
+    return container.resolve(GUARD_REGISTRY_TOKEN);
+  }
+  const registry = new GuardRegistry;
+  container.registerInstance(GUARD_REGISTRY_TOKEN, registry);
+  return registry;
+}
+function registerReflector(container) {
+  if (container.isRegistered(REFLECTOR_TOKEN)) {
+    return container.resolve(REFLECTOR_TOKEN);
+  }
+  const reflector = new Reflector;
+  container.registerInstance(REFLECTOR_TOKEN, reflector);
+  return reflector;
+}
 function extractTokenFromHeader(ctx) {
   const authHeader = ctx.getHeader("authorization");
   if (!authHeader) {
@@ -6008,6 +6950,8 @@ OAuth2Controller = __legacyDecorateClassTS([
 ], OAuth2Controller);
 
 // src/security/security-module.ts
+var _guardRegistry = null;
+
 class SecurityModule {
   static forRoot(config) {
     const jwtUtil = new JWTUtil(config.jwt);
@@ -6016,13 +6960,23 @@ class SecurityModule {
     const authenticationManager = new AuthenticationManager;
     authenticationManager.registerProvider(new JwtAuthenticationProvider(jwtUtil));
     authenticationManager.registerProvider(new OAuth2AuthenticationProvider(oauth2Service, jwtUtil));
+    const guardRegistry = new GuardRegistry;
+    if (_guardRegistry) {
+      _guardRegistry.clearGlobalGuards();
+    }
+    _guardRegistry = guardRegistry;
+    if (config.globalGuards && config.globalGuards.length > 0) {
+      guardRegistry.addGlobalGuards(...config.globalGuards);
+    }
+    const reflector = new Reflector;
     const securityFilter = createSecurityFilter({
       authenticationManager,
       excludePaths: [
         ...config.excludePaths || [],
         ...config.enableOAuth2Endpoints !== false ? [config.oauth2Prefix || "/oauth2"] : []
       ],
-      defaultAuthRequired: config.defaultAuthRequired ?? false
+      defaultAuthRequired: config.defaultAuthRequired ?? false,
+      guardRegistry
     });
     const controllers = [];
     const providers = [];
@@ -6039,6 +6993,12 @@ class SecurityModule {
     }, {
       provide: AuthenticationManager,
       useValue: authenticationManager
+    }, {
+      provide: GUARD_REGISTRY_TOKEN,
+      useValue: guardRegistry
+    }, {
+      provide: REFLECTOR_TOKEN,
+      useValue: reflector
     });
     middlewares.push(securityFilter);
     const existingMetadata = Reflect.getMetadata(MODULE_METADATA_KEY, SecurityModule) || {};
@@ -6051,12 +7011,29 @@ class SecurityModule {
         ...existingMetadata.exports || [],
         JWT_UTIL_TOKEN,
         OAUTH2_SERVICE_TOKEN,
-        AuthenticationManager
+        AuthenticationManager,
+        GUARD_REGISTRY_TOKEN,
+        REFLECTOR_TOKEN
       ]
     };
     Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, SecurityModule);
     return SecurityModule;
   }
+  static getGuardRegistry() {
+    return _guardRegistry;
+  }
+  static addGlobalGuards(...guards) {
+    if (_guardRegistry) {
+      _guardRegistry.addGlobalGuards(...guards);
+    }
+  }
+  static reset() {
+    if (_guardRegistry) {
+      _guardRegistry.clearGlobalGuards();
+    }
+    _guardRegistry = null;
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, SecurityModule);
+  }
 }
 SecurityModule = __legacyDecorateClassTS([
   Module({
@@ -6065,6 +7042,94 @@ SecurityModule = __legacyDecorateClassTS([
     middlewares: []
   })
 ], SecurityModule);
+// src/security/guards/builtin/auth-guard.ts
+init_decorators();
+init_http_exception();
+init_error_codes();
+class AuthGuard {
+  canActivate(context) {
+    const securityContext = SecurityContextHolder.getContext();
+    if (!securityContext.isAuthenticated()) {
+      throw new UnauthorizedException("Authentication required", undefined, "AUTH_REQUIRED" /* AUTH_REQUIRED */);
+    }
+    return true;
+  }
+}
+AuthGuard = __legacyDecorateClassTS([
+  Injectable()
+], AuthGuard);
+
+class OptionalAuthGuard {
+  canActivate(context) {
+    return true;
+  }
+}
+OptionalAuthGuard = __legacyDecorateClassTS([
+  Injectable()
+], OptionalAuthGuard);
+// src/security/guards/builtin/roles-guard.ts
+init_decorators();
+init_http_exception();
+init_error_codes();
+class RolesGuard {
+  reflector;
+  constructor(reflector) {
+    this.reflector = reflector || new Reflector;
+  }
+  canActivate(context) {
+    const requiredRoles = this.reflector.getAllAndMerge(ROLES_METADATA_KEY, context.getClass(), context.getMethodName());
+    if (!requiredRoles || requiredRoles.length === 0) {
+      return true;
+    }
+    const securityContext = SecurityContextHolder.getContext();
+    const authentication = securityContext.authentication;
+    if (!authentication || !authentication.authenticated) {
+      throw new ForbiddenException("Access denied: authentication required for role check", { requiredRoles }, "AUTH_INSUFFICIENT_PERMISSIONS" /* AUTH_INSUFFICIENT_PERMISSIONS */);
+    }
+    const userRoles = authentication.authorities || [];
+    const hasRole = requiredRoles.some((role) => userRoles.includes(role));
+    if (!hasRole) {
+      throw new ForbiddenException(`Access denied: required roles [${requiredRoles.join(", ")}], but user has [${userRoles.join(", ")}]`, { requiredRoles, userRoles }, "AUTH_INSUFFICIENT_PERMISSIONS" /* AUTH_INSUFFICIENT_PERMISSIONS */);
+    }
+    return true;
+  }
+}
+RolesGuard = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(REFLECTOR_TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Reflector === "undefined" ? Object : Reflector
+  ])
+], RolesGuard);
+function createRolesGuard(options = {}) {
+  const { matchAll = false, getRoles } = options;
+
+  class CustomRolesGuard {
+    reflector = new Reflector;
+    canActivate(context) {
+      const requiredRoles = this.reflector.getAllAndMerge(ROLES_METADATA_KEY, context.getClass(), context.getMethodName());
+      if (!requiredRoles || requiredRoles.length === 0) {
+        return true;
+      }
+      let userRoles;
+      if (getRoles) {
+        userRoles = getRoles(context);
+      } else {
+        const securityContext = SecurityContextHolder.getContext();
+        userRoles = securityContext.authentication?.authorities || [];
+      }
+      const hasRole = matchAll ? requiredRoles.every((role) => userRoles.includes(role)) : requiredRoles.some((role) => userRoles.includes(role));
+      if (!hasRole) {
+        throw new ForbiddenException(`Access denied: required roles [${requiredRoles.join(", ")}], user has [${userRoles.join(", ")}]`, { requiredRoles, userRoles, matchAll }, "AUTH_INSUFFICIENT_PERMISSIONS" /* AUTH_INSUFFICIENT_PERMISSIONS */);
+      }
+      return true;
+    }
+  }
+  CustomRolesGuard = __legacyDecorateClassTS([
+    Injectable()
+  ], CustomRolesGuard);
+  return CustomRolesGuard;
+}
 // src/health/health-module.ts
 init_module();
 
@@ -9511,26 +10576,387 @@ class ServiceMetricsCollector {
     this.metricsIntegration?.stop();
   }
 }
+// src/events/types.ts
+var EVENT_EMITTER_TOKEN = Symbol("@dangao/bun-server:events:emitter");
+var EVENT_OPTIONS_TOKEN = Symbol("@dangao/bun-server:events:options");
+var ON_EVENT_METADATA_KEY = Symbol("@dangao/bun-server:events:on-event");
+var EVENT_LISTENER_CLASS_METADATA_KEY = Symbol("@dangao/bun-server:events:listener-class");
+// src/events/service.ts
+class EventEmitterService {
+  listeners = new Map;
+  options;
+  constructor(options = {}) {
+    this.options = {
+      wildcard: false,
+      delimiter: ".",
+      maxListeners: 10,
+      ...options
+    };
+  }
+  emit(event, payload) {
+    const eventName = this.resolveEventName(event);
+    const matchedListeners = this.getMatchedListeners(eventName);
+    if (matchedListeners.length === 0) {
+      return;
+    }
+    const sortedListeners = this.sortListenersByPriority(matchedListeners);
+    for (const { listener, once, async: isAsync } of sortedListeners) {
+      try {
+        const result = listener(payload);
+        if (isAsync && result instanceof Promise) {
+          result.catch((error) => {
+            this.handleError(error, eventName, payload);
+          });
+        }
+      } catch (error) {
+        this.handleError(error, eventName, payload);
+      }
+      if (once) {
+        this.off(eventName, listener);
+      }
+    }
+  }
+  async emitAsync(event, payload) {
+    const eventName = this.resolveEventName(event);
+    const matchedListeners = this.getMatchedListeners(eventName);
+    if (matchedListeners.length === 0) {
+      return;
+    }
+    const sortedListeners = this.sortListenersByPriority(matchedListeners);
+    const promises = [];
+    const toRemove = [];
+    for (const { listener, once } of sortedListeners) {
+      try {
+        const result = listener(payload);
+        if (result instanceof Promise) {
+          promises.push(result.catch((error) => {
+            this.handleError(error, eventName, payload);
+          }));
+        }
+      } catch (error) {
+        this.handleError(error, eventName, payload);
+      }
+      if (once) {
+        toRemove.push(listener);
+      }
+    }
+    if (promises.length > 0) {
+      await Promise.all(promises);
+    }
+    for (const listener of toRemove) {
+      this.off(eventName, listener);
+    }
+  }
+  on(event, listener, options = {}) {
+    const eventName = this.resolveEventName(event);
+    return this.addListener(eventName, listener, false, options);
+  }
+  once(event, listener, options = {}) {
+    const eventName = this.resolveEventName(event);
+    return this.addListener(eventName, listener, true, options);
+  }
+  off(event, listener) {
+    const eventName = this.resolveEventName(event);
+    const eventListeners = this.listeners.get(eventName);
+    if (!eventListeners) {
+      return;
+    }
+    const index = eventListeners.findIndex((l) => l.listener === listener);
+    if (index !== -1) {
+      eventListeners.splice(index, 1);
+    }
+    if (eventListeners.length === 0) {
+      this.listeners.delete(eventName);
+    }
+  }
+  removeAllListeners(event) {
+    if (event !== undefined) {
+      const eventName = this.resolveEventName(event);
+      this.listeners.delete(eventName);
+    } else {
+      this.listeners.clear();
+    }
+  }
+  listenerCount(event) {
+    const eventName = this.resolveEventName(event);
+    const matchedListeners = this.getMatchedListeners(eventName);
+    return matchedListeners.length;
+  }
+  eventNames() {
+    return Array.from(this.listeners.keys());
+  }
+  addListener(event, listener, once, options) {
+    let eventListeners = this.listeners.get(event);
+    if (!eventListeners) {
+      eventListeners = [];
+      this.listeners.set(event, eventListeners);
+    }
+    if (this.options.maxListeners && eventListeners.length >= this.options.maxListeners) {
+      console.warn(`[EventEmitter] Max listeners (${this.options.maxListeners}) exceeded for event: ${String(event)}. ` + "This may indicate a memory leak.");
+    }
+    const registeredListener = {
+      listener,
+      once,
+      priority: options.priority ?? 0,
+      async: options.async ?? false
+    };
+    eventListeners.push(registeredListener);
+    return () => {
+      this.off(event, listener);
+    };
+  }
+  resolveEventName(event) {
+    if (typeof event === "symbol") {
+      return event;
+    }
+    if (this.options.globalPrefix) {
+      return `${this.options.globalPrefix}${this.options.delimiter}${event}`;
+    }
+    return event;
+  }
+  getMatchedListeners(event) {
+    const result = [];
+    const exactListeners = this.listeners.get(event);
+    if (exactListeners) {
+      result.push(...exactListeners);
+    }
+    if (this.options.wildcard && typeof event === "string") {
+      const delimiter = this.options.delimiter ?? ".";
+      const eventParts = event.split(delimiter);
+      for (const [key, listeners] of this.listeners.entries()) {
+        if (typeof key !== "string" || key === event) {
+          continue;
+        }
+        if (this.matchWildcard(eventParts, key.split(delimiter))) {
+          result.push(...listeners);
+        }
+      }
+    }
+    return result;
+  }
+  matchWildcard(eventParts, patternParts) {
+    let eventIndex = 0;
+    let patternIndex = 0;
+    while (patternIndex < patternParts.length) {
+      const pattern = patternParts[patternIndex];
+      if (pattern === "**") {
+        if (patternIndex === patternParts.length - 1) {
+          return true;
+        }
+        for (let i = eventIndex;i <= eventParts.length; i++) {
+          if (this.matchWildcard(eventParts.slice(i), patternParts.slice(patternIndex + 1))) {
+            return true;
+          }
+        }
+        return false;
+      } else if (pattern === "*") {
+        if (eventIndex >= eventParts.length) {
+          return false;
+        }
+        eventIndex++;
+        patternIndex++;
+      } else {
+        if (eventIndex >= eventParts.length || eventParts[eventIndex] !== pattern) {
+          return false;
+        }
+        eventIndex++;
+        patternIndex++;
+      }
+    }
+    return eventIndex === eventParts.length;
+  }
+  sortListenersByPriority(listeners) {
+    return [...listeners].sort((a, b) => b.priority - a.priority);
+  }
+  handleError(error, event, payload) {
+    if (this.options.onError) {
+      this.options.onError(error, event, payload);
+    } else {
+      console.error(`[EventEmitter] Error in listener for event "${String(event)}":`, error);
+    }
+  }
+}
+// src/events/decorators.ts
+import"reflect-metadata";
+function OnEvent(event, options = {}) {
+  return (target, propertyKey, descriptor) => {
+    const methodName = String(propertyKey);
+    const constructor = target.constructor;
+    const existingMetadata = Reflect.getMetadata(ON_EVENT_METADATA_KEY, constructor) || [];
+    const metadata = {
+      methodName,
+      event,
+      async: options.async ?? false,
+      priority: options.priority ?? 0
+    };
+    Reflect.defineMetadata(ON_EVENT_METADATA_KEY, [...existingMetadata, metadata], constructor);
+    Reflect.defineMetadata(EVENT_LISTENER_CLASS_METADATA_KEY, true, constructor);
+    return descriptor;
+  };
+}
+function getOnEventMetadata(target) {
+  return Reflect.getMetadata(ON_EVENT_METADATA_KEY, target);
+}
+function isEventListenerClass(target) {
+  return Reflect.getMetadata(EVENT_LISTENER_CLASS_METADATA_KEY, target) === true;
+}
+// src/events/event-module.ts
+init_module();
+import"reflect-metadata";
+class EventListenerScanner {
+  eventEmitter;
+  container;
+  constructor(eventEmitter, container) {
+    this.eventEmitter = eventEmitter;
+    this.container = container;
+  }
+  scanAndRegister(listenerClasses) {
+    for (const listenerClass of listenerClasses) {
+      this.registerListenerClass(listenerClass);
+    }
+  }
+  registerListenerClass(listenerClass) {
+    if (!isEventListenerClass(listenerClass)) {
+      return;
+    }
+    const metadata = getOnEventMetadata(listenerClass);
+    if (!metadata || metadata.length === 0) {
+      return;
+    }
+    const instance = this.container.resolve(listenerClass);
+    if (!instance) {
+      console.warn(`[EventModule] Failed to resolve listener class: ${listenerClass.name}. ` + "Make sure it is registered as a provider.");
+      return;
+    }
+    for (const listenerMetadata of metadata) {
+      const method = instance[listenerMetadata.methodName];
+      if (typeof method !== "function") {
+        console.warn(`[EventModule] Method "${listenerMetadata.methodName}" not found on ${listenerClass.name}`);
+        continue;
+      }
+      const boundMethod = method.bind(instance);
+      this.eventEmitter.on(listenerMetadata.event, boundMethod, {
+        async: listenerMetadata.async,
+        priority: listenerMetadata.priority
+      });
+    }
+  }
+}
+var EVENT_LISTENER_SCANNER_TOKEN = Symbol("@dangao/bun-server:events:scanner");
+
+class EventModule {
+  static listenerClasses = [];
+  static forRoot(options = {}) {
+    const providers2 = [];
+    const eventEmitter = new EventEmitterService(options);
+    providers2.push({
+      provide: EVENT_OPTIONS_TOKEN,
+      useValue: options
+    });
+    providers2.push({
+      provide: EVENT_EMITTER_TOKEN,
+      useValue: eventEmitter
+    });
+    const existingMetadata = Reflect.getMetadata(MODULE_METADATA_KEY, EventModule) || {};
+    const metadata = {
+      ...existingMetadata,
+      providers: [...existingMetadata.providers || [], ...providers2],
+      exports: [
+        ...existingMetadata.exports || [],
+        EVENT_EMITTER_TOKEN,
+        EVENT_OPTIONS_TOKEN
+      ]
+    };
+    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, EventModule);
+    EventModule.listenerClasses = [];
+    return EventModule;
+  }
+  static registerListeners(listenerClasses) {
+    EventModule.listenerClasses.push(...listenerClasses);
+  }
+  static initializeListeners(listenerContainer, additionalListeners = []) {
+    const registry = ModuleRegistry.getInstance();
+    const eventModuleRef = registry.getModuleRef(EventModule);
+    let eventEmitter;
+    if (eventModuleRef) {
+      try {
+        eventEmitter = eventModuleRef.container.resolve(EVENT_EMITTER_TOKEN);
+      } catch {}
+    }
+    if (!eventEmitter) {
+      console.warn("[EventModule] EventEmitter not found. Make sure EventModule.forRoot() is called and the module is registered.");
+      return;
+    }
+    const resolveContainer = listenerContainer ?? eventModuleRef?.container;
+    if (!resolveContainer) {
+      console.warn("[EventModule] No container available to resolve listeners.");
+      return;
+    }
+    const scanner = new EventListenerScanner(eventEmitter, resolveContainer);
+    const allListeners = [
+      ...EventModule.listenerClasses,
+      ...additionalListeners
+    ];
+    scanner.scanAndRegister(allListeners);
+  }
+  static getEventEmitter(container) {
+    const registry = ModuleRegistry.getInstance();
+    const moduleRef = registry.getModuleRef(EventModule);
+    if (moduleRef) {
+      try {
+        return moduleRef.container.resolve(EVENT_EMITTER_TOKEN);
+      } catch {}
+    }
+    if (container) {
+      try {
+        return container.resolve(EVENT_EMITTER_TOKEN);
+      } catch {}
+    }
+    return;
+  }
+}
+EventModule = __legacyDecorateClassTS([
+  Module({
+    providers: []
+  })
+], EventModule);
 export {
+  validateParameters,
+  validateObjectSync,
+  validateObject,
   scanInterceptorMetadata,
   requiresAuth,
+  registerReflector,
+  isValidateClass,
+  isGlobalModule,
+  isEventListenerClass,
+  getValidationMetadata,
   getTransactionMetadata,
+  getRolesMetadata,
   getRepositoryMetadata,
+  getOnEventMetadata,
+  getGuardsMetadata,
+  getGuardRegistry,
   getEntityMetadata,
   getColumnMetadata,
+  getClassValidationMetadata,
   getAuthMetadata,
   createUserKeyGenerator,
   createTokenKeyGenerator,
   createSwaggerUIMiddleware,
   createStaticFileMiddleware,
+  createSimpleValidator,
   createSessionMiddleware,
   createSecurityFilter,
+  createRolesGuard,
   createRequestLoggingMiddleware,
+  createRegexValidator,
   createRateLimitMiddleware,
   createLoggerMiddleware,
   createHttpMetricsMiddleware,
   createFileUploadMiddleware,
   createErrorHandlingMiddleware,
+  createCustomValidator,
   createCorsMiddleware,
   contextStore,
   checkRoles,
@@ -9538,10 +10964,15 @@ export {
   WebSocketGatewayRegistry,
   WebSocketGateway,
   ValidationError,
+  ValidateNested,
+  ValidateIf,
+  ValidateClass,
   Validate,
   UserInfoRequestInterceptor,
   UseMiddleware,
+  UseGuards,
   UnauthorizedException,
+  Transform,
   Transactional,
   TransactionStatus,
   TransactionManager,
@@ -9570,6 +11001,8 @@ export {
   RouteRegistry,
   Route,
   RoundRobinLoadBalancer,
+  RolesGuard,
+  Roles,
   RoleBasedAccessDecisionManager,
   RetryStrategyImpl,
   ResponseTransformInterceptor,
@@ -9578,11 +11011,14 @@ export {
   RequestWrapper,
   RequestLogInterceptor,
   Repository,
+  Reflector,
   RedisSessionStore,
   RedisCacheStore,
   RateLimiter,
   RateLimit,
   RandomLoadBalancer,
+  ROLES_METADATA_KEY,
+  REFLECTOR_TOKEN,
   QueueService,
   QueueModule,
   Queue,
@@ -9590,6 +11026,7 @@ export {
   Query,
   QUEUE_SERVICE_TOKEN,
   QUEUE_OPTIONS_TOKEN,
+  Property,
   Propagation,
   PrometheusFormatter,
   PrimaryKey,
@@ -9603,20 +11040,27 @@ export {
   PERMISSION_METADATA_KEY,
   PATCH,
   OrmService,
+  OptionalAuthGuard,
   OnOpen,
   OnMessage,
+  OnEvent,
   OnClose,
   ORM_SERVICE_TOKEN,
+  ON_EVENT_METADATA_KEY,
   OAuth2Service,
   OAuth2Controller,
   OAuth2AuthenticationProvider,
   OAUTH2_SERVICE_TOKEN,
   NotFoundException,
+  NotEquals,
+  NotContains,
+  NestedProperty,
   NacosServiceRegistry,
   NacosConfigCenter,
   ModuleRegistry,
   Module,
   MinLength,
+  Min,
   MiddlewarePipeline,
   MetricsModule,
   MetricsCollector,
@@ -9624,6 +11068,9 @@ export {
   MemorySessionStore,
   MemoryQueueStore,
   MemoryCacheStore,
+  MaxLength,
+  Max,
+  Matches,
   METRICS_SERVICE_TOKEN,
   METRICS_OPTIONS_TOKEN,
   LoggerModule,
@@ -9633,6 +11080,7 @@ export {
   Log,
   LoadBalancerFactory,
   Lifecycle,
+  Length,
   LeastActiveLoadBalancer,
   LOG_METADATA_KEY,
   LOGGER_TOKEN,
@@ -9640,10 +11088,39 @@ export {
   JWT_UTIL_TOKEN,
   JWTUtil,
   IsolationLevel,
+  IsUrl,
+  IsUUID,
   IsString,
+  IsSemVer,
+  IsPostalCode,
+  IsPositive,
+  IsPort,
+  IsPhoneNumber,
   IsOptional,
+  IsObject,
+  IsNumberString,
   IsNumber,
+  IsNotIn,
+  IsNotEmptyObject,
+  IsNotEmpty,
+  IsNegative,
+  IsMacAddress,
+  IsJSON,
+  IsInt,
+  IsIn,
+  IsIdCard,
+  IsIPv4,
+  IsHexColor,
   IsEmail,
+  IsDivisibleBy,
+  IsDefined,
+  IsDate,
+  IsCreditCard,
+  IsBoolean,
+  IsBetween,
+  IsArray,
+  IsAlphanumeric,
+  IsAlpha,
   InternalServerErrorException,
   InterceptorRegistry,
   InterceptorChain,
@@ -9656,12 +11133,26 @@ export {
   Header,
   HEALTH_OPTIONS_TOKEN,
   HEALTH_INDICATORS_TOKEN,
+  GuardRegistry,
+  Global,
+  GUARD_REGISTRY_TOKEN,
+  GUARDS_METADATA_KEY,
+  GLOBAL_MODULE_METADATA_KEY,
   GET,
   ForbiddenException,
+  ExecutionContextImpl,
   ExceptionFilterRegistry,
+  EventModule,
+  EventListenerScanner,
+  EventEmitterService,
   ErrorHandlerInterceptor,
+  Equals,
   Entity,
   EnableCacheProxy,
+  EVENT_OPTIONS_TOKEN,
+  EVENT_LISTENER_SCANNER_TOKEN,
+  EVENT_LISTENER_CLASS_METADATA_KEY,
+  EVENT_EMITTER_TOKEN,
   DrizzleBaseRepository,
   DatabaseService2 as DatabaseService,
   DatabaseModule,
@@ -9677,6 +11168,7 @@ export {
   ContextService,
   Context2 as ContextParam,
   Context,
+  Contains,
   Container,
   ConsoleTraceCollector,
   ConsistentHashLoadBalancer,
@@ -9713,7 +11205,15 @@ export {
   BaseInterceptor,
   BadRequestException,
   AuthenticationManager,
+  AuthGuard,
   Auth,
+  ArrayUnique,
+  ArrayNotEmpty,
+  ArrayNotContains,
+  ArrayNestedProperty,
+  ArrayMinSize,
+  ArrayMaxSize,
+  ArrayContains,
   Application,
   ApiTags,
   ApiResponse,