weaver-e10-builder 1.2.5 → 1.5.2

package/dist/commands/wf-form.js

@@ -6,6 +6,10 @@ import { getRichType, resolveBrowserConfig, richIdUnits, BROWSER_TYPE_CATALOG }
 import { dropFieldComponents, prepareLayoutForSave } from '../services/form-field-drop.js';
 import { BROWSER_BEAN_SEARCH, pickBrowserBean, browserBeanCandidates, toBrowserType } from '../services/browser.js';
 import { randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { buildConditionDetail, resolveWorkflowEffect, readLinkageConfig } from '../services/form-linkage-condition.js';
+import { resolveFormulaRefs } from '../services/formula-detail.js';
+import { FLOW_ROUTE, assertAssignableTarget, buildAssignExpression, buildDrivingColumnsBody, buildDrivingEventsBody, buildFdEffect, buildFormulaLinkageName, buildFormulaSavePayload, buildLinkageApiUrl, buildLinkageDeleteBody, buildLinkageListBody, buildLinkageQueryBody, buildLinkageSavePayload, buildLinkageUpdatePayload, buildMonitorActions, buildPreCheckBody, describeColumn, extractEffect, extractTriggerState, findColumnById, isAssignableTarget, moduleColumnsOf, partitionDrivingColumns, resolveDrivingColumn, resolveDrivingEvent, summarizeLinkage, targetDriftWarning, toBareLabel, } from '../services/form-formula-linkage.js';
 /** 流程表单选项配色（对齐浏览器抓包 styleConfig.OptionBackground，循环取用）。 */
 const OPTION_COLORS = ['#FFBD4F', '#FF716E', '#3BD8C3', '#5B8FF9', '#5AD8A6', '#F6BD16', '#E86452', '#6DC8EC', '#945FB9', '#FF99C3'];
 /**
@@ -34,7 +38,7 @@ function canon(ck) {
         textarea: 'TextArea', text: 'Text', number: 'Number', money: 'Money',
         date: 'Date', datetime: 'DateTime', select: 'Select', selectmultiple: 'SelectMultiple',
         // 平台的浏览按钮类型名是 RelateBrowser（不是 Browser）——写错会被拒「程序异常」
-        employee: 'Employee', department: 'Department', browser: 'RelateBrowser',
+        employee: 'Employee', department: 'Department', subcompany: 'SubCompany', browser: 'RelateBrowser',
         relatebrowser: 'RelateBrowser', 浏览: 'RelateBrowser',
         file: 'FileComponent', filecomponent: 'FileComponent', upload: 'FileComponent', 附件: 'FileComponent',
         ebuilder: 'EBuilder', eb: 'EBuilder', flow: 'Flow',
@@ -278,7 +282,7 @@ async function genIds(client, baseUrl, n) {
  */
 export const WF_FORM_HANDLED = new Set([
     'Number', 'Money', 'TextArea', 'Date', 'DateTime',
-    'Employee', 'Department', 'RelateBrowser', 'Select', 'EBuilder', 'Flow',
+    'Employee', 'Department', 'SubCompany', 'RelateBrowser', 'Select', 'EBuilder', 'Flow',
 ]);
 /**
  * 构建字段 jsonObj（add-field / add-fields 共用）。返回未带 fieldId 的模板，调用方填 fieldId。
@@ -327,6 +331,16 @@ export async function buildFieldJsonObj(client, baseUrl, fieldName, fieldType, t
             jsonObj.defaultExtend = { date: { type: 'current' }, time: { customValue: '00:00', type: 'custom' } };
         }
     }
+    else if (ck === 'SubCompany') {
+        Object.assign(jsonObj, {
+            componentKey: 'Subcompany',
+            isSingle: o.multiple ? false : true,
+            displayType: 'space', defaultExtend: { type: 'custom', relation: 'current' },
+            viewDataDetail: true, showDimension: true,
+            pcDisplaySelectedCount: { type: 'default' },
+            mobileDisplaySelectedCount: { type: 'default' },
+        });
+    }
     else if (ck === 'Employee' || ck === 'Department') {
         jsonObj.isSingle = o.multiple ? false : true;
         if (o.defaultCurrent && ck === 'Employee') {
@@ -453,13 +467,13 @@ export function registerWorkflowFormCommands(program) {
     }
     // ---------- wf-form add-field ----------
     wfForm.command('add-field')
-        .description('给流程表单加字段（Text/TextArea/Number/Money/Date/DateTime/Select/Employee/Department/浏览按钮/EBuilder/Flow）')
+        .description('给流程表单加字段（Text/TextArea/Number/Money/Date/DateTime/Select/Employee/Department/SubCompany/浏览按钮/EBuilder/Flow）')
         .argument('<formId>', '流程表单 formId')
         .argument('<fieldName>', '字段名')
         .argument('<fieldType>', '字段类型')
         .argument('[title]', '字段显示名（不传同 fieldName）')
         .option('--sub-form-id <id>', '在指定明细子表里加字段（明细表 subFormId）')
-        .option('--multiple', '多选（Employee/Department/浏览按钮/下拉Select→SelectMultiple）')
+        .option('--multiple', '多选（Employee/Department/SubCompany/浏览按钮/下拉Select→SelectMultiple）')
         .option('--precision <n>', '小数位（Number 缺省 0 / Money 缺省 2 / 百分比缺省 1）')
         .option('--percent', 'Number 百分比显示（numberType=percentage）')
         .option('--default <value>', 'Number/Money 默认值')
@@ -864,7 +878,12 @@ export function registerWorkflowFormCommands(program) {
         .description('显隐联动管理（/api/workflow/core/form/setting/viewlinkage）')
         .argument('<formId>', '流程表单 formId')
         .argument('<name>', '联动名称')
-        .requiredOption('--config <json>', '联动配置 JSON：{"conditions":[{"field":"请假天数","operator":"EQUAL","value":"3"}],"actions":[{"prop":"hide","fields":["请假事由"]}]}。prop: hide/show/edit/readonly/required/hideLine；operator: EQUAL/NOT_EQUAL/GREATER/LESS/GREATER_EQUAL/LESS_EQUAL/EMPTY/NOT_EMPTY（默认 EQUAL）')
+        .requiredOption('--config <json>', '联动配置 JSON：{"conditions":[{"field":"请假天数","operator":"EQUAL","value":"3"}],"actions":[{"prop":"hide","fields":["请假事由"]}]}。prop: hide/show/edit/readonly/required/hideLine；'
+        + 'operator: EQUAL/NOT_EQUAL/CONTAIN/NOT_CONTAIN/GREATER/LESS/GREATER_EQUAL/LESS_EQUAL，'
+        + '**为空写 NULL（或 EMPTY，会归一）、不为空写 NOT_NULL**（默认 EQUAL）；'
+        + '顶层可选 "detailType":"AND|OR"（界面上「所有」/「任一」）；'
+        + '"effect" 指定生效维度：不写=当前表单，"workFlow"=当前工作流，"includeNode"=选择节点（后者另需 "nodeId"）')
+        .option('--workflow-id <id>', '流程 ID。生效维度选「当前工作流」或「选择节点」时必给（该联动挂在流程上，refId 也是它）')
         .action(async (formId, name, cmdOpts) => {
         try {
             const opts = program.opts();
@@ -874,13 +893,7 @@ export function registerWorkflowFormCommands(program) {
             const client = new ApiClient(auth);
             const baseUrl = auth.getBaseUrl();
             const ebb = { ebbusinessid: formId };
-            let cfg;
-            try {
-                cfg = JSON.parse(cmdOpts.config);
-            }
-            catch {
-                throw new Error('config JSON 解析失败');
-            }
+            const cfg = readLinkageConfig(cmdOpts.config);
             if (!Array.isArray(cfg.conditions) || !Array.isArray(cfg.actions) || !cfg.actions.length) {
                 throw new Error('config 需含 conditions[] 和非空 actions[]');
             }
@@ -906,15 +919,18 @@ export function registerWorkflowFormCommands(program) {
             // 这里曾写 `configs.find(c => !c.system)?.name ? '流程表单' : '流程表单'`——两个分支同值等于没写，
             // 且 configs 是**布局字段**数组、取到的是字段名而非表单名，照字面"修好"反而会把字段名当表单名发出去。
             const formName = '流程表单';
-            // conditions
+            // conditions。算子的归一与「为空不能带 sourceContent」那套规则和 eb 表那条路**同一份**
+            // （见 services/form-linkage-condition.ts）—— 两边都是同一个平台接口族，踩的是同一个坑。
+            const condWarnings = [];
             const conditionDetails = cfg.conditions.map((c) => {
                 const f = findField(c.field);
                 if (!f)
                     throw new Error(`条件字段未找到: "${c.field}"，可用: ${allFields.map((x) => x.name).join(', ')}`);
-                return {
-                    targetId: String(f.id), detailSymbol: c.operator || 'EQUAL', sourceType: 'CONSTANT',
-                    sourceContent: JSON.stringify(c.options ? { formField: { id: String(f.id) }, dataOptions: c.options } : { formField: { id: String(f.id) }, content: c.value !== undefined ? String(c.value) : '' }),
-                };
+                const { detail, warnings: w } = buildConditionDetail({
+                    fieldId: String(f.id), operator: c.operator, value: c.value, options: c.options,
+                });
+                condWarnings.push(...w);
+                return detail;
             });
             // actions
             const linkageDetails = cfg.actions.map((a) => ({
@@ -927,12 +943,30 @@ export function registerWorkflowFormCommands(program) {
                 }),
                 detailOptions: [],
             }));
+            // 生效维度。工作流表单这条路由上设计器提供四种（当前表单 / 表单布局 / 当前工作流 / 选择节点），
+            // 解析统一收在 services/form-linkage-condition.ts 的 `resolveWorkflowEffect` 里 ——
+            // 函数联动那边用的是同一份，别再内联第二遍。
+            const { effect, refId } = await resolveWorkflowEffect(client, baseUrl, {
+                module: MODULE, route: ROUTE, formId,
+                dimension: cfg.effect,
+                workflowId: cmdOpts.workflowId,
+                nodeKey: cfg.nodeId || cfg.node,
+                layoutId: cfg.layoutId,
+            });
+            const fdEffect = buildFdEffect(formId, effect, MODULE);
             const payload = {
-                fdEffect: { formId, effectModule: MODULE, effectType: 'form', effectName: '当前表单', optionList: [{ effectValue: formId, effectName: '当前表单' }] },
-                condition: { targetId: formId, targetName: formName, targetModule: MODULE, conditionType: 'FIELD', conditionDetails, formulaId: '', formulaName: '' },
+                fdEffect,
+                // targetName 设计器不发，去掉；targetModule 是 workflow
+                condition: { targetId: formId, targetModule: MODULE, conditionType: 'FIELD', conditionDetails, formulaId: '', formulaName: '' },
                 linkageDetails,
-                module: MODULE, formId, refId: formId, enableState: '1', linkageName: name, customParam: {},
+                // ⚠ `refId` 是**这条联动挂在谁身上**，在这条路由上就是**流程 ID**；原来写死 formId 是错的。
+                // 注意它**不等于** optionList 的取值 —— 选「选择节点」时取值是节点 ID，refId 仍是流程 ID
+                // （设计器报文里这两处就是这么分的，别照着「取值」抄）。refId 由 resolveWorkflowEffect 一并给出。
+                module: MODULE, formId, refId,
+                enableState: '1', linkageName: name,
             };
+            for (const w of condWarnings)
+                console.error(`  ⚠ ${w}`);
             const r = await client.post(`${baseUrl}${ROUTE}/setting/viewlinkage/add`, payload, ebb);
             if (r?.code !== 200 || !r?.status)
                 throw new Error(`联动添加失败: ${r?.msg || '未知错误'}`);
@@ -1000,6 +1034,7 @@ export function registerWorkflowFormCommands(program) {
         .requiredOption('--target <fieldId>', '目标字段 ID（公式结果写入此字段）')
         .option('--name <name>', '公式名称（默认自动生成）')
         .option('--return-type <type>', '返回类型: Number / String / Date', 'Number')
+        .option('--formula-id <id>', '要**更新**的已有公式 ID（原地改，不新建）。不传则新建一条')
         .action(async (formId, cmdOpts) => {
         try {
             const opts = program.opts();
@@ -1016,19 +1051,34 @@ export function registerWorkflowFormCommands(program) {
                 process.exitCode = 1;
                 return;
             }
-            const formulaName = cmdOpts.name || `公式_${Date.now()}`;
+            // `--formula-id` 传已有 id 就是**原地更新**那张公式（不新建、返回的 id 不变）。
+            // 名字缺省沿用原公式名 —— 否则会被改成「公式_<时间戳>」，看着像新建了一条。
+            let formulaName = cmdOpts.name;
+            if (!formulaName && cmdOpts.formulaId) {
+                try {
+                    const d = await client.post(`${baseUrl}/api/excel/formula/detail`, { formulaId: cmdOpts.formulaId });
+                    formulaName = d?.resultJson?.data?.name || undefined;
+                }
+                catch { /* 读不到就退回自动生成 */ }
+            }
+            formulaName = formulaName || `公式_${Date.now()}`;
             const savePayload = {
                 expressSql: cmdOpts.expression, name: formulaName, parameters: parsed.parameters,
                 returnType: cmdOpts.returnType, validateType: 'normal', referenceType: 'assign',
                 extendParam: JSON.stringify({ exceptIds: cmdOpts.target, createType: 'once' }),
-                formulaId: null, dataSources: [], formulaType: 'normal', mainDataSource: [null],
+                formulaId: cmdOpts.formulaId || null, dataSources: [], formulaType: 'normal', mainDataSource: [null],
                 tempVariableList: [], nameAuto: false, module: MODULE, multiFuncSepType: 1,
             };
             const saveRes = await client.post(`${baseUrl}/api/excel/formula/save`, savePayload);
             if (!saveRes?.resultJson?.excute)
                 throw new Error(`公式保存失败: ${saveRes?.resultJson?.error || saveRes?.msg || '未知错误'}`);
             const expressId = saveRes.resultJson.id;
