@steedos-labs/plugin-workflow 3.0.44 → 3.0.46

package/main/default/routes/api_workflow_ai_form_design_stream.router.js

@@ -62,7 +62,7 @@ router.post('/am/ai/form-design-stream', async function auth(req, res, next) {
     const baseURL = process.env.WORKFLOW_AI_BASE_URL || 'https://api.openai.com/v1';
     const model = process.env.WORKFLOW_AI_MODEL || 'gpt-4o';
 
-    const { fields, events, userRequest, images, instance_template, form_script, flow_events } = req.body;
+    const { fields, events, userRequest, images, instance_template, form_script, flow_events, name_forumla } = req.body;
 
     if (!userRequest) {
       sendEvent('error', { error: '请输入需求描述' });
@@ -89,6 +89,9 @@ router.post('/am/ai/form-design-stream', async function auth(req, res, next) {
     if (flow_events) {
       extraSections += `\n\n## 流程事件 (flow_events)\n\`\`\`javascript\n${flow_events}\n\`\`\``;
     }
+    if (name_forumla) {
+      extraSections += `\n\n## 旧版标题公式 (name_forumla)\n${name_forumla}\n\n说明：标题公式用 {字段名} 引用字段值，升级时需将其中的 {旧字段名} 替换为 {新版字段name}，输出到 nameFormula 字段。`;
+    }
 
     const userContent = `## 当前表单字段\n${fieldsJson}\n\n## 当前事件脚本\n${eventsJson}${extraSections}\n\n## 用户需求\n${userRequest}\n\n请返回修改后的完整 JSON 对象（包含 tableColumns、fields 和 events）。`;
 
@@ -312,8 +315,6 @@ router.post('/am/ai/form-design-stream', async function auth(req, res, next) {
       return s || 'field_' + Math.random().toString(36).slice(2, 6);
     }
 
-    const tblCols = (typeof result.tableColumns === 'number' && result.tableColumns >= 1) ? Math.min(result.tableColumns, 3) : 2;
-
     if (result.fields) {
       for (const field of result.fields) {
         // Backward compat: map legacy userPicker/groupPicker to new types
@@ -329,15 +330,9 @@ router.post('/am/ai/form-design-stream', async function auth(req, res, next) {
         if (field.name && !jsIdentifierRe.test(field.name)) {
           field.name = sanitizeName(field.name);
         }
-        if (field.type === 'section' || field.type === 'table' || field.type === 'grid') {
-          field.tableColspan = tblCols;
-          field.colspan = 12;
-        } else {
-          // AI outputs colspan as 1..tableColumns; convert to tableColspan + 12-grid colspan
-          const aiColspan = Math.max(1, Math.min(Number(field.colspan) || 1, tblCols));
-          field.tableColspan = aiColspan;
-          field.colspan = (aiColspan >= tblCols) ? 12 : Math.round(12 / tblCols * aiColspan);
-        }
+        // Remove colspan/tableColspan from AI output — layout is determined by field type defaults
+        delete field.colspan;
+        delete field.tableColspan;
         if (field.type === 'table' && Array.isArray(field.children)) {
           for (const child of field.children) {
             // Backward compat: map legacy types in children
@@ -438,8 +433,8 @@ function buildSystemPrompt() {
   - "orgMulti" — 组织（多选，选择多个部门）
   - "reference" — 对象选择（选择指定对象的记录，支持多选，可展示记录的多个字段）
   - "richtext" — 富文本（支持格式化文本、颜色、链接等）
+  - "autoNumber" — 自动编号（只读字段，自动生成带前缀、日期、序号的唯一编号）
 - required: 布尔值，是否必填
-- colspan: 数字，字段占几列，取值范围 1~tableColumns。默认 1（占一列），设为 tableColumns 则独占一行。section 和 table 始终等于 tableColumns
 - description: 字符串，字段说明/提示文字，支持 HTML
 - placeholder: 字符串，输入占位提示
 - defaultValue: 字符串，默认值
@@ -551,6 +546,16 @@ function buildSystemPrompt() {
   - displayFields: 数组，选择记录后额外展示的字段，格式 [{ "field": "字段API名", "label": "显示标签" }]
   - pickerMultiple: 布尔值，是否允许多选，默认 true
 
+- autoNumber 类型（自动编号）：
+  - 自动编号字段始终为只读（readonly: true），运行时由系统自动生成唯一编号
+  - autoNumberPrefix: 字符串，编号前缀，如 "SN-"、"HT-"，默认 ""
+  - autoNumberSuffix: 字符串，编号后缀，默认 ""
+  - autoNumberPadding: 数字，序号位数（补零），默认 4，如 4 → 0001
+  - autoNumberDateFormat: 字符串，日期片段格式，可选值："none"(无日期) | "YYYY"(年) | "YYYYMM"(年月，默认) | "YYYYMMDD"(年月日)
+  - autoNumberResetCycle: 字符串，序号重置周期，可选值："none"(不重置) | "yearly"(每年) | "monthly"(每月，默认) | "daily"(每天)
+  - 生成的编号格式示例：前缀 + 日期 + 序号 + 后缀，如 "SN-202603-0001"
+  - 示例：{ "type": "autoNumber", "label": "合同编号", "name": "contract_no", "readonly": true, "autoNumberPrefix": "HT-", "autoNumberDateFormat": "YYYYMM", "autoNumberPadding": 4, "autoNumberResetCycle": "monthly" }
+
 - 可见性规则（任何字段都可设置）：
   - visibilityRules: 数组，控制字段显示/隐藏的规则，当所有/任一规则满足时字段可见，否则隐藏。每条规则格式：
     { "field": "控制字段的name", "operator": "操作符", "value": "比较值" }
@@ -597,7 +602,7 @@ if (field.name === 'quantity' || field.name === 'unit_price') {
 ## 规则
 1. 修改时尽可能保留用户已有字段的 name，只改需要改的部分
 2. 新增字段的 name 必须是合法的 JavaScript 变量名（字母/下划线开头，仅含字母、数字、下划线），要语义清晰
-3. section 分组、table 子表、grid 网格的 colspan 必须等于 tableColumns（即独占整行）
+3. section 分组、table 子表、grid 网格始终独占整行，不需要设置 colspan
 4. formula 字段的公式表达式使用 \${} 语法，内部直接引用字段名，如 "\${unit_price * quantity}"；公式内部不能再嵌套 \${}，错误示例："\${RMB(\${amount})}"，正确示例："\${RMB(amount)}"
 5. formula 字段只能使用上方"支持的函数（完整列表）"中列出的 36 个函数，禁止使用任何 Excel 专有函数（NETWORKDAYS、WORKDAY、EDATE、SUMIF、VLOOKUP、IFERROR、EOMONTH 等）或 JavaScript 方法（Math.floor、parseFloat、toString 等），违反此规则会导致运行时报错
 6. 如果用户只要求修改脚本/事件，则 fields 保持原样不变
@@ -628,7 +633,7 @@ if (field.name === 'quantity' || field.name === 'unit_price') {
 - 分析模板时，首先统计 HTML 表格展开所有 colspan 后的**实际最大总列数**（包含标签列和数据列），然后选择布局方案：
 - **⭐ 优先使用方案二（grid 网格字段）**。只有当模板表格极其简单（总列数 ≤ 6 且无 rowspan/colspan）时才考虑方案一。如果你不确定该用哪个，请使用方案二。
 
-#### 方案一：简单布局（tableColumns + tableColspan）
+#### 方案一：简单布局（tableColumns）
 适用条件：模板 HTML 表格展开后总列数 ≤ 6（含标签列），每行最多 3 个输入字段，且无 rowspan/colspan 合并单元格。**如果模板中出现任何 rowspan 或 colspan，则不得使用方案一，必须使用方案二。**
 
   1. **确定 tableColumns**（每行字段数）：
@@ -636,19 +641,16 @@ if (field.name === 'quantity' || field.name === 'unit_price') {
      - 模板中每行有 2 个输入字段 → tableColumns=2
      - 模板中每行有 3 个输入字段 → tableColumns=3（最大值）
 
-  2. **字段 tableColspan**：基于 tableColumns 栅格设置，默认每个字段占 1 列
-     - tableColumns=2 时：每个字段默认 tableColspan=1，独占一行的字段 tableColspan=2
-     - tableColumns=3 时：每个字段默认 tableColspan=1，跨两列的 tableColspan=2，独占一行的 tableColspan=3
-     - 注意：tableColspan 的最大值等于 tableColumns
+  2. **字段排布**：每个字段默认占 1 列，按顺序自动流入行中
 
   3. **分组布局**：模板中的分类标题应转为 type="section" 字段
 
   4. **字段 label**：优先使用模板中该字段旁边的显示文本
 
 #### 方案二：复杂表格布局（grid 网格字段）⭐ 默认首选方案
-适用条件：模板 HTML 表格展开后总列数 > 6，或者存在**任何 rowspan 或 colspan**，或者有多级表头（主标题下有子标题），或者表格结构无法用 tableColumns(1-3) + colspan 简单表达。**绝大多数审批单模板都应使用此方案。**
+适用条件：模板 HTML 表格展开后总列数 > 6，或者存在**任何 rowspan 或 colspan**，或者有多级表头（主标题下有子标题），或者表格结构无法用 tableColumns(1-3) 简单表达。**绝大多数审批单模板都应使用此方案。**
 
-**必须使用 grid 网格字段来精确还原表格布局。禁止将复杂模板用 tableColumns + colspan 简化处理。如果模板有任何 rowspan/colspan 合并单元格，就必须使用 grid。**
+**必须使用 grid 网格字段来精确还原表格布局。禁止将复杂模板用 tableColumns 简化处理。如果模板有任何 rowspan/colspan 合并单元格，就必须使用 grid。**
 
 转换步骤：
   1. **分析 HTML 表格结构**：统计表格的总行数和总列数（考虑 colspan 展开后的最大列数），确定 gridRows 和 gridCols
@@ -658,7 +660,7 @@ if (field.name === 'quantity' || field.name === 'unit_price') {
      - HTML 的 \`rowspan\`/\`colspan\` 属性直接映射到 gridData 单元格的 \`rowspan\`/\`colspan\`
   3. **构建 children 数组**：为每个 input 类型的单元格创建对应的子字段，通过 fieldId 关联
   4. **设置 gridColumnWidths**：根据 HTML 表格各列的实际宽度比例设置百分比数组
-  5. **grid 字段的 colspan 设为 tableColumns**（独占整行），tableColumns 可设为 1
+  5. **grid 字段始终独占整行**，tableColumns 可设为 1
 
 转换示例 — 假设模板有一个 5 列表格（标题+4个数据列）：
   HTML: \`<tr><td rowspan="3">工程名称</td><td>材料费</td><td>{{values.clf_bq}}</td><td>{{values.clf_lj}}</td><td>{{values.clf_bz}}</td></tr>\`
@@ -666,7 +668,7 @@ if (field.name === 'quantity' || field.name === 'unit_price') {
   \`\`\`json
   {
     "type": "grid", "label": "费用明细", "name": "cost_grid",
-    "gridRows": 10, "gridCols": 5, "colspan": 1,
+    "gridRows": 10, "gridCols": 5,
     "gridColumnWidths": [15, 15, 25, 25, 20],
     "gridData": [
       { "row": 0, "col": 0, "cellType": "label", "value": "工程名称", "rowspan": 3, "align": "center" },
@@ -718,6 +720,19 @@ if (field.name === 'quantity' || field.name === 'unit_price') {
   \`\`\`json
   { "name": "apply_increase_amount", "type": "number", "max": 4999999.99, "precision": 2 }
   \`\`\`
+### 旧版自动编号字段迁移
+- 旧版表单中的自动编号字段通过 default_value 属性实现，格式为 \`default_value = "auto_number('规则名称')"\`
+- 新版必须将此类字段转换为 \`type: "autoNumber"\` 类型
+- 迁移规则：
+  - 遇到字段的 default_value 包含 \`auto_number(...)\` 时，将该字段的 type 改为 "autoNumber"，设置 readonly: true
+  - 删除原有的 default_value 属性
+  - 如果旧版编号规则名称中能推断出前缀、日期格式等信息，相应设置 autoNumberPrefix、autoNumberDateFormat 等属性；否则使用默认值
+  - 默认配置：autoNumberPrefix: ""、autoNumberPadding: 4、autoNumberDateFormat: "YYYYMM"、autoNumberResetCycle: "monthly"
+- 迁移示例：
+  旧版字段：{ "name": "合同编号", "type": "text", "default_value": "auto_number('contract_no')" }
+  新版字段：{ "name": "contract_no", "label": "合同编号", "type": "autoNumber", "readonly": true, "autoNumberPrefix": "", "autoNumberPadding": 4, "autoNumberDateFormat": "YYYYMM", "autoNumberResetCycle": "monthly" }
+- migrationLog 记录格式："字段 <name>: default_value auto_number(...) 转换为 autoNumber 类型"
+
 ### 旧版 HTML 字段类型迁移
 - 旧版表单中存在 type 为 \"html\" 的字段，这是旧版的 HTML 编辑器字段，允许用户输入和编辑 HTML 格式的富文本内容
 - 新版表单中 **不再支持 \"html\" 类型**，已被 **\"richtext\"（富文本）** 类型完全替代
@@ -754,9 +769,17 @@ if (field.name === 'quantity' || field.name === 'unit_price') {
     "onValueChange": "脚本代码或空字符串",
     "onSubmit": "脚本代码或空字符串"
   },
+  "nameFormula": "标题公式（仅升级场景，将旧版标题公式中的字段引用更新为新版字段 name）",
   "migrationLog": ["迁移记录，仅升级场景需要"]
 }
 
+### nameFormula（标题公式，升级场景）
+当用户提供了旧版标题公式（name_forumla）时，需要将其中的字段引用更新为新版字段 name。
+- 旧版标题公式格式：用 {字段名} 引用字段值，如 "{申请人} 的 {类型} 申请"
+- 升级时将 {旧字段名} 替换为 {新字段name}，如 "{applicant_name} 的 {request_type} 申请"
+- 公式中的纯文本部分保持不变
+- 如果用户未提供旧版标题公式，则 nameFormula 字段可省略或返回空字符串
+
 ### migrationLog（迁移记录）
 当用户提供了 flow_events、form_script、instance_template 中包含业务逻辑（如校验、赋值、显隐控制等脚本代码）时，必须在 migrationLog 数组中为每条被迁移的逻辑记录一条说明，格式：
   "<来源>: <原逻辑简述> → <迁移到的具体位置>"

package/main/default/routes/api_workflow_instance_forward.router.js

@@ -205,7 +205,7 @@ router.post("/api/workflow/v2/instance/forward", requireAuthentication, async fu
                         const key = f.code;
                         let old_v = old_values[key];
                         if (old_v) {
-                            const fieldOptions = f.options?.split("\n").map(n => {
+                            const fieldOptions = _.isArray(f.options) ? f.options : f.options?.split("\n").map(n => {
                                 const itemSplits = n.split(":");
                                 return {
                                     label: itemSplits[0],
@@ -288,7 +288,7 @@ router.post("/api/workflow/v2/instance/forward", requireAuthentication, async fu
                 const key = field.code;
                 let old_v = old_values[key];
                 if (old_v) {
-                    const fieldOptions = field.options?.split("\n").map(n => {
+                    const fieldOptions = _.isArray(field.options) ? field.options : field.options?.split("\n").map(n => {
                         const itemSplits = n.split(":");
                         return {
                             label: itemSplits[0],

package/main/default/routes/api_workflow_next_step.router.js

@@ -65,7 +65,9 @@ const getNextSteps = async (flow, flowVersionId, instance, currentStep, judge, a
 
     let nextSteps = [];
     const lines = currentStep.lines;
-
+    if(!currentStep.id){
+        currentStep.id = currentStep._id;
+    }
     switch (currentStep.step_type) {
         case 'condition': //条件
             const stepIds = await UUFlowManager.getNextSteps(instance, flow, currentStep, judge, autoFormDoc);
@@ -336,6 +338,11 @@ router.post('/api/workflow/v2/nextSteps', requireAuthentication, async function
         const form = await objectql.getObject('forms').findOne(instance.form);
         const { fields } = await UUFlowManager.getFormVersion(form, instance.form_version);
         const resNextSteps = await calcSteps(instance, flow, flowVersionId, fields, values);
+
+        _.map(resNextSteps, (step) => {
+            step.stepHandler = instance.step_approve ? instance.step_approve[step._id] : null;
+        });
+
         res.status(200).send({
             'nextSteps': resNextSteps
         });

package/main/default/routes/api_workflow_next_step_users.router.js

@@ -29,7 +29,24 @@ const getFieldValue = (values, code)=>{
 
 const getFormFieldValue = (fields, values, fieldId)=>{
     const code = getFieldName(fields, fieldId);
-    return getFieldValue(values, code);
+    const _values =  getFieldValue(values, code);
+
+    if(_.isArray(_values)){
+        return _.map(_values, (value)=>{
+            if(_.isObject(value) && value.id){
+                return value.id;
+            }else{
+                return value;
+            }
+        })
+    }else{
+        if(_.isObject(_values) && _values.id){
+            return _values.id;
+        }else{
+            return _values;
+        }
+    }
+
 }
 
 /**
@@ -269,7 +286,10 @@ router.post('/api/workflow/v2/nextStepUsersValue', requireAuthentication, async
         for (let i = traces.length - 1; i >= 0; i--) {
             const trace = traces[i];
             if (trace.step === nextStepId && trace.approves && trace.approves.length > 0) {
-                newNextUsers = trace.approves.map(approve => approve.handler);
+                // 需要排除以下 approve.jude ['returned', 'terminated', 'retrieved'].includes(judge)
+                newNextUsers = trace.approves
+                    .filter(approve => !['returned', 'terminated', 'retrieved'].includes(approve.judge))
+                    .map(approve => approve.handler);
                 break;
             }
         }

package/main/default/routes/api_workflow_submit.router.js

@@ -55,11 +55,40 @@ router.post('/api/workflow/submit', requireAuthentication, async function (req,
     var hashData = req.body;
     var result = [];
     const instance_from_client = hashData['Instances'][0];
-    // beforeDraftSubmit
     const insId = instance_from_client._id;
-    await excuteTriggers({ when: 'beforeDraftSubmit', userId: userId, flowId: instance_from_client['flow'], insId: insId });
 
     try {
+        // 校验流程启用状态、流程版本和表单版本是否为最新
+        const flowsCollection = await getCollection('flows');
+        const formsCollection = await getCollection('forms');
+        const ins = await db.instances.findOne({ _id: insId });
+        if (!ins) {
+            throw new Error('申请单不存在');
+        }
+        const flow = await flowsCollection.findOne({ _id: ins.flow }, { projection: { state: 1, current: 1 } });
+        if (!flow) {
+            throw new Error('流程不存在');
+        }
+        // 校验流程是否已启用
+        if (flow.state !== 'enabled') {
+            throw new Error('流程未启用，操作失败');
+        }
+        // 校验流程版本是否为最新版
+        if (ins.flow_version !== flow.current._id) {
+            throw new Error('流程已升级，请刷新后重新填写提交');
+        }
+        const form = await formsCollection.findOne({ _id: ins.form }, { projection: { current: 1 } });
+        if (!form) {
+            throw new Error('表单不存在');
+        }
+        // 校验表单版本是否为最新版
+        if (ins.form_version !== form.current._id) {
+            throw new Error('表单已升级，请刷新后重新填写提交');
+        }
+
+        // beforeDraftSubmit
+        await excuteTriggers({ when: 'beforeDraftSubmit', userId: userId, flowId: instance_from_client['flow'], insId: insId });
+
         var r = await UUFlowManager.submit_instance(instance_from_client, userSession);
         if (r.alerts) {
             result.push(r);

package/main/default/routes/flow_form_design.ejs

@@ -70,6 +70,7 @@
       title: "<%=locale%>" === 'zh-CN' ? '流程表单设计器': 'Flow Form Designer',
       saveText: "<%=locale%>" === 'zh-CN' ? '保存': 'Save',
       deployText: "<%=locale%>" === 'zh-CN' ? '发布': 'Deploy',
+      unpkgUrl: "<%=unpkgUrl%>"
     };
 
     const getArgumentsList = (func)=>{
@@ -279,7 +280,7 @@
      * 保持同步。
      */
     const _getSafeCode = (code) => {
-      return code.replace(/（/g, '_').replace(/）/g, '').replace(/\(/g, '_').replace(/\)/g, '').replace(/、/g, '_').replace(/，/g, '_').replace(/%/g, '_').replace(/=/g, '_');
+      return code.replace(/（/g, '_').replace(/）/g, '').replace(/\(/g, '_').replace(/\)/g, '').replace(/、/g, '_').replace(/，/g, '_').replace(/%/g, '_').replace(/=/g, '_').replace(/：/g, '_').replace(/\//g, '_').replace(/-/g, '_');
     };
 
     /**
@@ -304,6 +305,9 @@
       const _isContextVariable = (code) => code === 'applicant' || code === 'approver';
 
       if (isFunction || isOperator || isObjectField || isDotField) {
+        // 将数学分组方括号 [] 转为圆括号 ()
+        newFormula = newFormula.replace(/\[/g, '(').replace(/\]/g, ')');
+
         if (isFunction) {
           newFormula = newFormula.replace(/sum\s*\(/ig, 'SUM(');
           newFormula = newFormula.replace(/average\s*\(/ig, 'AVG(');
@@ -621,7 +625,8 @@
           break;
         case "section":
           tpl.type = "steedos-field-group";
-          tpl.title = field.name;
+          // 历史表单 section 字段可能只有 code 没有 name，需要 fallback 到 code，避免 title 为 undefined 导致保存时分组字段丢失
+          tpl.title = field.name || field.code;
           tpl.description = field.description;
           tpl.body = []
           if (field.fields) {

package/main/default/routes/flow_form_design.router.js

@@ -31,7 +31,7 @@ router.get('/api/workflow/form_design', auth.requireAuthentication, async functi
         }
         const retUrl = req.query.retUrl || process.env.ROOT_URL + '/app/admin/flows/view/' + req.query.fid
         const steedosBuilderUrl = process.env.STEEDOS_BUILDER_URL || 'https://builder.steedos.cn';
-        const builderHost = `${steedosBuilderUrl}/object?${assetUrl}retUrl=${retUrl}&locale=${locale}&isObjectDesign=1&pType=objectDesign`;
+        const builderHost = `${steedosBuilderUrl}/object?${assetUrl}retUrl=${retUrl}&locale=${locale}&isObjectDesign=1&pType=objectDesign&unpkgUrl=${process.env.STEEDOS_UNPKG_URL || 'https://unpkg.steedos.cn'}`;
 
         const filename = __dirname+'/flow_form_design.ejs';
 
@@ -46,7 +46,8 @@ router.get('/api/workflow/form_design', auth.requireAuthentication, async functi
             userSession: userSession,
             id: flow.form,
             useOpenAPI: process.env.STEEDOS_PUBLIC_USE_OPEN_API,
-            locale
+            locale,
+            unpkgUrl: process.env.STEEDOS_UNPKG_URL || 'https://unpkg.steedos.cn',
         }
         const options = {}
         ejs.renderFile(filename, data, options, function(err, str){

package/main/default/routes/object_workflows.router.js

@@ -80,7 +80,7 @@ router.get('/api/object_workflows/workflow_field/options', requireAuthentication
                 if (f.fields) {
                     f.fields.forEach(function (ff) {
                         form_fields.push({
-                        'label': ff.name  || ff.code,
+                        'label': ff.label || ff.name  || ff.code,
                         'value': ff.code
                         });
                     });
@@ -89,14 +89,14 @@ router.get('/api/object_workflows/workflow_field/options', requireAuthentication
                 if (f.fields) {
                   f.fields.forEach(function (ff) {
                     form_fields.push({
-                      'label': (f.name || f.code) + "=>" + (ff.name || ff.code),
+                      'label': (f.label || f.name || f.code) + "=>" + (ff.label || ff.name || ff.code),
                       'value': f.code + '.' + ff.code
                     });
                   });
                 }
               } else {
                 form_fields.push({
-                  'label': f.name || f.code,
+                  'label': f.label || f.name || f.code,
                   'value': f.code
                 });
               }

package/main/default/test/test_formula_compat.js

@@ -95,7 +95,19 @@ const tableFieldMapCases = [
 const run = () => {
     console.log('[formula-compat] running tests...');
 
-    assert.strictEqual(getSafeCode('工程形象进度%(2)=(3)/(1)'), '工程形象进度__2__3/_1');
+    assert.strictEqual(getSafeCode('工程形象进度%(2)=(3)/(1)'), '工程形象进度__2__3__1');
+
+    // 方括号转换测试
+    assert.strictEqual(
+        mapFormula('[{油量（本地）} + {油量（异地）}]/{本月里程数}*100'),
+        '${(油量_本地 + 油量_异地)/本月里程数*100}',
+        '方括号分组应转换为圆括号'
+    );
+    assert.strictEqual(
+        mapFormula('{月末里程数} - {月初里程数}'),
+        '${月末里程数 - 月初里程数}',
+        '简单减法公式应正确转换'
+    );
 
     for (const item of cases) {
         const actual = mapFormula(item.input);
@@ -134,7 +146,7 @@ const run = () => {
     assert.strictEqual(map['数量'], '明细表', 'getTableFieldMap 应递归处理 section 中的 table');
     assert.strictEqual(map['标题'], undefined, 'getTableFieldMap 非子表字段不应在映射中');
 
-    const totalAssertions = 1 + cases.length + tableFieldMapCases.length + 4;
+    const totalAssertions = 1 + 2 + cases.length + tableFieldMapCases.length + 4;
     console.log(`[formula-compat] ${totalAssertions} assertions passed.`);
 };
 

package/main/default/test/test_migrateApprovalCommentsField.js

@@ -0,0 +1,220 @@
+const assert = require('assert');
+const mod = require('../../../src/rests/migrateApprovalCommentsField');
+
+const { matchesApprovalPattern, transformField, processFieldsArray } = mod._helpers;
+
+// ---------------------------------------------------------------------------
+// matchesApprovalPattern tests
+// ---------------------------------------------------------------------------
+const patternCases = [
+    { input: '{traces.步骤名}', expected: true },
+    { input: '${traces.步骤名}', expected: true },
+    { input: '{signature.traces.步骤名}', expected: true },
+    { input: '${signature.traces.步骤名}', expected: true },
+    { input: '{yijianlan:{step:"步骤名"}}', expected: true },
+    { input: '{普通字段}', expected: false },
+    { input: null, expected: false },
+    { input: undefined, expected: false }
+];
+
+// ---------------------------------------------------------------------------
+// processFieldsArray: flat (first-level) fields
+// ---------------------------------------------------------------------------
+const flatFields = [
+    {
+        type: 'input',
+        code: '主管经理意见',
+        formula: '{signature.traces.主管经理审核}',
+        _id: 'id-1'
+    },
+    {
+        type: 'input',
+        code: '普通字段',
+        _id: 'id-2'
+    }
+];
+
+// ---------------------------------------------------------------------------
+// processFieldsArray: nested section fields (the bug scenario)
+// ---------------------------------------------------------------------------
+const nestedFields = [
+    {
+        type: 'section',
+        code: '申请单位意见',
+        _id: 'sec-1',
+        fields: [
+            {
+                type: 'input',
+                code: '部门负责人意见',
+                formula: '{signature.traces.申请单位部门负责人意见}',
+                _id: 'id-3'
+            }
+        ]
+    },
+    {
+        type: 'section',
+        code: '财务处意见',
+        _id: 'sec-2',
+        fields: [
+            {
+                type: 'input',
+                code: '部门负责人意见1',
+                name: '部门负责人意见',
+                formula: '{signature.traces.财务处部门负责人意见}',
+                _id: 'id-4'
+            }
+        ]
+    }
+];
+
+// ---------------------------------------------------------------------------
+// processFieldsArray: deeply nested (section > section)
+// ---------------------------------------------------------------------------
+const deeplyNestedFields = [
+    {
+        type: 'section',
+        code: '外层',
+        _id: 'sec-outer',
+        fields: [
+            {
+                type: 'panel',
+                code: '内层',
+                _id: 'panel-inner',
+                fields: [
+                    {
+                        type: 'input',
+                        code: '深层签字字段',
+                        formula: '{traces.深层步骤}',
+                        _id: 'id-deep'
+                    }
+                ]
+            }
+        ]
+    }
+];
+
+// ---------------------------------------------------------------------------
+// processFieldsArray: mixed top-level and nested
+// ---------------------------------------------------------------------------
+const mixedFields = [
+    {
+        type: 'input',
+        code: '顶层签字字段',
+        formula: '{signature.traces.顶层步骤}',
+        _id: 'id-top'
+    },
+    {
+        type: 'section',
+        code: '分组',
+        _id: 'sec-mixed',
+        fields: [
+            {
+                type: 'input',
+                code: '嵌套签字字段',
+                formula: '{signature.traces.嵌套步骤}',
+                _id: 'id-nested'
+            },
+            {
+                type: 'input',
+                code: '普通嵌套字段',
+                _id: 'id-plain-nested'
+            }
+        ]
+    }
+];
+
+const run = () => {
+    console.log('[migrateApprovalCommentsField] running tests...');
+
+    // --- matchesApprovalPattern ---
+    for (const item of patternCases) {
+        assert.strictEqual(
+            matchesApprovalPattern(item.input),
+            item.expected,
+            `matchesApprovalPattern("${item.input}") should be ${item.expected}`
+        );
+    }
+    console.log(`  matchesApprovalPattern: ${patternCases.length} assertions passed.`);
+
+    // --- transformField: should transform a matching field ---
+    const transformed = transformField(flatFields[0]);
+    assert.ok(transformed, 'transformField should return a non-null result for matching field');
+    assert.strictEqual(transformed.type, 'steedos-field');
+    assert.strictEqual(transformed.__approval_comments_transformed, true);
+    assert.strictEqual(transformed.config.steps[0].name, '主管经理审核');
+    assert.strictEqual(transformed.config.steps[0].show_image_sign, true);
+
+    // --- transformField: should skip non-matching field ---
+    const skipped = transformField(flatFields[1]);
+    assert.strictEqual(skipped, null, 'transformField should return null for non-matching field');
+
+    // --- transformField: should skip already-transformed field ---
+    const alreadyTransformed = { ...flatFields[0], __approval_comments_transformed: true };
+    assert.strictEqual(transformField(alreadyTransformed), null, 'transformField should skip already-transformed fields');
+    console.log('  transformField: 4 assertions passed.');
+
+    // --- processFieldsArray: flat fields ---
+    const flatResult = processFieldsArray(flatFields, 'current.fields');
+    assert.strictEqual(flatResult.updates.length, 1, 'Flat: should transform 1 matching field');
+    assert.strictEqual(flatResult.updates[0].path, 'current.fields.0', 'Flat: path should be current.fields.0');
+    assert.ok(flatResult.unsets.includes('current.fields.0.formula'), 'Flat: formula should be in unsets');
+    console.log('  processFieldsArray (flat): 3 assertions passed.');
+
+    // --- processFieldsArray: nested section fields (the bug regression test) ---
+    const nestedResult = processFieldsArray(nestedFields, 'current.fields');
+    assert.strictEqual(nestedResult.updates.length, 2,
+        'Nested: should transform 2 matching fields inside sections');
+    const nestedPaths = nestedResult.updates.map(u => u.path);
+    assert.ok(nestedPaths.includes('current.fields.0.fields.0'),
+        'Nested: first nested field path should be current.fields.0.fields.0');
+    assert.ok(nestedPaths.includes('current.fields.1.fields.0'),
+        'Nested: second nested field path should be current.fields.1.fields.0');
+    assert.ok(nestedResult.unsets.includes('current.fields.0.fields.0.formula'),
+        'Nested: formula unset path should be current.fields.0.fields.0.formula');
+    assert.ok(nestedResult.unsets.includes('current.fields.1.fields.0.formula'),
+        'Nested: formula unset path should be current.fields.1.fields.0.formula');
+
+    // Verify step names are correct
+    const step0 = nestedResult.updates.find(u => u.path === 'current.fields.0.fields.0');
+    assert.strictEqual(step0.update.config.steps[0].name, '申请单位部门负责人意见',
+        'Nested: step name should match formula');
+    const step1 = nestedResult.updates.find(u => u.path === 'current.fields.1.fields.0');
+    assert.strictEqual(step1.update.config.steps[0].name, '财务处部门负责人意见',
+        'Nested: step name should match formula');
+    console.log('  processFieldsArray (nested sections): 7 assertions passed.');
+
+    // --- processFieldsArray: deeply nested (section > panel) ---
+    const deepResult = processFieldsArray(deeplyNestedFields, 'current.fields');
+    assert.strictEqual(deepResult.updates.length, 1, 'Deep: should transform 1 deeply nested field');
+    assert.strictEqual(deepResult.updates[0].path, 'current.fields.0.fields.0.fields.0',
+        'Deep: path should reflect full nesting depth');
+    assert.ok(deepResult.unsets.includes('current.fields.0.fields.0.fields.0.formula'),
+        'Deep: formula unset should use full nested path');
+    console.log('  processFieldsArray (deeply nested): 3 assertions passed.');
+
+    // --- processFieldsArray: mixed top-level and nested ---
+    const mixedResult = processFieldsArray(mixedFields, 'current.fields');
+    assert.strictEqual(mixedResult.updates.length, 2, 'Mixed: should transform 2 fields (1 top + 1 nested)');
+    const mixedPaths = mixedResult.updates.map(u => u.path);
+    assert.ok(mixedPaths.includes('current.fields.0'), 'Mixed: top-level field path should be current.fields.0');
+    assert.ok(mixedPaths.includes('current.fields.1.fields.0'), 'Mixed: nested field path should be current.fields.1.fields.0');
+    console.log('  processFieldsArray (mixed): 3 assertions passed.');
+
+    // --- processFieldsArray: historys path prefix ---
+    const historyResult = processFieldsArray(nestedFields, 'historys.0.fields');
+    assert.strictEqual(historyResult.updates.length, 2, 'History: should transform 2 nested fields');
+    const historyPaths = historyResult.updates.map(u => u.path);
+    assert.ok(historyPaths.includes('historys.0.fields.0.fields.0'),
+        'History: nested field path should use historys prefix');
+    assert.ok(historyPaths.includes('historys.0.fields.1.fields.0'),
+        'History: nested field path should use historys prefix');
+    console.log('  processFieldsArray (historys prefix): 3 assertions passed.');
+
+    console.log('[migrateApprovalCommentsField] All assertions passed.');
+};
+
+if (require.main === module) {
+    run();
+}
+
+module.exports = { run };