schema-dsl 1.0.8 → 1.1.0

package/lib/core/ErrorFormatter.js

@@ -38,20 +38,41 @@ class ErrorFormatter {
   /**
    * 格式化单个错误或错误数组
    * @param {Object|Array<Object>} error - 错误对象或错误数组
-   * @param {string} [locale] - 动态指定语言（可选）
+   * @param {string|Object} [localeOrOptions] - 语言代码字符串或选项对象
+   * @param {string} [localeOrOptions.locale] - 动态指定语言（可选）
+   * @param {Object} [localeOrOptions.messages] - 自定义错误消息（可选）
    * @returns {string|Array<Object>} 格式化后的错误消息或错误对象数组
    */
-  format(error, locale) {
+  format(error, localeOrOptions) {
+
+    // ✅ 支持两种调用方式：
+    // 1. format(errors, 'zh-CN') - 旧版兼容
+    // 2. format(errors, { locale: 'zh-CN', messages: {...} }) - 新版增强
+    let locale;
+    let customMessages;
+
+    if (typeof localeOrOptions === 'string') {
+      // 旧版：直接传入语言代码
+      locale = localeOrOptions;
+    } else if (typeof localeOrOptions === 'object' && localeOrOptions !== null) {
+      // 新版：传入选项对象
+      locale = localeOrOptions.locale;
+      customMessages = localeOrOptions.messages;
+    }
+
     // 如果是数组，格式化为详细对象数组
     if (Array.isArray(error)) {
-      return this.formatDetailed(error, locale);
+      return this.formatDetailed(error, locale, customMessages);
     }
 
     // 获取当前使用的消息模板
     const messages = locale ? this._loadMessages(locale) : this.messages;
 
+    // 合并自定义消息
+    const finalMessages = customMessages ? { ...messages, ...customMessages } : messages;
+
     // 单个错误对象格式化
-    const template = messages[error.type] || error.message;
+    const template = finalMessages[error.type] || error.message;
     return this._interpolate(template, {
       ...error,
       path: error.path || 'value',
@@ -73,9 +94,11 @@ class ErrorFormatter {
    * 格式化为详细对象
    * @param {Array<Object>} errors - ajv错误数组
    * @param {string} [locale] - 动态指定语言（可选）
+   * @param {Object} [customMessages] - 自定义错误消息（可选）
    * @returns {Array<Object>} 详细错误对象数组
    */
-  formatDetailed(errors, locale) {
+  formatDetailed(errors, locale, customMessages) {
+
     if (!Array.isArray(errors)) {
       errors = [errors];
     }
@@ -104,6 +127,9 @@ class ErrorFormatter {
     // 获取当前使用的消息模板
     const messages = locale ? this._loadMessages(locale) : this.messages;
 
+    // ✅ 合并参数传入的自定义消息（在整个 map 循环中使用）
+    const finalMessages = customMessages ? { ...messages, ...customMessages } : messages;
+
     return errors.map(err => {
       // 处理 ajv 错误格式
       const keyword = err.keyword || err.type || 'validation';
@@ -125,22 +151,27 @@ class ErrorFormatter {
 
       if (label) {
         // 如果显式设置了 label，尝试翻译它
-        if (messages[label]) {
-          label = messages[label];
+        if (finalMessages[label]) {
+          label = finalMessages[label];
         }
       } else {
         // 如果没有显式设置 label，尝试自动查找翻译 (label.fieldName)
         // 将路径分隔符 / 转换为 . (例如 address/city -> address.city)
         const autoKey = `label.${fieldName.replace(/\//g, '.')}`;
-        if (messages[autoKey]) {
-          label = messages[autoKey];
+        if (finalMessages[autoKey]) {
+          label = finalMessages[autoKey];
         } else {
           // 没找到翻译，回退到 fieldName
           label = fieldName;
         }
       }
 
-      const customMessages = schema._customMessages || {};
+      // Schema 中的自定义消息
+      const schemaCustomMessages = schema._customMessages || {};
+
+      // ✅ 合并优先级：schemaCustomMessages > finalMessages
+      // schemaCustomMessages 是字段级的自定义消息，优先级最高
+      const mergedMessages = { ...finalMessages, ...schemaCustomMessages };
 
       // 关键字映射 (ajv keyword -> schema-dsl 简写)
       // 支持 min/max 作为 minLength/maxLength 的简写
@@ -160,18 +191,38 @@ class ErrorFormatter {
       const mappedKeyword = keywordMap[keyword] || keyword;
       const type = schema.type || 'string';
 
-      // 查找自定义消息
-      // 优先级:
-      // 1. type.keyword (如 string.pattern)
-      // 2. type.mappedKeyword (如 string.min)
-      // 3. mappedKeyword (如 min)
-      // 4. keyword (如 minLength，向后兼容)
-      // 5. default
-      let message = customMessages[`${type}.${keyword}`] ||
-        customMessages[`${type}.${mappedKeyword}`] ||
-        customMessages[mappedKeyword] ||
-        customMessages[keyword] ||
-        customMessages['default'];
+
+      // ✅ 优化：如果 schema 中有自定义消息，优先使用
+      // 支持三种自定义消息格式：
+      // 1. 键引用：_customMessages.pattern = "pattern.objectId" → 查找语言包中的 "pattern.objectId"
+      // 2. 模板字符串：_customMessages.min = "{{#label}}必须大于{{#limit}}" → 直接使用并插值
+      // 3. 最终消息：_customMessages.pattern = "手机号格式不正确" → 直接使用
+      let message;
+
+      // 1. 首先检查 schema 是否为该 keyword 定义了自定义消息
+      let customValue = schemaCustomMessages[keyword] || schemaCustomMessages[mappedKeyword];
+
+      if (customValue) {
+        // 尝试从 mergedMessages 中查找这个键
+        const lookupResult = mergedMessages[customValue];
+
+        if (lookupResult) {
+          // 找到了，说明它是一个键引用
+          message = lookupResult;
+        } else {
+          // 没找到，说明它本身就是模板或最终消息，直接使用
+          message = customValue;
+        }
+      }
+
+      // 2. 如果没有自定义消息，按照通用查找顺序
+      if (!message) {
+        message = mergedMessages[`${type}.${keyword}`] ||
+          mergedMessages[`${type}.${mappedKeyword}`] ||
+          mergedMessages[mappedKeyword] ||
+          mergedMessages[keyword] ||
+          mergedMessages['default'];
+      }
 
       // 自动查找 format 类型的消息 (例如 format.email)
       if (!message && mappedKeyword === 'format' && err.params && err.params.format) {
@@ -181,25 +232,22 @@ class ErrorFormatter {
 
         const formatKey = `format.${formatName}`;
 
-        // 优先查找 customMessages 中的 format.email
-        if (customMessages[formatKey]) {
-          message = customMessages[formatKey];
-        }
-        // 其次查找全局/语言包中的 format.email
-        else if (messages[formatKey]) {
-          message = messages[formatKey];
+        // 优先查找 mergedMessages 中的 format.email
+        if (mergedMessages[formatKey]) {
+          message = mergedMessages[formatKey];
         }
       }
 
       if (!message) {
         // 使用默认模板
-        const template = messages[mappedKeyword] || messages[keyword] || err.message || 'Validation error';
+        const template = mergedMessages[mappedKeyword] || mergedMessages[keyword] || err.message || 'Validation error';
         message = template;
       } else {
         // 检查 message 是否为 key (包含点号且无空格，或者是已知的 key)
         // 如果是 key，尝试从 messages 中查找
-        if (typeof message === 'string' && (message.includes('.') || messages[message])) {
-          let translated = messages[message];
+        if (typeof message === 'string' && (message.includes('.') || mergedMessages[message])) {
+
+          let translated = mergedMessages[message];
 
           // 尝试回退查找 (例如 pattern.phone.cn -> pattern.phone)
           if (!translated && message.includes('.')) {
@@ -207,7 +255,7 @@ class ErrorFormatter {
             while (parts.length > 1 && !translated) {
               parts.pop();
               const fallbackKey = parts.join('.');
-              translated = messages[fallbackKey];
+              translated = mergedMessages[fallbackKey];
             }
           }
 

package/lib/core/Locale.js

@@ -63,12 +63,16 @@ class Locale {
 
   /**
    * 获取错误消息模板
-   * @param {string} type - 错误类型
+   * @param {string} type - 错误类型或消息字符串
    * @param {Object} [customMessages] - 自定义消息
+   * @param {string} [locale] - 指定语言（可选，默认使用当前语言）
    * @returns {string} 消息模板
    */
-  static getMessage(type, customMessages = {}) {
-    // 优先级: 自定义消息 > 全局自定义消息 > 语言包 > 默认消息
+  static getMessage(type, customMessages = {}, locale = null) {
+    // 使用指定的语言或当前全局语言
+    const targetLocale = locale || this.currentLocale;
+
+    // 优先级: 自定义消息 > 全局自定义消息 > 语言包 > ErrorCodes > 原字符串
 
     // 1. 自定义消息
     if (customMessages[type]) {
@@ -80,8 +84,8 @@ class Locale {
       return this.customMessages[type];
     }
 
-    // 3. 语言包
-    const localeMessages = this.locales[this.currentLocale];
+    // 3. 语言包（使用指定的语言）
+    const localeMessages = this.locales[targetLocale];
     if (localeMessages && localeMessages[type]) {
       return localeMessages[type];
     }
@@ -89,9 +93,10 @@ class Locale {
     // 4. 默认消息（从ErrorCodes获取）
     const errorInfo = getErrorInfo(type);
 
-    // 5. 如果是未知错误，尝试从语言包获取本地化的UNKNOWN_ERROR消息
-    if (errorInfo.code === 'UNKNOWN_ERROR' && localeMessages && localeMessages['UNKNOWN_ERROR']) {
-      return localeMessages['UNKNOWN_ERROR'];
+    // 5. 如果是未知错误，说明不是预定义的错误码
+    if (errorInfo.code === 'UNKNOWN_ERROR') {
+      // ✅ 向后兼容：直接返回原字符串（支持硬编码消息）
+      return type;
     }
 
     return errorInfo.message;

package/lib/core/Validator.js

@@ -115,18 +115,7 @@ class Validator {
    * @returns {Object} 验证结果 { valid: boolean, errors: Array, data: * }
    */
   validate(schema, data, options = {}) {
-    // ✅ 性能优化：提前检查语言切换，避免99%的无效操作
-    if (options.locale && options.locale !== Locale.getLocale()) {
-      const originalLocale = Locale.getLocale();
-      Locale.setLocale(options.locale);
-      try {
-        return this._validateInternal(schema, data, options);
-      } finally {
-        Locale.setLocale(originalLocale);
-      }
-    }
-
-    // 正常流程（无需切换语言）
+    // ✅ 优化：直接传递 locale 到内部方法，不再切换全局状态
     return this._validateInternal(schema, data, options);
   }
 
@@ -146,6 +135,24 @@ class Validator {
       schema = this.dslSchemaCache.get(schema);
     }
 
+    // ✅ 处理 ConditionalBuilder 条件链（运行时条件判断）
+    if (schema && schema._isConditional) {
+      // 顶层 ConditionalBuilder（直接作为 Schema 使用）
+      // 此时验证的是整个数据对象
+      return this._validateConditional(schema, data, null, data, options);
+    }
+
+    // ✅ 预处理包含 ConditionalBuilder 的 Schema
+    if (schema && schema.properties) {
+      const hasConditional = Object.values(schema.properties).some(
+        fieldSchema => fieldSchema && fieldSchema._isConditional
+      );
+
+      if (hasConditional) {
+        return this._validateWithConditionals(schema, data, options);
+      }
+    }
+
     // 检查是否需要移除额外字段 (clean 模式)
     if (schema && schema._removeAdditional) {
       // 创建新的 Validator 实例，启用 removeAdditional
@@ -175,10 +182,13 @@ class Validator {
       // 执行验证
       const valid = validate(data);
 
-      // 格式化错误
+      // ✅ 优化：直接传递 locale 和 messages 到格式化器，不修改全局状态
       const errors = valid ? [] : (
         shouldFormat
-          ? this.errorFormatter.format(validate.errors, locale)
+          ? this.errorFormatter.format(validate.errors, {
+              locale,
+              messages: options.messages
+            })
           : validate.errors
       );
 
@@ -377,9 +387,235 @@ class Validator {
   }
 
   /**
-   * 静态方法：创建验证器实例
+   * 验证包含 ConditionalBuilder 字段的 Schema
+   * @private
+   * @param {Object} schema - Schema 对象
+   * @param {*} data - 待验证的数据
+   * @param {Object} options - 验证选项
+   * @returns {Object} 验证结果
+   */
+  _validateWithConditionals(schema, data, options = {}) {
+    const errors = [];
+
+    // 深拷贝 schema，避免修改原始对象
+    const cleanSchema = JSON.parse(JSON.stringify(schema));
+    const conditionalFields = {};
+
+    // 提取所有条件字段
+    for (const [fieldName, fieldSchema] of Object.entries(schema.properties || {})) {
+      if (fieldSchema && fieldSchema._isConditional) {
+        conditionalFields[fieldName] = fieldSchema;
+        // 从 cleanSchema 中删除条件字段
+        delete cleanSchema.properties[fieldName];
+      }
+    }
+
+    // 先验证非条件字段
+    const baseResult = this._validateInternal(cleanSchema, data, options);
+    if (!baseResult.valid) {
+      errors.push(...baseResult.errors);
+    }
+
+    // 然后验证每个条件字段
+    for (const [fieldName, conditionalSchema] of Object.entries(conditionalFields)) {
+      // ✅ 传递字段名和完整数据对象
+      const fieldResult = this._validateConditional(
+        conditionalSchema,
+        data,
+        fieldName,
+        data[fieldName],
+        options
+      );
+
+      if (!fieldResult.valid) {
+        // 添加字段路径信息
+        fieldResult.errors.forEach(error => {
+          if (!error.path || error.path === '') {
+            error.path = fieldName;
+          }
+          errors.push(error);
+        });
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      data
+    };
+  }
+
+  /**
+   * 验证条件链（ConditionalBuilder）
+   * @private
+   * @param {Object} conditionalSchema - 条件 Schema 对象
+   * @param {*} data - 完整数据对象（用于条件判断）
+   * @param {string} fieldName - 字段名
+   * @param {*} fieldValue - 字段值（用于验证）
+   * @param {Object} options - 验证选项
+   * @returns {Object} 验证结果
+   */
+  _validateConditional(conditionalSchema, data, fieldName, fieldValue, options = {}) {
+    const locale = options.locale || Locale.getLocale();
+
+    try {
+      // ✅ 遍历条件链，执行第一个匹配的条件
+      // 对于 if/elseIf 链，只执行第一个满足条件的分支
+      for (let i = 0; i < conditionalSchema.conditions.length; i++) {
+        const cond = conditionalSchema.conditions[i];
+
+        // 执行组合条件（支持 and/or）
+        const matched = conditionalSchema._evaluateCondition(cond, data);
+
+        if (cond.action === 'throw') {
+          // ✅ message 模式：条件为 true 时抛错，条件为 false 时通过
+          if (matched) {
+            // ✅ 条件满足（true），抛出错误
+            // 支持多语言：如果 message 是 key（如 'conditional.underAge'），从语言包获取翻译
+            // 传递 locale 参数以支持动态语言切换
+            const errorMessage = Locale.getMessage(cond.message, options.messages || {}, locale);
+
+            return {
+              valid: false,
+              errors: [{
+                message: errorMessage,
+                path: '',
+                keyword: 'conditional',
+                params: { condition: cond.type }
+              }],
+              data
+            };
+          }
+          // 条件不满足（false），继续验证
+          continue;
+        }
+
+        // ✅ then/else 模式：找到第一个满足的条件就执行并返回
+        if (matched) {
+          // 条件满足，执行 then Schema
+          if (cond.then !== undefined && cond.then !== null) {
+            return this._executeThenBranch(cond.then, data, fieldValue, fieldName, options);
+          }
+
+          // 条件满足但没有 then，表示验证通过
+          return {
+            valid: true,
+            errors: [],
+            data
+          };
+        }
+
+        // ✅ 如果是 if/elseIf 条件不满足，继续检查下一个 elseIf
+        // 这样就支持了 if...elseIf...elseIf...else 链
+      }
+
+      // ✅ 所有条件都不满足，执行 else
+      if (conditionalSchema.else !== undefined) {
+        if (conditionalSchema.else === null) {
+          // else 为 null，表示跳过验证
+          return {
+            valid: true,
+            errors: [],
+            data
+          };
+        }
+
+        // 执行 else Schema
+        return this._executeThenBranch(conditionalSchema.else, data, fieldValue, fieldName, options);
+      }
+
+      // 没有 else，表示不验证
+      return {
+        valid: true,
+        errors: [],
+        data
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [{
+          message: `Conditional validation error: ${error.message}`,
+          path: '',
+          keyword: 'conditional'
+        }],
+        data
+      };
+    }
+  }
+
+  /**
+   * 执行 then 分支（提取公共逻辑）
+   * @private
+   * @param {*} thenSchema - then 分支的 Schema
+   * @param {*} data - 完整数据对象（用于嵌套条件判断）
+   * @param {*} fieldValue - 字段值（用于验证）
+   * @param {string} fieldName - 字段名
+   * @param {Object} options - 验证选项
+   */
+  _executeThenBranch(thenSchema, data, fieldValue, fieldName, options) {
+    const DslBuilder = require('./DslBuilder');
+
+    // ✅ 如果是 ConditionalBuilder 实例（未调用 toSchema），先转换
+    if (thenSchema && typeof thenSchema.toSchema === 'function') {
+      thenSchema = thenSchema.toSchema();
+    }
+
+    // ✅ 处理嵌套的 ConditionalBuilder（已转换为 Schema 对象）
+    if (thenSchema && thenSchema._isConditional) {
+      // 嵌套的条件构建器，递归处理
+      // 传递完整数据对象用于条件判断，传递字段值用于验证
+      return this._validateConditional(thenSchema, data, fieldName, fieldValue, options);
+    }
+
+    // 如果是字符串，解析为 Schema
+    if (typeof thenSchema === 'string') {
+      const builder = new DslBuilder(thenSchema);
+      thenSchema = builder.toSchema();
+    }
+
+    // ✅ 验证字段值
+    return this._validateFieldValue(thenSchema, fieldValue, fieldName, options);
+  }
+
+  /**
+   * 验证字段值（处理空字符串和 undefined）
+   * @private
+   * @param {Object} schema - Schema 对象
+   * @param {*} fieldValue - 字段值
+   * @param {string} fieldName - 字段名
+   * @param {Object} options - 验证选项
+   * @returns {Object} 验证结果
+   */
+  _validateFieldValue(schema, fieldValue, fieldName, options = {}) {
+    // ✅ 检查字段是否必填
+    const isRequired = schema && schema._required === true;
+
+    // ✅ 处理 undefined：可选字段缺失时跳过验证
+    if (!isRequired && fieldValue === undefined) {
+      return {
+        valid: true,
+        errors: [],
+        data: fieldValue
+      };
+    }
+
+    // ✅ 处理空字符串：可选字段的空字符串视为未提供
+    if (!isRequired && fieldValue === '') {
+      return {
+        valid: true,
+        errors: [],
+        data: fieldValue
+      };
+    }
+
+    // 正常验证
+    return this._validateInternal(schema, fieldValue, options);
+  }
+
+  /**
+   * 静态工厂方法
    * @static
-   * @param {Object} options - 配置选项
+   * @param {Object} options - ajv配置选项
    * @returns {Validator} Validator实例
    */
   static create(options) {

package/lib/locales/en-US.js

@@ -12,6 +12,11 @@ module.exports = {
   'max-depth': 'Maximum recursion depth ({{#depth}}) exceeded at {{#label}}',
   exception: '{{#label}} validation exception: {{#message}}',
 
+  // Conditional (ConditionalBuilder)
+  'conditional.underAge': 'Minors cannot register',
+  'conditional.blocked': 'Account has been blocked',
+  'conditional.notAllowed': 'Registration not allowed',
+
   // Formats
   'format.email': '{{#label}} must be a valid email address',
   'format.url': '{{#label}} must be a valid URL',
@@ -115,6 +120,15 @@ module.exports = {
   'pattern.password.strong': 'Password must be at least 8 characters and contain uppercase, lowercase letters and numbers',
   'pattern.password.veryStrong': 'Password must be at least 10 characters and contain uppercase, lowercase letters, numbers and special characters',
 
+  // Union Type
+  'pattern.emailOrPhone': 'Must be an email or phone number',
+  'pattern.usernameOrEmail': 'Must be a username or email',
+  'pattern.httpOrHttps': 'Must be a URL starting with http or https',
+
+  // oneOf (cross-type union) - v1.1.0
+  oneOf: '{{#label}} must match one of the following types',
+  'oneOf.invalid': '{{#label}} value does not match any allowed type',
+
   // Unknown error fallback
   'UNKNOWN_ERROR': 'Unknown validation error',
 

package/lib/locales/es-ES.js

@@ -99,6 +99,10 @@ module.exports = {
   // Unknown error fallback
   'UNKNOWN_ERROR': 'Error de validación desconocido',
 
+  // oneOf (unión entre tipos) - v1.1.0
+  oneOf: '{{#label}} debe coincidir con uno de los siguientes tipos',
+  'oneOf.invalid': 'El valor de {{#label}} no coincide con ningún tipo permitido',
+
   // Custom validation
   'CUSTOM_VALIDATION_FAILED': 'Validación fallida',
   'ASYNC_VALIDATION_NOT_SUPPORTED': 'La validación asíncrona no es compatible en validate() síncrono',

package/lib/locales/fr-FR.js

@@ -99,6 +99,10 @@ module.exports = {
   // Unknown error fallback
   'UNKNOWN_ERROR': 'Erreur de validation inconnue',
 
+  // oneOf (union de types) - v1.1.0
+  oneOf: '{{#label}} doit correspondre à l\'un des types suivants',
+  'oneOf.invalid': 'La valeur de {{#label}} ne correspond à aucun type autorisé',
+
   // Custom validation
   'CUSTOM_VALIDATION_FAILED': 'Validation échouée',
   'ASYNC_VALIDATION_NOT_SUPPORTED': 'La validation asynchrone n\'est pas prise en charge dans validate() synchrone',

package/lib/locales/ja-JP.js

@@ -12,6 +12,11 @@ module.exports = {
   'max-depth': '{{#label}}で最大再帰深度 ({{#depth}}) を超えました',
   exception: '{{#label}}の検証例外: {{#message}}',
 
+  // Conditional (ConditionalBuilder)
+  'conditional.underAge': '未成年者は登録できません',
+  'conditional.blocked': 'アカウントがブロックされています',
+  'conditional.notAllowed': '登録は許可されていません',
+
   // Formats
   'format.email': '{{#label}}は有効なメールアドレスである必要があります',
   'format.url': '{{#label}}は有効なURLである必要があります',
@@ -96,6 +101,10 @@ module.exports = {
   'pattern.password.strong': 'パスワードは少なくとも8文字で、大文字、小文字、数字を含む必要があります',
   'pattern.password.veryStrong': 'パスワードは少なくとも10文字で、大文字、小文字、数字、特殊文字を含む必要があります',
 
+  // oneOf (型の結合) - v1.1.0
+  oneOf: '{{#label}}は次のいずれかの型に一致する必要があります',
+  'oneOf.invalid': '{{#label}}の値は許可された型のいずれとも一致しません',
+
   // Unknown error fallback
   'UNKNOWN_ERROR': '不明な検証エラー',
 

package/lib/locales/zh-CN.js

@@ -12,6 +12,11 @@ module.exports = {
   'max-depth': '超过最大递归深度 ({{#depth}}) at {{#label}}',
   exception: '{{#label}}验证异常: {{#message}}',
 
+  // Conditional (ConditionalBuilder)
+  'conditional.underAge': '未成年用户不能注册',
+  'conditional.blocked': '账号已被封禁',
+  'conditional.notAllowed': '不允许注册',
+
   // Formats
   'format.email': '{{#label}}必须是有效的邮箱地址',
   'format.url': '{{#label}}必须是有效的URL地址',
@@ -115,6 +120,15 @@ module.exports = {
   'pattern.password.strong': '密码至少8位，需包含大小写字母和数字',
   'pattern.password.veryStrong': '密码至少10位，需包含大小写字母、数字和特殊字符',
 
+  // Union Type (联合类型)
+  'pattern.emailOrPhone': '必须是邮箱或手机号',
+  'pattern.usernameOrEmail': '必须是用户名或邮箱',
+  'pattern.httpOrHttps': '必须是 http 或 https 开头的 URL',
+
+  // oneOf (跨类型联合) - v1.1.0 新增
+  oneOf: '{{#label}}必须匹配以下类型之一',
+  'oneOf.invalid': '{{#label}}的值不匹配任何允许的类型',
+
   // Unknown error fallback
   'UNKNOWN_ERROR': '未知的验证错误',
 

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "schema-dsl",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "description": "简洁强大的JSON Schema验证库 - DSL语法 + String扩展 + 便捷validate",
   "main": "index.js",
+  "types": "index.d.ts",
   "exports": {
     ".": {
       "require": "./index.js",
@@ -57,8 +58,10 @@
     "ajv-formats": "^2.1.1"
   },
   "devDependencies": {
+    "benchmark": "^2.1.4",
     "chai": "^4.5.0",
     "eslint": "^8.57.1",
+    "express": "^5.2.1",
     "joi": "^18.0.2",
     "mocha": "^10.8.2",
     "monsqlize": "^1.0.1",
@@ -67,4 +70,4 @@
     "yup": "^1.7.1",
     "zod": "^4.2.1"
   }
-}
+}