-            console.error(`  公式已创建: ${expressId} (${saveRes.resultJson.formula})`);
+            // 说要更新就必须真的更新了 —— 平台万一悄悄新建一条，绑定会跟过去、旧公式留成孤儿。
+            if (cmdOpts.formulaId && String(expressId) !== String(cmdOpts.formulaId)) {
+                throw new Error(`期望原地更新 ${cmdOpts.formulaId}，平台返回的是 ${expressId}`
+                    + '（很可能新建了一条，旧公式已成为孤儿，请先在公式列表里核对）');
+            }
+            console.error(`  ${cmdOpts.formulaId ? '公式已更新' : '公式已创建'}: ${expressId} (${saveRes.resultJson.formula})`);
             // ffExpress 绑字段（saveFormFieldNew 重存带 ffExpress）
             try {
                 const gf = await client.post(`${baseUrl}${ROUTE}/field/manage/getFormField`, { module: MODULE, formTableField: { formField: { id: cmdOpts.target, form: { id: formId } } } }, ebb);
@@ -1294,7 +1344,7 @@ export function registerWorkflowFormCommands(program) {
         .argument('<formId>', '流程表单 formId')
         .argument('<fieldId>', '字段 fieldId（被带出的目标字段，如 联系方式）')
         .option('--title <title>', '修改字段标题')
-        .option('--multiple', '设为多选（Employee/Department/Browser isSingle=false；Select→SelectMultiple）')
+        .option('--multiple', '设为多选（Employee/Department/SubCompany/Browser isSingle=false；Select→SelectMultiple）')
         .option('--single', '设为单选（反向）')
         .option('--relate-from <关联字段>', 'EB关联带出：选 EBuilder 关联记录(如关联客户)后自动带出本字段值。传关联字段名/fieldId')
         .option('--relate-from-source <源字段>', '目标表单的源字段(如客户信息表的联系方式)fieldId 或字段名，--relate-from 必填。传字段名需 --sform-id 解析')
@@ -1321,7 +1371,7 @@ export function registerWorkflowFormCommands(program) {
             if (o.multiple === true || o.single === true) {
                 const multi = o.multiple === true;
                 const t = jsonObj.type;
-                if (t === 'Employee' || t === 'Department' || t === 'RelateBrowser') {
+                if (t === 'Employee' || t === 'Department' || t === 'SubCompany' || t === 'RelateBrowser') {
                     jsonObj.isSingle = !multi;
                     changes.push(`isSingle=${!multi}`);
                 }
@@ -1331,7 +1381,7 @@ export function registerWorkflowFormCommands(program) {
                     changes.push(`type=${jsonObj.type}`);
                 }
                 else {
-                    throw new Error(`字段类型 ${t} 不支持多选切换（仅 Employee/Department/浏览按钮/Select）`);
+                    throw new Error(`字段类型 ${t} 不支持多选切换（仅 Employee/Department/SubCompany/浏览按钮/Select）`);
                 }
             }
             // EB关联带出（ffRelateField）：选关联记录后自动带出目标表字段值
@@ -2031,6 +2081,431 @@ export function registerWorkflowFormCommands(program) {
             process.exitCode = 1;
         }
     });
+    // ---------- wf-form formula-linkage（流程表单的函数联动）----------
+    const flCmd = wfForm.command('formula-linkage')
+        .description('函数联动（流程表单，linkageType=excel）：list / read / events / columns / add / update / delete');
+    /** 这条路由的公共取数：驱动事件 + 驱动列（字段来源也从驱动列来，见 `drivingColumnsAsFieldSource`）。 */
+    async function wfLinkageContext(client, baseUrl, formId, workflowId) {
+        const ebb = { ebbusinessid: formId };
+        const loc = { formId, refId: workflowId || formId };
+        const [ev, col] = await Promise.all([
+            client.post(`${baseUrl}${buildLinkageApiUrl(FLOW_ROUTE, 'findFormDrivingEvents')}`, buildDrivingEventsBody(FLOW_ROUTE, loc), ebb),
+            client.post(`${baseUrl}${buildLinkageApiUrl(FLOW_ROUTE, 'findFormDrivingColumns')}`, buildDrivingColumnsBody(FLOW_ROUTE, loc), ebb),
+        ]);
+        if (ev?.code !== 200 || !ev?.status)
+            throw new Error(`查询触发事件失败: ${ev?.msg || '未知错误'}`);
+        if (col?.code !== 200 || !col?.status)
+            throw new Error(`查询可引用字段失败: ${col?.msg || '未知错误'}`);
+        const columns = (col.data?.drivingColumns || []);
+        return { events: (ev.data || []), columns, source: drivingColumnsAsFieldSource(columns) };
+    }
+    /** 解析这条路由的生效维度（四选一）。 */
+    async function wfEffectOf(client, baseUrl, formId, o) {
+        return resolveWorkflowEffect(client, baseUrl, {
+            module: MODULE, route: ROUTE, formId,
+            dimension: o.effect, workflowId: o.workflowId, nodeKey: o.node, layoutId: o.layoutId,
+        });
+    }
+    /** 回读一条，读不到就报错。 */
+    async function wfReadLinkage(client, baseUrl, formId, linkageId, workflowId) {
+        const refId = workflowId || formId;
+        const ebb = { ebbusinessid: formId };
+        const res = await client.post(`${baseUrl}${buildLinkageApiUrl(FLOW_ROUTE, 'queryById')}`, buildLinkageQueryBody(FLOW_ROUTE, { id: linkageId, formId, refId }), ebb);
+        if (res?.code !== 200 || !res?.status)
+            throw new Error(`查询失败: ${res?.msg || '未知错误'}`);
+        if (String(res?.data?.linkageType) !== 'excel') {
+            throw new Error(`这条的 linkageType 是 ${res?.data?.linkageType}，不是函数联动`);
+        }
+        return res.data;
+    }
+    flCmd.command('list')
+        .description('列出该流程表单下的函数联动')
+        .argument('<formId>', '流程表单 formId')
+        .option('--workflow-id <id>', '流程 ID（refId；不给按 formId 兜底）')
+        .option('--keyword <text>', '按联动名过滤')
+        .action(async (formId, cmdOpts) => {
+        try {
+            const opts = program.opts();
+            const auth = await AuthSession.fromOptions(opts);
+            if (!auth)
+                throw new Error('无法加载认证');
+            const client = new ApiClient(auth);
+            const baseUrl = auth.getBaseUrl();
+            const refId = cmdOpts.workflowId || formId;
+            const res = await client.post(`${baseUrl}${buildLinkageApiUrl(FLOW_ROUTE, 'fullPageQueryByFormId')}`, buildLinkageListBody(FLOW_ROUTE, { formId, refId, keyword: cmdOpts.keyword }), { ebbusinessid: formId });
+            if (res?.code !== 200 || !res?.status)
+                throw new Error(`查询失败: ${res?.msg || '未知错误'}`);
+            const total = Number(res?.data?.total ?? 0);
+            const records = res?.data?.records || [];
+            if (opts.json) {
+                console.log(JSON.stringify(records, null, 2));
+                return;
+            }
+            console.log(`共 ${total} 条函数联动:`);
+            for (const r of records) {
+                const s = summarizeLinkage(r);
+                console.log(`  [${s.id}] ${s.name} (${s.state ? '启用' : '停用'})`);
+                console.log(`      生效范围: ${wfEffectLabel(s.effect)}`);
+                console.log(`      触发: ${s.eventNames.join('、') || '—'} ← ${s.triggerNames.join('、') || '—'}`);
+            }
+            if (records.length)
+                console.log('  （列表不返回公式正文，要表达式/参数用 wf-form formula-linkage read）');
+            if (total === 0)
+                console.log(`  ℹ 查不到时先确认 --workflow-id：不传是按 formId=${formId} 当 refId 查的`);
+        }
+        catch (e) {
+            console.error(`查询函数联动失败: ${e.message}`);
+            process.exitCode = 1;
+        }
+    });
+    flCmd.command('read')
+        .description('查看一条函数联动（含公式表达式与参数）')
+        .argument('<formId>', '流程表单 formId')
+        .argument('<linkageId>', '联动 ID')
+        .option('--workflow-id <id>', '流程 ID（refId；不给按 formId 兜底）')
+        .action(async (formId, linkageId, cmdOpts) => {
+        try {
+            const opts = program.opts();
+            const auth = await AuthSession.fromOptions(opts);
+            if (!auth)
+                throw new Error('无法加载认证');
+            const client = new ApiClient(auth);
+            const baseUrl = auth.getBaseUrl();
+            const data = await wfReadLinkage(client, baseUrl, formId, linkageId, cmdOpts.workflowId);
+            if (opts.json) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            const s = summarizeLinkage(data);
+            console.log(`[${s.id}] ${s.name} (${s.state ? '启用' : '停用'})`);
+            console.log(`  refId: ${data?.refId || '—'}`);
+            console.log(`  生效范围: ${wfEffectLabel(s.effect)}`);
+            console.log(`  触发: ${s.eventNames.join('、') || '—'} ← ${s.triggerNames.join('、') || '—'}`);
+            console.log(`  公式: ${s.excelName} (excelId=${s.excelId})`);
+            console.log(`  表达式: ${s.expression || '-'}`);
+            if (s.parameters.length) {
+                console.log(`  参数 (${s.parameters.length}):`);
+                for (const p of s.parameters)
+                    console.log(`    ${p.fieldId}  ${p.title || p.name || ''}  [${p.properKey || ''}]`);
+            }
+        }
+        catch (e) {
+            console.error(`查询函数联动失败: ${e.message}`);
+            process.exitCode = 1;
+        }
+    });
+    flCmd.command('events')
+        .description('列出可用的触发事件（供 --event 取值）')
+        .argument('<formId>', '流程表单 formId')
+        .option('--workflow-id <id>', '流程 ID（refId；不给按 formId 兜底）')
+        .action(async (formId, cmdOpts) => {
+        try {
+            const opts = program.opts();
+            const auth = await AuthSession.fromOptions(opts);
+            if (!auth)
+                throw new Error('无法加载认证');
+            const client = new ApiClient(auth);
+            const baseUrl = auth.getBaseUrl();
+            const { events } = await wfLinkageContext(client, baseUrl, formId, cmdOpts.workflowId);
+            if (opts.json) {
+                console.log(JSON.stringify(events, null, 2));
+                return;
+            }
+            console.log(`共 ${events.length} 个触发事件:`);
+            for (const e of events) {
+                console.log(`  ${e.groupName} / ${e.name}  ${e.type}  ${e.selectColumn ? '（需 --trigger 指定字段）' : '（表单级，无需 --trigger）'}`);
+            }
+        }
+        catch (e) {
+            console.error(`查询触发事件失败: ${e.message}`);
+            process.exitCode = 1;
+        }
+    });
+    flCmd.command('columns')
+        .description('列出可用于公式引用与触发的字段')
+        .argument('<formId>', '流程表单 formId')
+        .option('--workflow-id <id>', '流程 ID（refId；不给按 formId 兜底）')
+        .option('--keyword <text>', '按字段名过滤')
+        .action(async (formId, cmdOpts) => {
+        try {
+            const opts = program.opts();
+            const auth = await AuthSession.fromOptions(opts);
+            if (!auth)
+                throw new Error('无法加载认证');
+            const client = new ApiClient(auth);
+            const baseUrl = auth.getBaseUrl();
+            const { columns } = await wfLinkageContext(client, baseUrl, formId, cmdOpts.workflowId);
+            if (opts.json) {
+                console.log(JSON.stringify(columns, null, 2));
+                return;
+            }
+            const kw = cmdOpts.keyword;
+            const shown = kw ? columns.filter((c) => String(c.name).includes(kw) || String(c.dataKey || '').includes(kw)) : columns;
+            const { assignable, unassignable } = partitionDrivingColumns(shown, FLOW_ROUTE);
+            const drifted = partitionDrivingColumns(columns, FLOW_ROUTE).drifted;
+            console.log(`可作赋值目标 (${assignable.length}) —— 也能作引用与触发:`);
+            for (const c of assignable)
+                console.log(describeColumn(c, FLOW_ROUTE));
+            console.log(`\n不可作赋值目标 (${unassignable.length}) —— 仍可作引用与触发:`);
+            for (const c of unassignable)
+                console.log(describeColumn(c, FLOW_ROUTE));
+            if (drifted.length) {
+                console.log(`\n⚠ ${drifted.length} 列形似系统字段但不在本路由的不可赋值清单里，已按「可赋值」处理:`);
+                for (const c of drifted)
+                    console.log(`  ${targetDriftWarning(c, FLOW_ROUTE)}`);
+            }
+            console.log(`\n共 ${columns.length} 列（其中 ${columns.filter((c) => isAssignableTarget(c, FLOW_ROUTE)).length} 列可作赋值目标）`);
+        }
+        catch (e) {
+            console.error(`查询可引用字段失败: ${e.message}`);
+            process.exitCode = 1;
+        }
+    });
+    flCmd.command('add')
+        .description('新增函数联动：事件 + 触发字段 + 赋值目标 + 公式')
+        .argument('<formId>', '流程表单 formId')
+        .requiredOption('--target <field>', '赋值目标字段（被写入）')
+        .requiredOption('--expression <expr>', '公式右侧函数体；也接受整段赋值式，或用 @文件 传长表达式')
+        .option('--event <event>', '触发事件（名称或 type，见 events），默认 changeField 值改变时', 'changeField')
+        .option('--trigger <fields...>', '触发字段，可多个')
+        .option('--effect <dimension>', '生效维度: form=当前表单（默认）/ formLayout=表单布局 / workFlow=当前工作流 / includeNode=选择节点')
+        .option('--workflow-id <id>', '流程 ID（refId，也是 workFlow/includeNode 的取值来源；不给按 formId 兜底）')
+        .option('--node <node>', 'includeNode 的节点（id 或节点名）')
+        .option('--layout-id <id>', 'formLayout 指定的布局 id（不传取默认布局）')
+        .option('--name <name>', '联动名称（默认「<公式名> - 公式_<时间戳>」）')
+        .option('--formula-name <name>', '公式名称')
+        .option('--formula-id <id>', '复用/更新已有公式（传了就原地更新那张公式）')
+        .action(async (formId, cmdOpts) => {
+        try {
+            const opts = program.opts();
+            const auth = await AuthSession.fromOptions(opts);
+            if (!auth)
+                throw new Error('无法加载认证');
+            const client = new ApiClient(auth);
+            const baseUrl = auth.getBaseUrl();
+            const ebb = { ebbusinessid: formId };
+            const refId = cmdOpts.workflowId || formId;
+            const { events, columns, source } = await wfLinkageContext(client, baseUrl, formId, cmdOpts.workflowId);
+            const event = resolveDrivingEvent(events, cmdOpts.event);
+            const targetCol = resolveDrivingColumn(columns, cmdOpts.target, FLOW_ROUTE);
+            assertAssignableTarget(targetCol, FLOW_ROUTE);
+            const drift = targetDriftWarning(targetCol, FLOW_ROUTE);
+            if (drift)
+                console.error(`  ⚠ ${drift}`);
+            const triggerCols = (cmdOpts.trigger || []).map((t) => resolveDrivingColumn(columns, t, FLOW_ROUTE));
+            if (!event.selectColumn && triggerCols.length) {
+                console.error(`  ⚠ 事件「${event.name}」是表单级的，不需要触发字段，--trigger 已忽略`);
+            }
+            const monitorActions = buildMonitorActions(event, triggerCols);
+            const { effect } = await wfEffectOf(client, baseUrl, formId, cmdOpts);
+            const { expression, stripped } = buildAssignExpression(targetCol, readExpressionArg(cmdOpts.expression));
+            if (stripped)
+                console.error('  ℹ 表达式自带赋值式，已按 --target 校验左侧并沿用右侧');
+            console.error(`  联动: ${effect.effectName} / ${event.name} ← ${triggerCols.map((c) => toBareLabel(c)).join('、') || '（表单级）'} → 填 ${toBareLabel(targetCol)}(${targetCol.id})`);
+            // 这条路由的 parameter **不带 appId 键**，所以 ctx 里不给 appId
+            const parsed = resolveFormulaRefs(expression, {
+                mainFields: source.mainFields, detailTables: source.detailTables,
+                moduleColumns: moduleColumnsOf(columns, FLOW_ROUTE),
+                formId, module: FLOW_ROUTE.module, hint: FLOW_ROUTE.columnsHint,
+            });
+            for (const w of parsed.warnings)
+                console.error(`  ⚠ ${w}`);
+            if (parsed.errors.length) {
+                for (const e of parsed.errors)
+                    console.error(`  ❌ ${e}`);
+                process.exitCode = 1;
+                return;
+            }
+            if (parsed.parameters[0]?.fieldId !== String(targetCol.id)) {
+                throw new Error(`赋值目标没有出现在公式参数表首位（首位是 ${parsed.parameters[0]?.fieldId ?? '空'}），已中止`);
+            }
+            const formulaName = cmdOpts.formulaName || '函数联动公式';
+            const saveRes = await client.post(`${baseUrl}/api/excel/formula/save`, buildFormulaSavePayload({
+                expression: parsed.normalizedExpression, name: formulaName,
+                parameters: parsed.parameters, formulaId: cmdOpts.formulaId || null, route: FLOW_ROUTE,
+            }));
+            if (!saveRes?.resultJson?.excute) {
+                throw new Error(`公式保存失败: ${saveRes?.resultJson?.error || saveRes?.msg || '未知错误'}`);
+            }
+            const excelId = String(saveRes.resultJson.id || '');
+            console.error(`  公式: ${excelId} ${formulaName}`);
+            const linkageName = cmdOpts.name || buildFormulaLinkageName(formulaName, new Date());
+            const linkRes = await client.post(`${baseUrl}${buildLinkageApiUrl(FLOW_ROUTE, 'saveFormDataLinkage')}`, buildLinkageSavePayload({
+                formId, appId: '', objId: '', linkageName, excelId, excelName: formulaName,
+                monitorActions, route: FLOW_ROUTE, refId,
+            }), ebb);
+            if (linkRes?.code !== 200 || !linkRes?.status) {
+                throw new Error(`联动保存失败: ${linkRes?.msg || '未知错误'}（公式已创建 excelId=${excelId}，可用 --formula-id ${excelId} 复用重试）`);
+            }
+            const linkageId = String(linkRes?.data?.id || '');
+            console.error(`  联动已创建: ${linkageId}`);
+            // preCheck 不通过不中止 —— 联动已经落库了，中止只会让人以为没建成
+            const pre = await client.post(`${baseUrl}${buildLinkageApiUrl(FLOW_ROUTE, 'preCheck')}`, buildPreCheckBody(FLOW_ROUTE, { formId, linkageIds: [linkageId], refId }), ebb);
+            if (pre?.code !== 200 || !pre?.status) {
+                console.error(`  ⚠ 平台校验未通过: ${pre?.msg || '未知错误'}（联动已落库，请在设计器里复核）`);
+            }
+            const rb = await client.post(`${baseUrl}${buildLinkageApiUrl(FLOW_ROUTE, 'queryById')}`, buildLinkageQueryBody(FLOW_ROUTE, { id: linkageId, formId, refId }), ebb);
+            const s = summarizeLinkage(rb?.data);
+            if (s.expression && s.expression !== parsed.normalizedExpression) {
+                console.error(`  ⚠ 平台回读的表达式与提交不一致，以平台为准: ${s.expression}`);
+            }
+            const out = {
+                success: true, linkageId, excelId, formId, refId, effect: effect.effectName,
+                expression: s.expression || parsed.normalizedExpression,
+                target: { id: targetCol.id, name: toBareLabel(targetCol) },
+                event: event.type, triggers: triggerCols.map((c) => ({ id: c.id, name: toBareLabel(c) })),
+            };
+            console.log(opts.json ? JSON.stringify(out, null, 2)
+                : `函数联动已创建: [${linkageId}] ${effect.effectName} / ${event.name} ← ${triggerCols.map((c) => toBareLabel(c)).join('、') || '（表单级）'} → ${toBareLabel(targetCol)}`);
+        }
+        catch (e) {
+            console.error(`新增函数联动失败: ${e.message}`);
+            process.exitCode = 1;
+        }
+    });
+    flCmd.command('update')
+        .description('改已有函数联动的触发条件/生效维度/名称/启停（不传的项沿用现有）')
+        .argument('<formId>', '流程表单 formId')
+        .argument('<linkageId>', '联动 ID')
+        .option('--event <event>', '改触发事件')
+        .option('--trigger <fields...>', '改触发字段')
+        .option('--effect <dimension>', '改生效维度: form / formLayout / workFlow / includeNode')
+        .option('--workflow-id <id>', '流程 ID（refId；不给沿用记录里的）')
+        .option('--node <node>', 'includeNode 的节点')
+        .option('--layout-id <id>', 'formLayout 指定的布局')
+        .option('--name <name>', '改联动名称')
+        .option('--state <onoff>', '启用或停用: on / off')
+        .action(async (formId, linkageId, cmdOpts) => {
+        try {
+            const opts = program.opts();
+            const auth = await AuthSession.fromOptions(opts);
+            if (!auth)
+                throw new Error('无法加载认证');
+            const client = new ApiClient(auth);
+            const baseUrl = auth.getBaseUrl();
+            const ebb = { ebbusinessid: formId };
+            const record = await wfReadLinkage(client, baseUrl, formId, linkageId, cmdOpts.workflowId);
+            const refId = String(record?.refId || cmdOpts.workflowId || formId);
+            const cur = extractTriggerState(record);
+            const { events, columns } = await wfLinkageContext(client, baseUrl, formId, cmdOpts.workflowId);
+            const event = resolveDrivingEvent(events, cmdOpts.event || cur.eventType);
+            const triggerInput = cmdOpts.trigger?.length ? cmdOpts.trigger : cur.triggerIds;
+            const triggerCols = [];
+            for (const t of triggerInput) {
+                const col = findColumnById(columns, t) || (() => { try {
+                    return resolveDrivingColumn(columns, t, FLOW_ROUTE);
+                }
+                catch {
+                    return undefined;
+                } })();
+                if (!col)
+                    throw new Error(`触发字段「${t}」在当前表单里找不到了（可能已被删除）。用 wf-form formula-linkage columns 复核`);
+                triggerCols.push(col);
+            }
+            const monitorActions = buildMonitorActions(event, triggerCols);
+            const effect = cmdOpts.effect
+                ? (await wfEffectOf(client, baseUrl, formId, cmdOpts)).effect
+                : extractEffect(record);
+            let linkageState = record?.linkageState !== false;
+            if (cmdOpts.state) {
+                const v = String(cmdOpts.state).toLowerCase();
+                if (v !== 'on' && v !== 'off')
+                    throw new Error('--state 只接受 on / off');
+                linkageState = v === 'on';
+            }
+            const res = await client.post(`${baseUrl}${buildLinkageApiUrl(FLOW_ROUTE, 'updateFormDataLinkage')}`, buildLinkageUpdatePayload(record, {
+                appId: '', objId: '',
+                linkageName: cmdOpts.name || String(record?.linkageName || ''),
+                linkageState, monitorActions, effect, route: FLOW_ROUTE, refId,
+            }), ebb);
+            if (res?.code !== 200 || !res?.status)
+                throw new Error(`更新失败: ${res?.msg || '未知错误'}`);
+            await client.post(`${baseUrl}${buildLinkageApiUrl(FLOW_ROUTE, 'preCheck')}`, buildPreCheckBody(FLOW_ROUTE, { formId, linkageIds: [linkageId], refId }), ebb);
+            const after = summarizeLinkage(await wfReadLinkage(client, baseUrl, formId, linkageId, refId));
+            const out = { success: true, linkageId, name: after.name, state: after.state, effect: wfEffectLabel(after.effect), event: after.eventNames.join('、'), triggers: after.triggerNames };
+            console.log(opts.json ? JSON.stringify(out, null, 2)
+                : `函数联动已更新: [${linkageId}] ${after.name} (${after.state ? '启用' : '停用'})  ${wfEffectLabel(after.effect)} / ${after.eventNames.join('、')} ← ${after.triggerNames.join('、')}`);
+        }
+        catch (e) {
+            console.error(`更新函数联动失败: ${e.message}`);
+            process.exitCode = 1;
+        }
+    });
+    flCmd.command('delete')
+        .description('删除函数联动（支持批量）')
+        .argument('<formId>', '流程表单 formId')
+        .argument('<linkageIds...>', '联动 ID')
+        .option('--workflow-id <id>', '流程 ID（refId；不给按 formId 兜底）')
+        .action(async (formId, linkageIds, cmdOpts) => {
+        try {
+            const opts = program.opts();
+            const auth = await AuthSession.fromOptions(opts);
+            if (!auth)
+                throw new Error('无法加载认证');
+            const client = new ApiClient(auth);
+            const baseUrl = auth.getBaseUrl();
+            const refId = cmdOpts.workflowId || formId;
+            const res = await client.post(`${baseUrl}${buildLinkageApiUrl(FLOW_ROUTE, 'deleteFormDataLinkage')}`, buildLinkageDeleteBody(FLOW_ROUTE, { ids: linkageIds, formId, refId }), { ebbusinessid: formId });
+            if (res?.code !== 200 || !res?.status)
+                throw new Error(`删除失败: ${res?.msg || '未知错误'}`);
+            const deleted = res?.data || [];
+            if (!deleted.length)
+                throw new Error('没有删掉任何一条（回显 0 条）。先 list 核对 id 是否存在、是否属于本表单');
+            // 服务端回显的 id 与传入的 linkageId 不是同一套（与 eb 表那条路由一样），
+            // 所以打印**用户传的 id**，回显只在数量对不上时提一句
+            const mismatch = deleted.length !== linkageIds.length;
+            console.log(opts.json ? JSON.stringify({ success: true, deleted: linkageIds, serverEcho: deleted }, null, 2)
+                : `已删除 ${linkageIds.length} 条函数联动: ${linkageIds.join(', ')}`);
+            if (mismatch)
+                console.error(`  ⚠ 服务端回显 ${deleted.length} 条（${deleted.join(', ')}），与请求的 ${linkageIds.length} 条对不上，请用 list 复核`);
+        }
+        catch (e) {
+            console.error(`删除函数联动失败: ${e.message}`);
+            process.exitCode = 1;
+        }
+    });
     return wfForm;
 }
+/** `--expression @file` 支持：公式里常带引号与换行，走文件比在命令行里转义省事。 */
+function readExpressionArg(raw) {
+    const v = String(raw || '');
+    if (!v.startsWith('@'))
+        return v;
+    try {
+        return readFileSync(v.slice(1), 'utf-8').trim();
+    }
+    catch (e) {
+        throw new Error(`读取表达式文件失败: ${v.slice(1)}（${e?.message || e}）`);
+    }
+}
+/** 生效维度的可读写法：当前表单 / 表单布局（布局名）/ 当前工作流（流程名【V1】）/ 选择节点（节点名）。 */
+function wfEffectLabel(e) {
+    if (!e || e.effectType === 'form')
+        return '当前表单';
+    return e.optionName ? `${e.effectName}（${e.optionName}）` : String(e.effectName || e.effectType);
+}
+/**
+ * 把驱动列映射成 `resolveFormulaRefs` 认的字段来源（形状对齐 eb 表 `getEbField` 的 main/detail）。
+ *
+ * **故意不走 `getConfig`**：那条路要先拿 `getFormLayout` 给的 layoutId，而流程表单这个接口
+ * 对部分表单直接 500（`Form.isPhysicalTable()` 上 NPE，`form` 为 null），连既有的
+ * `wf-form read` 都读不出来；退一步用空 layoutId 调 `getConfig`，回的是 9 个系统字段、**零业务字段**。
+ * 而驱动列本来就是这条路由自己给的字段清单 —— 业务字段与模块字段都在里面，id/名称/类型齐备，够用。
+ */
+function drivingColumnsAsFieldSource(columns) {
+    const business = columns.filter((c) => String(c.groupId) !== 'moduleField');
+    const strayDetail = business.find((c) => c.address && String(c.address) !== '主表');
+    if (strayDetail) {
+        // 没有实测过流程表单的明细字段在驱动列里长什么样（连 detailTableId 都拿不到），
+        // 与其猜一个 sFormId 发出去，不如停下来
+        throw new Error(`驱动列里出现了非主表字段「${strayDetail.name}」（address=${strayDetail.address}）。`
+            + '流程表单的明细字段尚未支持，请反馈这条表单的 findFormDrivingColumns 返回');
+    }
+    return {
+        mainFields: business.map((c) => ({
+            id: c.id, showName: toBareLabel(c), dataKey: c.dataKey, componentKey: c.descType,
+        })),
+        detailTables: [],
+    };
+}
 //# sourceMappingURL=wf-form.js.map