midway-fatcms 0.0.6 → 0.0.7

package/dist/libs/crud-pro/models/RequestModel.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestModel = void 0;
 const _ = require("lodash");
 const MixinUtils_1 = require("../utils/MixinUtils");
+const OrderByUtils_1 = require("../utils/OrderByUtils");
 const exceptions_1 = require("../exceptions");
 const defaultConfigs_1 = require("../defaultConfigs");
 class RequestModel {
@@ -10,109 +11,11 @@ class RequestModel {
         Object.assign(this, req);
         this.visitor = visitor;
         this.columns = MixinUtils_1.MixinUtils.parseColumns(req.columns);
-        this.orderBys = this.parseOrderBys(req.orderBy);
+        this.orderBys = OrderByUtils_1.OrderByUtils.parseOrderBys(req.orderBy);
         const limitOffset = this.parseOffsetList(req);
         this.limit = limitOffset.limit;
         this.offset = limitOffset.offset;
     }
-    /**
-     * 解析 orderBy 参数为 IOrderByItem 数组
-     *
-     * 支持的格式：
-     * 1. 字符串格式（逗号分隔多个字段）：
-     *    - 标准 SQL 格式：'created_at DESC, amount ASC'
-     *    - 简写 +/- 格式：'created_at-, amount+'（'-' 表示 DESC，'+' 或省略表示 ASC）
-     *    - 默认升序：'order_id'（无后缀时默认为 ASC）
-     *
-     * 2. 数组格式：
-     *    - 纯对象数组：[{ fieldName: 'created_at', orderType: 'desc' }]
-     *    - 混合数组1（字符串+对象）：['order_id', { fieldName: 'amount', orderType: 'asc' }]
-     *    - 混合数组2（字符串+对象）：['order_id+', { fieldName: 'amount', orderType: 'asc' }]
-     *    - 混合数组3（字符串+对象）：['order_id DESC', { fieldName: 'amount', orderType: 'asc' }]
-     *      注：数组中的字符串元素支持标准 SQL 格式和简写格式，与字符串参数格式一致。
-     *
-     * SQL 注入防护：
-     * - 所有字段名必须通过 MixinUtils.isValidFieldName() 校验
-     * - 只允许 ASC/DESC 作为排序方向
-     *
-     * @param orderByStr 排序参数，可以是字符串或数组
-     * @returns IOrderByItem[] 解析后的排序项数组
-     */
-    parseOrderBys(orderByStr) {
-        if (MixinUtils_1.MixinUtils.isEmpty(orderByStr)) {
-            return [];
-        }
-        // 数组格式：支持字符串和对象混合
-        if (Array.isArray(orderByStr)) {
-            return orderByStr
-                .map(item => this.parseOrderByItem(item))
-                .filter((o) => !!o);
-        }
-        // 字符串格式：逗号分隔多个字段
-        return orderByStr
-            .split(',')
-            .map(s => s.trim())
-            .filter(s => !!s)
-            .map(item => this.parseOrderByString(item))
-            .filter((o) => !!o);
-    }
-    /**
-     * 解析单个排序项（数组元素）
-     */
-    parseOrderByItem(item) {
-        // 字符串格式：解析标准 SQL 格式或简写格式
-        if (typeof item === 'string') {
-            return this.parseOrderByString(item);
-        }
-        // 对象格式：提取 fieldName 和 orderType
-        const { fieldName, orderType = 'asc' } = item || {};
-        if (!fieldName) {
-            return null;
-        }
-        this.validateFieldName(fieldName, fieldName);
-        return { fieldName, orderType };
-    }
-    /**
-     * 解析字符串格式的排序项（支持标准 SQL 和简写格式）
-     */
-    parseOrderByString(orderByStr) {
-        let orderType = 'asc';
-        let fieldName = orderByStr;
-        // 检查是否为空格分隔的标准 SQL 格式（如 'created_at DESC'）
-        const spaceIndex = orderByStr.lastIndexOf(' ');
-        if (spaceIndex > 0) {
-            const beforeSpace = orderByStr.substring(0, spaceIndex).trim();
-            const afterSpace = orderByStr.substring(spaceIndex + 1).trim().toUpperCase();
-            if (afterSpace === 'ASC' || afterSpace === 'DESC') {
-                fieldName = beforeSpace;
-                orderType = afterSpace.toLowerCase();
-            }
-            else {
-                throw new exceptions_1.CommonException(exceptions_1.Exceptions.REQUEST_MODEL_PARSE_ORDER_BY_FAILED, orderByStr);
-            }
-        }
-        else if (orderByStr.endsWith('+')) {
-            // 简写格式：+ 表示升序
-            fieldName = orderByStr.slice(0, -1);
-            orderType = 'asc';
-        }
-        else if (orderByStr.endsWith('-')) {
-            // 简写格式：- 表示降序
-            fieldName = orderByStr.slice(0, -1);
-            orderType = 'desc';
-        }
-        fieldName = fieldName.trim();
-        this.validateFieldName(fieldName, orderByStr);
-        return { fieldName, orderType };
-    }
-    /**
-     * SQL 注入防护：校验字段名格式
-     */
-    validateFieldName(fieldName, originalValue) {
-        if (MixinUtils_1.MixinUtils.isEmpty(fieldName) || !MixinUtils_1.MixinUtils.isValidFieldName(fieldName)) {
-            throw new exceptions_1.CommonException(exceptions_1.Exceptions.REQUEST_MODEL_PARSE_ORDER_BY_FAILED, originalValue);
-        }
-    }
     parseOffsetList(req) {
         const { limit, offset, pageSize, pageNo } = req;
         const limitOffset = {

package/dist/libs/crud-pro/utils/OrderByUtils.d.ts

@@ -0,0 +1,70 @@
+import { IOrderByItem } from '../interfaces';
+/**
+ * OrderBy 解析工具类
+ *
+ * 提供统一的 orderBy 参数解析功能，支持多种格式：
+ * 1. 字符串格式（逗号分隔多个字段）：
+ *    - 标准 SQL 格式：'created_at DESC, amount ASC'
+ *    - 简写 +/- 格式：'created_at-, amount+'（'-' 表示 DESC，'+' 或省略表示 ASC）
+ *    - 默认升序：'order_id'（无后缀时默认为 ASC）
+ *
+ * 2. 数组格式：
+ *    - 纯对象数组：[{ fieldName: 'created_at', orderType: 'desc' }]
+ *    - 混合数组（字符串+对象）：['order_id+', { fieldName: 'amount', orderType: 'asc' }]
+ *
+ * SQL 注入防护：
+ * - 所有字段名必须通过 MixinUtils.isValidFieldName() 校验
+ * - 只允许 ASC/DESC 作为排序方向
+ */
+export declare class OrderByUtils {
+    /**
+     * 解析 orderBy 参数为 IOrderByItem 数组
+     *
+     * @param orderByStr 排序参数，可以是字符串或数组
+     * @returns IOrderByItem[] 解析后的排序项数组
+     */
+    static parseOrderBys(orderByStr: any): IOrderByItem[];
+    /**
+     * 获取第一个排序项
+     *
+     * @param orderByStr 排序参数
+     * @returns IOrderByItem | null 第一个排序项，无则返回 null
+     */
+    static getFirstOrderBy(orderByStr: any): IOrderByItem | null;
+    /**
+     * 判断是否为 ASC 升序排序
+     *
+     * @param orderByStr 排序参数
+     * @returns true 表示 ASC，false 表示 DESC 或无排序
+     */
+    static isFirstOrderByAsc(orderByStr: any): boolean;
+    /**
+     * 判断是否为 DESC 降序排序
+     *
+     * @param orderByStr 排序参数
+     * @returns true 表示 DESC，false 表示 ASC 或无排序
+     */
+    static isFirstOrderByDesc(orderByStr: any): boolean;
+    /**
+     * 判断排序字段是否匹配指定的时间字段
+     *
+     * 用于分表查询时校验排序字段是否为分表字段
+     *
+     * @param orderByStr 排序参数
+     * @param timeColumn 时间字段名
+     * @returns true 表示匹配，false 表示不匹配或无排序
+     */
+    static isOrderByTimeColumn(orderByStr: any, timeColumn: string): boolean;
+    /**
+     * 解析单个排序项（数组元素）
+     */
+    private static parseOrderByItem;
+    /**
+     * 解析字符串格式的排序项（支持标准 SQL 和简写格式）
+     */
+    private static parseOrderByString;
+    /**
+     * SQL 注入防护：校验字段名格式
+     */
+    private static validateFieldName;
+}

package/dist/libs/crud-pro/utils/OrderByUtils.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderByUtils = void 0;
+const MixinUtils_1 = require("./MixinUtils");
+const exceptions_1 = require("../exceptions");
+/**
+ * OrderBy 解析工具类
+ *
+ * 提供统一的 orderBy 参数解析功能，支持多种格式：
+ * 1. 字符串格式（逗号分隔多个字段）：
+ *    - 标准 SQL 格式：'created_at DESC, amount ASC'
+ *    - 简写 +/- 格式：'created_at-, amount+'（'-' 表示 DESC，'+' 或省略表示 ASC）
+ *    - 默认升序：'order_id'（无后缀时默认为 ASC）
+ *
+ * 2. 数组格式：
+ *    - 纯对象数组：[{ fieldName: 'created_at', orderType: 'desc' }]
+ *    - 混合数组（字符串+对象）：['order_id+', { fieldName: 'amount', orderType: 'asc' }]
+ *
+ * SQL 注入防护：
+ * - 所有字段名必须通过 MixinUtils.isValidFieldName() 校验
+ * - 只允许 ASC/DESC 作为排序方向
+ */
+class OrderByUtils {
+    /**
+     * 解析 orderBy 参数为 IOrderByItem 数组
+     *
+     * @param orderByStr 排序参数，可以是字符串或数组
+     * @returns IOrderByItem[] 解析后的排序项数组
+     */
+    static parseOrderBys(orderByStr) {
+        if (MixinUtils_1.MixinUtils.isEmpty(orderByStr)) {
+            return [];
+        }
+        // 数组格式：支持字符串和对象混合
+        if (Array.isArray(orderByStr)) {
+            return orderByStr
+                .map(item => this.parseOrderByItem(item))
+                .filter((o) => !!o);
+        }
+        // 字符串格式：逗号分隔多个字段
+        return orderByStr
+            .split(',')
+            .map(s => s.trim())
+            .filter(s => !!s)
+            .map(item => this.parseOrderByString(item))
+            .filter((o) => !!o);
+    }
+    /**
+     * 获取第一个排序项
+     *
+     * @param orderByStr 排序参数
+     * @returns IOrderByItem | null 第一个排序项，无则返回 null
+     */
+    static getFirstOrderBy(orderByStr) {
+        const orderBys = this.parseOrderBys(orderByStr);
+        return orderBys.length > 0 ? orderBys[0] : null;
+    }
+    /**
+     * 判断是否为 ASC 升序排序
+     *
+     * @param orderByStr 排序参数
+     * @returns true 表示 ASC，false 表示 DESC 或无排序
+     */
+    static isFirstOrderByAsc(orderByStr) {
+        const first = this.getFirstOrderBy(orderByStr);
+        if (!first) {
+            return false;
+        }
+        return first.orderType.toUpperCase() === 'ASC';
+    }
+    /**
+     * 判断是否为 DESC 降序排序
+     *
+     * @param orderByStr 排序参数
+     * @returns true 表示 DESC，false 表示 ASC 或无排序
+     */
+    static isFirstOrderByDesc(orderByStr) {
+        const first = this.getFirstOrderBy(orderByStr);
+        if (!first) {
+            return false;
+        }
+        return first.orderType.toUpperCase() === 'DESC';
+    }
+    /**
+     * 判断排序字段是否匹配指定的时间字段
+     *
+     * 用于分表查询时校验排序字段是否为分表字段
+     *
+     * @param orderByStr 排序参数
+     * @param timeColumn 时间字段名
+     * @returns true 表示匹配，false 表示不匹配或无排序
+     */
+    static isOrderByTimeColumn(orderByStr, timeColumn) {
+        const first = this.getFirstOrderBy(orderByStr);
+        if (!first) {
+            return false;
+        }
+        return first.fieldName === timeColumn;
+    }
+    /**
+     * 解析单个排序项（数组元素）
+     */
+    static parseOrderByItem(item) {
+        // 字符串格式：解析标准 SQL 格式或简写格式
+        if (typeof item === 'string') {
+            return this.parseOrderByString(item);
+        }
+        // 对象格式：提取 fieldName 和 orderType
+        const { fieldName, orderType = 'asc' } = item || {};
+        if (!fieldName) {
+            return null;
+        }
+        this.validateFieldName(fieldName, fieldName);
+        return { fieldName, orderType };
+    }
+    /**
+     * 解析字符串格式的排序项（支持标准 SQL 和简写格式）
+     */
+    static parseOrderByString(orderByStr) {
+        let orderType = 'asc';
+        let fieldName = orderByStr;
+        // 检查是否为空格分隔的标准 SQL 格式（如 'created_at DESC'）
+        const spaceIndex = orderByStr.lastIndexOf(' ');
+        if (spaceIndex > 0) {
+            const beforeSpace = orderByStr.substring(0, spaceIndex).trim();
+            const afterSpace = orderByStr.substring(spaceIndex + 1).trim().toUpperCase();
+            if (afterSpace === 'ASC' || afterSpace === 'DESC') {
+                fieldName = beforeSpace;
+                orderType = afterSpace.toLowerCase();
+            }
+            else {
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.REQUEST_MODEL_PARSE_ORDER_BY_FAILED, orderByStr);
+            }
+        }
+        else if (orderByStr.endsWith('+')) {
+            // 简写格式：+ 表示升序
+            fieldName = orderByStr.slice(0, -1);
+            orderType = 'asc';
+        }
+        else if (orderByStr.endsWith('-')) {
+            // 简写格式：- 表示降序
+            fieldName = orderByStr.slice(0, -1);
+            orderType = 'desc';
+        }
+        fieldName = fieldName.trim();
+        this.validateFieldName(fieldName, orderByStr);
+        return { fieldName, orderType };
+    }
+    /**
+     * SQL 注入防护：校验字段名格式
+     */
+    static validateFieldName(fieldName, originalValue) {
+        if (MixinUtils_1.MixinUtils.isEmpty(fieldName) || !MixinUtils_1.MixinUtils.isValidFieldName(fieldName)) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.REQUEST_MODEL_PARSE_ORDER_BY_FAILED, originalValue);
+        }
+    }
+}
+exports.OrderByUtils = OrderByUtils;

