@steedos-labs/plugin-workflow 3.0.84 → 3.0.86

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

@@ -1,11 +1,11 @@
 const express = require("express");
 const router = express.Router();
-const { instanceNumberBuilder } = require("../manager/instance_number_rules");
+const autoNumberManager = require("../manager/instance_number_rules");
+const { instanceNumberBuilder } = autoNumberManager;
 const objectql = require('@steedos/objectql');
 const _ = require('lodash');
 const UUFlowManager = require('../manager/uuflow_manager');
 const { requireAuthentication } = require("@steedos/auth");
-const { getCollection } = require('../utils/collection');
 
 // 获取用户当前的 approve
 const getUserApprove = ({ instance, userId }) => {
@@ -39,192 +39,25 @@ const getUserApprove = ({ instance, userId }) => {
     return currentApprove;
 };
 
-// ===== 新设计器 autoNumber 字段：基于字段配置直接生成编号 =====
-
-// 序号补零
-const padNumber = (num, length) => {
-    if (length <= 0) return String(num);
-    const str = String(num);
-    return str.length >= length ? str : '0'.repeat(length - str.length) + str;
-};
-
-// 根据日期格式生成日期片段
-const formatDatePart = (dateFormat, yyyy, mm, dd) => {
-    const mmStr = mm < 10 ? '0' + mm : String(mm);
-    const ddStr = dd < 10 ? '0' + dd : String(dd);
-    switch (dateFormat) {
-        case 'YYYY': return String(yyyy);
-        case 'YYYYMM': return String(yyyy) + mmStr;
-        case 'YYYYMMDD': return String(yyyy) + mmStr + ddStr;
-        default: return ''; // 'none' 或 undefined
-    }
-};
-
-// 根据重置周期判断是否需要重置序号
-const shouldResetNumber = (resetCycle, storedRule, yyyy, mm, dd) => {
-    switch (resetCycle) {
-        case 'yearly': return yyyy !== storedRule.year;
-        case 'monthly': return yyyy !== storedRule.year || mm !== storedRule.month;
-        case 'daily': return yyyy !== storedRule.year || mm !== storedRule.month || dd !== storedRule.day;
-        default: return false; // 'none' - 永不重置
-    }
-};
-
 /**
  * 基于字段配置生成自动编号（新设计器 autoNumber 类型字段）
  * 同样使用 instance_number_rules 集合做序号持久化，如果尚未创建规则记录则自动创建
  */
 const generateAutoNumberFromFieldConfig = async (spaceId, fieldConfig) => {
-    const db = await getCollection("instance_number_rules");
-
-    const ruleName = fieldConfig.auto_number_name;
-    const prefix = fieldConfig.autoNumberPrefix || '';
-    const suffix = fieldConfig.autoNumberSuffix || '';
-    const paddingLen = fieldConfig.autoNumberPadding != null ? fieldConfig.autoNumberPadding : 4;
-    const dateFormat = fieldConfig.autoNumberDateFormat || 'YYYYMM';
-    const resetCycle = fieldConfig.autoNumberResetCycle || 'monthly';
-
-    const now = new Date();
-    const yyyy = now.getFullYear();
-    const mm = now.getMonth() + 1;
-    const dd = now.getDate();
-
-    let numberRules = await db.findOne({ space: spaceId, name: ruleName });
-
-    if (!numberRules) {
-        // 首次使用该字段，自动创建规则记录
-        await db.insertOne({
-            space: spaceId,
-            name: ruleName,
-            year: yyyy,
-            month: mm,
-            day: dd,
-            first_number: 1,
-            number: 0,
-            rules: '' // 新类型字段不使用 rules 模板
-        });
-        numberRules = await db.findOne({ space: spaceId, name: ruleName });
-    }
-
-    let nextNumber = (numberRules.number || 0) + 1;
-
-    if (shouldResetNumber(resetCycle, numberRules, yyyy, mm, dd)) {
-        nextNumber = numberRules.first_number || 1;
-    }
-
-    const paddedNumber = padNumber(nextNumber, paddingLen);
-    const datePart = formatDatePart(dateFormat, yyyy, mm, dd);
-    const autoNumber = prefix + datePart + paddedNumber + suffix;
-
-    await db.updateOne(
-        { _id: numberRules._id },
-        { $set: { year: yyyy, month: mm, day: dd, number: nextNumber } }
-    );
-
-    return autoNumber;
+    return autoNumberManager.generateAutoNumberFromFieldConfig(spaceId, fieldConfig);
 };
 
 // 获取可编辑的自动编号字段
-const getEditableAutoNumberFields = async (step, formId, formVersion) => {
+const getEditableAutoNumberFields = async (step, formId, formVersion, spaceId) => {
     const permissions = step.permissions || {};
     const form = await UUFlowManager.getForm(formId);
     const formV = await UUFlowManager.getFormVersion(form, formVersion);
-    
-    const autoNumberFields = [];
-    const pushedFieldKeys = new Set();
-
-    const getFieldKey = (field) => field?.code || field?.name;
-    const isAutoNumberTypeField = (field) => {
-        const fieldType = (field?.type || '').toString().toLowerCase();
-        return fieldType === 'autonumber' || field?.type === 'autoNumber';
-    };
-    const canGenerateAutoNumber = (field) => {
-        const fieldKey = getFieldKey(field);
-        if (!fieldKey) return false;
-        const permission = permissions[fieldKey];
-        if (permission === 'editable') return true;
-        return false;
-    };
-    
-    // 检查字段是否是自动编号字段（通过 formula 判断）
-    const isAutoNumberField = (field) => {
-        if (!field) return false;
-        const hasLegacyAutoNumberFormula = field.default_value && typeof field.default_value === 'string' && field.default_value.trim().startsWith('auto_number(');
-        return hasLegacyAutoNumberFormula || isAutoNumberTypeField(field);
-    };
-    
-    // 从 formula 中提取自动编号规则名称
-    const extractAutoNumberName = (formula) => {
-        // 匹配 auto_number("xxx") 或 auto_number('xxx') 或 auto_number(xxx)
-        const match = formula.match(/auto_number\s*\(\s*['"]?([^'"()]+?)['"]?\s*\)/);
-        return match ? match[1].trim() : null;
-    };
-
-    const getAutoNumberRuleName = (field) => {
-        // 1) 兼容旧字段公式：default_value = auto_number(...)
-        if (field?.default_value && typeof field.default_value === 'string') {
-            const byFormula = extractAutoNumberName(field.default_value);
-            if (byFormula) return byFormula;
-        }
 
-        // 2) 兼容常见字段属性命名
-        const fromProps =
-            field?.auto_number_name ||
-            field?.autoNumberName ||
-            field?.auto_number_rule ||
-            field?.autoNumberRule ||
-            field?.auto_number_rule_name ||
-            field?.autoNumberRuleName;
-        if (fromProps && typeof fromProps === 'string') {
-            return fromProps.trim();
-        }
-
-        // 3) 对于新设计器 autoNumber 字段，默认回退到字段标识（code/name）
-        return getFieldKey(field);
-    };
-
-    const tryPushAutoNumberField = (field) => {
-        if (!isAutoNumberField(field) || !canGenerateAutoNumber(field)) {
-            return;
-        }
-        const fieldKey = getFieldKey(field);
-        const autoNumberName = getAutoNumberRuleName(field);
-        if (!fieldKey || !autoNumberName || pushedFieldKeys.has(fieldKey)) {
-            return;
-        }
-        pushedFieldKeys.add(fieldKey);
-
-        const fieldInfo = {
-            code: fieldKey,
-            auto_number_name: autoNumberName,
-        };
-
-        // 新设计器 autoNumber 字段，携带配置属性用于直接生成编号
-        if (isAutoNumberTypeField(field)) {
-            fieldInfo.isNewType = true;
-            fieldInfo.autoNumberPrefix = field.autoNumberPrefix;
-            fieldInfo.autoNumberSuffix = field.autoNumberSuffix;
-            fieldInfo.autoNumberPadding = field.autoNumberPadding;
-            fieldInfo.autoNumberDateFormat = field.autoNumberDateFormat;
-            fieldInfo.autoNumberResetCycle = field.autoNumberResetCycle;
-        }
-
-        autoNumberFields.push(fieldInfo);
-    };
-
-    for (const field of formV.fields || []) {
-        if (field.type === "section") {
-            // 处理 section 中的字段
-            for (const sectionField of field.fields || []) {
-                tryPushAutoNumberField(sectionField);
-            }
-        } else {
-            // 处理普通字段
-            tryPushAutoNumberField(field);
-        }
-    }
-    
-    return autoNumberFields;
+    return autoNumberManager.collectAutoNumberFields(formV.fields || [], permissions, {
+        spaceId,
+        formId,
+        formName: form.name,
+    });
 };
 
 router.post('/api/workflow/v2/auto_number', requireAuthentication, async function (req, res) {
@@ -319,7 +152,7 @@ router.post('/api/workflow/v2/auto_number', requireAuthentication, async functio
         }
 
         // 获取可编辑的自动编号字段
-        const autoNumberFields = await getEditableAutoNumberFields(step, instance.form, instance.form_version);
+        const autoNumberFields = await getEditableAutoNumberFields(step, instance.form, instance.form_version, instance.space);
         if (autoNumberFields.length === 0) {
             return res.status(200).send({
                 success: true,
@@ -379,4 +212,4 @@ router.post('/api/workflow/v2/auto_number', requireAuthentication, async functio
 });
 
 
-exports.default = router;
+exports.default = router;

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

@@ -40,6 +40,15 @@ const FlowversionAPI = {
         return str.replace(/\"/g, "&quot;").replace(/\n/g, "<br/>");
     },
 
+    getSafeEdgeLabel: function (str) {
+        // Mermaid edge label (A-->|text|B) 对部分符号（如括号/竖线）解析不稳定，先做保守清洗。
+        return FlowversionAPI.replaceErrorSymbol(String(str || ''))
+            .replace(/[|]/g, '｜')
+            .replace(/[()（）\[\]{}<>]/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+    },
+
     getStepHandlerName: async function (step, insId, instance) {
         const db = {
             users: await getCollection('users'),
@@ -113,12 +122,10 @@ const FlowversionAPI = {
 
     getStepLabel: function (stepName, stepHandlerName) {
         // 返回sstepName与stepHandlerName结合的步骤显示名称
+        // 注意：必须单行输出，避免 replaceErrorSymbol 把模板字符串的换行替换成 <br/> 撑高节点
         let nodeStr = "";
         if (stepName) {
-            nodeStr = `<div class='graph-node'>
-				<div class='step-name'>${stepName}</div>
-				<div class='step-handler-name'>${stepHandlerName}</div>
-			</div>`;
+            nodeStr = `<div class='graph-node'><div class='step-name'>${stepName}</div><div class='step-handler-name'>${stepHandlerName}</div></div>`;
             // 把特殊字符清空或替换，以避免mermaidAPI出现异常
             nodeStr = FlowversionAPI.replaceErrorSymbol(nodeStr);
         }
@@ -196,8 +203,12 @@ const FlowversionAPI = {
                     let toStep = steps.find(s => s._id === line.to_step);
                     let toStepName = await FlowversionAPI.getStepName(toStep, cachedStepNames, instance_id, instance);
                     if (step.step_type === "condition" && line.name) {
-                        let lineName = FlowversionAPI.replaceErrorSymbol(line.name);
-                        nodes.push(`	${step._id}("${stepName}")-->|${lineName}|${line.to_step}("${toStepName}")`);
+                        let lineName = FlowversionAPI.getSafeEdgeLabel(line.name);
+                        if (lineName) {
+                            nodes.push(`	${step._id}("${stepName}")-->|${lineName}|${line.to_step}("${toStepName}")`);
+                        } else {
+                            nodes.push(`	${step._id}("${stepName}")-->${line.to_step}("${toStepName}")`);
+                        }
                     } else {
                         nodes.push(`	${step._id}("${stepName}")-->${line.to_step}("${toStepName}")`);
                     }
@@ -294,12 +305,10 @@ const FlowversionAPI = {
 
     getTraceName: function (traceName, approveHandlerName) {
         // 返回trace节点名称
+        // 注意：必须单行输出，避免 replaceErrorSymbol 把模板字符串的换行替换成 <br/> 撑高节点
         let nodeStr = "";
         if (traceName) {
-            nodeStr = `<div class='graph-node'>
-				<div class='trace-name'>${traceName}</div>
-				<div class='trace-handler-name'>${approveHandlerName}</div>
-			</div>`;
+            nodeStr = `<div class='graph-node'><div class='trace-name'>${traceName}</div><div class='trace-handler-name'>${approveHandlerName}</div></div>`;
             nodeStr = FlowversionAPI.replaceErrorSymbol(nodeStr);
         }
         return nodeStr;
@@ -871,6 +880,12 @@ const FlowversionAPI = {
 						.graph-node {
 							padding: 4px 8px;
 						}
+						.node foreignObject > div {
+							height: 100% !important;
+							display: flex !important;
+							align-items: center;
+							justify-content: center;
+						}
 						.graph-node .step-name {
 							font-weight: 500;
 							margin-bottom: 2px;
@@ -1054,4 +1069,4 @@ router.get('/api/workflow/chart/traces', requireAuthentication, async function (
 router.get('/api/workflow/chart/traces_expand', requireAuthentication, async function (req, res) {
     await FlowversionAPI.sendHtmlResponse(req, res, "traces_expand");
 });
-exports.default = router;
+exports.default = router;

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

@@ -113,7 +113,8 @@ router.get('/api/workflow/export/instances', requireAuthentication, async functi
         const str = fs.readFileSync(path.resolve(__dirname, '../server/ejs/export_instances.ejs'), 'utf8');
         const template = ejs.compile(str);
         let lang = 'en';
-        if (userSession.locale === 'zh-cn') {
+        const locale = String(userSession.locale || userSession.language || '').toLowerCase().replace('_', '-');
+        if (locale.startsWith('zh')) {
             lang = 'zh-CN';
         }
         const utcOffset = timezoneoffset / -60;

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

@@ -192,7 +192,7 @@ router.post("/api/workflow/v2/instance/forward", requireAuthentication, async fu
 
         // Process fields
         for (const field of fields) {
-            const exists_field = _.find(old_fields, f => f.type == field.type && f.code == field.code);
+            const exists_field = _.find(old_fields, f => f.code == field.code);
             if (exists_field) common_fields.push(field);
 
             const select_input_field = _.find(old_fields, f => 
@@ -241,6 +241,10 @@ router.post("/api/workflow/v2/instance/forward", requireAuthentication, async fu
                                 old_v = new_multiSelected.join(",");
                             }
 
+                            if (f.type == "lookup" && _.isObject(old_v) && old_v._id) {
+                                old_v = old_v._id;
+                            }
+
                             new_values[key] = old_v;
                         }
                     }
@@ -281,6 +285,10 @@ router.post("/api/workflow/v2/instance/forward", requireAuthentication, async fu
                                         old_v = new_multiSelected.join(",");
                                     }
 
+                                    if (f.type == "lookup" && _.isObject(old_v) && old_v._id) {
+                                        old_v = old_v._id;
+                                    }
+
                                     new_table_row_values[key] = old_v;
                                 }
                             }
@@ -324,6 +332,10 @@ router.post("/api/workflow/v2/instance/forward", requireAuthentication, async fu
                         old_v = new_multiSelected.join(",");
                     }
 
+                    if (field.type == "lookup" && _.isObject(old_v) && old_v._id) {
+                        old_v = old_v._id;
+                    }
+
                     new_values[key] = old_v;
                 }
             }

package/main/default/routes/buildFormDesignSystemPrompt.js

@@ -208,13 +208,14 @@ function buildFormDesignSystemPrompt({ chineseFieldNames = false, isUpgrade = fa
 
 - autoNumber 类型（自动编号）：
   - 自动编号字段始终为只读（readonly: true），运行时由系统自动生成唯一编号
+  - auto_number_name: 字符串，可选，编号规则名称；留空时系统按表单和字段自动生成
   - 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" }
+  - 示例：{ "type": "autoNumber", "label": "合同编号", "name": "contract_no", "readonly": true, "auto_number_name": "合同编号", "autoNumberPrefix": "HT-", "autoNumberDateFormat": "YYYYMM", "autoNumberPadding": 4, "autoNumberResetCycle": "monthly" }
 
 - 动态显隐条件（任何字段都可设置）：${chineseFieldNames ? `
   - visibilityExpression: 字符串，条件表达式，控制字段显示/隐藏。当表达式结果为 true 时字段可见，否则隐藏。
@@ -438,11 +439,11 @@ ${formulaRule}
 - 迁移规则：
   - 遇到字段的 default_value 包含 \`auto_number(...)\` 时，将该字段的 type 改为 "autoNumber"，设置 readonly: true
   - 删除原有的 default_value 属性
-  - 如果旧版编号规则名称中能推断出前缀、日期格式等信息，相应设置 autoNumberPrefix、autoNumberDateFormat 等属性；否则使用默认值
+  - 如果旧版编号规则名称中能推断出前缀、日期格式等信息，相应设置 auto_number_name、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" }
+  新版字段：{ "name": "contract_no", "label": "合同编号", "type": "autoNumber", "readonly": true, "auto_number_name": "contract_no", "autoNumberPrefix": "", "autoNumberPadding": 4, "autoNumberDateFormat": "YYYYMM", "autoNumberResetCycle": "monthly" }
 - migrationLog 记录格式："字段 <name>: default_value auto_number(...) 转换为 autoNumber 类型"
 
 ### 旧版 HTML 字段类型迁移

package/main/default/server/ejs/export_instances.ejs

@@ -7,6 +7,14 @@
 
 	<Worksheet ss:Name="<%= form_name %>" >
 		<Table>
+			<%
+				var getFieldDisplayName = function(field) {
+					if (!field) {
+						return '';
+					}
+					return field.label || field.title || field.name || field.code || '';
+				};
+			%>
 			<!-- 编号 -->
 			<Column ss:Width="35"/>
 			<!-- 名称 -->
@@ -52,13 +60,13 @@
 				<Cell><Data ss:Type="String"><%= t('export.current_step_start_date',{},lang) %></Data></Cell>
 				<% _.each(fields, function(field) { %>
 					<% if (field.type != "table" && field.type != "section") { %>
-						<Cell><Data ss:Type="String"><%= field.name ? field.name : field.code %></Data></Cell>
+						<Cell><Data ss:Type="String"><%= getFieldDisplayName(field) %></Data></Cell>
 					<% } %>
 
 					<% if (field.type == "section" && field.fields) {
 						_.each(field.fields, function(sec) {
 					%>
-							<Cell><Data ss:Type="String"><%= sec.name ? sec.name : sec.code %></Data></Cell>
+							<Cell><Data ss:Type="String"><%= getFieldDisplayName(sec) %></Data></Cell>
 						<% }) %>
 					<% } %>
 				<% }) %>
@@ -259,7 +267,7 @@
 	</Worksheet>
 
 	<% _.each(table_fields, function(table_field) { %>
-		<Worksheet ss:Name="<%= table_field.name ? table_field.name : table_field.code %>" >
+		<Worksheet ss:Name="<%= getFieldDisplayName(table_field) %>" >
 			<Table>
 				<!-- 编号 -->
 				<Column ss:Width="35"/>
@@ -296,7 +304,7 @@
 					<Cell><Data ss:Type="String"><%= t('export.current_step_name',{},lang) %></Data></Cell>
 					<Cell><Data ss:Type="String"><%= t('export.current_step_start_date',{},lang) %></Data></Cell>
 					<% _.each(table_field.fields, function(field) { %>
-								<Cell><Data ss:Type="String"><%= field.name ? field.name : field.code %></Data></Cell>
+							<Cell><Data ss:Type="String"><%= getFieldDisplayName(field) %></Data></Cell>
 					<% }) %>
 				</Row>
 				<% _.each(ins_to_xls, function(ins) { %>

package/main/default/test/test_getApproveValues.js

@@ -0,0 +1,221 @@
+/**
+ * 回归测试：UUFlowManager.getApproveValues 对公式子字段的兜底识别。
+ *
+ * 背景：
+ *  - issue: 子表保存后刷新，公式子字段计算结果丢失（线上现象）
+ *  - PR #781 在过滤规则中加 `c.formula ||` 放权
+ *  - 但部分历史表单设计器保存时丢失了字段的 `formula` 属性，
+ *    公式表达式被转存到 `default_value`，形如 "${...}"
+ *  - 因此除了 `c.formula` 之外，还需把 `default_value` 形如 "${...}" 的字段视为公式字段
+ *
+ * 用法：
+ *   node main/default/test/test_getApproveValues.js
+ *   或 yarn workspace @steedos-labs/plugin-workflow test:approve-values
+ */
+
+const assert = require('assert');
+
+// 注意：require uuflow_manager.js 会顺带加载 @steedos/objectql 等运行时依赖；
+// 本机已验证可独立加载，无需启动完整 server。
+const UUFlowManager = require('../manager/uuflow_manager.js');
+
+// Monkey-patch DB 读取函数，注入测试用 form schema
+const fakeForms = {};
+UUFlowManager.getForm = async function (form_id) {
+    if (!fakeForms[form_id]) throw new Error(`fake form not found: ${form_id}`);
+    return fakeForms[form_id];
+};
+UUFlowManager.getFormVersion = function (form, form_version) {
+    if (form.current && form.current._id === form_version) return form.current;
+    const h = (form.historys || []).find(f => f._id === form_version);
+    if (!h) throw new Error(`fake form version not found: ${form_version}`);
+    return h;
+};
+
+let passed = 0;
+let failed = 0;
+
+async function run(name, fn) {
+    try {
+        await fn();
+        console.log(`  ✓ ${name}`);
+        passed++;
+    } catch (e) {
+        console.log(`  ✗ ${name}`);
+        console.log(`    ${e.message}`);
+        if (e.actual !== undefined) {
+            console.log(`    actual:   ${JSON.stringify(e.actual)}`);
+            console.log(`    expected: ${JSON.stringify(e.expected)}`);
+        }
+        failed++;
+    }
+}
+
+(async () => {
+    console.log('UUFlowManager.getApproveValues 公式子字段兜底识别');
+
+    // 通用：父表 readonly，前两个子字段 editable，第三个（公式）无显式权限
+    const permissions = {
+        '表格': 'readable',
+        '加油量': 'editable',
+        '单价': 'editable',
+        '金额': 'readable',
+    };
+
+    const submittedRow = {
+        _id: 'row1',
+        '加油量': '10',
+        '单价': '8',
+        '金额': '80', // 客户端计算出的公式值
+    };
+
+    await run('公式子字段带 formula 属性（本地新版 schema）→ 保留金额', async () => {
+        fakeForms['F1'] = {
+            current: {
+                _id: 'V1',
+                fields: [{
+                    type: 'table',
+                    code: '表格',
+                    fields: [
+                        { type: 'number', code: '加油量' },
+                        { type: 'number', code: '单价' },
+                        { type: 'number', code: '金额', formula: '{加油量}*{单价}' },
+                    ],
+                }],
+            },
+        };
+        const approve_values = { '表格': [Object.assign({}, submittedRow)] };
+        const out = await UUFlowManager.getApproveValues(approve_values, permissions, 'F1', 'V1');
+        assert.deepStrictEqual(out['表格'][0], submittedRow);
+    });
+
+    await run('公式子字段无 formula、default_value 为 ${...}（线上老 schema）→ 保留金额', async () => {
+        fakeForms['F2'] = {
+            current: {
+                _id: 'V2',
+                fields: [{
+                    type: 'table',
+                    code: '表格',
+                    fields: [
+                        { type: 'number', code: '加油量', default_value: '0.00' },
+                        { type: 'number', code: '单价', default_value: '0.00' },
+                        { type: 'number', code: '金额', default_value: '${加油量*单价}' },
+                    ],
+                }],
+            },
+        };
+        const approve_values = { '表格': [Object.assign({}, submittedRow)] };
+        const out = await UUFlowManager.getApproveValues(approve_values, permissions, 'F2', 'V2');
+        assert.deepStrictEqual(out['表格'][0], submittedRow,
+            '老 schema 公式子字段应被识别保留，否则保存后刷新公式值会丢失');
+    });
+
+    await run('普通子字段 default_value 是纯字符串 → 不当作公式，无 editable 权限则删除', async () => {
+        fakeForms['F3'] = {
+            current: {
+                _id: 'V3',
+                fields: [{
+                    type: 'table',
+                    code: '表格',
+                    fields: [
+                        { type: 'text', code: '加油量' },
+                        { type: 'text', code: '单价' },
+                        { type: 'text', code: '备注', default_value: '默认备注' },
+                    ],
+                }],
+            },
+        };
+        const perms = { '表格': 'readable', '加油量': 'editable', '单价': 'editable', '备注': 'readable' };
+        const row = { _id: 'r', '加油量': '1', '单价': '2', '备注': '客户端写入' };
+        const approve_values = { '表格': [Object.assign({}, row)] };
+        const out = await UUFlowManager.getApproveValues(approve_values, perms, 'F3', 'V3');
+        assert.strictEqual(out['表格'][0]['备注'], undefined, '普通字段不应被当作公式保留');
+        assert.strictEqual(out['表格'][0]['加油量'], '1');
+    });
+
+    await run('default_value 形如 "${"... 但未完整闭合 → 不当作公式', async () => {
+        fakeForms['F4'] = {
+            current: {
+                _id: 'V4',
+                fields: [{
+                    type: 'table',
+                    code: '表格',
+                    fields: [
+                        { type: 'text', code: '加油量' },
+                        { type: 'text', code: '怪字段', default_value: '${unclosed' },
+                    ],
+                }],
+            },
+        };
+        const perms = { '表格': 'readable', '加油量': 'editable', '怪字段': 'readable' };
+        const row = { _id: 'r', '加油量': '1', '怪字段': 'x' };
+        const approve_values = { '表格': [Object.assign({}, row)] };
+        const out = await UUFlowManager.getApproveValues(approve_values, perms, 'F4', 'V4');
+        assert.strictEqual(out['表格'][0]['怪字段'], undefined);
+    });
+
+    await run('顶层公式字段无 formula、default_value=${...} → 保留', async () => {
+        fakeForms['F5'] = {
+            current: {
+                _id: 'V5',
+                fields: [
+                    { type: 'number', code: '数量' },
+                    { type: 'number', code: '小计', default_value: '${数量*10}' },
+                ],
+            },
+        };
+        const perms = { '数量': 'editable', '小计': 'readable' };
+        const approve_values = { '数量': '5', '小计': '50' };
+        const out = await UUFlowManager.getApproveValues(approve_values, perms, 'F5', 'V5');
+        assert.strictEqual(out['小计'], '50', '顶层公式字段应同样被兜底识别');
+    });
+
+    await run('section 内公式子字段无 formula、default_value=${...} → 保留', async () => {
+        fakeForms['F6'] = {
+            current: {
+                _id: 'V6',
+                fields: [{
+                    type: 'section',
+                    code: 'section1',
+                    fields: [
+                        { type: 'number', code: '数量' },
+                        { type: 'number', code: '小计', default_value: '${数量*10}' },
+                    ],
+                }],
+            },
+        };
+        const perms = { '数量': 'editable', '小计': 'readable' };
+        const approve_values = { '数量': '5', '小计': '50' };
+        const out = await UUFlowManager.getApproveValues(approve_values, perms, 'F6', 'V6');
+        assert.strictEqual(out['小计'], '50', 'section 内公式字段应同样被兜底识别');
+    });
+
+    await run('permissions 为 null → 直接返回 {}', async () => {
+        const out = await UUFlowManager.getApproveValues({ x: 1 }, null, 'F1', 'V1');
+        assert.deepStrictEqual(out, {});
+    });
+
+    await run('historys 版本中的老 schema 同样生效', async () => {
+        fakeForms['F7'] = {
+            current: { _id: 'V7_NEW', fields: [] },
+            historys: [{
+                _id: 'V7_OLD',
+                fields: [{
+                    type: 'table',
+                    code: '表格',
+                    fields: [
+                        { type: 'number', code: '加油量', default_value: '0.00' },
+                        { type: 'number', code: '单价', default_value: '0.00' },
+                        { type: 'number', code: '金额', default_value: '${加油量*单价}' },
+                    ],
+                }],
+            }],
+        };
+        const approve_values = { '表格': [Object.assign({}, submittedRow)] };
+        const out = await UUFlowManager.getApproveValues(approve_values, permissions, 'F7', 'V7_OLD');
+        assert.deepStrictEqual(out['表格'][0], submittedRow);
+    });
+
+    console.log(`\n${passed} passed, ${failed} failed`);
+    process.exit(failed === 0 ? 0 : 1);
+})();