koatty_validation 1.4.0 → 1.6.1

package/dist/index.js

@@ -1,6 +1,6 @@
 /*!
 * @Author: richen
-* @Date: 2025-06-10 23:32:27
+* @Date: 2025-10-23 20:54:39
 * @License: BSD (3-Clause)
 * @Copyright (c) - <richenlin(at)gmail.com>
 * @HomePage: https://koatty.org/
@@ -10,8 +10,8 @@
 var helper = require('koatty_lib');
 require('reflect-metadata');
 var koatty_container = require('koatty_container');
-var classValidator = require('class-validator');
 var lruCache = require('lru-cache');
+var classValidator = require('class-validator');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -33,1418 +33,1524 @@ function _interopNamespaceDefault(e) {
 var helper__namespace = /*#__PURE__*/_interopNamespaceDefault(helper);
 
 /**
- * @ author: richen
- * @ copyright: Copyright (c) - <richenlin(at)gmail.com>
- * @ license: MIT
- * @ version: 2020-03-20 11:34:38
+ * koatty_validation type definitions
+ * @author richen
+ * @copyright Copyright (c) - <richenlin(at)gmail.com>
+ * @license MIT
+ */
+/**
+ * Parameter type key constant
  */
-// tslint:disable-next-line: no-import-side-effect
-// 参数类型键常量
 const PARAM_TYPE_KEY = 'PARAM_TYPE_KEY';
+
 /**
- * Set property as included in the process of transformation.
- *
- * @export
- * @param {Object} object
- * @param {(string | symbol)} propertyName
+ * Performance cache module - Provides multi-level caching and performance monitoring
+ * @author richen
  */
-function setExpose(object, propertyName) {
-    const types = Reflect.getMetadata("design:type", object, propertyName);
-    if (types) {
-        const originMap = koatty_container.getOriginMetadata(PARAM_TYPE_KEY, object);
-        originMap.set(propertyName, types.name);
-    }
-}
 /**
- * plain object convert to class instance
- *
- * @export
- * @param {*} clazz
- * @param {*} data
- * @param {boolean} [convert=false]
- * @returns
+ * Metadata cache
  */
