lan-low-code-cli 2.8.0 → 2.9.0

package/README.md

@@ -363,6 +363,46 @@ llc flow delete  --id <flowId> --yes
 这两个端点要求 `entityId` 带 `sys-modeling#` 前缀（CLI 自动补），裸 id 会返回 500。
 失败默认只告警，`--strict-schema` 升级为错误。
 
+**节点必填校验**（复刻 IDE 规则表与豁免逻辑）：
+
+- `TransformNode`：必填 `outParam` 与 `outputParamMapping`（`valueFormula` 或非空 `pointMappings`）；
+  `outParam` 为空时平台会豁免映射校验，但 `outParam` 本身仍必填
+- `ExecuteNode` / `InterfaceNode` / `SubActionNode` / `FlowBotsNode`：必填各自编码字段，存在入参 Schema 时必填参数映射
+- `BranchNode`：必填 `conditionType` / `flowWay` 及匹配的 `formulaConfig` / `ruleConfig`（有分支出边时自动生成）
+- `LoopNode`：必填 `loopDefine.type`；`MessageNode`：按 `subjectType` / `messageLink.linkType` 校验内容与链接
+- `AddDataNode` / `AddOrUpdateNode`：分类表单或未填 `commitType` 时豁免 `flow`
+- 校验失败时输出 `field` 与修复建议，`flow validate` / `flow compile` 退出码为 `1`，不会写入环境
+
+**参数映射（`TransformNode` / `ExecuteNode` 等）**：
+
+```json
+{
+  "id": "N4",
+  "type": "TransformNode",
+  "name": "转换",
+  "config": {
+    "outParam": {
+      "fd_title": { "type": "string", "description": "标题" },
+      "fd_amount": { "type": "number" }
+    },
+    "mapping": {
+      "fd_title": "$N2.fd_title",
+      "fd_amount": "$N2.fd_amount"
+    }
+  }
+}
+```
+
+- `outParam` 可写字段映射对象（自动转成 `{id:'responseBody',type:'object',properties:{...}}` 的 JSON Schema 字符串），
+  也可直接写完整 Schema 或 Schema 字符串；编译器写入 `outParamType=1`
+- `mapping` 的 `$<节点id>.<路径>` 自动转成
+  `{sourceType:'node',sourcePath:'node.N2.fd_title',targetPath:'fd_title'}`；`$context.<路径>` 转为上下文映射
+- 编译器同时把出参 Schema 写入 `extraAttr.context_outputParam`，供下游映射与 IDE 显示
+- 未写 `mapping` 时，若上游节点已提供 `context.context_outputParam`，按同名字段自动推断，并给出
+  `MAPPING_AUTO_INFERRED` 提示
+- 常量或表达式请用 `{ "paramMappingWay": "formula", "valueFormula": "..." }`；
+  `ExecuteNode` / `InterfaceNode` / `SubActionNode` / `FlowBotsNode` 用同一 `mapping` 生成 `inputParamMapping`
+
 **边界与已知限制**：
 
 - `AddDataNode` / `AddOrUpdateNode` 的 `fields` 是平台真实结构

package/dist/commands/flow.js

