digitalsee-ai-flow-cli 0.1.6 → 0.1.8

package/dist/utils/format.js

@@ -7,6 +7,7 @@ exports.fillConfigSchemaDefaults = fillConfigSchemaDefaults;
 exports.parseVariableRefs = parseVariableRefs;
 exports.mergeConfigValues = mergeConfigValues;
 exports.validateNodePropertyValues = validateNodePropertyValues;
+exports.validateSpecialNodeType = validateSpecialNodeType;
 exports.deepMerge = deepMerge;
 function configSchemaToParams(subParams) {
     if (!subParams || !Array.isArray(subParams))
@@ -15,25 +16,25 @@ function configSchemaToParams(subParams) {
         name: p.name,
         type: inferFieldType(p),
         required: p.required ?? false,
-        description: sanitizeDescription(p.description || ""),
+        description: sanitizeDescription(p.description || ''),
         display_name: p.display_name || p.name,
         options: normalizeOptionValues(p.option_value_objects ?? p.option_values),
         default: p.value,
     }));
 }
 function sanitizeDescription(desc) {
-    return desc.replace(/\u0000/g, "\\u0000");
+    return desc.replace(/\u0000/g, '\\u0000');
 }
 function normalizeOptionValues(raw) {
     if (!raw || !Array.isArray(raw) || raw.length === 0)
         return undefined;
     return raw
         .map((item) => {
-        if (typeof item === "string") {
+        if (typeof item === 'string') {
             const v = item.trim();
             return v ? { key: v, label: v } : null;
         }
-        const value = String(item?.value ?? item?.label ?? "").trim();
+        const value = String(item?.value ?? item?.label ?? '').trim();
         if (!value)
             return null;
         const label = String(item?.label ?? value).trim() || value;
@@ -48,77 +49,79 @@ function inferFieldType(param) {
     if (param.type) {
         return param.type;
     }
-    return "string";
+    return 'string';
 }
 function inferScenarios(actionName, description) {
     const scenarios = [];
-    const text = `${actionName} ${description || ""}`.toLowerCase();
-    if (text.includes("trigger") || text.includes("webhook")) {
-        scenarios.push("作为流程触发器，在外部事件发生时启动工作流");
+    const text = `${actionName} ${description || ''}`.toLowerCase();
+    if (text.includes('trigger') || text.includes('webhook')) {
+        scenarios.push('作为流程触发器，在外部事件发生时启动工作流');
     }
-    if (text.includes("http") || text.includes("api") || text.includes("rest")) {
-        scenarios.push("调用外部 HTTP API 接口，实现系统间的数据交互");
+    if (text.includes('http') || text.includes('api') || text.includes('rest')) {
+        scenarios.push('调用外部 HTTP API 接口，实现系统间的数据交互');
     }
-    if (text.includes("database") ||
-        text.includes("sql") ||
-        text.includes("mysql") ||
-        text.includes("postgres") ||
-        text.includes("数据")) {
-        scenarios.push("连接数据库，执行数据查询或写入操作");
+    if (text.includes('database') ||
+        text.includes('sql') ||
+        text.includes('mysql') ||
+        text.includes('postgres') ||
+        text.includes('数据')) {
+        scenarios.push('连接数据库，执行数据查询或写入操作');
     }
-    if (text.includes("email") || text.includes("mail") || text.includes("邮件")) {
-        scenarios.push("发送或接收邮件通知");
+    if (text.includes('email') || text.includes('mail') || text.includes('邮件')) {
+        scenarios.push('发送或接收邮件通知');
     }
-    if (text.includes("ai") || text.includes("llm") || text.includes("model")) {
-        scenarios.push("调用 AI 大模型进行文本生成、分析或推理");
+    if (text.includes('ai') || text.includes('llm') || text.includes('model')) {
+        scenarios.push('调用 AI 大模型进行文本生成、分析或推理');
     }
-    if (text.includes("condition") || text.includes("条件")) {
-        scenarios.push("根据条件判断结果进行流程分支控制");
+    if (text.includes('condition') || text.includes('条件')) {
+        scenarios.push('根据条件判断结果进行流程分支控制');
     }
-    if (text.includes("loop") || text.includes("循环")) {
-        scenarios.push("对数据集进行批量循环处理");
+    if (text.includes('loop') || text.includes('循环')) {
+        scenarios.push('对数据集进行批量循环处理');
     }
-    if (text.includes("transform") || text.includes("转换") || text.includes("map")) {
-        scenarios.push("对数据进行格式转换或映射处理");
+    if (text.includes('transform') || text.includes('转换') || text.includes('map')) {
+        scenarios.push('对数据进行格式转换或映射处理');
     }
-    if (text.includes("notification") || text.includes("通知") || text.includes("message")) {
-        scenarios.push("发送消息通知或告警");
+    if (text.includes('notification') || text.includes('通知') || text.includes('message')) {
+        scenarios.push('发送消息通知或告警');
     }
     if (scenarios.length === 0) {
-        scenarios.push("执行自定义业务逻辑操作");
+        scenarios.push('执行自定义业务逻辑操作');
     }
     return scenarios;
 }
 function sanitizeFileName(name) {
     return name
-        .replace(/[<>:"/\\|?*]/g, "_")
-        .replace(/\s+/g, "_")
-        .replace(/^\.+/, "")
+        .replace(/[<>:"/\\|?*]/g, '_')
+        .replace(/\s+/g, '_')
+        .replace(/^\.+/, '')
         .substring(0, 200);
 }
 function fillConfigSchemaDefaults(schema) {
     const clone = JSON.parse(JSON.stringify(schema));
     function walk(node) {
-        if (!node || typeof node !== "object")
+        if (!node || typeof node !== 'object')
             return;
-        if (node.sub_params && Array.isArray(node.sub_params)) {
-            for (const child of node.sub_params) {
-                if (child.value === undefined || child.value === null) {
-                    child.value = inferDefaultValue(child);
+        const n = node;
+        if (n.sub_params && Array.isArray(n.sub_params)) {
+            for (const child of n.sub_params) {
+                const c = child;
+                if (c.value === undefined || c.value === null) {
+                    c.value = inferDefaultValue(c);
                 }
-                child.update = true;
-                walk(child);
+                c.update = true;
+                walk(c);
             }
         }
-        if (node.value === undefined || node.value === null) {
-            if (node.sub_params) {
-                node.value = null;
+        if (n.value === undefined || n.value === null) {
+            if (n.sub_params) {
+                n.value = null;
             }
             else {
-                node.value = inferDefaultValue(node);
+                n.value = inferDefaultValue(n);
             }
         }
-        node.update = true;
+        n.update = true;
     }
     walk(clone);
     return clone;
@@ -126,43 +129,43 @@ function fillConfigSchemaDefaults(schema) {
 function inferDefaultValue(param) {
     if (param.value !== undefined && param.value !== null)
         return param.value;
-    const type = (param.page_control || param.type || "").toUpperCase();
-    if (type === "SELECT") {
+    const type = (param.page_control || param.type || '').toUpperCase();
+    if (type === 'SELECT') {
         if (param.multi_valued)
             return [];
         const options = param.option_value_objects ?? param.option_values;
         if (options && Array.isArray(options) && options.length > 0) {
             const first = options[0];
-            if (typeof first === "string")
+            if (typeof first === 'string')
                 return first;
-            if (typeof first === "object" && first !== null) {
-                return first.value ?? first.label ?? "";
+            if (typeof first === 'object' && first !== null) {
+                return first.value ?? first.label ?? '';
             }
         }
         return null;
     }
     switch (type) {
-        case "NUMBER":
+        case 'NUMBER':
             return 0;
-        case "BOOLEAN":
-        case "SWITCH":
+        case 'BOOLEAN':
+        case 'SWITCH':
             return false;
-        case "DATE":
-        case "TIME":
-        case "DATETIME":
+        case 'DATE':
+        case 'TIME':
+        case 'DATETIME':
             return null;
-        case "JSON":
-            return "{}";
-        case "EXTEND_OBJ":
-        case "FIXED_OBJ":
+        case 'JSON':
+            return '{}';
+        case 'EXTEND_OBJ':
+        case 'FIXED_OBJ':
             return param.sub_params ? null : {};
-        case "TEXTAREA":
-        case "PASSWORD":
-        case "HIDDEN":
-        case "LABEL":
-        case "TEXT":
+        case 'TEXTAREA':
+        case 'PASSWORD':
+        case 'HIDDEN':
+        case 'LABEL':
+        case 'TEXT':
         default:
-            return "";
+            return '';
     }
 }
 function parseVariableRefs(text) {
@@ -173,7 +176,7 @@ function parseVariableRefs(text) {
         refs.push({
             raw: match[0],
             nodeId: match[1],
-            path: match[2] || "",
+            path: match[2] || '',
         });
     }
     return refs;
@@ -181,12 +184,14 @@ function parseVariableRefs(text) {
 function mergeConfigValues(schema, overrides) {
     const clone = JSON.parse(JSON.stringify(schema));
     function walk(node, overrideMap) {
-        if (!node?.sub_params)
+        const n = node;
+        if (!n.sub_params)
             return;
-        for (const child of node.sub_params) {
-            if (child.name && child.name in overrideMap) {
-                const val = overrideMap[child.name];
-                if (child.sub_params && typeof val === "object" && !Array.isArray(val)) {
+        for (const child of n.sub_params) {
+            const childName = child.name;
+            if (childName && childName in overrideMap) {
+                const val = overrideMap[childName];
+                if (child.sub_params && typeof val === 'object' && !Array.isArray(val)) {
                     walk(child, val);
                 }
                 else {
@@ -207,29 +212,30 @@ function mergeConfigValues(schema, overrides) {
 function validateNodePropertyValues(schema) {
     const errors = [];
     function walk(node, path) {
-        if (!node || typeof node !== "object")
+        if (!node || typeof node !== 'object')
             return;
-        if (node.sub_params && Array.isArray(node.sub_params)) {
-            for (const child of node.sub_params) {
-                const childPath = path
-                    ? `${path}.${child.name || "(anonymous)"}`
-                    : (child.name || "(anonymous)");
-                checkField(child, childPath);
-                walk(child, childPath);
+        const n = node;
+        if (n.sub_params && Array.isArray(n.sub_params)) {
+            for (const child of n.sub_params) {
+                const c = child;
+                const cName = String(c.name || '(anonymous)');
+                const childPath = path ? `${path}.${cName}` : cName;
+                checkField(c, childPath);
+                walk(c, childPath);
             }
         }
     }
     function checkField(field, fieldPath) {
         const val = field.value;
-        const pageControl = (field.page_control || field.type || "").toUpperCase();
-        const isEmpty = val === undefined || val === null || val === "";
+        const pageControl = String(field.page_control || field.type || '').toUpperCase();
+        const isEmpty = val === undefined || val === null || val === '';
         // 1. 检查必填字段
         if (field.required && isEmpty) {
             errors.push({
                 field: fieldPath,
-                rule: "required",
+                rule: 'required',
                 message: `必填字段 "${field.display_name} : ${field.name}" 未提供值`,
-                sample: "",
+                sample: '',
             });
         }
         // 2. 如果有值，检查值类型是否匹配 page_control
@@ -240,65 +246,65 @@ function validateNodePropertyValues(schema) {
     function checkTypeConstraint(field, fieldPath, pageControl, val) {
         const sample = JSON.stringify(val).substring(0, 80);
         switch (pageControl) {
-            case "SELECT":
+            case 'SELECT':
                 if (field.multi_valued) {
                     if (!Array.isArray(val)) {
                         errors.push({
                             field: fieldPath,
-                            rule: "type",
+                            rule: 'type',
                             message: `SELECT(multi) 字段 "${field.display_name || field.name}" 期望 array 类型，实际为 ${typeof val}`,
                             sample,
                         });
                     }
                 }
                 else {
-                    if (typeof val !== "string") {
+                    if (typeof val !== 'string') {
                         errors.push({
                             field: fieldPath,
-                            rule: "type",
+                            rule: 'type',
                             message: `SELECT 字段 "${field.display_name || field.name}" 期望 string 类型，实际为 ${typeof val}`,
                             sample,
                         });
                     }
                 }
                 break;
-            case "NUMBER":
-                if (typeof val !== "number") {
+            case 'NUMBER':
+                if (typeof val !== 'number') {
                     errors.push({
                         field: fieldPath,
-                        rule: "type",
+                        rule: 'type',
                         message: `NUMBER 字段 "${field.display_name || field.name}" 期望 number 类型，实际为 ${typeof val}`,
                         sample,
                     });
                 }
                 break;
-            case "BOOLEAN":
-            case "SWITCH":
-                if (typeof val !== "boolean") {
+            case 'BOOLEAN':
+            case 'SWITCH':
+                if (typeof val !== 'boolean') {
                     errors.push({
                         field: fieldPath,
-                        rule: "type",
+                        rule: 'type',
                         message: `${pageControl} 字段 "${field.display_name || field.name}" 期望 boolean 类型，实际为 ${typeof val}`,
                         sample,
                     });
                 }
                 break;
-            case "EXTEND_OBJ":
-            case "FIXED_OBJ":
-                if (typeof val !== "object" || Array.isArray(val)) {
+            case 'EXTEND_OBJ':
+            case 'FIXED_OBJ':
+                if (typeof val !== 'object' || Array.isArray(val)) {
                     errors.push({
                         field: fieldPath,
-                        rule: "type",
-                        message: `${pageControl} 字段 "${field.display_name || field.name}" 期望 object 类型，实际为 ${Array.isArray(val) ? "array" : typeof val}`,
+                        rule: 'type',
+                        message: `${pageControl} 字段 "${field.display_name || field.name}" 期望 object 类型，实际为 ${Array.isArray(val) ? 'array' : typeof val}`,
                         sample,
                     });
                 }
                 break;
-            case "JSON":
-                if (typeof val !== "string") {
+            case 'JSON':
+                if (typeof val !== 'string') {
                     errors.push({
                         field: fieldPath,
-                        rule: "type",
+                        rule: 'type',
                         message: `JSON 字段 "${field.display_name || field.name}" 期望 JSON 字符串，实际为 ${typeof val}`,
                         sample,
                     });
@@ -310,34 +316,34 @@ function validateNodePropertyValues(schema) {
                     catch {
                         errors.push({
                             field: fieldPath,
-                            rule: "format",
+                            rule: 'format',
                             message: `JSON 字段 "${field.display_name || field.name}" 的值不是有效的 JSON`,
                             sample: val.substring(0, 80),
                         });
                     }
                 }
                 break;
-            case "DATE":
-            case "TIME":
-            case "DATETIME":
-                if (typeof val !== "string") {
+            case 'DATE':
+            case 'TIME':
+            case 'DATETIME':
+                if (typeof val !== 'string') {
                     errors.push({
                         field: fieldPath,
-                        rule: "type",
+                        rule: 'type',
                         message: `${pageControl} 字段 "${field.display_name || field.name}" 期望日期/时间字符串，实际为 ${typeof val}`,
                         sample,
                     });
                 }
                 break;
-            case "TEXT":
-            case "TEXTAREA":
-            case "PASSWORD":
-            case "HIDDEN":
-            case "LABEL":
-                if (typeof val !== "string") {
+            case 'TEXT':
+            case 'TEXTAREA':
+            case 'PASSWORD':
+            case 'HIDDEN':
+            case 'LABEL':
+                if (typeof val !== 'string') {
                     errors.push({
                         field: fieldPath,
-                        rule: "type",
+                        rule: 'type',
                         message: `${pageControl} 字段 "${field.display_name || field.name}" 期望 string 类型，实际为 ${typeof val}`,
                         sample,
                     });
@@ -347,23 +353,338 @@ function validateNodePropertyValues(schema) {
                 break;
         }
     }
-    walk(schema, "");
+    walk(schema, '');
+    return errors;
+}
+const VALID_CONDITION_OPERATORS = new Set([
+    'eq',
+    'ne',
+    'gt',
+    'ge',
+    'lt',
+    'le',
+    'sw',
+    'ew',
+    'co',
+    'nco',
+    'in',
+    'nin',
+    'is_null',
+    'is_not_null',
+]);
+const NULL_OPERATORS = new Set(['is_null', 'is_not_null']);
+const LOOP_TYPES = new Set(['NUMBER', 'ARRAY', 'CONDITION']);
+const ERROR_EXEC_OPTIONS = new Set(['END', 'CONTINUE', 'BREAK']);
+const SPECIAL_NODE_TYPES = new Set(['ConditionNode', 'LoopNode', 'SelfLoopNode', 'SwitchNode']);
+function safeSample(val) {
+    return (JSON.stringify(val) ?? '').substring(0, 80);
+}
+function validateOrList(orList, path) {
+    const errors = [];
+    if (!Array.isArray(orList)) {
+        errors.push({
+            field: path,
+            rule: 'type',
+            message: `${path} 必须是 array 类型`,
+            sample: safeSample(orList),
+        });
+        return errors;
+    }
+    if (orList.length === 0) {
+        errors.push({
+            field: path,
+            rule: 'required',
+            message: `${path} 至少需要 1 个条件组`,
+            sample: '',
+        });
+        return errors;
+    }
+    orList.forEach((orItem, i) => {
+        const orPath = `${path}[${i}]`;
+        if (!orItem || typeof orItem !== 'object') {
+            errors.push({
+                field: orPath,
+                rule: 'type',
+                message: `${orPath} 必须是 object 类型`,
+                sample: safeSample(orItem),
+            });
+            return;
+        }
+        const andList = orItem.and_list;
+        if (!Array.isArray(andList)) {
+            errors.push({
+                field: `${orPath}.and_list`,
+                rule: 'type',
+                message: `${orPath}.and_list 必须是 array 类型`,
+                sample: safeSample(andList),
+            });
+            return;
+        }
+        if (andList.length === 0) {
+            errors.push({
+                field: `${orPath}.and_list`,
+                rule: 'required',
+                message: `${orPath}.and_list 至少需要 1 个条件`,
+                sample: '',
+            });
+            return;
+        }
+        andList.forEach((item, j) => {
+            const itemPath = `${orPath}.and_list[${j}]`;
+            if (!item || typeof item !== 'object') {
+                errors.push({
+                    field: itemPath,
+                    rule: 'type',
+                    message: `${itemPath} 必须是 object 类型`,
+                    sample: safeSample(item),
+                });
+                return;
+            }
+            if (!item.query || typeof item.query !== 'string' || !item.query.trim()) {
+                errors.push({
+                    field: `${itemPath}.query`,
+                    rule: 'required',
+                    message: `${itemPath}.query 是必填字段，须为变量引用`,
+                    sample: '',
+                });
+            }
+            if (!item.operator || typeof item.operator !== 'string') {
+                errors.push({
+                    field: `${itemPath}.operator`,
+                    rule: 'required',
+                    message: `${itemPath}.operator 是必填字段`,
+                    sample: '',
+                });
+            }
+            else if (!VALID_CONDITION_OPERATORS.has(item.operator)) {
+                errors.push({
+                    field: `${itemPath}.operator`,
+                    rule: 'type',
+                    message: `${itemPath}.operator 无效: "${item.operator}"，有效值: ${[...VALID_CONDITION_OPERATORS].join(', ')}`,
+                    sample: item.operator,
+                });
+            }
+            if (item.operator &&
+                !NULL_OPERATORS.has(item.operator) &&
+                (item.value === undefined || item.value === null)) {
+                errors.push({
+                    field: `${itemPath}.value`,
+                    rule: 'required',
+                    message: `${itemPath}.value 在运算符为 "${item.operator}" 时必须提供`,
+                    sample: '',
+                });
+            }
+        });
+    });
+    return errors;
+}
+/**
+ * 校验特殊节点类型（ConditionNode / LoopNode / SelfLoopNode / SwitchNode）的业务字段。
+ * 这些字段位于 data.properties 下，与 sub_params 同级。普通 ActionNode 直接返回空数组。
+ */
+function validateSpecialNodeType(nodeType, data) {
+    if (!SPECIAL_NODE_TYPES.has(nodeType))
+        return [];
+    const props = data.properties || {};
+    const errors = [];
+    switch (nodeType) {
+        case 'ConditionNode': {
+            if (props.or_list === undefined || props.or_list === null) {
+                errors.push({
+                    field: 'properties.or_list',
+                    rule: 'required',
+                    message: 'ConditionNode 缺少必填字段 properties.or_list',
+                    sample: '',
+                });
+            }
+            else {
+                errors.push(...validateOrList(props.or_list, 'properties.or_list'));
+            }
+            break;
+        }
+        case 'LoopNode':
+        case 'SelfLoopNode': {
+            // LoopNode 字段在 properties 下双份存在：直接属性 + sub_params[].value
+            // CLI --data 只填充 sub_params，API 返回时两者都有，需要从两处查找
+            const loopField = (name) => {
+                if (props[name] !== undefined && props[name] !== null)
+                    return props[name];
+                const subParams = props.sub_params;
+                if (Array.isArray(subParams)) {
+                    const entry = subParams.find((s) => s.name === name);
+                    if (entry && entry.value !== undefined && entry.value !== null)
+                        return entry.value;
+                }
+                return undefined;
+            };
+            const loopType = loopField('type');
+            if (!loopType || !LOOP_TYPES.has(loopType)) {
+                errors.push({
+                    field: 'properties.type',
+                    rule: 'required',
+                    message: `循环节点 properties.type 必须是 NUMBER / ARRAY / CONDITION 之一，当前为 "${loopType}"`,
+                    sample: loopType || '',
+                });
+            }
+            if (loopType === 'NUMBER') {
+                const startVal = loopField('start');
+                const endVal = loopField('end');
+                if (typeof startVal !== 'number') {
+                    errors.push({
+                        field: 'properties.start',
+                        rule: 'type',
+                        message: `NUMBER 循环的 properties.start 必须是 number 类型，当前为 ${typeof startVal}`,
+                        sample: String(startVal),
+                    });
+                }
+                else if (startVal < 1) {
+                    errors.push({
+                        field: 'properties.start',
+                        rule: 'type',
+                        message: `NUMBER 循环的 properties.start 必须 >= 1，当前为 ${startVal}`,
+                        sample: String(startVal),
+                    });
+                }
+                if (typeof endVal !== 'number') {
+                    errors.push({
+                        field: 'properties.end',
+                        rule: 'type',
+                        message: `NUMBER 循环的 properties.end 必须是 number 类型，当前为 ${typeof endVal}`,
+                        sample: String(endVal),
+                    });
+                }
+                else if (typeof startVal === 'number' && endVal < startVal) {
+                    errors.push({
+                        field: 'properties.end',
+                        rule: 'type',
+                        message: `NUMBER 循环的 properties.end (${endVal}) 必须 >= properties.start (${startVal})`,
+                        sample: String(endVal),
+                    });
+                }
+            }
+            if (loopType === 'ARRAY' || loopType === 'CONDITION') {
+                const exprVal = loopField('expression');
+                if (!exprVal || typeof exprVal !== 'string' || !exprVal.trim()) {
+                    errors.push({
+                        field: 'properties.expression',
+                        rule: 'required',
+                        message: `${loopType} 循环的 properties.expression 是必填字段`,
+                        sample: exprVal ? String(exprVal).substring(0, 80) : '',
+                    });
+                }
+            }
+            const ascVal = loopField('asc');
+            if (typeof ascVal !== 'boolean') {
+                errors.push({
+                    field: 'properties.asc',
+                    rule: 'type',
+                    message: `properties.asc 必须是 boolean 类型，当前为 ${typeof ascVal}`,
+                    sample: String(ascVal),
+                });
+            }
+            const errExecVal = loopField('errorExec');
+            if (!errExecVal || !ERROR_EXEC_OPTIONS.has(errExecVal)) {
+                errors.push({
+                    field: 'properties.errorExec',
+                    rule: 'required',
+                    message: `properties.errorExec 必须是 END / CONTINUE / BREAK 之一，当前为 "${errExecVal}"`,
+                    sample: errExecVal ? String(errExecVal) : '',
+                });
+            }
+            break;
+        }
+        case 'SwitchNode': {
+            const branches = props.branches;
+            if (!Array.isArray(branches)) {
+                errors.push({
+                    field: 'properties.branches',
+                    rule: 'type',
+                    message: `properties.branches 必须是 array 类型，当前为 ${typeof branches}`,
+                    sample: safeSample(branches),
+                });
+            }
+            else if (branches.length < 2 || branches.length > 10) {
+                errors.push({
+                    field: 'properties.branches',
+                    rule: 'type',
+                    message: `properties.branches 需要 2-10 个分支，当前为 ${branches.length} 个`,
+                    sample: '',
+                });
+            }
+            else {
+                const seenIds = new Set();
+                branches.forEach((branch, i) => {
+                    const brPath = `properties.branches[${i}]`;
+                    if (!branch || typeof branch !== 'object') {
+                        errors.push({
+                            field: brPath,
+                            rule: 'type',
+                            message: `${brPath} 必须是 object 类型`,
+                            sample: safeSample(branch),
+                        });
+                        return;
+                    }
+                    if (!branch.id || typeof branch.id !== 'string' || !branch.id.trim()) {
+                        errors.push({
+                            field: `${brPath}.id`,
+                            rule: 'required',
+                            message: `${brPath}.id 是必填字段`,
+                            sample: '',
+                        });
+                    }
+                    else if (seenIds.has(branch.id)) {
+                        errors.push({
+                            field: `${brPath}.id`,
+                            rule: 'type',
+                            message: `分支 id "${branch.id}" 重复`,
+                            sample: branch.id,
+                        });
+                    }
+                    else {
+                        seenIds.add(branch.id);
+                    }
+                    if (!branch.name || typeof branch.name !== 'string' || !branch.name.trim()) {
+                        errors.push({
+                            field: `${brPath}.name`,
+                            rule: 'required',
+                            message: `${brPath}.name 是必填字段`,
+                            sample: '',
+                        });
+                    }
+                    if (!branch.or_list) {
+                        errors.push({
+                            field: `${brPath}.or_list`,
+                            rule: 'required',
+                            message: `${brPath}.or_list 是必填字段`,
+                            sample: '',
+                        });
+                    }
+                    else {
+                        errors.push(...validateOrList(branch.or_list, `${brPath}.or_list`));
+                    }
+                });
+            }
+            break;
+        }
+    }
     return errors;
 }
 function isPlainObject(value) {
     return (value !== null &&
-        typeof value === "object" &&
+        typeof value === 'object' &&
         !Array.isArray(value) &&
-        Object.prototype.toString.call(value) === "[object Object]");
+        Object.prototype.toString.call(value) === '[object Object]');
 }
 function deepMerge(target, ...sources) {
+    const tgt = target;
     for (const source of sources) {
-        if (source == null || typeof source !== "object" || Array.isArray(source)) {
+        if (source == null || typeof source !== 'object' || Array.isArray(source)) {
             continue;
         }
-        const subParams = target.sub_params;
-        for (const key of Object.keys(source)) {
-            const srcVal = source[key];
+        const src = source;
+        const subParams = tgt.sub_params;
+        for (const key of Object.keys(src)) {
+            const srcVal = src[key];
             // sub_params-aware merge: 匹配 name 并原地修改 target 的 sub_params 中的 value
             if (Array.isArray(subParams)) {
                 const matched = subParams.find((item) => item.name === key);
@@ -377,12 +698,36 @@ function deepMerge(target, ...sources) {
                     continue;
                 }
             }
-            const tgtVal = target[key];
-            if (isPlainObject(tgtVal) && isPlainObject(srcVal)) {
-                target[key] = deepMerge({ ...tgtVal }, srcVal);
+            const tgtVal = tgt[key];
+            // sub_params 数组按 name 合并，避免整体替换导致数据丢失
+            if (key === 'sub_params' && Array.isArray(tgtVal) && Array.isArray(srcVal)) {
+                const tgtArr = tgtVal;
+                for (const srcItem of srcVal) {
+                    if (!srcItem || typeof srcItem.name !== 'string') {
+                        tgtArr.push(srcItem);
+                        continue;
+                    }
+                    const matched = tgtArr.find((t) => t.name === srcItem.name);
+                    if (matched) {
+                        if (matched.sub_params && isPlainObject(srcItem.value)) {
+                            deepMerge(matched, srcItem.value);
+                        }
+                        else if (srcItem.value !== undefined) {
+                            matched.value = srcItem.value;
+                        }
+                        if (srcItem.update !== undefined)
+                            matched.update = srcItem.update;
+                    }
+                    else {
+                        tgtArr.push(srcItem);
+                    }
+                }
+            }
+            else if (isPlainObject(tgtVal) && isPlainObject(srcVal)) {
+                tgt[key] = deepMerge({ ...tgtVal }, srcVal);
             }
             else {
-                target[key] = srcVal;
+                tgt[key] = srcVal;
             }
         }
     }