package/dist/libs/crud-sharding/ShardingCrudPro.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ShardingCrudPro = void 0;
+const OrderByUtils_1 = require("../../libs/crud-pro/utils/OrderByUtils");
 const keys_1 = require("../../libs/crud-pro/models/keys");
 const ShardingConfig_1 = require("./ShardingConfig");
 const ShardingRouter_1 = require("./ShardingRouter");
@@ -603,38 +604,26 @@ class ShardingCrudPro {
             return;
         }
         const orderBy = reqJson.orderBy;
-        const expectedDesc = `${timeColumn} DESC`;
-        const expectedAsc = `${timeColumn} ASC`;
         // 1. 必须传 orderBy
         if (!orderBy) {
             throw new Error(`[ShardingCrudPro] 查询操作必须传 orderBy 参数。` +
                 `期望值: '${timeColumn} DESC' 或 '${timeColumn} ASC'`);
         }
-        // 2. 校验 orderBy 格式（直接字符串比较，避免正则转义问题）
-        if (typeof orderBy === 'string') {
-            const upper = orderBy.trim().toUpperCase();
-            if (upper !== expectedDesc.toUpperCase() && upper !== expectedAsc.toUpperCase()) {
-                throw new Error(`[ShardingCrudPro] orderBy 参数必须是 '${timeColumn} DESC' 或 '${timeColumn} ASC'，` +
-                    `当前值: '${orderBy}'`);
-            }
+        // 2. 使用工具类解析并校验首个排序字段是否为 timeColumn
+        const firstOrderBy = OrderByUtils_1.OrderByUtils.getFirstOrderBy(orderBy);
+        if (!firstOrderBy) {
+            throw new Error(`[ShardingCrudPro] orderBy 参数格式错误，无法解析。` +
+                `期望值: '${timeColumn} DESC' 或 '${timeColumn} ASC'`);
         }
-        else if (Array.isArray(orderBy)) {
-            // 数组格式：首个排序字段必须是 timeColumn DESC/ASC，允许附加次级排序
-            if (orderBy.length === 0) {
-                throw new Error(`[ShardingCrudPro] orderBy 数组不能为空，首个排序字段必须为 '${timeColumn} DESC' 或 '${timeColumn} ASC'`);
-            }
-            const firstItem = orderBy[0];
-            const firstItemStr = typeof firstItem === 'string'
-                ? firstItem
-                : `${firstItem.fieldName} ${firstItem.orderType || 'ASC'}`;
-            const upper = firstItemStr.trim().toUpperCase();
-            if (upper !== expectedDesc.toUpperCase() && upper !== expectedAsc.toUpperCase()) {
-                throw new Error(`[ShardingCrudPro] orderBy 数组首个排序字段必须为 '${timeColumn} DESC' 或 '${timeColumn} ASC'，` +
-                    `当前值: '${firstItemStr}'`);
-            }
+        if (firstOrderBy.fieldName !== timeColumn) {
+            throw new Error(`[ShardingCrudPro] orderBy 首个排序字段必须为 '${timeColumn}'，` +
+                `当前值: '${firstOrderBy.fieldName}'`);
         }
-        else {
-            throw new Error(`[ShardingCrudPro] orderBy 参数格式错误，期望字符串或数组。`);
+        // 校验排序方向是否为 ASC 或 DESC
+        const orderType = firstOrderBy.orderType.toUpperCase();
+        if (orderType !== 'ASC' && orderType !== 'DESC') {
+            throw new Error(`[ShardingCrudPro] orderBy 排序方向必须是 'ASC' 或 'DESC'，` +
+                `当前值: '${firstOrderBy.orderType}'`);
         }
     }
     /**
@@ -646,20 +635,7 @@ class ShardingCrudPro {
      * @returns true 表示 ASC，false 表示 DESC
      */
     isAscOrderBy(reqJson) {
-        const orderBy = reqJson.orderBy;
-        if (!orderBy)
-            return false;
-        if (typeof orderBy === 'string') {
-            return orderBy.trim().toUpperCase().endsWith('ASC');
-        }
-        if (Array.isArray(orderBy) && orderBy.length > 0) {
-            const firstItem = orderBy[0];
-            const firstItemStr = typeof firstItem === 'string'
-                ? firstItem
-                : `${firstItem.fieldName} ${firstItem.orderType || 'ASC'}`;
-            return firstItemStr.trim().toUpperCase().endsWith('ASC');
-        }
-        return false;
+        return OrderByUtils_1.OrderByUtils.isFirstOrderByAsc(reqJson.orderBy);
     }
     /**
      * 根据排序方向对分表列表进行排序

package/dist/libs/crud-sharding/ShardingMerger.d.ts

@@ -55,8 +55,8 @@ export declare class ShardingMerger {
      * - orderBy 为 timeColumn DESC 或 timeColumn ASC
      *
      * 执行流程：
-     * 1. 并行查询所有分表
-     * 2. 按表顺序拼接结果（无需排序）
+     * 1. 串行查询分表，按表顺序拼接
+     * 2. 达到 maxRows 上限后立即停止，避免查询无关表
      *
      * @param crudPro CrudPro 实例
      * @param tables 分表列表（DESC: 新→旧，ASC: 旧→新）

package/dist/libs/crud-sharding/ShardingMerger.js

@@ -75,8 +75,8 @@ class ShardingMerger {
      * - orderBy 为 timeColumn DESC 或 timeColumn ASC
      *
      * 执行流程：
-     * 1. 并行查询所有分表
-     * 2. 按表顺序拼接结果（无需排序）
+     * 1. 串行查询分表，按表顺序拼接
+     * 2. 达到 maxRows 上限后立即停止，避免查询无关表
      *
      * @param crudPro CrudPro 实例
      * @param tables 分表列表（DESC: 新→旧，ASC: 旧→新）
@@ -86,14 +86,16 @@ class ShardingMerger {
      * @returns 数据列表
      */
     async mergeQuery(crudPro, tables, reqJson, cfgJson, maxRows = 10000) {
-        // 并行查询所有分表
-        const dataPromises = tables.map(table => this.queryRowsSafe(crudPro, table, reqJson, cfgJson, maxRows));
-        const dataResults = await Promise.all(dataPromises);
-        // 按表顺序拼接（表顺序即数据顺序，无需排序）
+        // 串行查询分表，按表顺序拼接，达到上限即停
         let allRows = [];
-        for (let i = 0; i < dataResults.length; i++) {
-            allRows = allRows.concat(dataResults[i]);
-            // 达到上限后停止
+        for (const table of tables) {
+            const needMore = maxRows - allRows.length;
+            if (needMore <= 0) {
+                break;
+            }
+            const rows = await this.queryRowsSafe(crudPro, table, reqJson, cfgJson, needMore);
+            allRows = allRows.concat(rows);
+            // 达到上限后停止，不再查询后续表
             if (allRows.length >= maxRows) {
                 allRows = allRows.slice(0, maxRows);
                 break;

package/dist/service/curd/README.md

@@ -824,7 +824,30 @@ await sharding.insert({
 
 ### linkColumnRelationDatas
 
-独立于 CRUD 操作，直接对已有数据行执行关联填充：
+独立于 CRUD 操作，直接对已有数据行执行关联填充。适用于数据来自缓存、外部接口或其他非 CurdMixService 渠道，但仍需要字典翻译、用户信息等关联数据的场景。
+
+> ⚠️ 该方法会**原地修改** `rows` 数组中的对象，不会返回新数组。
+
+#### 方法签名
+
+```typescript
+linkColumnRelationDatas(rows: any[], param: ILinkColumnRelationParam): Promise<void>
+```
+
+#### 参数接口
+
+```typescript
+interface ILinkColumnRelationParam {
+  columnsRelations: ColumnRelation[];  // 关联配置数组
+}
+```
+
+| 参数 | 类型 | 说明 |
+|------|------|------|
+| `rows` | `any[]` | 待填充的数据行数组；为空或非数组时直接返回 |
+| `param.columnsRelations` | `ColumnRelation[]` | 关联规则配置，与 CRUD 配置中的 `columnsRelation` 格式一致 |
+
+#### 基础用法
 
 ```typescript
 // 场景：从缓存或其他来源获取了数据行，仍需要关联填充
@@ -840,9 +863,85 @@ await curdMixService.linkColumnRelationDatas(rows, {
     },
   ],
 });
-// rows 中的每行会自动追加 sex_text 字段
+// rows 中的每行会原地追加 sex_text 字段
 ```
 
+#### 多关联类型组合
+
+```typescript
+const rows = await redisCache.get('order_list');
+
+await curdMixService.linkColumnRelationDatas(rows, {
+  columnsRelations: [
+    // 字典翻译
+    {
+      relatedType: 'dict',
+      relatedCode: 'OrderStatus',
+      sourceColumn: 'status',
+      targetColumns: [
+        { from: 'label', to: 'status_text' },
+        { from: 'color', to: 'status_color' },
+      ],
+    },
+    // 系统配置枚举
+    {
+      relatedType: 'sysCfgEnum',
+      relatedCode: 'PayMethod',
+      sourceColumn: 'pay_method',
+      targetColumns: [
+        { from: 'label', to: 'pay_method_info.label' },
+        { from: 'style', to: 'pay_method_info.style' },
+      ],
+    },
+    // 用户信息填充
+    {
+      relatedType: 'accountBasic',
+      sourceColumn: 'created_by',
+      targetColumns: [],  // 空 = 使用默认映射
+    },
+    // 工作台信息
+    {
+      relatedType: 'workbenchBasic',
+      sourceColumn: 'workbench_code',
+      targetColumns: [
+        { from: 'workbench_domain', to: 'workbench_info.workbench_domain' },
+        { from: 'workbench_name', to: 'workbench_info.workbench_name' },
+      ],
+    },
+  ],
+});
+```
+
+#### 与 CrudProQuick 配合使用
+
+```typescript
+const quick = curdProService.getQuickCrud('mydb', SqlDbType.mysql, 't_order');
+
+// 先用 CrudProQuick 获取原始数据（不带关联）
+const rows = await quick.getList({
+  condition: { status: 'paid' },
+});
+
+// 再用 linkColumnRelationDatas 补充关联数据
+await curdMixService.linkColumnRelationDatas(rows, {
+  columnsRelations: [
+    {
+      relatedType: 'dict',
+      relatedCode: 'OrderStatus',
+      sourceColumn: 'status',
+      targetColumns: [{ from: 'label', to: 'status_text' }],
+    },
+    {
+      relatedType: 'accountBasic',
+      sourceColumn: 'created_by',
+      targetColumns: [],
+    },
+  ],
+});
+```
+
+> **提示**：如果 CRUD 操作本身就需要关联填充，建议直接使用 `CurdMixService.executeCrudByCfg()` 配置 `columnsRelation`，一步完成查询和填充。`linkColumnRelationDatas` 适用于数据已存在的二次填充场景。
+
 ## ColumnRelation 配置
 
 ```typescript

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "midway-fatcms",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "This is a midway component sample",
   "main": "dist/index.js",
   "typings": "index.d.ts",
@@ -30,6 +30,7 @@
     "src/**/*.html",
     "src/**/*.ico",
     "src/**/*.md",
+    ".qoder/**/*.md",
     "index.d.ts",
     "tsconfig.json",
     ".prettierrc.js",