@@ -57,12 +57,20 @@ function buildOptions(opts) {
 function printDiagnostics(result, force) {
     const errors = result.diagnostics.filter((d) => d.level === 'error');
     const warnings = result.diagnostics.filter((d) => d.level === 'warn');
-    warnings.forEach((d) => logger_1.logger.warn(`[${d.code}] ${d.message}`));
+    warnings.forEach((d) => {
+        logger_1.logger.warn(`[${d.code}] ${d.message}`);
+        if (d.hint)
+            logger_1.logger.info(logger_1.color.gray(`    ↳ ${d.hint}`));
+    });
     if (errors.length === 0) {
         logger_1.logger.success(`离线校验通过（${result.diagnostics.length - errors.length} 条提示）`);
         return;
     }
-    errors.forEach((d) => logger_1.logger.error(`[${d.code}] ${d.message}`));
+    errors.forEach((d) => {
+        logger_1.logger.error(`[${d.code}] ${d.message}`);
+        if (d.hint)
+            logger_1.logger.info(logger_1.color.gray(`    ↳ ${d.hint}`));
+    });
     if (!force) {
         throw new Error(`离线校验未通过（${errors.length} 项错误）；修正 spec 后重试，或追加 --force 仅用于查看输出`);
     }
@@ -594,6 +602,12 @@ function registerFlowCommand(program) {
             printDiagnostics(result, Boolean(opts.force));
         }
         const isUpdate = Boolean(spec.fdId);
+        let current;
+        if (isUpdate) {
+            current = await flow_1.flowApi.get(client, String(spec.fdId));
+            if (!current?.fdId)
+                throw new Error(`动作流不存在：${spec.fdId}`);
+        }
         if (!isUpdate) {
             let unique;
             try {
@@ -606,7 +620,15 @@ function registerFlowCommand(program) {
                 throw new Error(`流程编码 ${spec.code} 在应用 ${spec.appCode} 中已存在；更换 code，或更新已有流程时在 spec 中写 fdId`);
             }
         }
-        const payload = buildPublishPayload(result);
+        // 更新时合并现有 VO，避免把 fdStatus / dynamicProps / fdCreator 等服务端字段覆盖掉
+        const payload = isUpdate
+            ? {
+                ...current,
+                ...result.basicInfo,
+                fdStatus: current?.fdStatus ?? result.basicInfo.fdStatus,
+                fdDesign: result.fdDesign,
+            }
+            : buildPublishPayload(result);
         if (!opts.yes) {
             logger_1.logger.warn(`预览模式：未写入。目标应用 ${spec.appCode}；确认 payload 后追加 --yes`);
             logger_1.logger.json(payload);

package/dist/commands/operation.js

@@ -291,9 +291,11 @@ function buildCreatePayload(opts, flow) {
             fdModelName: FLOW_MODEL_NAME,
             fdCode: flow.fdCode,
         };
-        const incParams = buildIncParams(opts.incParams);
-        if (incParams !== undefined)
-            config.incParams = incParams;
+        const builtInc = buildIncParams(opts.incParams);
+        if (builtInc) {
+            config.incParams = builtInc.incParams;
+            config.formIncParams = builtInc.formIncParams;
+        }
         const active = flow.fdProcessActive ?? {};
         if (active.fdFormId) {
             // 动作流绑定了表单：按钮按当前文档 id/ids 传参
@@ -343,7 +345,17 @@ function assertTriggerableFlow(flow) {
         throw new Error(`动作流 ${flow.fdName ?? flow.fdId} 未开启「操作触发」，请在 trigger.fdRunType 中包含 operate 后重新发布`);
     }
 }
-/** --inc-params 支持 @file 或内联 JSON；返回平台要求的 [{field:{name},value:{val}}] */
+/**
+ * 编译动作流入参。
+ *
+ * 平台落库结构（addOperationModal/content.tsx:533-576）：
+ *   fdConfig.incParams     = [{ batchNo: 'B001' }, { repeat: 2 }]
+ *   fdConfig.formIncParams = [{ field: { name: 'batchNo' } }, ...]
+ * 入参支持三种写法：
+ *   对象 { "batchNo": "B001", "repeat": 2 }
+ *   数组 [{ "batchNo": "B001" }]
+ *   数组 [{ "field": { "name": "batchNo" }, "value": { "val": "B001" } }]
+ */
 function buildIncParams(input) {
     if (input === undefined || input === null || input === '')
         return undefined;
@@ -355,9 +367,33 @@ function buildIncParams(input) {
     catch (err) {
         throw new Error(`--inc-params 不是合法 JSON：${err.message}`);
     }
-    if (!Array.isArray(parsed))
-        throw new Error('--inc-params 需为数组：[{field:{name},value:{val}}]');
-    return parsed;
+    const entries = [];
+    const pushEntry = (name, value) => {
+        entries.push({ [name]: value });
+    };
+    if (Array.isArray(parsed)) {
+        for (const item of parsed) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const record = item;
+            const field = record.field;
+            if (field && typeof field.name === 'string') {
+                const value = record.value;
+                pushEntry(field.name, value && 'val' in value ? value.val : record.value);
+                continue;
+            }
+            Object.entries(record).forEach(([name, value]) => pushEntry(name, value));
+        }
+    }
+    else if (parsed && typeof parsed === 'object') {
+        Object.entries(parsed).forEach(([name, value]) => pushEntry(name, value));
+    }
+    if (entries.length === 0)
+        return undefined;
+    return {
+        incParams: entries,
+        formIncParams: entries.map((entry) => ({ field: { name: Object.keys(entry)[0] } })),
+    };
 }
 /**
  * 基于现有操作构造 update 请求体。
@@ -440,9 +476,11 @@ function buildUpdatePayload(current, opts, flow) {
             fdModelName: FLOW_MODEL_NAME,
             fdCode: flow.fdCode,
         };
-        const incParams = buildIncParams(opts.incParams);
-        if (incParams !== undefined)
-            config.incParams = incParams;
+        const builtInc = buildIncParams(opts.incParams);
+        if (builtInc) {
+            config.incParams = builtInc.incParams;
+            config.formIncParams = builtInc.formIncParams;
+        }
     }
     else {
         const dialogId = opts.dialogId !== undefined

package/dist/generator/flow/compiler.js

@@ -20,6 +20,7 @@ exports.normalizeGraph = normalizeGraph;
 exports.compileFlow = compileFlow;
 const layout_1 = require("./layout");
 Object.defineProperty(exports, "NODE_SIZE", { enumerable: true, get: function () { return layout_1.NODE_SIZE; } });
+const mapping_1 = require("./mapping");
 const schema_1 = require("./schema");
 const validate_1 = require("./validate");
 Object.defineProperty(exports, "hasErrors", { enumerable: true, get: function () { return validate_1.hasErrors; } });
@@ -104,6 +105,10 @@ function normalizeGraph(spec, mode, hints = {}) {
     if (business.length === 0 && edges.length === 0)
         addEdge({ from: startId, to: endId });
     const byId = new Map(nodes.map((n) => [n.id, n]));
+    // 在必填校验与节点实例化之前统一补齐参数映射（TransformNode 等）
+    for (const node of nodes) {
+        (0, mapping_1.prepareNodeConfig)(node, diagnostics, { edges, byId });
+    }
     const ranks = { [startId]: 0 };
     const branchTargets = new Set();
     for (const edge of edges) {

package/dist/generator/flow/mapping.js

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * 参数映射编译器
+ *
+ * 平台里映射的持久化结构只有两种（`configuration/controls/paramMapping/index.tsx:100-135`）：
+ *   point:   { paramMappingWay:'point',   pointMappings:[{ sourceType, sourcePath, targetPath }] }
+ *   formula: { paramMappingWay:'formula', valueFormula:'<JSON 字符串>' }
+ *
+ * spec 里允许更友好的写法（编译后会被删除，不落库）：
+ *   "config": {
+ *     "outParam": { "fd_title": { "type": "string", "description": "标题" } },
+ *     "mapping":  { "fd_title": "$N2.fd_title", "fd_amount": "$N2.fd_amount" }
+ *   }
+ *
+ * - `outParam` 也接受完整 JSON Schema（含 type/properties）或 JSON 字符串；
+ * - `mapping` 的值支持 `$<节点id>.<路径>` 与 `$context.<路径>`；
+ * - 也接受 `{ paramMappingWay:'formula', valueFormula:'...' }` 或 pointMappings 数组直接透传。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareNodeConfig = prepareNodeConfig;
+const JSON_TYPES = new Set(['string', 'number', 'integer', 'boolean', 'array', 'object']);
+const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+const NODE_REF = /^\$([0-9a-zA-Z_]{2,32})\.(.+)$/;
+const CONTEXT_REF = /^\$context\.(.+)$/;
+function targetPathOf(key) {
+    const index = key.indexOf('.');
+    return index >= 0 ? key.slice(index + 1) : key;
+}
+/** 字段映射 → JSON Schema（`{id:'responseBody', type:'object', properties:{...}}`） */
+function buildSchemaFromFields(fields) {
+    const properties = {};
+    for (const [name, raw] of Object.entries(fields)) {
+        if (isRecord(raw)) {
+            properties[name] = { id: name, required: false, ...raw };
+            continue;
+        }
+        if (typeof raw === 'string' && JSON_TYPES.has(raw)) {
+            properties[name] = { id: name, type: raw, required: false, description: '' };
+            continue;
+        }
+        properties[name] = {
+            id: name,
+            type: 'string',
+            required: false,
+            ...(typeof raw === 'string' && raw ? { description: raw } : {}),
+        };
+    }
+    return { id: 'responseBody', type: 'object', description: '', properties };
+}
+/** 统一 outParam：字符串原样保留，对象转成 JSON Schema 字符串 */
+function normalizeOutParam(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return {};
+        try {
+            const parsed = JSON.parse(trimmed);
+            return isRecord(parsed) ? { text: trimmed, schema: parsed } : { text: value };
+        }
+        catch {
+            return { text: value };
+        }
+    }
+    if (isRecord(value)) {
+        const isSchema = 'type' in value || 'properties' in value || '$ref' in value;
+        const schema = isSchema
+            ? { id: 'responseBody', type: 'object', description: '', ...value }
+            : buildSchemaFromFields(value);
+        return { text: JSON.stringify(schema), schema };
+    }
+    return {};
+}
+function parseMappingSource(expr) {
+    if (typeof expr !== 'string')
+        return undefined;
+    const value = expr.trim();
+    const contextMatch = CONTEXT_REF.exec(value);
+    if (contextMatch) {
+        return { sourceType: 'context', sourcePath: `context.${contextMatch[1]}` };
+    }
+    const nodeMatch = NODE_REF.exec(value);
+    if (nodeMatch) {
+        return { sourceType: 'node', sourcePath: `node.${nodeMatch[1]}.${nodeMatch[2]}` };
+    }
+    return undefined;
+}
+/** `{ 目标字段: 表达式 }` → pointMappings */
+function buildPointMapping(mapping, diagnostics, nodeId, field) {
+    const pointMappings = [];
+    for (const [target, expr] of Object.entries(mapping)) {
+        if (target === 'paramMappingWay' || target === 'pointMappings' || target === 'valueFormula')
+            continue;
+        const source = parseMappingSource(expr);
+        if (!source) {
+            diagnostics.push({
+                level: 'warn',
+                code: 'MAPPING_VALUE_UNSUPPORTED',
+                message: `节点 ${nodeId} 的映射 ${target} 不是 $节点.路径 / $context.路径 形式，已跳过`,
+                nodeId,
+                field,
+                hint: '常量或表达式请改用 { "paramMappingWay": "formula", "valueFormula": "..." }',
+            });
+            continue;
+        }
+        pointMappings.push({ sourceType: source.sourceType, sourcePath: source.sourcePath, targetPath: targetPathOf(target) });
+    }
+    if (pointMappings.length === 0)
+        return undefined;
+    return { paramMappingWay: 'point', pointMappings };
+}
+/** 把 spec 的 mapping 统一成平台结构 */
+function buildMapping(input, diagnostics, nodeId, field) {
+    if (typeof input === 'string') {
+        const value = input.trim();
+        if (!value)
+            return undefined;
+        if (value.startsWith('{'))
+            return { paramMappingWay: 'formula', valueFormula: value };
+        diagnostics.push({
+            level: 'error', code: 'MAPPING_FORMULA_INVALID',
+            message: `节点 ${nodeId} 的 ${field} 字符串必须是 valueFormula 的 JSON`, nodeId, field,
+        });
+        return undefined;
+    }
+    if (Array.isArray(input)) {
+        return input.length > 0 ? { paramMappingWay: 'point', pointMappings: input } : undefined;
+    }
+    if (!isRecord(input))
+        return undefined;
+    if (input.paramMappingWay === 'formula') {
+        if (typeof input.valueFormula === 'string' && input.valueFormula.trim()) {
+            return { paramMappingWay: 'formula', valueFormula: input.valueFormula };
+        }
+        if (input.valueFormula !== undefined) {
+            return { paramMappingWay: 'formula', valueFormula: JSON.stringify(input.valueFormula) };
+        }
+        diagnostics.push({
+            level: 'error', code: 'MAPPING_FORMULA_REQUIRED',
+            message: `节点 ${nodeId} 的 ${field} 声明 paramMappingWay=formula 但缺少 valueFormula`, nodeId, field,
+        });
+        return undefined;
+    }
+    return buildPointMapping(input, diagnostics, nodeId, field);
+}
+/** 平台要求 valueFormula 是字符串；对象写法统一序列化 */
+function normalizeMappingValue(value) {
+    if (!isRecord(value))
+        return value;
+    if (value.valueFormula !== undefined && typeof value.valueFormula !== 'string') {
+        return { ...value, valueFormula: JSON.stringify(value.valueFormula) };
+    }
+    return value;
+}
+/** 上游已有 `context_outputParam` 时，按同名字段自动补齐 point 映射 */
+function inferFromUpstream(node, outputNames, graph) {
+    for (const edge of graph.edges.filter((item) => item.to === node.id)) {
+        const upstream = graph.byId.get(edge.from);
+        const upstreamContext = upstream?.context;
+        const schema = upstreamContext?.context_outputParam;
+        if (!isRecord(schema))
+            continue;
+        const properties = isRecord(schema.properties) ? schema.properties : undefined;
+        if (!properties)
+            continue;
+        const pointMappings = outputNames
+            .filter((name) => name in properties)
+            .map((name) => ({
+            sourceType: 'node',
+            sourcePath: `node.${edge.from}.${name}`,
+            targetPath: name,
+        }));
+        if (pointMappings.length > 0)
+            return { pointMappings, upstreamId: edge.from };
+    }
+    return undefined;
+}
+/**
+ * 在归一化阶段就地补齐节点配置（校验与实例化都会读取同一份 config）。
+ * 只处理参数映射相关的 nodeType，其余节点原样返回。
+ */
+function prepareNodeConfig(node, diagnostics, graph) {
+    const config = { ...(node.config ?? {}) };
+    node.config = config;
+    if (node.type === 'TransformNode') {
+        const normalized = normalizeOutParam(config.outParam);
+        if (normalized.text) {
+            config.outParam = normalized.text;
+            if (config.outParamType === undefined)
+                config.outParamType = 1;
+            if (normalized.schema) {
+                // IDE 的 onParamChange 会把出参 Schema 写入 context_outputParam（transformNode.tsx:64-67）
+                node.context = { ...(node.context ?? {}), context_outputParam: normalized.schema };
+            }
+        }
+        else if (config.outParam !== undefined) {
+            diagnostics.push({
+                level: 'error', code: 'OUT_PARAM_INVALID',
+                message: `节点 ${node.id} 的 config.outParam 需为 JSON Schema 字符串或字段映射对象`,
+                nodeId: node.id, field: 'outParam',
+            });
+        }
+        if (config.outputParamMapping !== undefined) {
+            config.outputParamMapping = normalizeMappingValue(config.outputParamMapping);
+        }
+        else if (config.mapping !== undefined) {
+            const generated = buildMapping(config.mapping, diagnostics, node.id, 'mapping');
+            if (generated)
+                config.outputParamMapping = generated;
+        }
+        if (config.outputParamMapping === undefined && normalized.schema && isRecord(normalized.schema.properties) && graph) {
+            const names = Object.keys(normalized.schema.properties);
+            const inferred = inferFromUpstream(node, names, graph);
+            if (inferred) {
+                config.outputParamMapping = { paramMappingWay: 'point', pointMappings: inferred.pointMappings };
+                diagnostics.push({
+                    level: 'warn', code: 'MAPPING_AUTO_INFERRED',
+                    message: `节点 ${node.id} 未提供 mapping，已按上游 ${inferred.upstreamId} 的同名字段自动生成 ${inferred.pointMappings.length} 条映射`,
+                    nodeId: node.id, field: 'outputParamMapping',
+                });
+            }
+        }
+        delete config.mapping;
+        return;
+    }
+    if (node.type === 'EndNode') {
+        const normalized = normalizeOutParam(config.outParam);
+        if (normalized.text) {
+            config.outParam = normalized.text;
+            // 主动触发的结束节点 outParamType=0（endNode.tsx:46）
+            if (config.outParamType === undefined)
+                config.outParamType = 0;
+            if (normalized.schema) {
+                node.context = { ...(node.context ?? {}), context_outputParam: normalized.schema };
+            }
+        }
+        if (config.outputParamMapping !== undefined) {
+            config.outputParamMapping = normalizeMappingValue(config.outputParamMapping);
+        }
+        else if (config.mapping !== undefined) {
+            const generated = buildMapping(config.mapping, diagnostics, node.id, 'mapping');
+            if (generated)
+                config.outputParamMapping = generated;
+        }
+        delete config.mapping;
+        return;
+    }
+    if (['ExecuteNode', 'InterfaceNode', 'SubActionNode', 'FlowBotsNode'].includes(node.type)) {
+        if (config.inputParamMapping !== undefined) {
+            config.inputParamMapping = normalizeMappingValue(config.inputParamMapping);
+        }
+        else if (config.mapping !== undefined) {
+            const generated = buildMapping(config.mapping, diagnostics, node.id, 'mapping');
+            if (generated)
+                config.inputParamMapping = generated;
+        }
+        delete config.mapping;
+    }
+}

package/dist/generator/flow/schema.js

@@ -7,7 +7,7 @@
  * 必填规则来自 `configuration/nodes/utils.tsx:37-288` 与 `validate.ts:13-17`。
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONTEXT_KEYS = exports.FLOW_CODE_PATTERN = exports.NODE_ID_PATTERN = exports.KNOWN_START_WAYS = exports.MULTI_OUT_NODE_TYPES = exports.NODE_REQUIRED = exports.NODE_DEFAULTS = exports.NODE_FIELD_WHITELIST = void 0;
+exports.CONTEXT_KEYS = exports.FLOW_CODE_PATTERN = exports.NODE_ID_PATTERN = exports.KNOWN_START_WAYS = exports.MULTI_OUT_NODE_TYPES = exports.NODE_REQUIRED_RULES = exports.NODE_DEFAULTS = exports.NODE_FIELD_WHITELIST = void 0;
 /** 节点专属字段白名单；未列出的 nodeType 视为未知类型（透传 config 并告警） */
 exports.NODE_FIELD_WHITELIST = {
     StartNode: ['startNodeDef'],
@@ -53,25 +53,166 @@ exports.NODE_DEFAULTS = {
     LoopNode: { loopDefine: { type: 'LoopArray' } },
     MessageNode: { grantPermission: true },
 };
-/** 发布前 IDE 强校验的必填字段（configuration/nodes/utils.tsx:37-288） */
-exports.NODE_REQUIRED = {
-    AddDataNode: ['dataSourceVO', 'flow', 'fields'],
-    QueryDataNode: ['target'],
-    UpdateDataNode: ['bindNode'],
-    DeleteDataNode: ['bindNode'],
-    FilterDataNode: ['bindNode'],
-    BranchNode: ['conditionType', 'flowWay'],
-    SubActionNode: ['actionFlowCode'],
-    InterfaceNode: ['apiType', 'apiMethodPath'],
-    ExecuteNode: ['executeCode'],
-    QueryStatisticsNode: ['target'],
-    AddOrUpdateNode: ['dataSourceVO', 'flow', 'fields'],
-    LoopNode: ['loopDefine'],
-    AssignValueNode: ['assignValueRuleConfigs'],
-    CreateKmReviewNode: ['kmReviewTemplate', 'fdSubject'],
-    FlowBotsNode: ['flowBotsCode'],
-    MessageNode: ['subject', 'messageTarget'],
-    MessageEliminateNode: ['eliminateRange', 'eliminateType'],
+const record = (value) => value && typeof value === 'object' && !Array.isArray(value)
+    ? value
+    : {};
+/** 节点是否有入参 Schema（决定参数映射是否必填） */
+const hasInParam = (ctx) => {
+    const inParam = record(record(ctx.node.context).context_fdInParam);
+    return Object.keys(record(inParam.properties)).length > 0;
+};
+/** Execute/Interface/SubAction/FlowBots 共用的「code + 参数映射」规则 */
+const mappingRules = (codeField, codeMessage) => [
+    { field: codeField, message: codeMessage },
+    {
+        field: 'paramMappingWay',
+        message: '参数映射不能为空',
+        read: (config) => record(config.inputParamMapping).paramMappingWay ?? 'point',
+        skipIf: (ctx) => !hasInParam(ctx),
+    },
+    {
+        field: 'fdParam',
+        message: '参数映射不能为空',
+        hint: 'inputParamMapping 需提供 valueFormula（非 point）或非空 pointMappings',
+        read: (config) => {
+            const mapping = record(config.inputParamMapping);
+            if (Object.keys(mapping).length === 0)
+                return undefined;
+            if ((mapping.paramMappingWay ?? 'point') !== 'point')
+                return mapping.valueFormula;
+            const points = mapping.pointMappings;
+            return Array.isArray(points) && points.length > 0 ? points : undefined;
+        },
+        skipIf: (ctx) => !hasInParam(ctx),
+    },
+];
+/** 分类表单 / 未选提交方式时，AddData 不要求选流程 */
+const skipFlowRequired = (ctx) => {
+    if (!ctx.config.commitType)
+        return true;
+    return String(record(ctx.config.dataSourceVO).entityId ?? '').includes('sys-modeling-main');
+};
+exports.NODE_REQUIRED_RULES = {
+    AddDataNode: [
+        { field: 'dataSourceVO', message: '目标表单不能为空' },
+        { field: 'flow', message: '选择流程不能为空', skipIf: skipFlowRequired },
+        { field: 'fields', message: '表单字段不能为空' },
+    ],
+    AddOrUpdateNode: [
+        { field: 'dataSourceVO', message: '选择表单不能为空' },
+        { field: 'flow', message: '选择流程不能为空', skipIf: skipFlowRequired },
+    ],
+    QueryDataNode: [{ field: 'target', message: '查询对象不能为空' }],
+    QueryLoopNode: [{ field: 'target', message: '查询对象不能为空' }],
+    UpdateDataNode: [{ field: 'bindNode', message: '请选择节点' }],
+    DeleteDataNode: [{ field: 'bindNode', message: '请选择删除节点' }],
+    FilterDataNode: [{ field: 'bindNode', message: '过滤节点不能为空' }],
+    BranchNode: [
+        { field: 'conditionType', message: '请设置条件' },
+        { field: 'flowWay', message: '请设置流转方式' },
+        {
+            field: 'formulaConfig',
+            message: '请设置公式定义',
+            // rule 模式免公式；有出边时编译器会按 branchFormulas 自动生成
+            skipIf: (ctx) => ctx.config.conditionType === 'rule' || ctx.outgoing > 0,
+        },
+        { field: 'ruleConfig', message: '请设置匹配规则', skipIf: (ctx) => ctx.config.conditionType === 'formula' },
+    ],
+    LoopNode: [
+        { field: 'loopType', message: '请设置循环方式', read: (config) => record(config.loopDefine).type },
+    ],
+    TransformNode: [
+        {
+            field: 'outParam',
+            message: '出参设置不能为空',
+            hint: 'config.outParam 需为输出参数 JSON Schema 字符串；可用 llc flow templates 从真实流程抽取',
+        },
+        {
+            field: 'paramMappingWay',
+            message: '参数映射不能为空',
+            read: (config) => record(config.outputParamMapping).paramMappingWay ?? 'point',
+            skipIf: (ctx) => !ctx.config.outParam,
+        },
+        {
+            field: 'fdParam',
+            message: '参数映射不能为空',
+            hint: 'outputParamMapping 需提供 valueFormula（非 point）或非空 pointMappings',
+            read: (config) => {
+                const mapping = record(config.outputParamMapping);
+                if (Object.keys(mapping).length === 0)
+                    return undefined;
+                if ((mapping.paramMappingWay ?? 'point') !== 'point')
+                    return mapping.valueFormula;
+                const points = mapping.pointMappings;
+                return Array.isArray(points) && points.length > 0 ? points : undefined;
+            },
+            skipIf: (ctx) => !ctx.config.outParam,
+        },
+    ],
+    AssignValueNode: [{ field: 'assignValueRuleConfigs', message: '赋值规则不能为空' }],
+    ExecuteNode: mappingRules('executeCode', '集成函数不能为空'),
+    InterfaceNode: mappingRules('apiMethodPath', '内部接口不能为空'),
+    SubActionNode: mappingRules('actionFlowCode', '子动作不能为空'),
+    FlowBotsNode: mappingRules('flowBotsCode', 'flowBots不能为空'),
+    MessageNode: [
+        { field: 'notifyType', message: '通知方式不能为空' },
+        { field: 'subject', message: '消息内容不能为空', skipIf: (ctx) => ctx.config.subjectType === 'TEMPLATE' },
+        {
+            field: 'templateCode',
+            message: '请选择通知模板',
+            skipIf: (ctx) => {
+                const subjectType = ctx.config.subjectType;
+                return subjectType === undefined || subjectType === '' || subjectType === 'CUSTOM';
+            },
+        },
+        {
+            field: 'linkPage',
+            message: '视图不能为空',
+            skipIf: (ctx) => {
+                const linkType = record(ctx.config.messageLink).linkType;
+                return linkType === undefined || linkType === 'default';
+            },
+        },
+        {
+            field: 'linkUrl',
+            message: '链接不能为空',
+            read: (config) => record(config.messageLink).linkUrl,
+            skipIf: (ctx) => {
+                const linkType = record(ctx.config.messageLink).linkType;
+                return linkType === undefined || linkType === 'view' || linkType === 'edit';
+            },
+        },
+    ],
+    MessageEliminateNode: [{ field: 'eventCode', message: '事件编码不允许为空' }],
+    QueryStatisticsNode: [
+        { field: 'target', message: '查询目标不能为空' },
+        {
+            field: 'statisticsConfig',
+            message: '统计维度和统计项不能全为空',
+            read: (config) => {
+                const dimensions = Array.isArray(config.statisticsDimensions) ? config.statisticsDimensions : [];
+                const items = Array.isArray(config.statisticsItems) ? config.statisticsItems : [];
+                return dimensions.length + items.length > 0 ? { dimensions, items } : undefined;
+            },
+        },
+    ],
+    CreateKmReviewNode: [
+        { field: 'kmReviewTemplate', message: '流程模板不能为空' },
+        { field: 'fdSubject', message: '流程标题不能为空' },
+        {
+            field: 'orgElement',
+            message: '创建人不能为空',
+            read: (config) => record(config.fdCreator).orgElement,
+            skipIf: (ctx) => (record(ctx.config.fdCreator).valueRule ?? 'Fixed') === 'Var',
+        },
+        {
+            field: 'formula',
+            message: '创建人不能为空',
+            read: (config) => record(config.fdCreator).formula,
+            skipIf: (ctx) => (record(ctx.config.fdCreator).valueRule ?? 'Fixed') === 'Fixed',
+        },
+        { field: 'fields', message: '表单字段不能为空' },
+    ],
 };
 /** 允许多条出边的节点（validateCommonVertex 的 getwayMap，另有 StartNode） */
 exports.MULTI_OUT_NODE_TYPES = new Set(['BranchNode', 'parallelGateway', 'StartNode']);

package/dist/generator/flow/validate.js

@@ -17,6 +17,16 @@ const err = (code, message, nodeId) => ({
 const warn = (code, message, nodeId) => ({
     level: 'warn', code, message, nodeId,
 });
+/** 与平台 validateRequired 一致：空串、空数组、null/undefined 视为未填 */
+function isBlank(value) {
+    if (value === undefined || value === null)
+        return true;
+    if (typeof value === 'string')
+        return value.trim() === '';
+    if (Array.isArray(value))
+        return value.length === 0;
+    return false;
+}
 /** 基础信息校验 */
 function validateSpec(spec) {
     const out = [];
@@ -80,9 +90,21 @@ function validateGraph(graph, spec, startWay = 'StartActiveNode') {
         }
         // 与编译器一致：默认值（如 BranchNode.conditionType / flowWay）也算已填
         const config = { ...(schema_1.NODE_DEFAULTS[node.type] ?? {}), ...(node.config ?? {}) };
-        for (const field of schema_1.NODE_REQUIRED[node.type] ?? []) {
-            if (config[field] === undefined || config[field] === null || config[field] === '') {
-                out.push(err('NODE_FIELD_REQUIRED', `节点 ${node.id}（${node.type}）缺少必填字段 ${field}`, node.id));
+        const outgoing = graph.edges.filter((edge) => edge.from === node.id).length;
+        const ruleContext = { config, node: { context: node.context }, outgoing };
+        for (const rule of schema_1.NODE_REQUIRED_RULES[node.type] ?? []) {
+            if (rule.skipIf?.(ruleContext))
+                continue;
+            const value = rule.read ? rule.read(config) : config[rule.field];
+            if (isBlank(value)) {
+                out.push({
+                    level: 'error',
+                    code: 'NODE_FIELD_REQUIRED',
+                    message: `节点 ${node.id}（${node.type}）缺少必填字段 ${rule.field}：${rule.message}`,
+                    nodeId: node.id,
+                    field: rule.field,
+                    ...(rule.hint ? { hint: rule.hint } : {}),
+                });
             }
         }
     }

package/dist/index.js

@@ -12,7 +12,7 @@ const locale_1 = require("./commands/locale");
 const operation_1 = require("./commands/operation");
 const template_1 = require("./commands/template");
 const logger_1 = require("./utils/logger");
-const VERSION = '2.8.0';
+const VERSION = '2.9.0';
 const program = new commander_1.Command();
 exports.program = program;
 program

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lan-low-code-cli",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "description": "lan-low-code cli：低代码表单引擎命令行工具（创建表单、获取可用字段、自动完善表单字段）",
   "keywords": [
     "low-code",

package/skills/lan-low-code-cli/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: lan-low-code-cli
-version: 2.8.0
+version: 2.9.0
 author: Pig George
 description: Operate the Landray low-code form engine through the `llc` CLI. Use when the user asks to create, inspect, modify, publish, or delete low-code apps and forms; generate field configs; configure layouts (grid/tabs), field permissions, options, i18n, or control actions (onChange/onLoad); or run pre-publish validation. Also use for troubleshooting form loading/rendering errors.
 tags:

package/skills/lan-low-code-cli/SKILL.zh-CN.md

@@ -1,6 +1,6 @@
 ---
 name: lan-low-code-cli
-version: 2.8.0
+version: 2.9.0
 author: Pig George
 description: 通过 `llc` CLI 操作蓝凌低代码表单引擎。适用于：创建、查看、修改、发布或删除低代码应用与表单；生成字段配置；配置布局（栅格/页签）、字段权限、选项、多语言、控件动作（onChange/onLoad）；或执行发布前校验、排查表单加载/渲染报错。
 tags:

package/skills/lan-low-code-cli/references/cli-contract.md

@@ -285,6 +285,25 @@ Application-scoped action flows. Every write command needs `--yes` and an explic
 - `fields` of `AddDataNode` / `AddOrUpdateNode` uses the platform's real shape
   (`{field:{...},value:{format,valueJson}}`); the CLI passes it through and only validates field
   names — it does **not** synthesise formulas. Use `llc flow templates` / `flow get` for golden shapes.
+- **Per-node required fields** mirror the IDE rules table (`configuration/nodes/utils.tsx`) plus its
+  exemptions (`validate.ts`):
+  `TransformNode` requires `outParam` **and** `outputParamMapping` (`valueFormula`, or non-empty
+  `pointMappings`; mapping is exempt only when `outParam` is empty);
+  `ExecuteNode`/`InterfaceNode`/`SubActionNode`/`FlowBotsNode` require their code field
+  (`executeCode`/`apiMethodPath`/`actionFlowCode`/`flowBotsCode`) and a mapping when an inbound
+  Schema exists; `BranchNode` requires `conditionType`/`flowWay` plus the matching
+  `formulaConfig`/`ruleConfig` (auto-generated when branch edges exist); `LoopNode` requires
+  `loopDefine.type`; `MessageNode` validates `notifyType`/`subject`/`templateCode`/`linkPage`/`linkUrl`
+  by `subjectType` and `messageLink.linkType`; `AddDataNode`/`AddOrUpdateNode` skip `flow` for
+  category forms or when `commitType` is absent. Diagnostics carry `field` and `hint`; errors exit `1`.
+- **Parameter mapping shorthand**: `TransformNode` accepts `config.outParam` as a field map
+  (`{"fd_title":{"type":"string","description":"标题"}}`) or a full JSON Schema / Schema string, plus
+  `config.mapping` as `{"targetPath":"$<nodeId>.<path>"}` (also `$context.<path>`). The compiler emits
+  `outParamType=1`, `outParam` (Schema string), `outputParamMapping` (`pointMappings`) and copies the
+  Schema into `extraAttr.context_outputParam`. When `mapping` is absent it is inferred from an upstream
+  `context.context_outputParam` by matching field names (`MAPPING_AUTO_INFERRED` warning). Constants or
+  expressions require `{"paramMappingWay":"formula","valueFormula":"..."}`. `ExecuteNode` /
+  `InterfaceNode` / `SubActionNode` / `FlowBotsNode` reuse `config.mapping` for `inputParamMapping`.
 - Publishing derives `fdProcessActive` on the backend from `startNodeDef`; `fdStatus=1` means enabled.
   `flow logs` endpoints vary by deployment (`ModelingProcessLog/findAll` vs
   `sysModelingLog/findAllWithAppId`); use `--endpoint` if the defaults fail.

package/skills/lan-low-code-cli/references/cli-contract.zh-CN.md

@@ -272,6 +272,24 @@ llc operation detach --form-id <fdId> --operation-id <operationId>            #
 - `AddDataNode` / `AddOrUpdateNode` 的 `fields` 使用平台真实结构
   （`{field:{...},value:{format,valueJson}}`）；CLI 原样透传并只校验字段名，**不臆造公式**。
   需要真实结构请用 `llc flow templates` / `flow get` 抽取 golden 骨架。
+- **节点级必填校验**复刻 IDE 规则表（`configuration/nodes/utils.tsx`）及其豁免逻辑（`validate.ts`）：
+  `TransformNode` 必填 `outParam` **和** `outputParamMapping`（`valueFormula` 或非空
+  `pointMappings`；仅当 `outParam` 为空时豁免映射）；`ExecuteNode` / `InterfaceNode` /
+  `SubActionNode` / `FlowBotsNode` 必填各自的编码字段（`executeCode` / `apiMethodPath` /
+  `actionFlowCode` / `flowBotsCode`），且存在入参 Schema 时必填参数映射；`BranchNode` 必填
+  `conditionType` / `flowWay` 及对应的 `formulaConfig` / `ruleConfig`（有分支出边时自动生成）；
+  `LoopNode` 必填 `loopDefine.type`；`MessageNode` 按 `subjectType` 与 `messageLink.linkType`
+  校验 `notifyType` / `subject` / `templateCode` / `linkPage` / `linkUrl`；
+  `AddDataNode` / `AddOrUpdateNode` 在分类表单或未填 `commitType` 时豁免 `flow`。
+  诊断会带 `field` 与 `hint`，有错误时退出码为 `1`。
+- **参数映射简写**：`TransformNode` 的 `config.outParam` 可写字段映射对象
+  （`{"fd_title":{"type":"string","description":"标题"}}`），也可写完整 JSON Schema 或 Schema 字符串；
+  `config.mapping` 支持 `{"目标字段":"$<节点id>.<路径>"}`（也支持 `$context.<路径>`）。编译器会输出
+  `outParamType=1`、`outParam`（Schema 字符串）、`outputParamMapping`（`pointMappings`），并把 Schema
+  写入 `extraAttr.context_outputParam`。未写 `mapping` 时，会按上游 `context.context_outputParam`
+  的同名字段自动推断，并给出 `MAPPING_AUTO_INFERRED` 提示。常量或表达式需改用
+  `{"paramMappingWay":"formula","valueFormula":"..."}`。`ExecuteNode` / `InterfaceNode` /
+  `SubActionNode` / `FlowBotsNode` 复用 `config.mapping` 生成 `inputParamMapping`。
 - 发布时后端从 `startNodeDef` 派生 `fdProcessActive`；`fdStatus=1` 表示已启用。
   `flow logs` 端点因部署而异（`ModelingProcessLog/findAll` 与
   `sysModelingLog/findAllWithAppId`）；默认都失败时用 `--endpoint` 指定。