schema-dsl 2.3.0 → 2.3.1

package/lib/utils/SchemaUtils.js

@@ -45,42 +45,13 @@ class SchemaUtils {
     return fragments;
   }
 
-  // ========== Schema合并 ==========
-
-  /**
-   * 合并多个Schema
-   * @param {...Object} schemas - 要合并的Schema对象
-   * @returns {Object} 合并后的Schema
-   *
-   * @example
-   * const baseUser = dsl({ name: 'string!', email: 'email!' });
-   * const withAge = dsl({ age: 'number:18-120' });
-   * const merged = SchemaUtils.merge(baseUser, withAge);
-   */
-  static merge(...schemas) {
-    const result = {
-      type: 'object',
-      properties: {},
-      required: []
-    };
-
-    schemas.forEach(schema => {
-      if (schema.properties) {
-        Object.assign(result.properties, schema.properties);
-      }
-      if (schema.required) {
-        result.required = [...new Set([...result.required, ...schema.required])];
-      }
-    });
-
-    return result;
-  }
+  // ========== Schema复用和扩展 ==========
 
   /**
    * 扩展Schema（类似继承）
    * @param {Object} baseSchema - 基础Schema
    * @param {Object} extensions - 扩展定义
-   * @returns {Object} 扩展后的Schema
+   * @returns {Object} 扩展后的Schema（支持链式调用）
    *
    * @example
    * const baseUser = dsl({ name: 'string!', email: 'email!' });
@@ -90,12 +61,35 @@ class SchemaUtils {
    * });
    */
   static extend(baseSchema, extensions) {
-    const { dsl } = require('../adapters/DslAdapter');
+    const dsl = require('../adapters/DslAdapter');
     const extensionSchema = typeof extensions === 'function'
       ? extensions
       : dsl(extensions);
 
-    return this.merge(baseSchema, extensionSchema);
+    // 合并 properties
+    const result = {
+      type: 'object',
+      properties: {},
+      required: []
+    };
+
+    // 复制基础 schema
+    if (baseSchema.properties) {
+      Object.assign(result.properties, baseSchema.properties);
+    }
+    if (baseSchema.required) {
+      result.required = [...baseSchema.required];
+    }
+
+    // 添加扩展
+    if (extensionSchema.properties) {
+      Object.assign(result.properties, extensionSchema.properties);
+    }
+    if (extensionSchema.required) {
+      result.required = [...new Set([...result.required, ...extensionSchema.required])];
+    }
+
+    return this._makeChainable(result);
   }
 
   /**
@@ -124,19 +118,86 @@ class SchemaUtils {
       }
     });
 
-    return result;
+    return this._makeChainable(result);
   }
 
   /**
    * 排除Schema的部分字段
    * @param {Object} schema - 原始Schema
    * @param {string[]} fields - 要排除的字段
-   * @returns {Object} 新Schema
+   * @returns {Object} 新Schema（支持链式调用）
    */
   static omit(schema, fields) {
-    const allFields = Object.keys(schema.properties || {});
-    const keepFields = allFields.filter(f => !fields.includes(f));
-    return this.pick(schema, keepFields);
+    const result = this._clone(schema);
+
+    fields.forEach(field => {
+      if (result.properties) {
+        delete result.properties[field];
+      }
+      if (result.required) {
+        result.required = result.required.filter(f => f !== field);
+      }
+    });
+
+    // 清理空数组
+    if (result.required && result.required.length === 0) {
+      delete result.required;
+    }
+
+    return this._makeChainable(result);
+  }
+
+  // ========== v2.1.0 新增：Schema转换方法（支持链式调用） ==========
+
+  /**
+   * 部分验证：移除必填限制
+   *
+   * @param {Object} schema - 原始Schema
+   * @param {string[]} fields - 要验证的字段（可选，默认全部）
+   * @returns {Object} 新Schema（支持链式调用）
+   *
+   * @example
+   * // 所有字段变为可选
+   * const partialSchema = SchemaUtils.partial(userSchema);
+   *
+   * @example
+   * // 只验证指定字段
+   * const updateSchema = SchemaUtils.partial(userSchema, ['name', 'age']);
+   *
+   * @example
+   * // 链式调用
+   * const patchSchema = SchemaUtils
+   *   .pick(userSchema, ['name', 'age'])
+   *   .partial();
+   */
+  static partial(schema, fields = null) {
+    let result;
+
+    if (fields) {
+      // 只保留指定字段 (pick 已经返回 chainable 对象)
+      result = this.pick(schema, fields);
+      // 提取原始 schema
+      if (result._isChainable) {
+        result = this._extractSchema(result);
+      }
+    } else {
+      result = this._clone(schema);
+    }
+
+    // 移除所有 required
+    delete result.required;
+
+    // 递归处理嵌套对象
+    if (result.properties) {
+      Object.keys(result.properties).forEach(key => {
+        const prop = result.properties[key];
+        if (prop && prop.type === 'object' && prop.required) {
+          delete prop.required;
+        }
+      });
+    }
+
+    return this._makeChainable(result);
   }
 
   // ========== 性能监控 ==========
@@ -307,6 +368,77 @@ class SchemaUtils {
   static clone(schema) {
     return JSON.parse(JSON.stringify(schema));
   }
+
+  /**
+   * 深拷贝Schema
+   * @private
+   * @param {Object} schema - 原始Schema
+   * @returns {Object} 拷贝后的Schema
+   */
+  static _clone(schema) {
+    // 如果是 chainable 对象，先提取原始 schema
+    if (schema && schema._isChainable) {
+      schema = this._extractSchema(schema);
+    }
+    return JSON.parse(JSON.stringify(schema));
+  }
+
+  /**
+   * 使 schema 支持链式调用
+   * @private
+   * @param {Object} schema - Schema对象
+   * @returns {Object} 支持链式调用的 Schema
+   */
+  static _makeChainable(schema) {
+    // 如果已经是 chainable，直接返回
+    if (schema && schema._isChainable) {
+      return schema;
+    }
+
+    // 复制 schema 的所有属性
+    const chainable = Object.assign({}, schema);
+
+    // 标记为 chainable
+    Object.defineProperty(chainable, '_isChainable', {
+      value: true,
+      enumerable: false,
+      configurable: false
+    });
+
+    // 添加链式方法（只保留核心4个方法）
+    const methods = ['partial', 'omit', 'pick', 'extend'];
+    const self = this;  // 保存 this 引用
+    methods.forEach(method => {
+      Object.defineProperty(chainable, method, {
+        value: (...args) => {
+          // 提取原始 schema（去掉链式方法）
+          const rawSchema = self._extractSchema(chainable);
+          // 调用 SchemaUtils 的静态方法
+          return SchemaUtils[method](rawSchema, ...args);
+        },
+        enumerable: false,
+        configurable: false
+      });
+    });
+
+    return chainable;
+  }
+
+  /**
+   * 从 chainable 对象中提取原始 schema
+   * @private
+   * @param {Object} chainable - Chainable对象
+   * @returns {Object} 原始 Schema
+   */
+  static _extractSchema(chainable) {
+    const schema = {};
+    for (const key in chainable) {
+      if (chainable.hasOwnProperty(key) && key !== '_isChainable') {
+        schema[key] = chainable[key];
+      }
+    }
+    return schema;
+  }
 }
 
 module.exports = SchemaUtils;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "schema-dsl",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "简洁强大的JSON Schema验证库 - DSL语法 + String扩展 + 便捷validate",
   "main": "index.js",
   "exports": {