@hzab/data-model 1.8.6 → 1.8.8-beta

package/CHANGELOG.md

@@ -1,4 +1,8 @@
-# @hzab/data-model@1.8.5
+# @hzab/data-model@1.8.8
+
+feat: array-data-model 支持 query 过滤
+
+# @hzab/data-model@1.8.6
 
 fix: getToken opt.hasCookie 是否读取 cookie 的 token。默认不读取 cookie 的 token
 fix: setToken 默认不设置到 cookie 上

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@hzab/data-model",
-  "version": "1.8.6",
+  "version": "1.8.8-beta",
   "description": "data model",
   "main": "src",
   "scripts": {
     "dev": "npm run prepare && webpack serve -c ./config/webpack.config.js --env local",
     "build": "webpack -c ./config/webpack.config.js --env production",
+    "publish-beta": "npm publish --beta",
     "publish-patch": "npm version patch && npm publish --access public",
     "publish-minor": "npm version minor && npm publish --access public",
     "publish-major": "npm version major && npm publish --access public",

package/src/ArrayUtils.js

@@ -30,7 +30,7 @@ export class ArrayUtils {
    * @returns
    */
   findItemById(id) {
-    if (hasId(id)) {
+    if (this._hasId(id)) {
       return null;
     }
     const { _idKey } = this;
@@ -42,99 +42,157 @@ export class ArrayUtils {
    * @param {*} id
    * @returns
    */
-  findItem(query = {}) {
-    const { _idKey } = this;
-    const id = query[_idKey];
-    if (hasId(id)) {
+  findItem(query = {}, options = {}) {
+    const { fuzzy = false, ignoreCase = false } = options;
+    const id = query[this._idKey];
+
+    if (!this._hasId(id)) {
       return this.findItemById(id);
     }
-    // TODO: query 查询
-    return _.cloneDeep(this._list.find((it) => it[_idKey] === id));
+
+    const validQuery = this._filterEmptyQuery(query);
+    if (_.isEmpty(validQuery)) {
+      return null;
+    }
+
+    const matchItem = this._list.find((item) => {
+      return this._isItemMatchQuery(item, validQuery, { fuzzy, ignoreCase });
+    });
+
+    return matchItem ? _.cloneDeep(matchItem) : null;
   }
 
   /**
-   * 获取列表
-   * TODO: 搜索？
-   * @param {*} query
+   * 通过 query 筛选列表（支持多条件筛选、分页、排序）
+   * @param {Object} query - 综合查询参数
+   * @param {number} [query.pageNum=1] - 页码（默认1）
+   * @param {number} [query.pageSize=10] - 每页条数（默认10）
+   * @param {string|string[]} [query.sortKey] - 排序字段（支持嵌套路径，如 'user.age'）
+   * @param {string} [query.sortType='desc'] - 排序方式（desc/asc）
+   * @param {string} [query.orderByColumn] - 兼容旧排序字段参数
+   * @param {string} [query.isAsc] - 兼容旧排序方式参数
+   * @param {Object} [options={}] - 查询选项
+   * @param {boolean} [options.fuzzy=false] - 字符串字段是否开启模糊匹配
+   * @param {boolean} [options.ignoreCase=true] - 模糊匹配时是否忽略大小写
+   * @returns {Object} 分页结果
+   * @returns {Object[]} result.list - 筛选后的列表（深拷贝）
+   * @returns {Object} result.pagination - 分页信息（current/total/pageSize）
    */
-  findListByQuery(query) {
-    const { pageNum = 1, pageSize = 10, sortKey, sortType, orderByColumn, isAsc } = query || {};
-    // 排序
-    const _list = this.getSortList(sortKey || orderByColumn, sortType || isAsc);
-
-    // 分页
-    // 边界检查
-    if (pageNum < 1 || pageSize <= 0) {
-      return { list: [], pagination: { current: 1, total: 0 } };
-    }
-    // 计算起始索引
-    const startIndex = (pageNum - 1) * pageSize;
-    // 如果起始索引超出数组长度，返回空数组
-    if (startIndex >= _list.length) {
-      return { list: [], pagination: { current: 1, total: 0 } };
+  findListByQuery(query = {}, options = {}) {
+    const {
+      pageNum = 1,
+      pageSize = 10,
+      sortKey,
+      sortType,
+      orderByColumn,
+      isAsc,
+      ...filterQuery // 提取筛选条件（排除分页排序参数）
+    } = query;
+
+    const { fuzzy = true, ignoreCase = false } = options;
+
+    // 数据筛选（基于 query 条件）
+    let filteredList = [...this._list];
+    const validFilterQuery = this._filterEmptyQuery(filterQuery);
+
+    if (!_.isEmpty(validFilterQuery)) {
+      filteredList = filteredList.filter((item) => {
+        return this._isItemMatchQuery(item, validFilterQuery, { fuzzy, ignoreCase });
+      });
     }
-    // 计算结束索引
-    const endIndex = startIndex + pageSize;
 
-    // 使用 slice 方法截取数据
-    return { list: _list.slice(startIndex, endIndex), pagination: { current: pageNum, total: this.getCount() } };
+    // 数据排序（基于筛选后的数据）
+    const sortedList = this.getSortList(
+      sortKey || orderByColumn,
+      sortType || isAsc,
+      filteredList, // 传入筛选后列表，避免排序影响原数据
+    );
+
+    // 分页处理（边界校验）
+    const pagination = {
+      current: Math.max(1, pageNum), // 页码最小为1
+      pageSize: Math.max(1, pageSize), // 每页条数最小为1
+      total: filteredList.length,
+    };
+
+    // 计算分页截取范围
+    const startIndex = (pagination.current - 1) * pagination.pageSize;
+    const endIndex = startIndex + pagination.pageSize;
+    const paginatedList = sortedList.slice(startIndex, endIndex);
+
+    return {
+      list: _.cloneDeep(paginatedList),
+      pagination: { ...pagination },
+    };
   }
 
   /**
    * 对目标数据进行多维度排序
-   * @param list
-   * @param {*} sortKey 排序的字段 支持 a.b.c 写法
-   * @param {*} sortType 排序方式 正序: asc 倒序: desc
-   * @returns
+   * @param {string|string[]|Object[]} sortKey - 排序字段配置
+   * @param {string} sortType - 排序方式（desc/asc）
+   * @param {Object[]} [customList] - 自定义排序列表（默认使用内部 _list）
+   * @returns {Object[]} 排序后的列表
    */
-  getSortList(sortKey, sortType) {
-    const _list = _.cloneDeep(this._list);
+  getSortList(sortKey, sortType, customList) {
+    const sourceList = customList || this._list;
+    const _list = _.cloneDeep(sourceList);
+
+    // 无排序条件时直接返回原列表
     if (!sortKey && !sortType) {
       return _list;
     }
+
+    // 统一排序字段格式为数组
     const paths = Array.isArray(sortKey) ? sortKey : [sortKey];
+
     _list.sort((a, b) => {
-      return this.compareData(a, b, { paths, sortType });
+      return this.compareData(a, b, { paths, sortType, pathIdx: 0 });
     });
+
     return _list;
   }
 
   /**
-   * 根据传入的 paths 比较对象目标数据先后顺序
-   * @param dataA
-   * @param dataB
-   * @param opt
-   * @param opt.paths 数据 path 数组
-   * @param opt.pathIdx 当前数据下标
-   * @param opt.sortType 排序规则
-   * @returns
+   * 比较两个数据对象的排序顺序（支持多字段优先级排序）
+   * @param {Object} dataA - 比较对象A
+   * @param {Object} dataB - 比较对象B
+   * @param {Object} opt - 比较配置
+   * @param {string[]|Object[]} opt.paths - 排序字段路径数组
+   * @param {number} opt.pathIdx - 当前比较的字段索引
+   * @param {string} opt.sortType - 排序方式（desc/asc）
+   * @returns {number} 排序结果（-1/0/1）
    */
-  compareData(dataA, dataB, opt = { paths, pathIdx: 0, sortType: "desc" }) {
+  compareData(dataA, dataB, opt = {}) {
     const { paths, pathIdx = 0, sortType = "desc" } = opt;
-    const path = paths[pathIdx];
-    let _path = path;
+    const currentPath = paths[pathIdx];
 
-    if (path && typeof path === "object") {
-      // 外部自定义比较函数
-      if (typeof path.customCompare === "function") {
-        return direction * path.customCompare(dataA, dataB, opt);
-      }
-      _path = path.path;
+    // 处理自定义比较逻辑
+    if (currentPath && typeof currentPath === "object" && typeof currentPath.customCompare === "function") {
+      const direction = sortType === "asc" ? -1 : 1;
+      return direction * currentPath.customCompare(dataA, dataB, opt);
     }
 
-    /** 排序规则 */
+    // 提取实际字段路径（支持配置对象格式）
+    const path = typeof currentPath === "object" ? currentPath.path : currentPath;
+    if (!path) {
+      return 0;
+    }
+
+    // 确定排序方向（支持按字段单独配置排序方式）
     let direction = 1;
-    // 兼容 string 及 object 类型
     let _sortType = sortType;
     if (typeof _sortType === "object") {
-      _sortType = _sortType[_path];
+      _sortType = _sortType[path] || "desc";
     }
     if (_sortType === "asc") {
       direction = -1;
     }
 
-    let valueA = this.handleValByKey(dataA, path);
-    let valueB = this.handleValByKey(dataB, path);
+    // 获取并处理字段值（支持日期转换、自定义格式化）
+    const valueA = this.handleValByKey(dataA, currentPath);
+    const valueB = this.handleValByKey(dataB, currentPath);
+
+    // 数值比较
     if (valueA < valueB) {
       return -1 * direction;
     }
@@ -142,43 +200,53 @@ export class ArrayUtils {
       return 1 * direction;
     }
 
-    if (pathIdx + 1 >= paths.length) {
-      return 0;
-    }
-
-    if (valueA == valueB) {
-      // 继续使用次选排序规则排序
+    // 当前字段值相等时，使用下一个优先级字段排序
+    if (pathIdx + 1 < paths.length) {
       return this.compareData(dataA, dataB, { ...opt, pathIdx: pathIdx + 1 });
     }
+
+    // 所有字段都相等时，保持原有顺序
+    return 0;
   }
 
   /**
-   * 根据 path 配置对数据进行处理
-   * @param {Object} data 数据
-   * @param {string/Object} path 取值路径字符串 或 取值配置
-   * @param {string} path.path 取值路径字符串
-   * @param {string} path.type 值类型 用于进行相关转换
-   * @param {Function} path.customFormat 自定义数据处理函数
+   * 根据路径获取并处理字段值（支持嵌套路径、类型转换、自定义格式化）
+   * @param {Object} data - 数据源对象
+   * @param {string|Object} pathConfig - 字段配置
+   * @param {string} [pathConfig.path] - 字段路径（如 'user.address.city'）
+   * @param {string} [pathConfig.type] - 字段类型（支持 'date' 自动转时间戳）
+   * @param {Function} [pathConfig.customFormat] - 自定义值处理函数
+   * @returns {*} 处理后的字段值
    */
-  handleValByKey(data, path) {
-    if (typeof path === "string") {
-      return _.get(data, path);
+  handleValByKey(data, pathConfig) {
+    // 处理字符串路径
+    if (typeof pathConfig === "string") {
+      return _.get(data, pathConfig);
     }
-    if (path === null || path === undefined) {
-      return;
+
+    // 处理空配置
+    if (_.isNil(pathConfig)) {
+      return undefined;
     }
-    if (typeof path === "object") {
-      let val = _.get(data, path.path);
-      // 日期格式转为时间戳进行比较
-      if (path?.type === "date") {
-        val = dayjs(val).valueOf();
+
+    // 处理对象配置
+    if (typeof pathConfig === "object") {
+      let val = _.get(data, pathConfig.path);
+
+      // 日期类型转换为时间戳（便于数值比较）
+      if (pathConfig.type === "date") {
+        val = dayjs(val).isValid() ? dayjs(val).valueOf() : 0;
       }
-      // 外部自定义数据格式函数,便于排序比较
-      if (typeof path?.customFormat === "function") {
-        val = customFormat(val);
+
+      // 自定义值格式化
+      if (typeof pathConfig.customFormat === "function") {
+        val = pathConfig.customFormat(val, data);
       }
+
       return val;
     }
+
+    return undefined;
   }
 
   /**
@@ -202,10 +270,13 @@ export class ArrayUtils {
    */
   pushItem(data) {
     // TODO: id 去重
-    const item = _.cloneDeep(data);
-    this.setId(item);
-    this.setCreateTime(item);
-    this._list.push(item);
+    const items = Array.isArray(data) ? data : [data];
+    items.forEach((item) => {
+      const cloneItem = _.cloneDeep(item);
+      this._setId(cloneItem);
+      this._setCreateTime(cloneItem);
+      this._list.push(cloneItem);
+    });
     return STATE_CODE.SUC;
   }
 
@@ -216,8 +287,8 @@ export class ArrayUtils {
   unshiftItem(data) {
     // TODO: id 去重
     const item = _.cloneDeep(data);
-    this.setId(item);
-    this.setCreateTime(item);
+    this._setId(item);
+    this._setCreateTime(item);
     this._list.unshift(item);
     return STATE_CODE.SUC;
   }
@@ -230,7 +301,7 @@ export class ArrayUtils {
   replaceItem(data) {
     const { _idKey, _list } = this;
     const id = data[_idKey];
-    if (hasId(id)) {
+    if (this._hasId(id)) {
       return STATE_CODE.ERR_INPUT_ID;
     }
     const idx = _list.findIndex((it) => it[_idKey] === id);
@@ -238,7 +309,7 @@ export class ArrayUtils {
       return STATE_CODE.NOT_FOUNT;
     }
     _list.splice(idx, 1, data);
-    this.setUpdateTime(data);
+    this._setUpdateTime(data);
     return STATE_CODE.SUC;
   }
 
@@ -250,7 +321,7 @@ export class ArrayUtils {
   updateItemValue(data) {
     const { _idKey, _list } = this;
     const id = data[_idKey];
-    if (hasId(id)) {
+    if (this._hasId(id)) {
       return STATE_CODE.ERR_INPUT_ID;
     }
     const item = _list.find((it) => it[_idKey] === id);
@@ -260,7 +331,7 @@ export class ArrayUtils {
     Object.keys(data).forEach((key) => {
       item[key] = data[key];
     });
-    this.setUpdateTime(data);
+    this._setUpdateTime(data);
     return STATE_CODE.SUC;
   }
 
@@ -272,7 +343,7 @@ export class ArrayUtils {
    */
   delItem(id) {
     const { _idKey, _list } = this;
-    if (hasId(id)) {
+    if (this._hasId(id)) {
       return STATE_CODE.ERR_INPUT_ID;
     }
     const idx = _list.findIndex((it) => it[_idKey] === id);
@@ -283,15 +354,165 @@ export class ArrayUtils {
     return STATE_CODE.SUC;
   }
 
+  /**
+   * 检查单个 item 是否匹配所有 query 条件
+   * @private
+   * @param {Object} item - 待检查的列表项
+   * @param {Object} query - 查询条件
+   * @param {Object} options - 匹配选项
+   * @param {boolean} options.fuzzy - 是否开启模糊匹配
+   * @param {boolean} options.ignoreCase - 模糊匹配是否忽略大小写
+   * @returns {boolean} 是否匹配所有条件
+   */
+  _isItemMatchQuery(item, query, { fuzzy, ignoreCase }) {
+    // 遍历所有查询条件，必须全部满足才返回 true
+    return Object.entries(query).every(([key, targetValue]) => {
+      // 获取 item 中对应字段的值（支持嵌套路径，如 'user.name'）
+      const itemValue = _.get(item, key);
+
+      // 处理空值情况（null/undefined 仅匹配 null/undefined）
+      if (_.isNil(itemValue)) {
+        return _.isNil(targetValue);
+      }
+
+      // 处理数组类型查询（支持 in 操作，如 { status: [1, 2] }）
+      if (Array.isArray(targetValue)) {
+        return targetValue.some((val) => this._compareSingleValue(itemValue, val, fuzzy, ignoreCase));
+      }
+
+      // 处理范围查询（如 { age: { $gt: 18, $lt: 30 } }）
+      if (typeof targetValue === "object" && !Array.isArray(targetValue)) {
+        return this._handleRangeQuery(itemValue, targetValue);
+      }
+
+      // 处理普通值匹配（精确/模糊）
+      return this._compareSingleValue(itemValue, targetValue, fuzzy, ignoreCase);
+    });
+  }
+
+  /**
+   * 比较单个值是否匹配（支持精确/模糊匹配）
+   * @private
+   * @param {*} itemValue - 列表项字段值
+   * @param {*} targetValue - 查询目标值
+   * @param {boolean} fuzzy - 是否模糊匹配
+   * @param {boolean} ignoreCase - 是否忽略大小写
+   * @returns {boolean} 是否匹配
+   */
+  _compareSingleValue(itemValue, targetValue, fuzzy, ignoreCase) {
+    // 类型不同时直接不匹配（避免隐式类型转换导致的问题）
+    if (typeof itemValue !== typeof targetValue) {
+      // 特殊处理：数字和字符串数字的匹配（如 123 和 '123'）
+      if (
+        (typeof itemValue === "number" && typeof targetValue === "string" && !isNaN(Number(targetValue))) ||
+        (typeof itemValue === "string" && typeof targetValue === "number" && !isNaN(Number(itemValue)))
+      ) {
+        return Number(itemValue) === targetValue;
+      }
+      return false;
+    }
+
+    // 字符串处理（支持模糊匹配和大小写忽略）
+    if (typeof itemValue === "string" && fuzzy) {
+      const itemStr = ignoreCase ? itemValue.toLowerCase() : itemValue;
+      const targetStr = ignoreCase ? String(targetValue).toLowerCase() : String(targetValue);
+      return itemStr.includes(targetStr);
+    }
+
+    // 其他类型（数字、布尔等）精确匹配
+    return itemValue === targetValue;
+  }
+
+  /**
+   * 处理范围查询（如 $gt/$lt/$gte/$lte）
+   * @private
+   * @param {number|string|Date} itemValue - 列表项字段值
+   * @param {Object} rangeConfig - 范围配置（{ $gt: 18, $lt: 30 }）
+   * @returns {boolean} 是否在范围内
+   */
+  _handleRangeQuery(itemValue, rangeConfig) {
+    const { $gt, $lt, $gte, $lte } = rangeConfig;
+    let isValid = true;
+
+    // 转换为可比较的类型（优先处理日期）
+    const compareValue = this._convertToComparableValue(itemValue);
+    const convertTarget = (val) => this._convertToComparableValue(val);
+
+    // 大于（>）
+    if ($gt !== undefined) {
+      isValid = isValid && compareValue > convertTarget($gt);
+    }
+    // 小于（<）
+    if ($lt !== undefined) {
+      isValid = isValid && compareValue < convertTarget($lt);
+    }
+    // 大于等于（>=）
+    if ($gte !== undefined) {
+      isValid = isValid && compareValue >= convertTarget($gte);
+    }
+    // 小于等于（<=）
+    if ($lte !== undefined) {
+      isValid = isValid && compareValue <= convertTarget($lte);
+    }
+
+    return isValid;
+  }
+
+  /**
+   * 将值转换为可比较的类型（统一数字、日期格式）
+   * @private
+   * @param {*} value - 待转换的值
+   * @returns {number|string} 可比较的值
+   */
+  _convertToComparableValue(value) {
+    // 日期转换为时间戳
+    if (value instanceof Date || dayjs(value).isValid()) {
+      return dayjs(value).valueOf();
+    }
+    // 字符串数字转换为数字
+    if (typeof value === "string" && !isNaN(Number(value))) {
+      return Number(value);
+    }
+    return value;
+  }
+
+  /**
+   * 过滤空查询条件（移除 undefined/null/空字符串/空数组/空对象）
+   * @private
+   * @param {Object} query - 原始查询条件
+   * @returns {Object} 过滤后的有效查询条件
+   */
+  _filterEmptyQuery(query) {
+    return Object.entries(query).reduce((acc, [key, value]) => {
+      // 保留非空值：
+      // 1. 不是 null/undefined
+      // 2. 不是空字符串
+      // 3. 不是空数组
+      // 4. 不是空对象
+      if (
+        !_.isNil(value) &&
+        value !== "" &&
+        !(Array.isArray(value) && value.length === 0) &&
+        !(typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0)
+      ) {
+        acc[key] = value;
+      }
+      return acc;
+    }, {});
+  }
+
+  _hasId(id) {
+    return _.isNil(id) || id === "";
+  }
+
   /**
    * 子项没有 id 的时候自动添加
    * @param {*} item
    * @returns
    */
-  setId(item) {
-    const { _idKey } = this;
-    if (!item[_idKey]) {
-      item[_idKey] = nanoid();
+  _setId(item) {
+    if (_.isObject(item) && this._hasId(item[this._idKey])) {
+      item[this._idKey] = nanoid();
     }
     return item;
   }
@@ -300,21 +521,19 @@ export class ArrayUtils {
    * 设置创建时间
    * @param {*} item
    */
-  setCreateTime(item) {
-    item.createTime = Date.now();
+  _setCreateTime(item) {
+    if (_.isObject(item) && this._hasId(item.createTime)) {
+      item.createTime = Date.now();
+    }
   }
 
   /**
    * 设置更新时间
    * @param {*} item
    */
-  setUpdateTime(item) {
+  _setUpdateTime(item) {
     item.createTime = Date.now();
   }
 }
 
-export const hasId = (id) => {
-  return _.isNil(id) || id === "";
-};
-
 export default ArrayUtils;

package/src/array-data-model.js

@@ -107,6 +107,17 @@ class ArrayDataModel extends ArrayUtils {
     this.multipleDeleteReqMap = multipleDeleteReqMap;
     /** DELETE 批量删除 接口请求结果数据处理回调 */
     this.multipleDeleteResMap = multipleDeleteResMap;
+
+    const {
+      /**
+       *
+       * @param {Object} [options={}] - 查询选项
+       * @param {boolean} [options.fuzzy=false] - 字符串字段是否开启模糊匹配
+       * @param {boolean} [options.ignoreCase=true] - 模糊匹配时是否忽略大小写
+       */
+      arrOptions,
+    } = params || {};
+    this._arrOptions = arrOptions;
   }
 
   /**
@@ -123,7 +134,7 @@ class ArrayDataModel extends ArrayUtils {
     }
 
     return new Promise((resolve, reject) => {
-      let res = this.findItem(query);
+      let res = this.findItem(query, this._arrOptions);
       if (this.getMap) {
         res = this.getMap(res);
       }
@@ -151,7 +162,7 @@ class ArrayDataModel extends ArrayUtils {
     if (this.getListFunc) {
       resultList = await this.getListFunc(query);
     } else {
-      const getPro = this.findListByQuery(query);
+      const getPro = this.findListByQuery(query, this._arrOptions);
       resultList = await getPro;
     }
     if (this.getListMap) {