-function plainToClass(clazz, data, convert = false) {
-    if (helper__namespace.isClass(clazz)) {
-        if (!helper__namespace.isObject(data)) {
-            data = {};
-        }
-        if (data instanceof clazz) {
-            return data;
+class MetadataCache {
+    constructor() {
+        this.cache = new WeakMap();
+    }
+    static getInstance() {
+        if (!MetadataCache.instance) {
+            MetadataCache.instance = new MetadataCache();
         }
-        return assignDtoParams(clazz, data, convert);
+        return MetadataCache.instance;
     }
-    return data;
-}
-/**
- * assign dto params
- * @param clazz
- * @param data
- * @param convert
- * @returns
- */
-function assignDtoParams(clazz, data, convert = false) {
-    const cls = Reflect.construct(clazz, []);
-    if (convert) {
-        const metaData = getDtoParamsMeta(clazz, cls);
-        for (const [key, type] of metaData) {
-            if (key && data[key] !== undefined) {
-                cls[key] = convertParamsType(data[key], type);
-            }
+    /**
+     * Get metadata cache for a class
+     */
+    getClassCache(target) {
+        if (!this.cache.has(target)) {
+            this.cache.set(target, new Map());
         }
+        return this.cache.get(target);
     }
-    else {
-        for (const key in cls) {
-            if (Object.prototype.hasOwnProperty.call(data, key) &&
-                data[key] !== undefined) {
-                cls[key] = data[key];
-            }
+    /**
+     * Cache metadata
+     */
+    setMetadata(target, key, value) {
+        const classCache = this.getClassCache(target);
+        classCache.set(key, value);
+    }
+    /**
+     * Get cached metadata
+     */
+    getMetadata(target, key) {
+        const classCache = this.getClassCache(target);
+        return classCache.get(key);
+    }
+    /**
+     * Check if metadata is cached
+     */
+    hasMetadata(target, key) {
+        const classCache = this.getClassCache(target);
+        return classCache.has(key);
+    }
+    /**
+     * Clear cache for a specific class
+     */
+    clearClassCache(target) {
+        if (this.cache.has(target)) {
+            this.cache.delete(target);
         }
     }
-    return cls;
 }
 /**
- * get class prototype type def.
- * @param clazz
- * @param cls
- * @returns
+ * Validation result cache
  */
-function getDtoParamsMeta(clazz, cls) {
-    // Non-own properties are inherited from the prototype chain,  
-    // ensure that properties are not polluted
-    if (!Object.prototype.hasOwnProperty.call(cls, "_typeDef") &&
-        ("_typeDef" in cls)) {
-        return cls._typeDef;
+class ValidationCache {
+    constructor(options) {
+        this.hits = 0;
+        this.misses = 0;
+        this.cache = new lruCache.LRUCache({
+            max: (options === null || options === void 0 ? void 0 : options.max) || 5000,
+            ttl: (options === null || options === void 0 ? void 0 : options.ttl) || 1000 * 60 * 10, // 10 minutes
+            allowStale: (options === null || options === void 0 ? void 0 : options.allowStale) || false,
+            updateAgeOnGet: (options === null || options === void 0 ? void 0 : options.updateAgeOnGet) || true,
+        });
     }
-    const typeDef = koatty_container.getOriginMetadata(PARAM_TYPE_KEY, clazz);
-    Reflect.defineProperty(clazz.prototype, "_typeDef", {
-        enumerable: true,
-        configurable: false,
-        writable: false,
-        value: typeDef,
-    });
-    return typeDef;
-}
-/**
- * convertDtoParamsType
- *
- * @param {*} clazz
- * @param {*} cls
- * @returns {*} cls
- */
-function convertDtoParamsType(clazz, cls) {
-    if (Object.prototype.hasOwnProperty.call(cls, "_typeDef")) {
-        for (const key in cls) {
-            if (Object.prototype.hasOwnProperty.call(cls._typeDef, key) &&
-                cls[key] !== undefined) {
-                cls[key] = convertParamsType(cls[key], cls._typeDef[key]);
-            }
+    static getInstance(options) {
+        if (!ValidationCache.instance) {
+            ValidationCache.instance = new ValidationCache(options);
         }
+        return ValidationCache.instance;
     }
-    else {
-        const originMap = koatty_container.getOriginMetadata(PARAM_TYPE_KEY, clazz);
-        for (const [key, type] of originMap) {
-            if (key && cls[key] !== undefined) {
-                cls[key] = convertParamsType(cls[key], type);
-            }
+    /**
+     * 生成缓存键
+     */
+    generateKey(validator, value, ...args) {
+        const valueStr = this.serializeValue(value);
+        const argsStr = args.length > 0 ? JSON.stringify(args) : '';
+        return `${validator}:${valueStr}:${argsStr}`;
+    }
+    /**
+     * 序列化值用于缓存键
+     */
+    serializeValue(value) {
+        if (value === null)
+            return 'null';
+        if (value === undefined)
+            return 'undefined';
+        if (typeof value === 'string')
+            return `s:${value}`;
+        if (typeof value === 'number')
+            return `n:${value}`;
+        if (typeof value === 'boolean')
+            return `b:${value}`;
+        if (Array.isArray(value))
+            return `a:${JSON.stringify(value)}`;
+        if (typeof value === 'object')
+            return `o:${JSON.stringify(value)}`;
+        return String(value);
+    }
+    /**
+     * 获取缓存的验证结果
+     */
+    get(validator, value, ...args) {
+        const key = this.generateKey(validator, value, ...args);
+        const result = this.cache.get(key);
+        // Track cache hits and misses
+        if (result !== undefined) {
+            this.hits++;
+        }
+        else {
+            this.misses++;
+        }
+        return result;
+    }
+    /**
+     * 缓存验证结果
+     */
+    set(validator, value, result, ...args) {
+        const key = this.generateKey(validator, value, ...args);
+        this.cache.set(key, result);
+    }
+    /**
+     * 检查是否存在缓存
+     */
+    has(validator, value, ...args) {
+        const key = this.generateKey(validator, value, ...args);
+        return this.cache.has(key);
+    }
+    /**
+     * 删除特定缓存
+     */
+    delete(validator, value, ...args) {
+        const key = this.generateKey(validator, value, ...args);
+        return this.cache.delete(key);
+    }
+    /**
+     * 清空缓存
+     */
+    clear() {
+        this.cache.clear();
+        this.hits = 0;
+        this.misses = 0;
+    }
+    /**
+     * 获取缓存统计
+     */
+    getStats() {
+        const totalRequests = this.hits + this.misses;
+        const hitRate = totalRequests > 0 ? this.hits / totalRequests : 0;
+        return {
+            size: this.cache.size,
+            max: this.cache.max,
+            calculatedSize: this.cache.calculatedSize,
+            keyCount: this.cache.size,
+            hits: this.hits,
+            misses: this.misses,
+            hitRate: Math.round(hitRate * 10000) / 100, // Percentage with 2 decimal places
+            totalRequests,
+        };
+    }
+    /**
+     * 设置缓存TTL
+     */
+    setTTL(validator, value, ttl, ...args) {
+        const key = this.generateKey(validator, value, ...args);
+        const existingValue = this.cache.get(key);
+        if (existingValue !== undefined) {
+            this.cache.set(key, existingValue, { ttl });
         }
     }
-    return cls;
 }
 /**
- * 绑定参数类型转换
- *
- * @param {*} param
- * @param {string} type
- * @returns {*}
+ * 正则表达式缓存
  */
-function convertParamsType(param, type) {
-    try {
-        switch (type) {
-            case "Number":
-            case "number":
-                if (helper__namespace.isNaN(param)) {
-                    return NaN;
-                }
-                if (helper__namespace.isNumber(param)) {
-                    return param;
-                }
-                if (helper__namespace.isNumberString(param)) {
-                    return helper__namespace.toNumber(param);
-                }
-                return NaN;
-            case "Boolean":
-            case "boolean":
-                return !!param;
-            case "Array":
-            case "array":
-            case "Tuple":
-            case "tuple":
-                if (helper__namespace.isArray(param)) {
-                    return param;
-                }
-                return helper__namespace.toArray(param);
-            case "String":
-            case "string":
-                if (helper__namespace.isString(param)) {
-                    return param;
-                }
-                return helper__namespace.toString(param);
-            case "Null":
-            case "null":
-                return null;
-            case "Undefined":
-            case "undefined":
-                return undefined;
-            case "Bigint":
-            case "bigint":
-                if (typeof param === 'bigint') {
-                    return param;
-                }
-                return BigInt(param);
-            // case "object":
-            // case "enum":
-            default: //any
-                return param;
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+class RegexCache {
+    constructor(options) {
+        this.cache = new lruCache.LRUCache({
+            max: (options === null || options === void 0 ? void 0 : options.max) || 200,
+            ttl: (options === null || options === void 0 ? void 0 : options.ttl) || 1000 * 60 * 30, // 30 minutes
+            allowStale: (options === null || options === void 0 ? void 0 : options.allowStale) || false,
+            updateAgeOnGet: (options === null || options === void 0 ? void 0 : options.updateAgeOnGet) || true,
+        });
     }
-    catch (_err) {
-        return param;
+    static getInstance(options) {
+        if (!RegexCache.instance) {
+            RegexCache.instance = new RegexCache(options);
+        }
+        return RegexCache.instance;
     }
-}
-/**
- * Check the base types.
- *
- * @param {*} value
- * @param {string} type
- * @returns {*}
- */
-function checkParamsType(value, type) {
-    switch (type) {
-        case "Number":
-        case "number":
-            if (!helper__namespace.isNumber(value) || helper__namespace.isNaN(value)) {
-                return false;
-            }
-            return true;
-        case "Boolean":
-        case "boolean":
-            if (!helper__namespace.isBoolean(value)) {
-                return false;
-            }
-            return true;
-        case "Array":
-        case "array":
-        case "Tuple":
-        case "tuple":
-            if (!helper__namespace.isArray(value)) {
-                return false;
-            }
-            return true;
-        case "String":
-        case "string":
-            if (!helper__namespace.isString(value)) {
-                return false;
-            }
-            return true;
-        case "Object":
-        case "object":
-        case "Enum":
-        case "enum":
-            if (helper__namespace.isTrueEmpty(value)) {
-                return false;
+    /**
+     * 获取缓存的正则表达式
+     */
+    get(pattern, flags) {
+        const key = flags ? `${pattern}:::${flags}` : pattern;
+        let regex = this.cache.get(key);
+        if (!regex) {
+            try {
+                regex = new RegExp(pattern, flags);
+                this.cache.set(key, regex);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
             }
-            return true;
-        case "Null":
-        case "null":
-            if (!helper__namespace.isNull(value)) {
-                return false;
+            catch (_error) {
+                // 如果正则表达式无效，抛出错误
+                throw new Error(`Invalid regex pattern: ${pattern}`);
             }
-            return true;
-        case "Undefined":
-        case "undefined":
-            if (!helper__namespace.isUndefined(value)) {
-                return false;
+        }
+        return regex;
+    }
+    /**
+     * 预编译常用正则表达式
+     */
+    precompile(patterns) {
+        patterns.forEach(({ pattern, flags }) => {
+            try {
+                this.get(pattern, flags);
             }
-            return true;
-        case "Bigint":
-        case "bigint":
-            if (typeof value !== 'bigint') {
-                return false;
+            catch (error) {
+                console.warn(`Failed to precompile regex: ${pattern}`, error);
             }
-            return true;
-        default: //any
-            return true;
-    }
-}
-/**
- * Checks if value is a chinese name.
- *
- * @param {string} value
- * @returns {boolean}
- */
-function cnName(value) {
-    const reg = /^([a-zA-Z0-9\u4e00-\u9fa5\·]{1,10})$/;
-    return reg.test(value);
-}
-/**
- * Checks if value is a idCard number.
- *
- * @param {string} value
- * @returns
- */
-function idNumber(value) {
-    if (/^\d{15}$/.test(value)) {
-        return true;
-    }
-    if ((/^\d{17}[0-9X]$/).test(value)) {
-        const vs = '1,0,x,9,8,7,6,5,4,3,2'.split(',');
-        const ps = '7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2'.split(',');
-        const ss = value.toLowerCase().split('');
-        let r = 0;
-        for (let i = 0; i < 17; i++) {
-            r += ps[i] * ss[i];
-        }
-        const isOk = (vs[r % 11] === ss[17]);
-        return isOk;
+        });
     }
-    return false;
-}
-/**
- * Checks if value is a mobile phone number.
- *
- * @param {string} value
- * @returns {boolean}
- */
-function mobile(value) {
-    const reg = /^(13|14|15|16|17|18|19)\d{9}$/;
-    return reg.test(value);
-}
-/**
- * Checks if value is a zipCode.
- *
- * @param {string} value
- * @returns {boolean}
- */
-function zipCode(value) {
-    const reg = /^\d{6}$/;
-    return reg.test(value);
-}
-/**
- * Checks if value is a plateNumber.
- *
- * @param {string} value
- * @returns {boolean}
- */
-function plateNumber(value) {
-    // let reg = new RegExp('^(([\u4e00-\u9fa5][a-zA-Z]|[\u4e00-\u9fa5]{2}\d{2}|[\u4e00-\u9fa5]{2}[a-zA-Z])[-]?|([wW][Jj][\u4e00-\u9fa5]{1}[-]?)|([a-zA-Z]{2}))([A-Za-z0-9]{5}|[DdFf][A-HJ-NP-Za-hj-np-z0-9][0-9]{4}|[0-9]{5}[DdFf])$');
-    // let xReg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}(([0-9]{5}[DF]$)|([DF][A-HJ-NP-Z0-9][0-9]{4}$))/;
-    const xReg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领]{1}[A-Z]{1}(([0-9]{5}[DF]$)|([DF][A-HJ-NP-Z0-9][0-9]{4}$))/;
-    // let cReg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}[A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9挂学警港澳]{1}$/;
-    const cReg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领]{1}[A-Z]{1}[A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9挂学警港澳]{1}$/;
-    if (value.length === 7) {
-        return cReg.test(value);
+    /**
+     * 获取缓存统计
+     */
+    getStats() {
+        return {
+            size: this.cache.size,
+            max: this.cache.max,
+            calculatedSize: this.cache.calculatedSize,
+        };
     }
-    else {
-        //新能源车牌
-        return xReg.test(value);
+    /**
+     * 清空缓存
+     */
+    clear() {
+        this.cache.clear();
     }
 }
-
-/*
- * @Description:
- * @Usage:
- * @Author: richen
- * @Date: 2021-11-25 10:47:04
- * @LastEditTime: 2024-01-03 14:32:49
- */
-// constant
-const PARAM_RULE_KEY = 'PARAM_RULE_KEY';
-const PARAM_CHECK_KEY = 'PARAM_CHECK_KEY';
-const ENABLE_VALIDATED = "ENABLE_VALIDATED";
 /**
- * paramterTypes
- *
- * @export
- * @enum {number}
+ * 性能监控
  */
-exports.paramterTypes = void 0;
-(function (paramterTypes) {
-    paramterTypes[paramterTypes["Number"] = 0] = "Number";
-    paramterTypes[paramterTypes["number"] = 1] = "number";
-    paramterTypes[paramterTypes["String"] = 2] = "String";
-    paramterTypes[paramterTypes["string"] = 3] = "string";
-    paramterTypes[paramterTypes["Boolean"] = 4] = "Boolean";
-    paramterTypes[paramterTypes["boolean"] = 5] = "boolean";
-    paramterTypes[paramterTypes["Array"] = 6] = "Array";
-    paramterTypes[paramterTypes["array"] = 7] = "array";
-    paramterTypes[paramterTypes["Tuple"] = 8] = "Tuple";
-    paramterTypes[paramterTypes["tuple"] = 9] = "tuple";
-    paramterTypes[paramterTypes["Object"] = 10] = "Object";
-    paramterTypes[paramterTypes["object"] = 11] = "object";
-    paramterTypes[paramterTypes["Enum"] = 12] = "Enum";
-    paramterTypes[paramterTypes["enum"] = 13] = "enum";
-    paramterTypes[paramterTypes["Bigint"] = 14] = "Bigint";
-    paramterTypes[paramterTypes["bigint"] = 15] = "bigint";
-    paramterTypes[paramterTypes["Null"] = 16] = "Null";
-    paramterTypes[paramterTypes["null"] = 17] = "null";
-    paramterTypes[paramterTypes["Undefined"] = 18] = "Undefined";
-    paramterTypes[paramterTypes["undefined"] = 19] = "undefined";
-})(exports.paramterTypes || (exports.paramterTypes = {}));
-class ValidateClass {
+class PerformanceMonitor {
     constructor() {
+        this.metrics = new Map();
     }
-    /**
-     *
-     *
-     * @static
-     * @returns
-     * @memberof ValidateUtil
-     */
     static getInstance() {
-        return this.instance || (this.instance = new ValidateClass());
-    }
-    /**
-     * validated data vs dto class
-     *
-     * @param {*} Clazz
-     * @param {*} data
-     * @param {boolean} [convert=false] auto convert parameters type
-     * @returns {Promise<any>}
-     * @memberof ValidateClass
-     */
-    async valid(Clazz, data, convert = false) {
-        let obj = {};
-        if (data instanceof Clazz) {
-            obj = data;
-        }
-        else {
-            obj = plainToClass(Clazz, data, convert);
-        }
-        let errors = [];
-        if (convert) {
-            errors = await classValidator.validate(obj);
-        }
-        else {
-            errors = await classValidator.validate(obj, { skipMissingProperties: true });
-        }
-        if (errors.length > 0) {
-            throw new Error(Object.values(errors[0].constraints)[0]);
+        if (!PerformanceMonitor.instance) {
+            PerformanceMonitor.instance = new PerformanceMonitor();
         }
-        return obj;
+        return PerformanceMonitor.instance;
     }
-}
-/**
- * ClassValidator for manual
- */
-const ClassValidator = ValidateClass.getInstance();
-/**
- * Validator Functions
- */
-const ValidFuncs = {
-    /**
-     * Checks value is not empty, undefined, null, '', NaN, [], {} and any empty string(including spaces,
-     * tabs, formfeeds, etc.), returns false
-     */
-    IsNotEmpty: (value) => {
-        return !helper__namespace.isEmpty(value);
-    },
-    /**
-     * Checks if a given value is a real date.
-     */
-    IsDate: (value) => {
-        return helper__namespace.isDate(value);
-    },
-    /**
-     * Checks if the string is an email. If given value is not a string, then it returns false.
-     */
-    IsEmail: (value, options) => {
-        return classValidator.isEmail(value, options);
-    },
-    /**
-     * Checks if the string is an IP (version 4 or 6). If given value is not a string, then it returns false.
-     */
-    IsIP: (value, version) => {
-        return classValidator.isIP(value, version);
-    },
-    /**
-     * Checks if the string is a valid phone number.
-     * @param value — the potential phone number string to test
-     * @param region 2 characters uppercase country code (e.g. DE, US, CH). If users must enter the intl.
-     * prefix (e.g. +41), then you may pass "ZZ" or null as region.
-     * See [google-libphonenumber, metadata.js:countryCodeToRegionCodeMap on github]
-     * {@link https://github.com/ruimarinho/google-libphonenumber/blob/1e46138878cff479aafe2ce62175c6c49cb58720/src/metadata.js#L33}
-     */
-    IsPhoneNumber: (value, region) => {
-        return classValidator.isPhoneNumber(value, region);
-    },
     /**
-     * Checks if the string is an url. If given value is not a string, then it returns false.
-     */
-    IsUrl: (value, options) => {
-        return classValidator.isURL(value, options);
-    },
-    /**
-     * check if the string is a hash of type algorithm. Algorithm is one of
-     * ['md4', 'md5', 'sha1', 'sha256', 'sha384', 'sha512', 'ripemd128', 'ripemd160', 'tiger128', 'tiger160', 'tiger192', 'crc32', 'crc32b']
+     * 开始计时
      */
-    IsHash: (value, algorithm) => {
-        return classValidator.isHash(value, algorithm);
-    },
+    startTimer(name) {
+        const start = performance.now();
+        return () => {
+            const duration = performance.now() - start;
+            this.recordMetric(name, duration);
+        };
+    }
     /**
-     * Checks if value is a chinese name.
+     * 记录性能指标
      */
-    IsCnName: (value) => {
-        if (!helper__namespace.isString(value)) {
-            return false;
+    recordMetric(name, duration) {
+        if (!this.metrics.has(name)) {
+            this.metrics.set(name, {
+                count: 0,
+                totalTime: 0,
+                avgTime: 0,
+                maxTime: 0,
+                minTime: Infinity,
+                lastExecutionTime: new Date(),
+            });
         }
-        return cnName(value);
-    },
+        const metric = this.metrics.get(name);
+        metric.count++;
+        metric.totalTime += duration;
+        metric.avgTime = metric.totalTime / metric.count;
+        metric.maxTime = Math.max(metric.maxTime, duration);
+        metric.minTime = Math.min(metric.minTime, duration);
+        metric.lastExecutionTime = new Date();
+    }
     /**
-     * Checks if value is a idcard number.
+     * 获取性能报告
      */
-    IsIdNumber: (value) => {
-        if (!helper__namespace.isString(value)) {
-            return false;
+    getReport() {
+        const report = {};
+        for (const [name, metric] of this.metrics) {
+            report[name] = {
+                ...metric,
+                minTime: metric.minTime === Infinity ? 0 : metric.minTime,
+                avgTimeFormatted: `${metric.avgTime.toFixed(2)}ms`,
+                totalTimeFormatted: `${metric.totalTime.toFixed(2)}ms`,
+            };
         }
-        return idNumber(value);
-    },
+        return report;
+    }
     /**
-     * Checks if value is a zipCode.
+     * 获取热点分析（执行时间最长的操作）
      */
-    IsZipCode: (value) => {
-        if (!helper__namespace.isString(value)) {
-            return false;
-        }
-        return zipCode(value);
-    },
+    getHotspots(limit = 10) {
+        return Array.from(this.metrics.entries())
+            .map(([name, metric]) => ({
+            name,
+            avgTime: metric.avgTime,
+            count: metric.count,
+        }))
+            .sort((a, b) => b.avgTime - a.avgTime)
+            .slice(0, limit);
+    }
     /**
-     * Checks if value is a mobile phone number.
+     * 清空指标
      */
-    IsMobile: (value) => {
-        if (!helper__namespace.isString(value)) {
-            return false;
-        }
-        return mobile(value);
-    },
+    clear() {
+        this.metrics.clear();
+    }
     /**
-     * Checks if value is a plateNumber.
+     * 导出性能数据为CSV格式
      */
-    IsPlateNumber: (value) => {
-        if (!helper__namespace.isString(value)) {
-            return false;
+    exportToCSV() {
+        const headers = ['Name', 'Count', 'Total Time (ms)', 'Avg Time (ms)', 'Max Time (ms)', 'Min Time (ms)', 'Last Execution'];
+        const rows = [headers.join(',')];
+        for (const [name, metric] of this.metrics) {
+            const row = [
+                name,
+                metric.count.toString(),
+                metric.totalTime.toFixed(2),
+                metric.avgTime.toFixed(2),
+                metric.maxTime.toFixed(2),
+                (metric.minTime === Infinity ? 0 : metric.minTime).toFixed(2),
+                metric.lastExecutionTime.toISOString(),
+            ];
+            rows.push(row.join(','));
         }
-        return plateNumber(value);
-    },
-    /**
-     * Checks if value matches ("===") the comparison.
-     */
-    Equals: (value, comparison) => {
-        return classValidator.equals(value, comparison);
-    },
-    /**
-     * Checks if value does not match ("!==") the comparison.
-     */
-    NotEquals: (value, comparison) => {
-        return classValidator.notEquals(value, comparison);
-    },
-    /**
-     * Checks if the string contains the seed. If given value is not a string, then it returns false.
-     */
-    Contains: (value, seed) => {
-        return classValidator.contains(value, seed);
-    },
-    /**
-     * Checks if given value is in a array of allowed values.
-     */
-    IsIn: (value, possibleValues) => {
-        return classValidator.isIn(value, possibleValues);
-    },
-    /**
-     * Checks if given value not in a array of allowed values.
-     */
-    IsNotIn: (value, possibleValues) => {
-        return classValidator.isNotIn(value, possibleValues);
-    },
-    /**
-     * Checks if the first number is greater than or equal to the second.
-     */
-    Gt: (num, min) => {
-        return helper__namespace.toNumber(num) > min;
-    },
-    /**
-     * Checks if the first number is less than or equal to the second.
-     */
-    Lt: (num, max) => {
-        return helper__namespace.toNumber(num) < max;
-    },
-    /**
-     * Checks if the first number is greater than or equal to the second.
-     */
-    Gte: (num, min) => {
-        return helper__namespace.toNumber(num) >= min;
-    },
-    /**
-     * Checks if the first number is less than or equal to the second.
-     */
-    Lte: (num, max) => {
-        return helper__namespace.toNumber(num) <= max;
-    },
-};
+        return rows.join('\n');
+    }
+}
+// 导出单例实例
+const metadataCache = MetadataCache.getInstance();
+const validationCache = ValidationCache.getInstance();
+const regexCache = RegexCache.getInstance();
+const performanceMonitor = PerformanceMonitor.getInstance();
 /**
- * Use functions or built-in rules for validation.
- *
- * @export
- * @param {ValidRules} rule
- * @param {unknown} value
- * @param {(string | ValidOtpions)} [options]
- * @returns {*}
+ * 缓存装饰器 - 用于缓存验证函数结果
  */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-const FunctionValidator = {
-    IsNotEmpty: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    IsDate: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    IsEmail: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    IsIP: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    IsPhoneNumber: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    IsUrl: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    IsHash: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    IsCnName: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    IsIdNumber: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    IsZipCode: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    IsMobile: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    IsPlateNumber: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    Equals: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    NotEquals: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    Contains: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    IsIn: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    IsNotIn: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    Gt: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    Lt: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    Gte: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    },
-    Lte: function (_value, _options) {
-        throw new Error("Function not implemented.");
-    }
-};
-/* eslint-enable @typescript-eslint/no-unused-vars */
-Object.keys(ValidFuncs).forEach((key) => {
-    FunctionValidator[key] = (value, options) => {
-        let validOptions;
-        if (typeof options === 'string') {
-            validOptions = { message: options, value: null };
-        }
-        else {
-            validOptions = options || { message: `ValidatorError: invalid arguments.`, value: null };
-        }
-        if (!ValidFuncs[key](value, validOptions.value)) {
-            throw new Error(validOptions.message || `ValidatorError: invalid arguments.`);
-        }
+function cached(validator, ttl) {
+    return function (target, propertyName, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            const value = args[0];
+            const additionalArgs = args.slice(1);
+            // 尝试从缓存获取结果
+            const cachedResult = validationCache.get(validator, value, ...additionalArgs);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            // 执行验证并缓存结果
+            const endTimer = performanceMonitor.startTimer(validator);
+            try {
+                const result = originalMethod.apply(this, args);
+                validationCache.set(validator, value, result, ...additionalArgs);
+                // If TTL is specified, set expiration time
+                if (ttl && ttl > 0) {
+                    validationCache.setTTL(validator, value, ttl, ...additionalArgs);
+                }
+                return result;
+            }
+            finally {
+                endTimer();
+            }
+        };
+        return descriptor;
     };
-});
-
+}
 /**
- * 装饰器工厂 - 消除装饰器代码重复
- * @author richen
+ * 获取所有缓存统计信息
  */
+function getAllCacheStats() {
+    return {
+        validation: validationCache.getStats(),
+        regex: regexCache.getStats(),
+        performance: performanceMonitor.getReport(),
+        hotspots: performanceMonitor.getHotspots(),
+    };
+}
 /**
- * 创建验证装饰器的工厂函数
- * @param options 装饰器配置选项
- * @returns 装饰器工厂函数
+ * 预热缓存 - 预编译常用正则表达式
  */
-function createValidationDecorator(options) {
-    const { name, validator, defaultMessage, requiresValue = false } = options;
-    return function decoratorFactory(...args) {
-        // 处理参数：最后一个参数是ValidationOptions，前面是验证函数的参数
-        const validationOptions = args[args.length - 1];
-        const validatorArgs = requiresValue ? args.slice(0, -1) : [];
-        return function propertyDecorator(object, propertyName) {
-            // 设置属性为可导出
-            setExpose(object, propertyName);
-            // 注册验证装饰器
-            classValidator.registerDecorator({
-                name,
-                target: object.constructor,
-                propertyName,
-                options: validationOptions,
-                constraints: validatorArgs,
-                validator: {
-                    validate(value) {
-                        try {
-                            return validator(value, ...validatorArgs);
-                        }
-                        catch {
-                            return false;
-                        }
-                    },
-                    defaultMessage(validationArguments) {
-                        const property = validationArguments.property;
-                        return defaultMessage
-                            ? defaultMessage.replace('$property', property)
-                            : `Invalid value for ${property}`;
-                    }
-                }
-            });
-        };
-    };
+function warmupCaches() {
+    // 预编译中文验证相关的正则表达式
+    const commonPatterns = [
+        { pattern: '^[\u4e00-\u9fa5]{2,8}$' }, // 中文姓名
+        { pattern: '^1[3-9]\\d{9}$' }, // 手机号
+        { pattern: '^\\d{6}$' }, // 邮政编码
+        { pattern: '^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼]' }, // 车牌号开头
+    ];
+    regexCache.precompile(commonPatterns);
 }
 /**
- * 创建简单验证装饰器（不需要额外参数）
- * @param name 装饰器名称
- * @param validator 验证函数
- * @param defaultMessage 默认错误信息
- * @returns 装饰器函数
+ * 清空所有缓存
  */
-function createSimpleDecorator(name, validator, defaultMessage) {
-    return createValidationDecorator({
-        name,
-        validator,
-        defaultMessage,
-        requiresValue: false
-    });
+function clearAllCaches() {
+    validationCache.clear();
+    regexCache.clear();
+    performanceMonitor.clear();
 }
 /**
- * 创建带参数的验证装饰器
- * @param name 装饰器名称
- * @param validator 验证函数
- * @param defaultMessage 默认错误信息
- * @returns 装饰器工厂函数
+ * 配置缓存设置
  */
-function createParameterizedDecorator(name, validator, defaultMessage) {
-    return createValidationDecorator({
-        name,
-        validator,
-        defaultMessage,
-        requiresValue: true
-    });
+function configureCaches(options) {
+    if (options.validation) {
+        // 重新创建验证缓存实例
+        ValidationCache.instance = new ValidationCache(options.validation);
+    }
+    if (options.regex) {
+        // 重新创建正则缓存实例
+        RegexCache.instance = new RegexCache(options.regex);
+    }
 }
 
 /**
- * 重构后的装饰器定义 - 使用工厂函数消除重复
- * @author richen
+ * @ author: richen
+ * @ copyright: Copyright (c) - <richenlin(at)gmail.com>
+ * @ license: MIT
+ * @ version: 2020-03-20 11:34:38
  */
-// 中国本土化验证装饰器
-const IsCnName = createSimpleDecorator('IsCnName', (value) => helper__namespace.isString(value) && cnName(value), 'must be a valid Chinese name');
-const IsIdNumber = createSimpleDecorator('IsIdNumber', (value) => helper__namespace.isString(value) && idNumber(value), 'must be a valid ID number');
-const IsZipCode = createSimpleDecorator('IsZipCode', (value) => helper__namespace.isString(value) && zipCode(value), 'must be a valid zip code');
-const IsMobile = createSimpleDecorator('IsMobile', (value) => helper__namespace.isString(value) && mobile(value), 'must be a valid mobile number');
-const IsPlateNumber = createSimpleDecorator('IsPlateNumber', (value) => helper__namespace.isString(value) && plateNumber(value), 'must be a valid plate number');
-// 基础验证装饰器
-const IsNotEmpty = createSimpleDecorator('IsNotEmpty', (value) => !helper__namespace.isEmpty(value), 'should not be empty');
-const IsDate = createSimpleDecorator('IsDate', (value) => helper__namespace.isDate(value), 'must be a valid date');
-// 带参数的验证装饰器
-const Equals = createParameterizedDecorator('Equals', (value, comparison) => value === comparison, 'must equal to $constraint1');
-const NotEquals = createParameterizedDecorator('NotEquals', (value, comparison) => value !== comparison, 'should not equal to $constraint1');
-const Contains = createParameterizedDecorator('Contains', (value, seed) => helper__namespace.isString(value) && value.includes(seed), 'must contain $constraint1');
-const IsIn = createParameterizedDecorator('IsIn', (value, possibleValues) => possibleValues.includes(value), 'must be one of the following values: $constraint1');
-const IsNotIn = createParameterizedDecorator('IsNotIn', (value, possibleValues) => !possibleValues.includes(value), 'should not be one of the following values: $constraint1');
-// 数值比较装饰器
-const Gt = createParameterizedDecorator('Gt', (value, min) => helper__namespace.toNumber(value) > min, 'must be greater than $constraint1');
-const Gte = createParameterizedDecorator('Gte', (value, min) => helper__namespace.toNumber(value) >= min, 'must be greater than or equal to $constraint1');
-const Lt = createParameterizedDecorator('Lt', (value, max) => helper__namespace.toNumber(value) < max, 'must be less than $constraint1');
-const Lte = createParameterizedDecorator('Lte', (value, max) => helper__namespace.toNumber(value) <= max, 'must be less than or equal to $constraint1');
-// 复杂验证装饰器（需要特殊处理）
-function IsEmail(options, validationOptions) {
-    return createParameterizedDecorator('IsEmail', (value) => classValidator.isEmail(value, options), 'must be a valid email')(validationOptions);
-}
-function IsIP(version, validationOptions) {
-    return createParameterizedDecorator('IsIP', (value) => classValidator.isIP(value, version), 'must be a valid IP address')(validationOptions);
-}
-function IsPhoneNumber(region, validationOptions) {
-    return createParameterizedDecorator('IsPhoneNumber', (value) => classValidator.isPhoneNumber(value, region), 'must be a valid phone number')(validationOptions);
-}
-function IsUrl(options, validationOptions) {
-    return createParameterizedDecorator('IsUrl', (value) => classValidator.isURL(value, options), 'must be a valid URL')(validationOptions);
-}
-function IsHash(algorithm, validationOptions) {
-    return createParameterizedDecorator('IsHash', (value) => classValidator.isHash(value, algorithm), 'must be a valid hash')(validationOptions);
-}
-// 基础工具装饰器（从原始decorator.ts移植）
+// tslint:disable-next-line: no-import-side-effect
 /**
- * 标记属性为可导出
+ * Set property as included in the process of transformation.
+ *
+ * @export
+ * @param {Object} object
+ * @param {(string | symbol)} propertyName
  */
-function Expose() {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-    };
+function setExpose(object, propertyName) {
+    const types = Reflect.getMetadata("design:type", object, propertyName);
+    if (types) {
+        const originMap = koatty_container.getOriginMetadata(PARAM_TYPE_KEY, object);
+        originMap.set(propertyName, types.name);
+    }
 }
 /**
- * Expose的别名
+ * plain object convert to class instance
+ *
+ * @export
+ * @param {*} clazz
+ * @param {*} data
+ * @param {boolean} [convert=false]
+ * @returns
  */
-function IsDefined() {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-    };
+function plainToClass(clazz, data, convert = false) {
+    if (helper__namespace.isClass(clazz)) {
+        if (!helper__namespace.isObject(data)) {
+            data = {};
+        }
+        if (data instanceof clazz) {
+            return data;
+        }
+        return assignDtoParams(clazz, data, convert);
+    }
+    return data;
 }
 /**
- * 参数验证装饰器
+ * assign dto params
+ * @param clazz
+ * @param data
+ * @param convert
+ * @returns
  */
-function Valid(rule, options) {
-    return function (object, propertyName, parameterIndex) {
-        // 这里保持与原始实现一致
-        const existingRules = Reflect.getOwnMetadata("validate", object, propertyName) || {};
-        existingRules[parameterIndex] = { rule, options };
-        Reflect.defineMetadata("validate", existingRules, object, propertyName);
-    };
+function assignDtoParams(clazz, data, convert = false) {
+    const cls = Reflect.construct(clazz, []);
+    if (convert) {
+        const metaData = getDtoParamsMeta(clazz, cls);
+        for (const [key, type] of metaData) {
+            if (key && data[key] !== undefined) {
+                cls[key] = convertParamsType(data[key], type);
+            }
+        }
+    }
+    else {
+        for (const key in cls) {
+            if (Object.prototype.hasOwnProperty.call(data, key) &&
+                data[key] !== undefined) {
+                cls[key] = data[key];
+            }
+        }
+    }
+    return cls;
 }
 /**
- * 方法验证装饰器
+ * get class prototype type def.
+ * @param clazz
+ * @param cls
+ * @returns
  */
-function Validated() {
-    return function (object, propertyName, descriptor) {
-        const originalMethod = descriptor.value;
-        descriptor.value = function (...args) {
-            // 这里可以添加验证逻辑
-            return originalMethod.apply(this, args);
-        };
-        return descriptor;
-    };
+function getDtoParamsMeta(clazz, cls) {
+    // Non-own properties are inherited from the prototype chain,  
+    // ensure that properties are not polluted
+    if (!Object.prototype.hasOwnProperty.call(cls, "_typeDef") &&
+        ("_typeDef" in cls)) {
+        return cls._typeDef;
+    }
+    const typeDef = koatty_container.getOriginMetadata(PARAM_TYPE_KEY, clazz);
+    Reflect.defineProperty(clazz.prototype, "_typeDef", {
+        enumerable: true,
+        configurable: false,
+        writable: false,
+        value: typeDef,
+    });
+    return typeDef;
 }
-
 /**
- * 改进的错误处理机制
- * @author richen
+ * convertDtoParamsType
+ *
+ * @param {*} clazz
+ * @param {*} cls
+ * @returns {*} cls
  */
+function convertDtoParamsType(clazz, cls) {
+    if (Object.prototype.hasOwnProperty.call(cls, "_typeDef")) {
+        for (const key in cls) {
+            if (Object.prototype.hasOwnProperty.call(cls._typeDef, key) &&
+                cls[key] !== undefined) {
+                cls[key] = convertParamsType(cls[key], cls._typeDef[key]);
+            }
+        }
+    }
+    else {
+        const originMap = koatty_container.getOriginMetadata(PARAM_TYPE_KEY, clazz);
+        for (const [key, type] of originMap) {
+            if (key && cls[key] !== undefined) {
+                cls[key] = convertParamsType(cls[key], type);
+            }
+        }
+    }
+    return cls;
+}
 /**
- * 错误信息国际化
+ * 绑定参数类型转换
+ *
+ * @param {*} param
+ * @param {string} type
+ * @returns {*}
  */
-const ERROR_MESSAGES = {
-    zh: {
-        // 中国本土化验证
-        IsCnName: '必须是有效的中文姓名',
-        IsIdNumber: '必须是有效的身份证号码',
-        IsZipCode: '必须是有效的邮政编码',
-        IsMobile: '必须是有效的手机号码',
-        IsPlateNumber: '必须是有效的车牌号码',
-        // 基础验证
-        IsNotEmpty: '不能为空',
-        IsDate: '必须是有效的日期',
-        IsEmail: '必须是有效的邮箱地址',
-        IsIP: '必须是有效的IP地址',
-        IsPhoneNumber: '必须是有效的电话号码',
-        IsUrl: '必须是有效的URL地址',
-        IsHash: '必须是有效的哈希值',
-        // 比较验证
-        Equals: '必须等于 {comparison}',
-        NotEquals: '不能等于 {comparison}',
-        Contains: '必须包含 {seed}',
-        IsIn: '必须是以下值之一: {possibleValues}',
-        IsNotIn: '不能是以下值之一: {possibleValues}',
-        Gt: '必须大于 {min}',
-        Gte: '必须大于或等于 {min}',
-        Lt: '必须小于 {max}',
-        Lte: '必须小于或等于 {max}',
-        // 通用错误
-        invalidParameter: '参数 {field} 无效',
-        validationFailed: '验证失败',
-    },
-    en: {
-        // Chinese localization validators
-        IsCnName: 'must be a valid Chinese name',
-        IsIdNumber: 'must be a valid ID number',
-        IsZipCode: 'must be a valid zip code',
-        IsMobile: 'must be a valid mobile number',
-        IsPlateNumber: 'must be a valid plate number',
-        // Basic validators
-        IsNotEmpty: 'should not be empty',
-        IsDate: 'must be a valid date',
-        IsEmail: 'must be a valid email',
-        IsIP: 'must be a valid IP address',
-        IsPhoneNumber: 'must be a valid phone number',
-        IsUrl: 'must be a valid URL',
-        IsHash: 'must be a valid hash',
-        // Comparison validators
-        Equals: 'must equal to {comparison}',
-        NotEquals: 'should not equal to {comparison}',
-        Contains: 'must contain {seed}',
-        IsIn: 'must be one of the following values: {possibleValues}',
-        IsNotIn: 'should not be one of the following values: {possibleValues}',
-        Gt: 'must be greater than {min}',
-        Gte: 'must be greater than or equal to {min}',
-        Lt: 'must be less than {max}',
-        Lte: 'must be less than or equal to {max}',
-        // Common errors
-        invalidParameter: 'invalid parameter {field}',
-        validationFailed: 'validation failed',
+function convertParamsType(param, type) {
+    try {
+        switch (type) {
+            case "Number":
+            case "number":
+                if (helper__namespace.isNaN(param)) {
+                    return NaN;
+                }
+                if (helper__namespace.isNumber(param)) {
+                    // Check for safe integer range
+                    if (Number.isInteger(param) && !Number.isSafeInteger(param)) {
+                        console.warn(`[koatty_validation] Number ${param} exceeds safe integer range`);
+                    }
+                    return param;
+                }
+                if (helper__namespace.isNumberString(param)) {
+                    const num = helper__namespace.toNumber(param);
+                    if (Number.isInteger(num) && !Number.isSafeInteger(num)) {
+                        console.warn(`[koatty_validation] Number ${param} exceeds safe integer range`);
+                    }
+                    return num;
+                }
+                return NaN;
+            case "Boolean":
+            case "boolean":
+                return !!param;
+            case "Array":
+            case "array":
+            case "Tuple":
+            case "tuple":
+                if (helper__namespace.isArray(param)) {
+                    return param;
+                }
+                return helper__namespace.toArray(param);
+            case "String":
+            case "string":
+                if (helper__namespace.isString(param)) {
+                    return param;
+                }
+                return helper__namespace.toString(param);
+            case "Null":
+            case "null":
+                return null;
+            case "Undefined":
+            case "undefined":
+                return undefined;
+            case "Bigint":
+            case "bigint":
+                if (typeof param === 'bigint') {
+                    return param;
+                }
+                return BigInt(param);
+            // case "object":
+            // case "enum":
+            default: //any
+                return param;
+        }
     }
-};
+    catch (error) {
+        // Log conversion errors for debugging
+        console.warn(`[koatty_validation] Type conversion error for type "${type}":`, error instanceof Error ? error.message : String(error));
+        return param;
+    }
+}
 /**
- * 增强的验证错误类
+ * Check the base types.
+ *
+ * @param {*} value
+ * @param {string} type
+ * @returns {*}
  */
-class KoattyValidationError extends Error {
-    constructor(errors, message) {
-        const errorMessage = message || 'Validation failed';
-        super(errorMessage);
-        this.name = 'KoattyValidationError';
-        this.errors = errors;
-        this.statusCode = 400;
-        this.timestamp = new Date();
-        // 确保正确的原型链
-        Object.setPrototypeOf(this, KoattyValidationError.prototype);
+function checkParamsType(value, type) {
+    switch (type) {
+        case "Number":
+        case "number":
+            if (!helper__namespace.isNumber(value) || helper__namespace.isNaN(value)) {
+                return false;
+            }
+            return true;
+        case "Boolean":
+        case "boolean":
+            if (!helper__namespace.isBoolean(value)) {
+                return false;
+            }
+            return true;
+        case "Array":
+        case "array":
+        case "Tuple":
+        case "tuple":
+            if (!helper__namespace.isArray(value)) {
+                return false;
+            }
+            return true;
+        case "String":
+        case "string":
+            if (!helper__namespace.isString(value)) {
+                return false;
+            }
+            return true;
+        case "Object":
+        case "object":
+        case "Enum":
+        case "enum":
+            if (helper__namespace.isTrueEmpty(value)) {
+                return false;
+            }
+            return true;
+        case "Null":
+        case "null":
+            if (!helper__namespace.isNull(value)) {
+                return false;
+            }
+            return true;
+        case "Undefined":
+        case "undefined":
+            if (!helper__namespace.isUndefined(value)) {
+                return false;
+            }
+            return true;
+        case "Bigint":
+        case "bigint":
+            if (typeof value !== 'bigint') {
+                return false;
+            }
+            return true;
+        default: //any
+            return true;
     }
-    /**
-     * 获取第一个错误信息
-     */
-    getFirstError() {
-        return this.errors[0];
+}
+/**
+ * Checks if value is a chinese name.
+ *
+ * @param {string} value
+ * @returns {boolean}
+ */
+function cnName(value) {
+    // Add length limit for security
+    if (value.length > 50) {
+        return false;
     }
-    /**
-     * 获取指定字段的错误
-     */
-    getFieldErrors(field) {
-        return this.errors.filter(error => error.field === field);
+    // Use regex cache for better performance
+    const reg = regexCache.get('^([a-zA-Z0-9\\u4e00-\\u9fa5\\·]{1,10})$');
+    return reg.test(value);
+}
+/**
+ * Checks if value is a idCard number.
+ *
+ * @param {string} value
+ * @returns
+ */
+function idNumber(value) {
+    // Add length limit for security
+    if (!value || value.length > 20) {
+        return false;
     }
-    /**
-     * 转换为JSON格式
-     */
-    toJSON() {
-        return {
-            name: this.name,
-            message: this.message,
-            statusCode: this.statusCode,
-            timestamp: this.timestamp,
-            errors: this.errors
-        };
+    // Check 15-digit ID
+    const reg15 = regexCache.get('^\\d{15}$');
+    if (reg15.test(value)) {
+        return true;
+    }
+    // Check 18-digit ID with validation
+    const reg18 = regexCache.get('^\\d{17}[0-9X]$');
+    if (reg18.test(value)) {
+        const vs = '1,0,x,9,8,7,6,5,4,3,2'.split(',');
+        const ps = '7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2'.split(',');
+        const ss = value.toLowerCase().split('');
+        let r = 0;
+        for (let i = 0; i < 17; i++) {
+            r += ps[i] * ss[i];
+        }
+        const isOk = (vs[r % 11] === ss[17]);
+        return isOk;
     }
+    return false;
 }
 /**
- * 错误信息格式化器
+ * Checks if value is a mobile phone number.
+ *
+ * @param {string} value
+ * @returns {boolean}
  */
-class ErrorMessageFormatter {
-    constructor(language = 'zh') {
-        this.language = 'zh';
-        this.language = language;
+function mobile(value) {
+    // Add length limit for security (prevent ReDoS)
+    if (!value || value.length > 20) {
+        return false;
     }
-    /**
-     * 设置语言
-     */
-    setLanguage(language) {
-        this.language = language;
+    const reg = regexCache.get('^(13|14|15|16|17|18|19)\\d{9}$');
+    return reg.test(value);
+}
+/**
+ * Checks if value is a zipCode.
+ *
+ * @param {string} value
+ * @returns {boolean}
+ */
+function zipCode(value) {
+    // Add length limit for security
+    if (!value || value.length > 10) {
+        return false;
+    }
+    const reg = regexCache.get('^\\d{6}$');
+    return reg.test(value);
+}
+/**
+ * Checks if value is a plateNumber.
+ *
+ * @param {string} value
+ * @returns {boolean}
+ */
+function plateNumber(value) {
+    // Add length limit for security
+    if (!value || value.length > 15) {
+        return false;
+    }
+    // New energy vehicle plate number (8 characters)
+    const xReg = regexCache.get('^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领]{1}[A-Z]{1}(([0-9]{5}[DF]$)|([DF][A-HJ-NP-Z0-9][0-9]{4}$))');
+    // Traditional vehicle plate number (7 characters)
+    const cReg = regexCache.get('^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领]{1}[A-Z]{1}[A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9挂学警港澳]{1}$');
+    if (value.length === 7) {
+        return cReg.test(value);
+    }
+    else {
+        // New energy vehicle plate
+        return xReg.test(value);
+    }
+}
+
+/*
+ * @Description:
+ * @Usage:
+ * @Author: richen
+ * @Date: 2021-11-25 10:47:04
+ * @LastEditTime: 2024-01-03 14:32:49
+ */
+// constant
+const PARAM_RULE_KEY = 'PARAM_RULE_KEY';
+const PARAM_CHECK_KEY = 'PARAM_CHECK_KEY';
+const ENABLE_VALIDATED = "ENABLE_VALIDATED";
+/**
+ * paramterTypes
+ *
+ * @export
+ * @enum {number}
+ */
+exports.paramterTypes = void 0;
+(function (paramterTypes) {
+    paramterTypes[paramterTypes["Number"] = 0] = "Number";
+    paramterTypes[paramterTypes["number"] = 1] = "number";
+    paramterTypes[paramterTypes["String"] = 2] = "String";
+    paramterTypes[paramterTypes["string"] = 3] = "string";
+    paramterTypes[paramterTypes["Boolean"] = 4] = "Boolean";
+    paramterTypes[paramterTypes["boolean"] = 5] = "boolean";
+    paramterTypes[paramterTypes["Array"] = 6] = "Array";
+    paramterTypes[paramterTypes["array"] = 7] = "array";
+    paramterTypes[paramterTypes["Tuple"] = 8] = "Tuple";
+    paramterTypes[paramterTypes["tuple"] = 9] = "tuple";
+    paramterTypes[paramterTypes["Object"] = 10] = "Object";
+    paramterTypes[paramterTypes["object"] = 11] = "object";
+    paramterTypes[paramterTypes["Enum"] = 12] = "Enum";
+    paramterTypes[paramterTypes["enum"] = 13] = "enum";
+    paramterTypes[paramterTypes["Bigint"] = 14] = "Bigint";
+    paramterTypes[paramterTypes["bigint"] = 15] = "bigint";
+    paramterTypes[paramterTypes["Null"] = 16] = "Null";
+    paramterTypes[paramterTypes["null"] = 17] = "null";
+    paramterTypes[paramterTypes["Undefined"] = 18] = "Undefined";
+    paramterTypes[paramterTypes["undefined"] = 19] = "undefined";
+})(exports.paramterTypes || (exports.paramterTypes = {}));
+class ValidateClass {
+    constructor() {
     }
     /**
-     * 格式化错误消息
+     *
+     *
+     * @static
+     * @returns
+     * @memberof ValidateUtil
      */
-    formatMessage(constraint, field, value, context) {
-        const messages = ERROR_MESSAGES[this.language];
-        let template = messages[constraint] || messages.invalidParameter;
-        // 替换占位符
-        template = template.replace('{field}', field);
-        // 优先使用上下文中的值，然后是传入的value
-        if (context) {
-            Object.entries(context).forEach(([key, val]) => {
-                template = template.replace(`{${key}}`, this.formatValue(val));
-            });
-        }
-        // 如果还有{value}占位符且传入了value，则替换
-        if (value !== undefined && template.includes('{value}')) {
-            template = template.replace('{value}', this.formatValue(value));
-        }
-        return template;
+    static getInstance() {
+        return this.instance || (this.instance = new ValidateClass());
     }
     /**
-     * 格式化值用于消息显示
-     * @private
+     * validated data vs dto class
+     *
+     * @param {*} Clazz
+     * @param {*} data
+     * @param {boolean} [convert=false] auto convert parameters type
+     * @returns {Promise<any>}
+     * @memberof ValidateClass
      */
-    formatValue(value) {
-        if (value === null)
-            return 'null';
-        if (value === undefined)
-            return 'undefined';
-        if (typeof value === 'number')
-            return String(value);
-        if (typeof value === 'string')
-            return `"${value}"`;
-        if (Array.isArray(value))
-            return `[${value.map(v => this.formatValue(v)).join(', ')}]`;
-        if (typeof value === 'object') {
-            try {
-                return JSON.stringify(value);
-            }
-            catch {
-                // 处理循环引用
-                return '[Circular Reference]';
-            }
+    async valid(Clazz, data, convert = false) {
+        let obj = {};
+        if (data instanceof Clazz) {
+            obj = data;
         }
-        return String(value);
+        else {
+            obj = plainToClass(Clazz, data, convert);
+        }
+        let errors = [];
+        if (convert) {
+            errors = await classValidator.validate(obj);
+        }
+        else {
+            errors = await classValidator.validate(obj, { skipMissingProperties: true });
+        }
+        if (errors.length > 0) {
+            throw new Error(Object.values(errors[0].constraints)[0]);
+        }
+        return obj;
     }
 }
 /**
- * 全局错误信息格式化器实例
- */
-const errorFormatter = new ErrorMessageFormatter();
-/**
- * 设置全局语言
+ * ClassValidator for manual
  */
-function setValidationLanguage(language) {
-    errorFormatter.setLanguage(language);
-}
+const ClassValidator = ValidateClass.getInstance();
 /**
- * 创建验证错误
+ * Helper function to wrap validation with cache
  */
-function createValidationError(field, value, constraint, customMessage, context) {
-    const message = customMessage || errorFormatter.formatMessage(constraint, field, value, context);
-    return {
-        field,
-        value,
-        constraint,
-        message,
-        context
+function withCache(validatorName, validatorFunc) {
+    return (value, ...args) => {
+        // Check cache first
+        const cached = validationCache.get(validatorName, value, ...args);
+        if (cached !== undefined) {
+            return cached;
+        }
+        // Execute validation
+        const result = validatorFunc(value, ...args);
+        // Cache the result
+        validationCache.set(validatorName, value, result, ...args);
+        return result;
     };
 }
 /**
- * 批量创建验证错误
- */
-function createValidationErrors(errors) {
-    const validationErrors = errors.map(error => createValidationError(error.field, error.value, error.constraint, error.message, error.context));
-    return new KoattyValidationError(validationErrors);
-}
-
-/**
- * 性能缓存模块 - 提供多层次缓存和性能监控
- * @author richen
- */
-/**
- * 元数据缓存
+ * Validator Functions
  */
-class MetadataCache {
-    constructor() {
-        this.cache = new WeakMap();
-    }
-    static getInstance() {
-        if (!MetadataCache.instance) {
-            MetadataCache.instance = new MetadataCache();
-        }
-        return MetadataCache.instance;
-    }
-    /**
-     * 获取类的元数据缓存
-     */
-    getClassCache(target) {
-        if (!this.cache.has(target)) {
-            this.cache.set(target, new Map());
-        }
-        return this.cache.get(target);
-    }
-    /**
-     * 缓存元数据
-     */
-    setMetadata(target, key, value) {
-        const classCache = this.getClassCache(target);
-        classCache.set(key, value);
-    }
+const ValidFuncs = {
     /**
-     * 获取缓存的元数据
+     * Checks value is not empty, undefined, null, '', NaN, [], {} and any empty string(including spaces,
+     * tabs, formfeeds, etc.), returns false
      */
-    getMetadata(target, key) {
-        const classCache = this.getClassCache(target);
-        return classCache.get(key);
-    }
+    IsNotEmpty: withCache('IsNotEmpty', (value) => {
+        return !helper__namespace.isEmpty(value);
+    }),
     /**
-     * 检查是否已缓存
+     * Checks if a given value is a real date.
      */
-    hasMetadata(target, key) {
-        const classCache = this.getClassCache(target);
-        return classCache.has(key);
-    }
+    IsDate: withCache('IsDate', (value) => {
+        return helper__namespace.isDate(value);
+    }),
     /**
-     * 清空指定类的缓存
+     * Checks if the string is an email. If given value is not a string, then it returns false.
      */
-    clearClassCache(target) {
-        if (this.cache.has(target)) {
-            this.cache.delete(target);
-        }
-    }
-}
-/**
- * 验证结果缓存
- */
-class ValidationCache {
-    constructor(options) {
-        this.cache = new lruCache.LRUCache({
-            max: (options === null || options === void 0 ? void 0 : options.max) || 5000,
-            ttl: (options === null || options === void 0 ? void 0 : options.ttl) || 1000 * 60 * 10, // 10分钟
-            allowStale: (options === null || options === void 0 ? void 0 : options.allowStale) || false,
-            updateAgeOnGet: (options === null || options === void 0 ? void 0 : options.updateAgeOnGet) || true,
-        });
-    }
-    static getInstance(options) {
-        if (!ValidationCache.instance) {
-            ValidationCache.instance = new ValidationCache(options);
-        }
-        return ValidationCache.instance;
-    }
+    IsEmail: withCache('IsEmail', (value, options) => {
+        return classValidator.isEmail(value, options);
+    }),
     /**
-     * 生成缓存键
+     * Checks if the string is an IP (version 4 or 6). If given value is not a string, then it returns false.
      */
-    generateKey(validator, value, ...args) {
-        const valueStr = this.serializeValue(value);
-        const argsStr = args.length > 0 ? JSON.stringify(args) : '';
-        return `${validator}:${valueStr}:${argsStr}`;
-    }
+    IsIP: withCache('IsIP', (value, version) => {
+        return classValidator.isIP(value, version);
+    }),
     /**
-     * 序列化值用于缓存键
+     * Checks if the string is a valid phone number.
+     * @param value — the potential phone number string to test
+     * @param region 2 characters uppercase country code (e.g. DE, US, CH). If users must enter the intl.
+     * prefix (e.g. +41), then you may pass "ZZ" or null as region.
+     * See [google-libphonenumber, metadata.js:countryCodeToRegionCodeMap on github]
+     * {@link https://github.com/ruimarinho/google-libphonenumber/blob/1e46138878cff479aafe2ce62175c6c49cb58720/src/metadata.js#L33}
      */
-    serializeValue(value) {
-        if (value === null)
-            return 'null';
-        if (value === undefined)
-            return 'undefined';
-        if (typeof value === 'string')
-            return `s:${value}`;
-        if (typeof value === 'number')
-            return `n:${value}`;
-        if (typeof value === 'boolean')
-            return `b:${value}`;
-        if (Array.isArray(value))
-            return `a:${JSON.stringify(value)}`;
-        if (typeof value === 'object')
-            return `o:${JSON.stringify(value)}`;
-        return String(value);
-    }
+    IsPhoneNumber: withCache('IsPhoneNumber', (value, region) => {
+        return classValidator.isPhoneNumber(value, region);
+    }),
     /**
-     * 获取缓存的验证结果
+     * Checks if the string is an url. If given value is not a string, then it returns false.
      */
-    get(validator, value, ...args) {
-        const key = this.generateKey(validator, value, ...args);
-        return this.cache.get(key);
-    }
+    IsUrl: withCache('IsUrl', (value, options) => {
+        return classValidator.isURL(value, options);
+    }),
     /**
-     * 缓存验证结果
+     * check if the string is a hash of type algorithm. Algorithm is one of
+     * ['md4', 'md5', 'sha1', 'sha256', 'sha384', 'sha512', 'ripemd128', 'ripemd160', 'tiger128', 'tiger160', 'tiger192', 'crc32', 'crc32b']
      */
-    set(validator, value, result, ...args) {
-        const key = this.generateKey(validator, value, ...args);
-        this.cache.set(key, result);
-    }
+    IsHash: withCache('IsHash', (value, algorithm) => {
+        return classValidator.isHash(value, algorithm);
+    }),
     /**
-     * 检查是否存在缓存
+     * Checks if value is a chinese name.
      */
-    has(validator, value, ...args) {
-        const key = this.generateKey(validator, value, ...args);
-        return this.cache.has(key);
-    }
+    IsCnName: withCache('IsCnName', (value) => {
+        if (!helper__namespace.isString(value)) {
+            return false;
+        }
+        return cnName(value);
+    }),
     /**
-     * 删除特定缓存
+     * Checks if value is a idcard number.
      */
-    delete(validator, value, ...args) {
-        const key = this.generateKey(validator, value, ...args);
-        return this.cache.delete(key);
-    }
+    IsIdNumber: withCache('IsIdNumber', (value) => {
+        if (!helper__namespace.isString(value)) {
+            return false;
+        }
+        return idNumber(value);
+    }),
     /**
-     * 清空缓存
+     * Checks if value is a zipCode.
      */
-    clear() {
-        this.cache.clear();
-    }
+    IsZipCode: withCache('IsZipCode', (value) => {
+        if (!helper__namespace.isString(value)) {
+            return false;
+        }
+        return zipCode(value);
+    }),
     /**
-     * 获取缓存统计
+     * Checks if value is a mobile phone number.
      */
-    getStats() {
-        return {
-            size: this.cache.size,
-            max: this.cache.max,
-            calculatedSize: this.cache.calculatedSize,
-            keyCount: this.cache.size,
-        };
-    }
+    IsMobile: withCache('IsMobile', (value) => {
+        if (!helper__namespace.isString(value)) {
+            return false;
+        }
+        return mobile(value);
+    }),
     /**
-     * 设置缓存TTL
+     * Checks if value is a plateNumber.
      */
-    setTTL(validator, value, ttl, ...args) {
-        const key = this.generateKey(validator, value, ...args);
-        const existingValue = this.cache.get(key);
-        if (existingValue !== undefined) {
-            this.cache.set(key, existingValue, { ttl });
-        }
-    }
-}
-/**
- * 正则表达式缓存
- */
-class RegexCache {
-    constructor(options) {
-        this.cache = new lruCache.LRUCache({
-            max: (options === null || options === void 0 ? void 0 : options.max) || 200,
-            ttl: (options === null || options === void 0 ? void 0 : options.ttl) || 1000 * 60 * 30, // 30分钟
-            allowStale: (options === null || options === void 0 ? void 0 : options.allowStale) || false,
-            updateAgeOnGet: (options === null || options === void 0 ? void 0 : options.updateAgeOnGet) || true,
-        });
-    }
-    static getInstance(options) {
-        if (!RegexCache.instance) {
-            RegexCache.instance = new RegexCache(options);
+    IsPlateNumber: withCache('IsPlateNumber', (value) => {
+        if (!helper__namespace.isString(value)) {
+            return false;
         }
-        return RegexCache.instance;
-    }
+        return plateNumber(value);
+    }),
     /**
-     * 获取缓存的正则表达式
+     * Checks if value matches ("===") the comparison.
      */
-    get(pattern, flags) {
-        const key = flags ? `${pattern}:::${flags}` : pattern;
-        let regex = this.cache.get(key);
-        if (!regex) {
-            try {
-                regex = new RegExp(pattern, flags);
-                this.cache.set(key, regex);
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            }
-            catch (_error) {
-                // 如果正则表达式无效，抛出错误
-                throw new Error(`Invalid regex pattern: ${pattern}`);
-            }
-        }
-        return regex;
-    }
+    Equals: withCache('Equals', (value, comparison) => {
+        return classValidator.equals(value, comparison);
+    }),
     /**
-     * 预编译常用正则表达式
+     * Checks if value does not match ("!==") the comparison.
      */
-    precompile(patterns) {
-        patterns.forEach(({ pattern, flags }) => {
-            try {
-                this.get(pattern, flags);
-            }
-            catch (error) {
-                console.warn(`Failed to precompile regex: ${pattern}`, error);
-            }
-        });
-    }
+    NotEquals: withCache('NotEquals', (value, comparison) => {
+        return classValidator.notEquals(value, comparison);
+    }),
     /**
-     * 获取缓存统计
+     * Checks if the string contains the seed. If given value is not a string, then it returns false.
      */
-    getStats() {
-        return {
-            size: this.cache.size,
-            max: this.cache.max,
-            calculatedSize: this.cache.calculatedSize,
-        };
-    }
+    Contains: withCache('Contains', (value, seed) => {
+        return classValidator.contains(value, seed);
+    }),
     /**
-     * 清空缓存
+     * Checks if given value is in a array of allowed values.
      */
-    clear() {
-        this.cache.clear();
-    }
-}
-/**
- * 性能监控
- */
-class PerformanceMonitor {
-    constructor() {
-        this.metrics = new Map();
-    }
-    static getInstance() {
-        if (!PerformanceMonitor.instance) {
-            PerformanceMonitor.instance = new PerformanceMonitor();
-        }
-        return PerformanceMonitor.instance;
-    }
+    IsIn: withCache('IsIn', (value, possibleValues) => {
+        return classValidator.isIn(value, possibleValues);
+    }),
     /**
-     * 开始计时
+     * Checks if given value not in a array of allowed values.
      */
-    startTimer(name) {
-        const start = performance.now();
-        return () => {
-            const duration = performance.now() - start;
-            this.recordMetric(name, duration);
-        };
-    }
+    IsNotIn: withCache('IsNotIn', (value, possibleValues) => {
+        return classValidator.isNotIn(value, possibleValues);
+    }),
     /**
-     * 记录性能指标
+     * Checks if the first number is greater than or equal to the second.
      */
-    recordMetric(name, duration) {
-        if (!this.metrics.has(name)) {
-            this.metrics.set(name, {
-                count: 0,
-                totalTime: 0,
-                avgTime: 0,
-                maxTime: 0,
-                minTime: Infinity,
-                lastExecutionTime: new Date(),
-            });
+    Gt: withCache('Gt', (num, min) => {
+        return helper__namespace.toNumber(num) > min;
+    }),
+    /**
+     * Checks if the first number is less than or equal to the second.
+     */
+    Lt: withCache('Lt', (num, max) => {
+        return helper__namespace.toNumber(num) < max;
+    }),
+    /**
+     * Checks if the first number is greater than or equal to the second.
+     */
+    Gte: withCache('Gte', (num, min) => {
+        return helper__namespace.toNumber(num) >= min;
+    }),
+    /**
+     * Checks if the first number is less than or equal to the second.
+     */
+    Lte: withCache('Lte', (num, max) => {
+        return helper__namespace.toNumber(num) <= max;
+    }),
+};
+/**
+ * Helper function to create validator function
+ */
+function createValidatorFunction(validatorFunc, defaultMessage) {
+    return (value, options) => {
+        let validOptions;
+        if (typeof options === 'string') {
+            validOptions = { message: options, value: null };
         }
-        const metric = this.metrics.get(name);
-        metric.count++;
-        metric.totalTime += duration;
-        metric.avgTime = metric.totalTime / metric.count;
-        metric.maxTime = Math.max(metric.maxTime, duration);
-        metric.minTime = Math.min(metric.minTime, duration);
-        metric.lastExecutionTime = new Date();
+        else {
+            validOptions = options || { message: defaultMessage, value: null };
+        }
+        if (!validatorFunc(value, validOptions.value)) {
+            // Priority: validOptions.message -> defaultMessage -> fallback error
+            let errorMessage = validOptions.message;
+            // If message is empty or whitespace, use defaultMessage
+            if (!errorMessage || !errorMessage.trim()) {
+                errorMessage = defaultMessage;
+            }
+            // If defaultMessage is also empty, use fallback
+            if (!errorMessage || !errorMessage.trim()) {
+                errorMessage = 'ValidatorError: invalid arguments.';
+            }
+            throw new Error(errorMessage);
+        }
+    };
+}
+/**
+ * Use functions or built-in rules for validation.
+ * Throws error if validation fails.
+ *
+ * @export
+ */
+const FunctionValidator = {
+    IsNotEmpty: createValidatorFunction(ValidFuncs.IsNotEmpty, 'Value should not be empty'),
+    IsDate: createValidatorFunction(ValidFuncs.IsDate, 'Must be a valid date'),
+    IsEmail: createValidatorFunction(ValidFuncs.IsEmail, 'Must be a valid email'),
+    IsIP: createValidatorFunction(ValidFuncs.IsIP, 'Must be a valid IP address'),
+    IsPhoneNumber: createValidatorFunction(ValidFuncs.IsPhoneNumber, 'Must be a valid phone number'),
+    IsUrl: createValidatorFunction(ValidFuncs.IsUrl, 'Must be a valid URL'),
+    IsHash: createValidatorFunction(ValidFuncs.IsHash, 'Must be a valid hash'),
+    IsCnName: createValidatorFunction(ValidFuncs.IsCnName, 'Must be a valid Chinese name'),
+    IsIdNumber: createValidatorFunction(ValidFuncs.IsIdNumber, 'Must be a valid ID number'),
+    IsZipCode: createValidatorFunction(ValidFuncs.IsZipCode, 'Must be a valid zip code'),
+    IsMobile: createValidatorFunction(ValidFuncs.IsMobile, 'Must be a valid mobile number'),
+    IsPlateNumber: createValidatorFunction(ValidFuncs.IsPlateNumber, 'Must be a valid plate number'),
+    Equals: createValidatorFunction(ValidFuncs.Equals, 'Values must be equal'),
+    NotEquals: createValidatorFunction(ValidFuncs.NotEquals, 'Values must not be equal'),
+    Contains: createValidatorFunction(ValidFuncs.Contains, 'Value must contain specified substring'),
+    IsIn: createValidatorFunction(ValidFuncs.IsIn, 'Value must be in the allowed list'),
+    IsNotIn: createValidatorFunction(ValidFuncs.IsNotIn, 'Value must not be in the forbidden list'),
+    Gt: createValidatorFunction(ValidFuncs.Gt, 'Value must be greater than threshold'),
+    Lt: createValidatorFunction(ValidFuncs.Lt, 'Value must be less than threshold'),
+    Gte: createValidatorFunction(ValidFuncs.Gte, 'Value must be greater than or equal to threshold'),
+    Lte: createValidatorFunction(ValidFuncs.Lte, 'Value must be less than or equal to threshold'),
+};
+
+/**
+ * Decorator Factory - Eliminate decorator code duplication
+ * @author richen
+ */
+/**
+ * Factory function to create validation decorators
+ * @param options Decorator configuration options
+ * @returns Decorator factory function
+ */
+function createValidationDecorator(options) {
+    const { name, validator, defaultMessage, requiresValue = false } = options;
+    return function decoratorFactory(...args) {
+        // Handle parameters: last parameter is ValidationOptions, previous ones are validator function parameters
+        const validationOptions = args[args.length - 1];
+        const validatorArgs = requiresValue ? args.slice(0, -1) : [];
+        return function propertyDecorator(object, propertyName) {
+            // Set property as exportable
+            setExpose(object, propertyName);
+            // Register validation decorator
+            classValidator.registerDecorator({
+                name,
+                target: object.constructor,
+                propertyName,
+                options: validationOptions,
+                constraints: validatorArgs,
+                validator: {
+                    validate(value) {
+                        try {
+                            return validator(value, ...validatorArgs);
+                        }
+                        catch {
+                            return false;
+                        }
+                    },
+                    defaultMessage(validationArguments) {
+                        const property = validationArguments.property;
+                        return defaultMessage
+                            ? defaultMessage.replace('$property', property)
+                            : `Invalid value for ${property}`;
+                    }
+                }
+            });
+        };
+    };
+}
+/**
+ * Create simple validation decorator (no additional parameters required)
+ * @param name Decorator name
+ * @param validator Validation function
+ * @param defaultMessage Default error message
+ * @returns Decorator function
+ */
+function createSimpleDecorator(name, validator, defaultMessage) {
+    return createValidationDecorator({
+        name,
+        validator,
+        defaultMessage,
+        requiresValue: false
+    });
+}
+/**
+ * Create parameterized validation decorator
+ * @param name Decorator name
+ * @param validator Validation function
+ * @param defaultMessage Default error message
+ * @returns Decorator factory function
+ */
+function createParameterizedDecorator(name, validator, defaultMessage) {
+    return createValidationDecorator({
+        name,
+        validator,
+        defaultMessage,
+        requiresValue: true
+    });
+}
+
+/**
+ * Improved error handling mechanism
+ * @author richen
+ */
+/**
+ * Error message internationalization
+ */
+const ERROR_MESSAGES = {
+    zh: {
+        // Chinese localization validation
+        IsCnName: '必须是有效的中文姓名',
+        IsIdNumber: '必须是有效的身份证号码',
+        IsZipCode: '必须是有效的邮政编码',
+        IsMobile: '必须是有效的手机号码',
+        IsPlateNumber: '必须是有效的车牌号码',
+        // Basic validation
+        IsNotEmpty: '不能为空',
+        IsDate: '必须是有效的日期',
+        IsEmail: '必须是有效的邮箱地址',
+        IsIP: '必须是有效的IP地址',
+        IsPhoneNumber: '必须是有效的电话号码',
+        IsUrl: '必须是有效的URL地址',
+        IsHash: '必须是有效的哈希值',
+        // Comparison validation
+        Equals: '必须等于 {comparison}',
+        NotEquals: '不能等于 {comparison}',
+        Contains: '必须包含 {seed}',
+        IsIn: '必须是以下值之一: {possibleValues}',
+        IsNotIn: '不能是以下值之一: {possibleValues}',
+        Gt: '必须大于 {min}',
+        Gte: '必须大于或等于 {min}',
+        Lt: '必须小于 {max}',
+        Lte: '必须小于或等于 {max}',
+        // Common errors
+        invalidParameter: '参数 {field} 无效',
+        validationFailed: '验证失败',
+    },
+    en: {
+        // Chinese localization validators
+        IsCnName: 'must be a valid Chinese name',
+        IsIdNumber: 'must be a valid ID number',
+        IsZipCode: 'must be a valid zip code',
+        IsMobile: 'must be a valid mobile number',
+        IsPlateNumber: 'must be a valid plate number',
+        // Basic validators
+        IsNotEmpty: 'should not be empty',
+        IsDate: 'must be a valid date',
+        IsEmail: 'must be a valid email',
+        IsIP: 'must be a valid IP address',
+        IsPhoneNumber: 'must be a valid phone number',
+        IsUrl: 'must be a valid URL',
+        IsHash: 'must be a valid hash',
+        // Comparison validators
+        Equals: 'must equal to {comparison}',
+        NotEquals: 'should not equal to {comparison}',
+        Contains: 'must contain {seed}',
+        IsIn: 'must be one of the following values: {possibleValues}',
+        IsNotIn: 'should not be one of the following values: {possibleValues}',
+        Gt: 'must be greater than {min}',
+        Gte: 'must be greater than or equal to {min}',
+        Lt: 'must be less than {max}',
+        Lte: 'must be less than or equal to {max}',
+        // Common errors
+        invalidParameter: 'invalid parameter {field}',
+        validationFailed: 'validation failed',
+    }
+};
+/**
+ * Enhanced validation error class
+ */
+class KoattyValidationError extends Error {
+    constructor(errors, message) {
+        const errorMessage = message || 'Validation failed';
+        super(errorMessage);
+        this.name = 'KoattyValidationError';
+        this.errors = errors;
+        this.statusCode = 400;
+        this.timestamp = new Date();
+        // Ensure correct prototype chain
+        Object.setPrototypeOf(this, KoattyValidationError.prototype);
     }
     /**
-     * 获取性能报告
+     * Get the first error message
      */
-    getReport() {
-        const report = {};
-        for (const [name, metric] of this.metrics) {
-            report[name] = {
-                ...metric,
-                minTime: metric.minTime === Infinity ? 0 : metric.minTime,
-                avgTimeFormatted: `${metric.avgTime.toFixed(2)}ms`,
-                totalTimeFormatted: `${metric.totalTime.toFixed(2)}ms`,
-            };
-        }
-        return report;
+    getFirstError() {
+        return this.errors[0];
     }
     /**
-     * 获取热点分析（执行时间最长的操作）
+     * Get errors for a specific field
      */
-    getHotspots(limit = 10) {
-        return Array.from(this.metrics.entries())
-            .map(([name, metric]) => ({
-            name,
-            avgTime: metric.avgTime,
-            count: metric.count,
-        }))
-            .sort((a, b) => b.avgTime - a.avgTime)
-            .slice(0, limit);
+    getFieldErrors(field) {
+        return this.errors.filter(error => error.field === field);
     }
     /**
-     * 清空指标
+     * Convert to JSON format
      */
-    clear() {
-        this.metrics.clear();
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            statusCode: this.statusCode,
+            timestamp: this.timestamp,
+            errors: this.errors
+        };
+    }
+}
+/**
+ * Error message formatter
+ */
+class ErrorMessageFormatter {
+    constructor(language = 'zh') {
+        this.language = 'zh';
+        this.language = language;
     }
     /**
-     * 导出性能数据为CSV格式
+     * Set language
      */
-    exportToCSV() {
-        const headers = ['Name', 'Count', 'Total Time (ms)', 'Avg Time (ms)', 'Max Time (ms)', 'Min Time (ms)', 'Last Execution'];
-        const rows = [headers.join(',')];
-        for (const [name, metric] of this.metrics) {
-            const row = [
-                name,
-                metric.count.toString(),
-                metric.totalTime.toFixed(2),
-                metric.avgTime.toFixed(2),
-                metric.maxTime.toFixed(2),
-                (metric.minTime === Infinity ? 0 : metric.minTime).toFixed(2),
-                metric.lastExecutionTime.toISOString(),
-            ];
-            rows.push(row.join(','));
+    setLanguage(language) {
+        this.language = language;
+    }
+    /**
+     * Format error message
+     */
+    formatMessage(constraint, field, value, context) {
+        const messages = ERROR_MESSAGES[this.language];
+        let template = messages[constraint] || messages.invalidParameter;
+        // Replace placeholders
+        template = template.replace('{field}', field);
+        // Prioritize values from context, then use passed value
+        if (context) {
+            Object.entries(context).forEach(([key, val]) => {
+                template = template.replace(`{${key}}`, this.formatValue(val));
+            });
         }
-        return rows.join('\n');
+        // If there's still a {value} placeholder and value was passed, replace it
+        if (value !== undefined && template.includes('{value}')) {
+            template = template.replace('{value}', this.formatValue(value));
+        }
+        return template;
     }
-}
-// 导出单例实例
-const metadataCache = MetadataCache.getInstance();
-const validationCache = ValidationCache.getInstance();
-const regexCache = RegexCache.getInstance();
-const performanceMonitor = PerformanceMonitor.getInstance();
-/**
- * 缓存装饰器 - 用于缓存验证函数结果
- */
-function cached(validator, ttl) {
-    return function (target, propertyName, descriptor) {
-        const originalMethod = descriptor.value;
-        descriptor.value = function (...args) {
-            const value = args[0];
-            const additionalArgs = args.slice(1);
-            // 尝试从缓存获取结果
-            const cachedResult = validationCache.get(validator, value, ...additionalArgs);
-            if (cachedResult !== undefined) {
-                return cachedResult;
-            }
-            // 执行验证并缓存结果
-            const endTimer = performanceMonitor.startTimer(validator);
+    /**
+     * Format value for message display
+     * @private
+     */
+    formatValue(value) {
+        if (value === null)
+            return 'null';
+        if (value === undefined)
+            return 'undefined';
+        if (typeof value === 'number')
+            return String(value);
+        if (typeof value === 'string')
+            return `"${value}"`;
+        if (Array.isArray(value))
+            return `[${value.map(v => this.formatValue(v)).join(', ')}]`;
+        if (typeof value === 'object') {
             try {
-                const result = originalMethod.apply(this, args);
-                validationCache.set(validator, value, result, ...additionalArgs);
-                // 如果指定了TTL，设置过期时间
-                if (ttl && ttl > 0) {
-                    validationCache.setTTL(validator, value, ttl, ...additionalArgs);
-                }
-                return result;
+                return JSON.stringify(value);
             }
-            finally {
-                endTimer();
+            catch {
+                // Handle circular references
+                return '[Circular Reference]';
             }
-        };
-        return descriptor;
-    };
+        }
+        return String(value);
+    }
 }
 /**
- * 获取所有缓存统计信息
+ * Global error message formatter instance
  */
-function getAllCacheStats() {
+const errorFormatter = new ErrorMessageFormatter();
+/**
+ * Set global language
+ */
+function setValidationLanguage(language) {
+    errorFormatter.setLanguage(language);
+}
+/**
+ * Create validation error
+ */
+function createValidationError(field, value, constraint, customMessage, context) {
+    const message = customMessage || errorFormatter.formatMessage(constraint, field, value, context);
     return {
-        validation: validationCache.getStats(),
-        regex: regexCache.getStats(),
-        performance: performanceMonitor.getReport(),
-        hotspots: performanceMonitor.getHotspots(),
+        field,
+        value,
+        constraint,
+        message,
+        context
     };
 }
 /**
- * 预热缓存 - 预编译常用正则表达式
+ * Create validation errors in batch
  */
-function warmupCaches() {
-    // 预编译中文验证相关的正则表达式
-    const commonPatterns = [
-        { pattern: '^[\u4e00-\u9fa5]{2,8}$' }, // 中文姓名
-        { pattern: '^1[3-9]\\d{9}$' }, // 手机号
-        { pattern: '^\\d{6}$' }, // 邮政编码
-        { pattern: '^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼]' }, // 车牌号开头
-    ];
-    regexCache.precompile(commonPatterns);
+function createValidationErrors(errors) {
+    const validationErrors = errors.map(error => createValidationError(error.field, error.value, error.constraint, error.message, error.context));
+    return new KoattyValidationError(validationErrors);
 }
+
 /**
- * 清空所有缓存
+ * Refactored decorator definitions - Using factory functions to eliminate duplication
+ * @author richen
  */
-function clearAllCaches() {
-    validationCache.clear();
-    regexCache.clear();
-    performanceMonitor.clear();
+// Chinese localization validation decorators
+const IsCnName = createSimpleDecorator('IsCnName', (value) => helper__namespace.isString(value) && cnName(value), 'must be a valid Chinese name');
+const IsIdNumber = createSimpleDecorator('IsIdNumber', (value) => helper__namespace.isString(value) && idNumber(value), 'must be a valid ID number');
+const IsZipCode = createSimpleDecorator('IsZipCode', (value) => helper__namespace.isString(value) && zipCode(value), 'must be a valid zip code');
+const IsMobile = createSimpleDecorator('IsMobile', (value) => helper__namespace.isString(value) && mobile(value), 'must be a valid mobile number');
+const IsPlateNumber = createSimpleDecorator('IsPlateNumber', (value) => helper__namespace.isString(value) && plateNumber(value), 'must be a valid plate number');
+// Basic validation decorators
+const IsNotEmpty = createSimpleDecorator('IsNotEmpty', (value) => !helper__namespace.isEmpty(value), 'should not be empty');
+const IsDate = createSimpleDecorator('IsDate', (value) => helper__namespace.isDate(value), 'must be a valid date');
+// Parameterized validation decorators
+const Equals = createParameterizedDecorator('Equals', (value, comparison) => value === comparison, 'must equal to $constraint1');
+const NotEquals = createParameterizedDecorator('NotEquals', (value, comparison) => value !== comparison, 'should not equal to $constraint1');
+const Contains = createParameterizedDecorator('Contains', (value, seed) => helper__namespace.isString(value) && value.includes(seed), 'must contain $constraint1');
+const IsIn = createParameterizedDecorator('IsIn', (value, possibleValues) => possibleValues.includes(value), 'must be one of the following values: $constraint1');
+const IsNotIn = createParameterizedDecorator('IsNotIn', (value, possibleValues) => !possibleValues.includes(value), 'should not be one of the following values: $constraint1');
+// 数值比较装饰器
+const Gt = createParameterizedDecorator('Gt', (value, min) => helper__namespace.toNumber(value) > min, 'must be greater than $constraint1');
+const Gte = createParameterizedDecorator('Gte', (value, min) => helper__namespace.toNumber(value) >= min, 'must be greater than or equal to $constraint1');
+const Lt = createParameterizedDecorator('Lt', (value, max) => helper__namespace.toNumber(value) < max, 'must be less than $constraint1');
+const Lte = createParameterizedDecorator('Lte', (value, max) => helper__namespace.toNumber(value) <= max, 'must be less than or equal to $constraint1');
+// 复杂验证装饰器（需要特殊处理）
+function IsEmail(options, validationOptions) {
+    return createParameterizedDecorator('IsEmail', (value) => classValidator.isEmail(value, options), 'must be a valid email')(validationOptions);
+}
+function IsIP(version, validationOptions) {
+    return createParameterizedDecorator('IsIP', (value) => classValidator.isIP(value, version), 'must be a valid IP address')(validationOptions);
+}
+function IsPhoneNumber(region, validationOptions) {
+    return createParameterizedDecorator('IsPhoneNumber', (value) => classValidator.isPhoneNumber(value, region), 'must be a valid phone number')(validationOptions);
 }
+function IsUrl(options, validationOptions) {
+    return createParameterizedDecorator('IsUrl', (value) => classValidator.isURL(value, options), 'must be a valid URL')(validationOptions);
+}
+function IsHash(algorithm, validationOptions) {
+    return createParameterizedDecorator('IsHash', (value) => classValidator.isHash(value, algorithm), 'must be a valid hash')(validationOptions);
+}
+// Basic utility decorators (migrated from original decorator.ts)
 /**
- * 配置缓存设置
+ * Mark property as exportable
  */
-function configureCaches(options) {
-    if (options.validation) {
-        // 重新创建验证缓存实例
-        ValidationCache.instance = new ValidationCache(options.validation);
-    }
-    if (options.regex) {
-        // 重新创建正则缓存实例
-        RegexCache.instance = new RegexCache(options.regex);
+function Expose() {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+    };
+}
+/**
+ * Alias for Expose
+ */
+function IsDefined() {
+    return function (object, propertyName) {
+        setExpose(object, propertyName);
+    };
+}
+/**
+ * Parameter validation decorator
+ */
+function Valid(rule, options) {
+    return function (object, propertyName, parameterIndex) {
+        // Keep consistent with original implementation
+        const existingRules = Reflect.getOwnMetadata("validate", object, propertyName) || {};
+        existingRules[parameterIndex] = { rule, options };
+        Reflect.defineMetadata("validate", existingRules, object, propertyName);
+    };
+}
+/**
+ * Synchronous validation function - Executes the actual validation logic
+ * @param args Method parameters
+ * @param paramTypes Parameter type metadata
+ * @returns Validated parameters and validation targets
+ */
+async function checkValidated(args, paramTypes) {
+    const validationTargets = [];
+    // Validate each parameter
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const paramType = paramTypes[i];
+        // If it's a class type and not a basic type, perform validation
+        if (paramType && typeof paramType === 'function' &&
+            paramType !== String && paramType !== Number &&
+            paramType !== Boolean && paramType !== Array &&
+            paramType !== Object && paramType !== Date) {
+            try {
+                // If parameter is not an instance of the target type, convert it to an instance
+                let validationTarget = arg;
+                if (!(arg instanceof paramType)) {
+                    validationTarget = Object.assign(new paramType(), arg);
+                }
+                const errors = await classValidator.validate(validationTarget);
+                if (errors.length > 0) {
+                    throw createValidationErrors(errors.map(e => ({
+                        field: e.property,
+                        value: e.value,
+                        constraint: Object.keys(e.constraints || {})[0] || 'unknown',
+                        message: Object.values(e.constraints || {})[0] || 'Validation failed',
+                        context: e.constraints
+                    })));
+                }
+                validationTargets.push(validationTarget);
+            }
+            catch (error) {
+                // If validation fails, rethrow the error
+                throw error;
+            }
+        }
+        else {
+            validationTargets.push(arg);
+        }
     }
+    return { validatedArgs: args, validationTargets };
+}
+/**
+ * Method validation decorator
+ * Automatically validates DTO objects in method parameters
+ * @param isAsync Whether to use async validation mode, default is true
+ *   - true: Async mode, validation is handled by IOC container in the framework (suitable for scenarios where parameter values need to be obtained asynchronously)
+ *   - false: Sync mode, validation is performed immediately when the method is called (suitable for scenarios where parameter values are already prepared)
+ */
+function Validated(isAsync = true) {
+    return function (target, propertyKey, descriptor) {
+        if (isAsync) {
+            // Async mode: Save metadata, validation will be performed by the framework after async parameter retrieval
+            koatty_container.IOCContainer.savePropertyData(PARAM_CHECK_KEY, {
+                dtoCheck: 1
+            }, target, propertyKey);
+        }
+        else {
+            // Sync mode: Perform validation immediately when the method is called
+            const originalMethod = descriptor.value;
+            descriptor.value = async function (...args) {
+                // Get parameter type metadata
+                const paramTypes = Reflect.getMetadata('design:paramtypes', target, propertyKey) || [];
+                // Execute validation
+                await checkValidated(args, paramTypes);
+                // Execute original method
+                return originalMethod.apply(this, args);
+            };
+        }
+        return descriptor;
+    };
 }
 
 exports.ClassValidator = ClassValidator;
@@ -1478,11 +1584,13 @@ exports.Lte = Lte;
 exports.NotEquals = NotEquals;
 exports.PARAM_CHECK_KEY = PARAM_CHECK_KEY;
 exports.PARAM_RULE_KEY = PARAM_RULE_KEY;
+exports.PARAM_TYPE_KEY = PARAM_TYPE_KEY;
 exports.Valid = Valid;
 exports.ValidFuncs = ValidFuncs;
 exports.Validated = Validated;
 exports.cached = cached;
 exports.checkParamsType = checkParamsType;
+exports.checkValidated = checkValidated;
 exports.clearAllCaches = clearAllCaches;
 exports.configureCaches = configureCaches;
 exports.convertDtoParamsType = convertDtoParamsType;