schema-dsl 1.2.5 → 2.0.1

package/lib/adapters/DslAdapter.js

@@ -1,995 +0,0 @@
-/**
- * DSL风格适配器 v2.0
- *
- * 统一的DSL Builder Pattern
- * 支持：纯字符串DSL + 链式调用扩展
- *
- * @module lib/adapters/DslAdapter
- * @version 2.0.0
- */
-
-const JSONSchemaCore = require("../core/JSONSchemaCore");
-const DslBuilder = require("../core/DslBuilder");
-
-// throw new Error('DEBUG FILE LOADED');
-
-/**
- * DSL适配器类
- * @class DslAdapter
- */
-class DslAdapter {
-  /**
-   * 解析DSL字符串为JSON Schema（内部使用）
-   * @static
-   * @param {string} dslString - DSL字符串
-   * @returns {Object} JSON Schema对象
-   */
-  static parseString(dslString) {
-    if (!dslString || typeof dslString !== "string") {
-      throw new Error("DSL must be a string");
-    }
-
-    const trimmed = dslString.trim();
-    let required = trimmed.endsWith("!");
-    let dslWithoutRequired = required ? trimmed.slice(0, -1) : trimmed;
-
-    // 特殊处理：array!数字范围 → array:数字范围 + 必填
-    // 支持: array!1-10, array!1-, array!-10
-    if (/^array![\d-]/.test(trimmed)) {
-      dslWithoutRequired = trimmed.replace(/^array!/, "array:");
-      required = true;
-    }
-
-    // 解析基本类型和约束
-    const schema = this._parseType(dslWithoutRequired);
-
-    return schema;
-  }
-
-  /**
-   * parse方法别名（向后兼容）
-   * @static
-   * @param {string} dslString - DSL字符串
-   * @returns {Object} JSON Schema对象
-   */
-  static parse(dslString) {
-    const schema = this.parseString(dslString);
-    schema._required = dslString.trim().endsWith("!");
-    return schema;
-  }
-
-  /**
-   * 解析类型和约束
-   * @private
-   * @static
-   * @param {string} dsl - DSL字符串（不含!）
-   * @returns {Object} JSON Schema对象
-   */
-  static _parseType(dsl) {
-    // 处理数组DSL语法
-    if (dsl.startsWith("array")) {
-      const schema = { type: "array" };
-
-      // 匹配模式: array:min-max<itemType> 或 array:constraint<itemType> 或 array<itemType>
-      // 支持: array:1-10, array:1-, array:-10, array:10, array<string>, array:1-10<string>
-      const arrayMatch = dsl.match(/^array(?::([^<]+?))?(?:<(.+)>)?$/);
-
-      if (arrayMatch) {
-        const [, constraint, itemType] = arrayMatch;
-
-        // 解析约束
-        if (constraint) {
-          const trimmedConstraint = constraint.trim();
-
-          if (trimmedConstraint.includes("-")) {
-            // 范围约束: min-max, min-, -max
-            const [min, max] = trimmedConstraint
-              .split("-")
-              .map((v) => v.trim());
-            if (min) schema.minItems = parseInt(min, 10);
-            if (max) schema.maxItems = parseInt(max, 10);
-          } else {
-            // 单个值 = 最大值
-            schema.maxItems = parseInt(trimmedConstraint, 10);
-          }
-        }
-
-        // 解析元素类型
-        if (itemType) {
-          schema.items = this._parseType(itemType.trim());
-        }
-
-        return schema;
-      }
-    }
-
-    // 处理 enum:x,y,z 格式（逗号分隔的枚举，优先于 | 检测）
-    // 支持格式：enum:a,b,c / enum:number:1,2,3 / enum:a|b|c
-    if (dsl.startsWith("enum:")) {
-      const enumBody = dsl.slice(5); // 去掉 'enum:' 前缀
-
-      // 检查是否有类型前缀：enum:number:1,2,3
-      const colonIdx = enumBody.indexOf(":");
-      let enumType = "string";
-      let enumValuesStr;
-
-      if (colonIdx !== -1) {
-        enumType = enumBody.slice(0, colonIdx);
-        enumValuesStr = enumBody.slice(colonIdx + 1);
-      } else {
-        enumValuesStr = enumBody;
-      }
-
-      // 统一分隔符：支持逗号和管道符
-      const separator = enumValuesStr.includes("|") ? "|" : ",";
-      const values = enumValuesStr
-        .split(separator)
-        .map((v) => v.trim())
-        .filter((v) => v);
-
-      if (values.length > 0) {
-        // 类型转换
-        if (enumType === "number") {
-          return { type: "number", enum: values.map((v) => parseFloat(v)) };
-        } else if (enumType === "integer") {
-          return { type: "integer", enum: values.map((v) => parseInt(v, 10)) };
-        } else if (enumType === "boolean") {
-          return { type: "boolean", enum: values.map((v) => v === "true") };
-        }
-        return { type: "string", enum: values };
-      }
-    }
-
-    // 检查是否为纯枚举（包含|但没有:且没有数字范围）
-    if (dsl.includes("|") && !dsl.includes(":") && !/^\w+\d+-\d+$/.test(dsl)) {
-      return {
-        type: "string",
-        enum: dsl.split("|").map((v) => v.trim()),
-      };
-    }
-
-    // 格式: type:constraint 或 type数字范围
-    // 例如: string:3-32, number:0-100
-    let type, constraint;
-
-    // 检查是否有冒号
-    const colonIndex = dsl.indexOf(":");
-
-    if (colonIndex !== -1) {
-      // 有冒号：string:3-32
-      type = dsl.substring(0, colonIndex);
-      constraint = dsl.substring(colonIndex + 1);
-    } else {
-      // 无冒号：检查是否有数字约束（string3-32）
-      const match = dsl.match(/^([a-z]+)(\d.*)$/i);
-      if (match) {
-        type = match[1];
-        constraint = match[2];
-      } else {
-        type = dsl;
-        constraint = "";
-      }
-    }
-
-    // 特殊处理 phone:country
-    if (type === "phone") {
-      const country = constraint || "cn";
-      const config = patterns.phone[country];
-      if (!config) throw new Error(`Unsupported country for phone: ${country}`);
-      return {
-        type: "string",
-        pattern: config.pattern.source,
-        minLength: config.min,
-        maxLength: config.max,
-        _customMessages: { pattern: config.key || config.msg },
-      };
-    }
-
-    // 特殊处理 idCard:country
-    if (type === "idCard") {
-      const country = constraint || "cn";
-      const config = patterns.idCard[country.toLowerCase()];
-      if (!config)
-        throw new Error(`Unsupported country for idCard: ${country}`);
-      return {
-        type: "string",
-        pattern: config.pattern.source,
-        minLength: config.min,
-        maxLength: config.max,
-        _customMessages: { pattern: config.key || config.msg },
-      };
-    }
-
-    // 特殊处理 creditCard:type
-    if (type === "creditCard") {
-      const cardType = constraint || "visa";
-      const config = patterns.creditCard[cardType.toLowerCase()];
-      if (!config) throw new Error(`Unsupported credit card type: ${cardType}`);
-      return {
-        type: "string",
-        pattern: config.pattern.source,
-        _customMessages: { pattern: config.key || config.msg },
-      };
-    }
-
-    // 特殊处理 licensePlate:country
-    if (type === "licensePlate") {
-      const country = constraint || "cn";
-      const config = patterns.licensePlate[country.toLowerCase()];
-      if (!config)
-        throw new Error(`Unsupported country for licensePlate: ${country}`);
-      return {
-        type: "string",
-        pattern: config.pattern.source,
-        _customMessages: { pattern: config.key || config.msg },
-      };
-    }
-
-    // 特殊处理 postalCode:country
-    if (type === "postalCode") {
-      const country = constraint || "cn";
-      const config = patterns.postalCode[country.toLowerCase()];
-      if (!config)
-        throw new Error(`Unsupported country for postalCode: ${country}`);
-      return {
-        type: "string",
-        pattern: config.pattern.source,
-        _customMessages: { pattern: config.key || config.msg },
-      };
-    }
-
-    // 特殊处理 passport:country
-    if (type === "passport") {
-      const country = constraint || "cn";
-      const config = patterns.passport[country.toLowerCase()];
-      if (!config)
-        throw new Error(`Unsupported country for passport: ${country}`);
-      return {
-        type: "string",
-        pattern: config.pattern.source,
-        _customMessages: { pattern: config.key || config.msg },
-      };
-    }
-
-    // 获取基础类型Schema
-    const baseSchema = this._getBaseType(type);
-
-    // 应用约束
-    if (constraint) {
-      const constraintSchema = this._parseConstraint(
-        baseSchema.type,
-        constraint,
-      );
-      Object.assign(baseSchema, constraintSchema);
-    }
-
-    return baseSchema;
-  }
-
-  /**
-   * 获取基本类型Schema
-   * @private
-   * @static
-   * @param {string} type - 类型名称
-   * @returns {Object} 基本类型Schema
-   */
-  static _getBaseType(type) {
-    const typeMap = {
-      // 基本类型
-      string: { type: "string" },
-      number: { type: "number" },
-      integer: { type: "integer" },
-      boolean: { type: "boolean" },
-      object: { type: "object" },
-      array: { type: "array" },
-      null: { type: "null" },
-
-      // 格式类型
-      date: { type: "string", format: "date" },
-      datetime: { type: "string", format: "date-time" },
-      time: { type: "string", format: "time" },
-      email: { type: "string", format: "email" },
-      url: { type: "string", format: "uri" },
-      uuid: { type: "string", format: "uuid" },
-      ipv4: { type: "string", format: "ipv4" },
-      ipv6: { type: "string", format: "ipv6" },
-
-      // 特殊类型（对比 joi 补充）
-      binary: { type: "string", contentEncoding: "base64" },
-      objectId: { type: "string", pattern: "^[0-9a-fA-F]{24}$" },
-      hexColor: {
-        type: "string",
-        pattern: "^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$",
-      },
-      macAddress: {
-        type: "string",
-        pattern: "^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$",
-      },
-      cron: {
-        type: "string",
-        pattern:
-          "^(\\*|([0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9])|\\*\\/([0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9])) (\\*|([0-9]|1[0-9]|2[0-3])|\\*\\/([0-9]|1[0-9]|2[0-3])) (\\*|([1-9]|1[0-9]|2[0-9]|3[0-1])|\\*\\/([1-9]|1[0-9]|2[0-9]|3[0-1])) (\\*|([1-9]|1[0-2])|\\*\\/([1-9]|1[0-2])) (\\*|([0-6])|\\*\\/([0-6]))$",
-      },
-      any: {}, // 任意类型
-    };
-
-    return typeMap[type] || { type: "string" };
-  }
-
-  /**
-   * 解析约束
-   * @private
-   * @static
-   * @param {string} baseType - 基础类型
-   * @param {string} constraint - 约束字符串
-   * @returns {Object} 约束对象
-   *
-   * @example
-   * // 比较运算符 (v1.2.0+)
-   * _parseConstraint('number', '>0')     // { exclusiveMinimum: 0 }
-   * _parseConstraint('number', '>=18')   // { minimum: 18 }
-   * _parseConstraint('number', '<100')   // { exclusiveMaximum: 100 }
-   * _parseConstraint('number', '<=100')  // { maximum: 100 }
-   * _parseConstraint('number', '=100')   // { enum: [100] }
-   * _parseConstraint('number', '>0.5')   // { exclusiveMinimum: 0.5 } 支持小数
-   */
-  static _parseConstraint(baseType, constraint) {
-    if (!constraint) return {};
-
-    const result = {};
-
-    // ========== 比较运算符（v1.1.2新增，最高优先级）==========
-    if (baseType === "number" || baseType === "integer") {
-      // 1. 大于等于: >=18, >=-10 (支持负数)
-      const gteMatch = constraint.match(/^>=(-?\d+(?:\.\d+)?)$/);
-      if (gteMatch) {
-        result.minimum = parseFloat(gteMatch[1]);
-        return result;
-      }
-
-      // 2. 小于等于: <=100, <=-10 (支持负数)
-      const lteMatch = constraint.match(/^<=(-?\d+(?:\.\d+)?)$/);
-      if (lteMatch) {
-        result.maximum = parseFloat(lteMatch[1]);
-        return result;
-      }
-
-      // 3. 大于: >0, >-10 (不包括边界值，支持负数)
-      const gtMatch = constraint.match(/^>(-?\d+(?:\.\d+)?)$/);
-      if (gtMatch) {
-        result.exclusiveMinimum = parseFloat(gtMatch[1]);
-        return result;
-      }
-
-      // 4. 小于: <100, <-10 (不包括边界值，支持负数)
-      const ltMatch = constraint.match(/^<(-?\d+(?:\.\d+)?)$/);
-      if (ltMatch) {
-        result.exclusiveMaximum = parseFloat(ltMatch[1]);
-        return result;
-      }
-
-      // 5. 等于: =100, =-10 (支持负数)
-      const eqMatch = constraint.match(/^=(-?\d+(?:\.\d+)?)$/);
-      if (eqMatch) {
-        result.enum = [parseFloat(eqMatch[1])];
-        return result;
-      }
-    }
-
-    // 枚举: value1|value2|value3 （优先检查，避免被数字范围误判）
-    if (constraint.includes("|") && !/^\d+-\d+$/.test(constraint)) {
-      result.enum = constraint.split("|").map((v) => v.trim());
-      return result;
-    }
-
-    // 范围约束: min-max 或 min- 或 -max
-    // 支持小数: 0.5-99.9
-    const rangeMatch = constraint.match(/^(\d*\.?\d*)-(\d*\.?\d*)$/);
-    if (rangeMatch) {
-      const [, min, max] = rangeMatch;
-      if (baseType === "string") {
-        if (min) result.minLength = parseInt(min, 10);
-        if (max) result.maxLength = parseInt(max, 10);
-      } else if (baseType === "array") {
-        if (min) result.minItems = parseInt(min, 10);
-        if (max) result.maxItems = parseInt(max, 10);
-      } else {
-        if (min) result.minimum = parseFloat(min);
-        if (max) result.maximum = parseFloat(max);
-      }
-      return result;
-    }
-
-    // 单个约束: min, max
-    // 支持小数: 99.99
-    const singleMatch = constraint.match(/^(\d+(?:\.\d+)?)$/);
-    if (singleMatch) {
-      const value = parseFloat(singleMatch[1]);
-      if (baseType === "string") {
-        result.maxLength = Math.floor(value);
-      } else if (baseType === "array") {
-        result.maxItems = Math.floor(value);
-      } else {
-        result.maximum = value;
-      }
-      return result;
-    }
-
-    return constraint;
-  }
-
-  /**
-   * 解析对象为Schema（支持DslBuilder）
-   * @static
-   * @param {Object} dslObject - DSL对象定义
-   * @returns {Object} JSON Schema对象
-   */
-  static parseObject(dslObject) {
-    const schema = {
-      type: "object",
-      properties: {},
-      required: [],
-    };
-
-    for (const [key, value] of Object.entries(dslObject)) {
-      let fieldKey = key;
-      let isFieldRequired = false;
-
-      // 检查 key 是否带 ! 后缀（表示该字段本身必填）
-      if (key.endsWith("!")) {
-        fieldKey = key.slice(0, -1);
-        isFieldRequired = true;
-      }
-
-      let fieldSchema;
-
-      // 1. Match 结构 (dsl.match)
-      if (value && value._isMatch) {
-        const matchSchema = this._buildMatchSchema(
-          value.field,
-          fieldKey,
-          value.map,
-        );
-        if (matchSchema) {
-          if (!schema.allOf) schema.allOf = [];
-          schema.allOf.push(matchSchema);
-        }
-        // 占位Schema，确保字段存在
-        fieldSchema = { description: `Depends on ${value.field}` };
-      }
-      // 2. If 结构 (dsl.if - 旧版本)
-      else if (value && value._isIf) {
-        const ifSchema = this._buildIfSchema(
-          value.condition,
-          fieldKey,
-          value.then,
-          value.else,
-        );
-        if (ifSchema) {
-          if (!schema.allOf) schema.allOf = [];
-          schema.allOf.push(ifSchema);
-        }
-        fieldSchema = {
-          description: `Conditional field based on ${value.condition}`,
-        };
-      }
-      // 3. ConditionalBuilder 结构 (dsl.if - 新版本)
-      else if (value && value._isConditional) {
-        // 调用 toSchema() 转换为 Schema 对象
-        const conditionalSchema =
-          typeof value.toSchema === "function" ? value.toSchema() : value;
-        // 保存条件链，留待 Validator 执行
-        fieldSchema = conditionalSchema;
-      }
-      // 4. DslBuilder 实例（链式调用结果）
-      else if (value instanceof DslBuilder) {
-        fieldSchema = value.toSchema();
-      }
-      // 5. 纯字符串 DSL
-      else if (typeof value === "string") {
-        const builder = new DslBuilder(value);
-        fieldSchema = builder.toSchema();
-      }
-      // 6. 嵌套对象
-      else if (
-        typeof value === "object" &&
-        !Array.isArray(value) &&
-        value !== null
-      ) {
-        fieldSchema = this.parseObject(value);
-      }
-      // 7. 其他类型（保留原样）
-      else {
-        fieldSchema = value;
-      }
-
-      // 处理必填标记（优先级：key! > 字段内部的!）
-      if (isFieldRequired) {
-        schema.required.push(fieldKey);
-      } else if (fieldSchema && fieldSchema._required) {
-        schema.required.push(fieldKey);
-        delete fieldSchema._required;
-      }
-
-      // 清理所有_required标记（包括嵌套的）
-      this._cleanRequiredMarks(fieldSchema);
-
-      schema.properties[fieldKey] = fieldSchema;
-    }
-
-    if (schema.required.length === 0) {
-      delete schema.required;
-    }
-
-    return schema;
-  }
-
-  /**
-   * 创建 Match 结构
-   * @static
-   * @param {string} field - 依赖字段名
-   * @param {Object} map - 值映射
-   * @returns {Object} Match结构
-   */
-  static match(field, map) {
-    return {
-      _isMatch: true,
-      field,
-      map,
-    };
-  }
-
-  /**
-   * 创建 If 结构
-   * @static
-   * @param {string} condition - 条件字段
-   * @param {string|Object} thenSchema - 满足条件时的Schema
-   * @param {string|Object} elseSchema - 不满足条件时的Schema
-   * @returns {Object} If结构
-   */
-  static if(condition, thenSchema, elseSchema) {
-    return {
-      _isIf: true,
-      condition,
-      then: thenSchema,
-      else: elseSchema,
-    };
-  }
-
-  /**
-   * 解析DSL定义（字符串/Builder/对象）
-   * @private
-   * @static
-   */
-  static _resolveDsl(dsl) {
-    if (!dsl) return {};
-    if (dsl instanceof DslBuilder) return dsl.toSchema();
-    if (typeof dsl === "string") return new DslBuilder(dsl).toSchema();
-    if (typeof dsl === "object" && !Array.isArray(dsl))
-      return this.parseObject(dsl);
-    return dsl;
-  }
-
-  /**
-   * 构建 Match 对应的 JSON Schema (if-then-else 链)
-   * @private
-   * @static
-   */
-  static _buildMatchSchema(conditionField, targetField, map) {
-    const entries = Object.entries(map).filter(([k]) => k !== "_default");
-    const defaultDsl = map._default;
-
-    const build = (index) => {
-      if (index >= entries.length) {
-        if (defaultDsl) {
-          // 处理 _default 值（可能是 Match、If 或普通 DSL）
-          if (defaultDsl._isMatch) {
-            return this._buildMatchSchema(
-              defaultDsl.field,
-              targetField,
-              defaultDsl.map,
-            );
-          } else if (defaultDsl._isIf) {
-            return this._buildIfSchema(
-              defaultDsl.condition,
-              targetField,
-              defaultDsl.then,
-              defaultDsl.else,
-            );
-          } else {
-            const s = this._resolveDsl(defaultDsl);
-            const isRequired = s._required;
-            this._cleanRequiredMarks(s);
-            const result = { properties: { [targetField]: s } };
-            if (isRequired) result.required = [targetField];
-            return result;
-          }
-        }
-        return {};
-      }
-
-      const [val, dsl] = entries[index];
-
-      // 处理分支值（可能是 Match、If 或普通 DSL）
-      let thenSchema;
-      // 先检查 null/undefined
-      if (dsl === null || dsl === undefined) {
-        // 跳过 null/undefined 分支，继续下一个
-        return build(index + 1);
-      } else if (dsl._isMatch) {
-        thenSchema = this._buildMatchSchema(dsl.field, targetField, dsl.map);
-      } else if (dsl._isIf) {
-        thenSchema = this._buildIfSchema(
-          dsl.condition,
-          targetField,
-          dsl.then,
-          dsl.else,
-        );
-      } else {
-        const branchSchema = this._resolveDsl(dsl);
-        const isRequired = branchSchema._required;
-        this._cleanRequiredMarks(branchSchema);
-        thenSchema = { properties: { [targetField]: branchSchema } };
-        if (isRequired) thenSchema.required = [targetField];
-      }
-
-      return {
-        if: { properties: { [conditionField]: { const: val } } },
-        then: thenSchema,
-        else: build(index + 1),
-      };
-    };
-
-    return build(0);
-  }
-
-  /**
-   * 构建 If 对应的 JSON Schema
-   * @private
-   * @static
-   */
-  static _buildIfSchema(conditionField, targetField, thenDsl, elseDsl) {
-    // 处理 then 分支
-    let thenResult;
-    if (thenDsl && thenDsl._isMatch) {
-      // then 是一个 Match 结构，需要递归构建
-      thenResult = this._buildMatchSchema(
-        thenDsl.field,
-        targetField,
-        thenDsl.map,
-      );
-    } else if (thenDsl && thenDsl._isIf) {
-      // then 是一个 If 结构，需要递归构建
-      thenResult = this._buildIfSchema(
-        thenDsl.condition,
-        targetField,
-        thenDsl.then,
-        thenDsl.else,
-      );
-    } else {
-      const thenSchema = this._resolveDsl(thenDsl);
-      const thenRequired = thenSchema._required;
-      this._cleanRequiredMarks(thenSchema);
-      thenResult = { properties: { [targetField]: thenSchema } };
-      if (thenRequired) thenResult.required = [targetField];
-    }
-
-    // 处理 else 分支
-    let elseResult = {};
-    if (elseDsl) {
-      if (elseDsl._isMatch) {
-        // else 也是一个 Match 结构
-        elseResult = this._buildMatchSchema(
-          elseDsl.field,
-          targetField,
-          elseDsl.map,
-        );
-      } else if (elseDsl._isIf) {
-        // else 也是一个 If 结构
-        elseResult = this._buildIfSchema(
-          elseDsl.condition,
-          targetField,
-          elseDsl.then,
-          elseDsl.else,
-        );
-      } else {
-        const elseSchema = this._resolveDsl(elseDsl);
-        const elseRequired = elseSchema._required;
-        this._cleanRequiredMarks(elseSchema);
-        elseResult = { properties: { [targetField]: elseSchema } };
-        if (elseRequired) elseResult.required = [targetField];
-      }
-    }
-
-    // 默认行为：检查字段值为 true (适用于 isVip: boolean)
-    return {
-      if: { properties: { [conditionField]: { const: true } } },
-      then: thenResult,
-      else: elseResult,
-    };
-  }
-
-  /**
-   * 解析对象为Schema（旧版本，兼容）
-   * @static
-   * @param {Object} dslObject - DSL对象定义
-   * @returns {Object} JSON Schema对象
-   */
-  static parseObjectOld(dslObject) {
-    if (!dslObject || typeof dslObject !== "object") {
-      throw new Error("DSL object must be an object");
-    }
-
-    const schema = {
-      type: "object",
-      properties: {},
-      required: [],
-    };
-
-    for (const [key, value] of Object.entries(dslObject)) {
-      if (typeof value === "string") {
-        const parsed = this.parse(value);
-
-        // 处理必填标记
-        if (parsed._required) {
-          schema.required.push(key);
-          delete parsed._required; // 清理临时标记
-        }
-
-        // 清理所有_required标记（包括嵌套的）
-        this._cleanRequiredMarks(parsed);
-
-        schema.properties[key] = parsed;
-      } else if (typeof value === "object") {
-        // 嵌套对象
-        schema.properties[key] = this.parseObject(value);
-      }
-    }
-
-    if (schema.required.length === 0) {
-      delete schema.required;
-    }
-
-    return schema;
-  }
-
-  /**
-   * 清理Schema中的临时标记
-   * @private
-   * @static
-   * @param {Object} schema - Schema对象
-   */
-  static _cleanRequiredMarks(schema) {
-    if (!schema || typeof schema !== "object") {
-      return;
-    }
-
-    // 只删除 _required 标记，保留其他扩展属性（如 _customValidators）
-    // 这些属性将由自定义关键字处理
-    delete schema._required;
-
-    // 递归处理properties
-    if (schema.properties) {
-      for (const prop of Object.values(schema.properties)) {
-        this._cleanRequiredMarks(prop);
-      }
-    }
-
-    // 递归处理items
-    if (schema.items) {
-      this._cleanRequiredMarks(schema.items);
-    }
-  }
-
-  /**
-   * 转换为JSONSchemaCore实例
-   * @static
-   * @param {string|Object} dsl - DSL字符串或对象
-   * @returns {JSONSchemaCore} JSONSchemaCore实例
-   */
-  static toCore(dsl) {
-    let schema;
-    if (typeof dsl === "string") {
-      // 创建DslBuilder并转为Schema
-      const builder = new DslBuilder(dsl);
-      schema = builder.toSchema();
-    } else {
-      schema = this.parseObject(dsl);
-    }
-    return new JSONSchemaCore(schema);
-  }
-}
-
-// ========== 导出统一API ==========
-
-/**
- * DSL函数 - 统一入口
- * @param {string|Object} definition - DSL字符串或对象定义
- * @returns {DslBuilder|Object} DslBuilder实例或JSON Schema对象
- *
- * @example
- * // 字符串：返回 DslBuilder（可链式调用）
- * const schema = dsl('email!')
- *   .pattern(/custom/)
- *   .messages({ 'string.pattern': '格式不正确' });
- *
- * // 对象：返回 JSON Schema
- * const schema = dsl({
- *   username: 'string:3-32!',
- *   email: dsl('email!').label('邮箱')
- * });
- */
-function dsl(definition) {
-  // 字符串：返回 DslBuilder
-  if (typeof definition === "string") {
-    return new DslBuilder(definition);
-  }
-
-  // 对象：解析对象Schema
-  if (typeof definition === "object" && !Array.isArray(definition)) {
-    return DslAdapter.parseObject(definition);
-  }
-
-  throw new Error("Invalid DSL definition: must be string or object");
-}
-
-/**
- * 便捷验证函数（同步）
- *
- * @param {Object|DslBuilder|string} schema - JSON Schema、DslBuilder实例或DSL对象
- * @param {*} data - 待验证数据
- * @param {Object} options - 验证选项
- * @returns {Object} 验证结果 { valid, errors, data }
- *
- * @example
- * // 方式1：传入 JSON Schema
- * const result1 = validate({ type: 'object', properties: {...} }, data);
- *
- * // 方式2：传入 DslBuilder 实例
- * const result2 = validate(dsl('email!'), data);
- *
- * // 方式3：传入 DSL 对象（自动转换）
- * const result3 = validate({ email: 'email!', age: 'number!' }, data);
- */
-function validate(schema, data, options = {}) {
-  const Validator = require("../core/Validator");
-
-  // ✅ 自动检测并转换 DSL 对象
-  if (_isDslObject(schema)) {
-    schema = DslAdapter.parseObject(schema);
-  }
-
-  const validator = new Validator(options);
-  return validator.validate(schema, data, options);
-}
-
-/**
- * 检测是否为 DSL 对象
- * @private
- * @param {*} obj - 待检测对象
- * @returns {boolean}
- */
-function _isDslObject(obj) {
-  // 不是普通对象，直接返回 false
-  if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
-    return false;
-  }
-
-  // 如果有 toSchema 方法，是 DslBuilder，不是 DSL 对象
-  if (typeof obj.toSchema === "function") {
-    return false;
-  }
-
-  // 如果有 _isConditional 标记，是 ConditionalBuilder
-  if (obj._isConditional) {
-    return false;
-  }
-
-  // 如果有标准 JSON Schema 的 type 字段，认为是 JSON Schema
-  if (
-    obj.type &&
-    [
-      "string",
-      "number",
-      "integer",
-      "boolean",
-      "object",
-      "array",
-      "null",
-    ].includes(obj.type)
-  ) {
-    return false;
-  }
-
-  // 如果有 properties 但所有属性值都是 JSON Schema 对象（包含 type），认为是 JSON Schema
-  if (obj.properties && typeof obj.properties === "object") {
-    const allStandardSchema = Object.values(obj.properties).every(
-      (prop) => prop && typeof prop === "object" && prop.type,
-    );
-    if (allStandardSchema) {
-      return false;
-    }
-  }
-
-  const values = Object.values(obj);
-
-  // ✅ 检查是否有 DslBuilder 实例（有 toSchema 方法的对象）
-  const hasDslBuilder = values.some(
-    (v) => v && typeof v === "object" && typeof v.toSchema === "function",
-  );
-
-  if (hasDslBuilder) {
-    return true;
-  }
-
-  // 检查是否有 DSL 格式的字符串值（如 'email!', 'string:3-32'）
-  const hasDslString = values.some(
-    (v) =>
-      typeof v === "string" &&
-      (v.includes(":") ||
-        v.includes("!") ||
-        v.includes("|") ||
-        [
-          "email",
-          "url",
-          "uuid",
-          "date",
-          "datetime",
-          "time",
-          "phone",
-          "objectId",
-        ].includes(v.split(":")[0].replace("!", ""))),
-  );
-
-  if (hasDslString) {
-    return true;
-  }
-
-  // 检查是否有嵌套的 DSL 对象
-  const hasNestedDslObject = values.some((v) => _isDslObject(v));
-
-  return hasNestedDslObject;
-}
-
-/**
- * 便捷异步验证函数
- *
- * @param {Object|DslBuilder|string} schema - JSON Schema、DslBuilder实例或DSL对象
- * @param {*} data - 待验证数据
- * @param {Object} options - 验证选项
- * @returns {Promise<*>} 验证通过返回数据
- * @throws {ValidationError} 验证失败抛出异常
- *
- * @example
- * try {
- *   // 方式1：传入 JSON Schema
- *   const data1 = await validateAsync({ type: 'object', properties: {...} }, inputData);
- *
- *   // 方式2：传入 DSL 对象（自动转换）
- *   const data2 = await validateAsync({ email: 'email!', age: 'number!' }, inputData);
- *
- *   console.log('验证通过:', data);
- * } catch (error) {
- *   if (error instanceof ValidationError) {
- *     console.error('验证失败:', error.errors);
- *   }
- * }
- */
-async function validateAsync(schema, data, options = {}) {
-  const Validator = require("../core/Validator");
-
-  // ✅ 自动检测并转换 DSL 对象
-  if (_isDslObject(schema)) {
-    schema = DslAdapter.parseObject(schema);
-  }
-
-  const validator = new Validator(options);
-  return validator.validateAsync(schema, data, options);
-}
-
-// 导出
-module.exports = dsl;
-module.exports.DslAdapter = DslAdapter;
-module.exports.DslBuilder = DslBuilder;
-module.exports.validate = validate;
-module.exports.validateAsync = validateAsync;