schema-dsl 1.2.4 → 2.0.0

package/lib/core/JSONSchemaCore.js

@@ -1,347 +0,0 @@
-/**
- * JSON Schema核心类
- *
- * 负责管理JSON Schema对象，提供统一的Schema表示
- * 所有适配器转换后的Schema都使用此类表示
- *
- * @module lib/core/JSONSchemaCore
- * @version 1.0.0
- */
-
-const CONSTANTS = require('../config/constants');
-
-/**
- * JSON Schema核心类
- *
- * @class JSONSchemaCore
- * @description 基于JSON Schema Draft 7标准
- */
-class JSONSchemaCore {
-  /**
-   * 构造函数
-   * @param {Object} schema - JSON Schema对象
-   * @param {Object} options - 配置选项
-   * @param {boolean} options.strict - 是否启用严格模式（默认false）
-   * @param {string} options.draft - JSON Schema草案版本（默认'draft-07'）
-   */
-  constructor(schema = {}, options = {}) {
-    this.schema = this._normalizeSchema(schema);
-    this.options = {
-      strict: options.strict || false,
-      draft: options.draft || 'draft-07',
-      ...options
-    };
-
-    // 确保$schema字段
-    if (!this.schema.$schema) {
-      this.schema.$schema = 'http://json-schema.org/draft-07/schema#';
-    }
-  }
-
-  /**
-   * 规范化Schema对象
-   * @private
-   * @param {Object} schema - 原始Schema
-   * @returns {Object} 规范化后的Schema
-   */
-  _normalizeSchema(schema) {
-    if (!schema || typeof schema !== 'object') {
-      return { type: 'object' };
-    }
-
-    // 深拷贝避免修改原对象
-    return JSON.parse(JSON.stringify(schema));
-  }
-
-  /**
-   * 获取Schema对象
-   * @returns {Object} JSON Schema对象
-   */
-  getSchema() {
-    return this.schema;
-  }
-
-  /**
-   * 设置Schema类型
-   * @param {string} type - 类型名称（string/number/boolean/object/array/null）
-   * @returns {JSONSchemaCore} 返回this支持链式调用
-   */
-  setType(type) {
-    const validTypes = ['string', 'number', 'integer', 'boolean', 'object', 'array', 'null'];
-    if (!validTypes.includes(type)) {
-      throw new Error(`Invalid type: ${type}. Valid types: ${validTypes.join(', ')}`);
-    }
-    this.schema.type = type;
-    return this;
-  }
-
-  /**
-   * 设置必填字段
-   * @param {string[]} required - 必填字段数组
-   * @returns {JSONSchemaCore} 返回this支持链式调用
-   */
-  setRequired(required) {
-    if (!Array.isArray(required)) {
-      throw new Error('Required must be an array');
-    }
-    this.schema.required = required;
-    return this;
-  }
-
-  /**
-   * 设置属性定义
-   * @param {string} name - 属性名
-   * @param {Object} propertySchema - 属性Schema
-   * @returns {JSONSchemaCore} 返回this支持链式调用
-   */
-  setProperty(name, propertySchema) {
-    if (!this.schema.properties) {
-      this.schema.properties = {};
-    }
-    this.schema.properties[name] = propertySchema;
-    return this;
-  }
-
-  /**
-   * 设置多个属性
-   * @param {Object} properties - 属性对象
-   * @returns {JSONSchemaCore} 返回this支持链式调用
-   */
-  setProperties(properties) {
-    if (typeof properties !== 'object' || properties === null) {
-      throw new Error('Properties must be an object');
-    }
-    this.schema.properties = { ...this.schema.properties, ...properties };
-    return this;
-  }
-
-  /**
-   * 设置数组items
-   * @param {Object} itemsSchema - items的Schema
-   * @returns {JSONSchemaCore} 返回this支持链式调用
-   */
-  setItems(itemsSchema) {
-    this.schema.items = itemsSchema;
-    return this;
-  }
-
-  /**
-   * 设置字符串格式
-   * @param {string} format - 格式（email/uri/date-time等）
-   * @returns {JSONSchemaCore} 返回this支持链式调用
-   */
-  setFormat(format) {
-    this.schema.format = format;
-    return this;
-  }
-
-  /**
-   * 设置字符串正则模式
-   * @param {string} pattern - 正则表达式字符串
-   * @returns {JSONSchemaCore} 返回this支持链式调用
-   */
-  setPattern(pattern) {
-    this.schema.pattern = pattern;
-    return this;
-  }
-
-  /**
-   * 设置数值范围（最小值）
-   * @param {number} min - 最小值
-   * @param {boolean} exclusive - 是否不包含边界（默认false）
-   * @returns {JSONSchemaCore} 返回this支持链式调用
-   */
-  setMinimum(min, exclusive = false) {
-    if (exclusive) {
-      this.schema.exclusiveMinimum = min;
-    } else {
-      this.schema.minimum = min;
-    }
-    return this;
-  }
-
-  /**
-   * 设置数值范围（最大值）
-   * @param {number} max - 最大值
-   * @param {boolean} exclusive - 是否不包含边界（默认false）
-   * @returns {JSONSchemaCore} 返回this支持链式调用
-   */
-  setMaximum(max, exclusive = false) {
-    if (exclusive) {
-      this.schema.exclusiveMaximum = max;
-    } else {
-      this.schema.maximum = max;
-    }
-    return this;
-  }
-
-  /**
-   * 设置字符串长度范围
-   * @param {number} min - 最小长度
-   * @param {number} max - 最大长度
-   * @returns {JSONSchemaCore} 返回this支持链式调用
-   */
-  setLength(min, max) {
-    if (min !== undefined) {
-      this.schema.minLength = min;
-    }
-    if (max !== undefined) {
-      this.schema.maxLength = max;
-    }
-    return this;
-  }
-
-  /**
-   * 设置数组长度范围
-   * @param {number} min - 最小长度
-   * @param {number} max - 最大长度
-   * @returns {JSONSchemaCore} 返回this支持链式调用
-   */
-  setArrayLength(min, max) {
-    if (min !== undefined) {
-      this.schema.minItems = min;
-    }
-    if (max !== undefined) {
-      this.schema.maxItems = max;
-    }
-    return this;
-  }
-
-  /**
-   * 设置枚举值
-   * @param {Array} values - 枚举值数组
-   * @returns {JSONSchemaCore} 返回this支持链式调用
-   */
-  setEnum(values) {
-    if (!Array.isArray(values)) {
-      throw new Error('Enum values must be an array');
-    }
-    this.schema.enum = values;
-    return this;
-  }
-
-  /**
-   * 设置默认值
-   * @param {*} value - 默认值
-   * @returns {JSONSchemaCore} 返回this支持链式调用
-   */
-  setDefault(value) {
-    this.schema.default = value;
-    return this;
-  }
-
-  /**
-   * 设置描述
-   * @param {string} description - 描述文本
-   * @returns {JSONSchemaCore} 返回this支持链式调用
-   */
-  setDescription(description) {
-    this.schema.description = description;
-    return this;
-  }
-
-  /**
-   * 设置标题
-   * @param {string} title - 标题文本
-   * @returns {JSONSchemaCore} 返回this支持链式调用
-   */
-  setTitle(title) {
-    this.schema.title = title;
-    return this;
-  }
-
-  /**
-   * 添加自定义关键字
-   * @param {string} keyword - 关键字名称
-   * @param {*} value - 关键字值
-   * @returns {JSONSchemaCore} 返回this支持链式调用
-   */
-  addCustomKeyword(keyword, value) {
-    this.schema[keyword] = value;
-    return this;
-  }
-
-  /**
-   * 合并另一个Schema
-   * @param {Object} otherSchema - 要合并的Schema对象
-   * @returns {JSONSchemaCore} 返回this支持链式调用
-   */
-  merge(otherSchema) {
-    this.schema = {
-      ...this.schema,
-      ...otherSchema
-    };
-    return this;
-  }
-
-  /**
-   * 转换为JSON字符串
-   * @param {number} space - 缩进空格数（默认2）
-   * @returns {string} JSON字符串
-   */
-  toJSON(space = 2) {
-    return JSON.stringify(this.schema, null, space);
-  }
-
-  /**
-   * 克隆当前Schema
-   * @returns {JSONSchemaCore} 新的JSONSchemaCore实例
-   */
-  clone() {
-    return new JSONSchemaCore(this.schema, this.options);
-  }
-
-  /**
-   * 验证Schema是否有效
-   * @returns {Object} 验证结果 { valid: boolean, errors: Array }
-   */
-  validateSchema() {
-    const errors = [];
-
-    // 基本验证
-    if (!this.schema.type && !this.schema.properties && !this.schema.items) {
-      errors.push('Schema must have type, properties, or items');
-    }
-
-    // 类型验证
-    if (this.schema.type) {
-      const validTypes = ['string', 'number', 'integer', 'boolean', 'object', 'array', 'null'];
-      if (!validTypes.includes(this.schema.type)) {
-        errors.push(`Invalid type: ${this.schema.type}`);
-      }
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-
-  /**
-   * 静态方法：从JSON字符串创建
-   * @static
-   * @param {string} jsonString - JSON字符串
-   * @returns {JSONSchemaCore} JSONSchemaCore实例
-   */
-  static fromJSON(jsonString) {
-    try {
-      const schema = JSON.parse(jsonString);
-      return new JSONSchemaCore(schema);
-    } catch (error) {
-      throw new Error(`Invalid JSON: ${error.message}`);
-    }
-  }
-
-  /**
-   * 静态方法：创建简单类型Schema
-   * @static
-   * @param {string} type - 类型名称
-   * @returns {JSONSchemaCore} JSONSchemaCore实例
-   */
-  static createSimpleType(type) {
-    return new JSONSchemaCore({ type });
-  }
-}
-
-module.exports = JSONSchemaCore;
-

package/lib/core/Locale.js

@@ -1,130 +0,0 @@
-/**
- * 语言管理器
- *
- * 管理多语言支持，提供语言切换功能
- *
- * @module lib/core/Locale
- */
-
-const { getErrorInfo } = require('./ErrorCodes');
-const defaultLocales = require('../locales');
-
-class Locale {
-  /**
-   * 当前语言
-   * @private
-   */
-  static currentLocale = 'en-US';
-
-  /**
-   * 语言包存储
-   * @private
-   */
-  static locales = { ...defaultLocales };
-
-  /**
-   * 自定义消息（全局）
-   * @private
-   */
-  static customMessages = {};
-
-  /**
-   * 设置当前语言
-   * @param {string} locale - 语言代码 (zh-CN, en-US等)
-   */
-  static setLocale(locale) {
-    this.currentLocale = locale;
-  }
-
-  /**
-   * 获取当前语言
-   * @returns {string} 当前语言代码
-   */
-  static getLocale() {
-    return this.currentLocale;
-  }
-
-  /**
-   * 添加语言包
-   * @param {string} locale - 语言代码
-   * @param {Object} messages - 消息对象
-   */
-  static addLocale(locale, messages) {
-    this.locales[locale] = { ...(this.locales[locale] || {}), ...messages };
-  }
-
-  /**
-   * 设置全局自定义消息
-   * @param {Object} messages - 消息对象
-   */
-  static setMessages(messages) {
-    this.customMessages = { ...this.customMessages, ...messages };
-  }
-
-  /**
-   * 获取错误消息配置
-   * @param {string} type - 错误类型或消息字符串
-   * @param {Object} [customMessages] - 自定义消息
-   * @param {string} [locale] - 指定语言（可选，默认使用当前语言）
-   * @returns {Object|string} 消息配置对象 { code, message } 或字符串（向后兼容）
-   * @version 1.1.5 - 支持对象格式
-   */
-  static getMessage(type, customMessages = {}, locale = null) {
-    // 使用指定的语言或当前全局语言
-    const targetLocale = locale || this.currentLocale;
-
-    // 优先级: 自定义消息 > 全局自定义消息 > 语言包 > ErrorCodes > 原字符串
-
-    // 1. 查找消息配置
-    let messageConfig = customMessages[type]
-                     || this.customMessages[type]
-                     || (this.locales[targetLocale] && this.locales[targetLocale][type]);
-
-    // 2. 如果未找到，尝试从 ErrorCodes 获取
-    if (!messageConfig) {
-      const errorInfo = getErrorInfo(type);
-      if (errorInfo.code === 'UNKNOWN_ERROR') {
-        // ✅ 向后兼容：直接返回原字符串（支持硬编码消息）
-        return type;
-      }
-      messageConfig = errorInfo.message;
-    }
-
-    // 3. 规范化为对象格式（v1.1.5 新增）
-    if (typeof messageConfig === 'string') {
-      // 字符串格式 → 转换为对象格式（向后兼容）
-      return { code: type, message: messageConfig };
-    }
-
-    if (typeof messageConfig === 'object' && messageConfig !== null && messageConfig.message) {
-      // 对象格式 → 直接使用
-      return {
-        code: messageConfig.code || type,  // 无 code 时使用 type 作为 code
-        message: messageConfig.message
-      };
-    }
-
-    // 4. 降级处理（边界情况）
-    return { code: type, message: type };
-  }
-
-  /**
-   * 获取所有可用语言
-   * @returns {Array<string>} 语言代码数组
-   */
-  static getAvailableLocales() {
-    return ['en-US', 'zh-CN', ...Object.keys(this.locales)];
-  }
-
-  /**
-   * 重置语言管理器
-   * 用于测试
-   */
-  static reset() {
-    this.currentLocale = 'en-US';
-    this.locales = { ...defaultLocales };
-    this.customMessages = {};
-  }
-}
-
-module.exports = Locale;

package/lib/core/MessageTemplate.js

@@ -1,98 +0,0 @@
-/**
- * 消息模板引擎
- *
- * 支持模板变量替换，如 {{#label}}, {{#limit}} 等
- *
- * @module lib/core/MessageTemplate
- */
-
-class MessageTemplate {
-  /**
-   * 创建消息模板实例
-   * @param {string} template - 模板字符串
-   */
-  constructor(template) {
-    this.template = template || '';
-  }
-
-  /**
-   * 渲染模板
-   * @param {Object} context - 上下文对象
-   * @param {string} [context.label] - 字段标签
-   * @param {string} [context.key] - 字段名
-   * @param {*} [context.value] - 当前值
-   * @param {*} [context.limit] - 限制值
-   * @param {Array|string} [context.valids] - 有效值列表
-   * @param {RegExp} [context.pattern] - 正则表达式
-   * @returns {string} 渲染后的消息
-   */
-  render(context = {}) {
-    let message = this.template;
-
-    // 定义支持的模板格式（按优先级）
-    const patterns = [
-      /\{\{#(\w+)\}\}/g,  // {{#variable}} - 优先级1（现有格式）
-      /\{\{(\w+)\}\}/g,   // {{variable}}  - 优先级2（无井号）
-      /\{(\w+)\}/g        // {variable}    - 优先级3（单花括号）
-    ];
-
-    // 按优先级依次替换
-    for (const pattern of patterns) {
-      message = message.replace(pattern, (match, key) => {
-        const value = context[key];
-
-        // 特殊处理
-        if (value === undefined || value === null) {
-          return match; // 保留原样
-        }
-
-        // 数组转字符串
-        if (Array.isArray(value)) {
-          return value.join(', ');
-        }
-
-        // RegExp转字符串
-        if (value instanceof RegExp) {
-          return value.toString();
-        }
-
-        // Date转字符串
-        if (value instanceof Date) {
-          return value.toISOString();
-        }
-
-        return String(value);
-      });
-    }
-
-    return message;
-  }
-
-  /**
-   * 静态方法：快速渲染
-   * @param {string} template - 模板字符串
-   * @param {Object} context - 上下文对象
-   * @returns {string} 渲染后的消息
-   */
-  static render(template, context) {
-    const instance = new MessageTemplate(template);
-    return instance.render(context);
-  }
-
-  /**
-   * 批量渲染
-   * @param {Object} templates - 模板对象 { type: template }
-   * @param {Object} context - 上下文对象
-   * @returns {Object} 渲染后的消息对象
-   */
-  static renderBatch(templates, context) {
-    const result = {};
-    for (const [type, template] of Object.entries(templates)) {
-      result[type] = MessageTemplate.render(template, context);
-    }
-    return result;
-  }
-}
-
-module.exports = MessageTemplate;
-