openyida 2026.5.21 → 2026.5.25

package/lib/process/configure-process.js

@@ -61,6 +61,172 @@ const COMPONENT_TO_RULE_TYPE = {
   EmployeeField: 'rule_employee',
 };
 
+const NODE_TYPE_ALIASES = {
+  approval: 'approval',
+  approver: 'approval',
+  approvalnode: 'approval',
+  operator: 'operator',
+  executor: 'operator',
+  handler: 'operator',
+  fill: 'operator',
+  filler: 'operator',
+  formfill: 'operator',
+  operatornode: 'operator',
+  multiapproval: 'multiApproval',
+  multiapprover: 'multiApproval',
+  multiapprovalnode: 'multiApproval',
+  carbon: 'carbon',
+  cc: 'carbon',
+  copy: 'carbon',
+  copynode: 'carbon',
+  carbonnode: 'carbon',
+  route: 'route',
+  branch: 'route',
+  branchnode: 'route',
+  conditioncontainer: 'route',
+  conditionnode: 'route',
+  parallel: 'parallel',
+  parallelbranch: 'parallel',
+  connector: 'ConnectorNode',
+  connectornode: 'ConnectorNode',
+  groovy: 'GroovyNode',
+  groovynode: 'GroovyNode',
+  javascript: 'JavaScriptNode',
+  js: 'JavaScriptNode',
+  javascriptnode: 'JavaScriptNode',
+  initiateapproval: 'InitiateApprovalNode',
+  subprocess: 'InitiateApprovalNode',
+  initiateapprovalnode: 'InitiateApprovalNode',
+  sendmessage: 'SendMessageNode',
+  message: 'SendMessageNode',
+  sendmessagenode: 'SendMessageNode',
+  sendemail: 'SendEmailNode',
+  email: 'SendEmailNode',
+  sendemailnode: 'SendEmailNode',
+  getdata: 'GetSingleDataNode',
+  getsingledata: 'GetSingleDataNode',
+  getsingledatanode: 'GetSingleDataNode',
+  getbatchdata: 'GetBatchDataNode',
+  getbatchdatanode: 'GetBatchDataNode',
+  adddata: 'AddDataNode',
+  createdata: 'AddDataNode',
+  adddatanode: 'AddDataNode',
+  updatedata: 'UpdateDataNode',
+  updatedatanode: 'UpdateDataNode',
+  deletedata: 'DeleteDataNode',
+  deletedatanode: 'DeleteDataNode',
+  sendcard: 'SendCardNode',
+  sendcardnode: 'SendCardNode',
+  cardnode: 'CardNode',
+  updatecard: 'UpdateCardNode',
+  updatecardnode: 'UpdateCardNode',
+  cardupdate: 'CardUpdateNode',
+  cardupdatenode: 'CardUpdateNode',
+  cycle: 'CycleContainer',
+  foreach: 'CycleContainer',
+  cyclecontainer: 'CycleContainer',
+  ai: 'AINode',
+  ainode: 'AINode',
+};
+
+const CONNECTOR_MODE_TO_PROCESS_TYPE = {
+  1: 'innerConnector',
+  3: 'thirdConnector',
+  5: 'httpConnector',
+  9: 'faasConnector',
+};
+
+const GENERIC_NODE_CONFIGS = {
+  ConnectorNode: {
+    processType: 'innerConnector',
+    title: ['连接器', 'Connector', 'コネクタ'],
+    propKeys: ['connectorRules'],
+  },
+  GroovyNode: {
+    processType: 'CodeExecutor',
+    title: ['Groovy', 'Groovy', 'Groovy'],
+    propKeys: ['groovy'],
+  },
+  JavaScriptNode: {
+    processType: 'CodeExecutor',
+    title: ['JavaScript', 'JavaScript', 'JavaScript'],
+    propKeys: ['JavaScript'],
+    propAliases: { javascript: 'JavaScript' },
+  },
+  InitiateApprovalNode: {
+    processType: 'initiateApproval',
+    title: ['子流程', 'Sub process', 'サブプロセス'],
+    propKeys: ['initiateApprovalRules'],
+  },
+  SendMessageNode: {
+    processType: 'sendMessage',
+    title: ['消息通知', 'Message notification', 'メッセージ通知'],
+    propKeys: ['sendMessageRules'],
+  },
+  SendEmailNode: {
+    processType: 'sendEmail',
+    title: ['发送邮件', 'Send email', 'メール送信'],
+    propKeys: ['sendEmailRules'],
+  },
+  GetSingleDataNode: {
+    processType: 'dataRetrieve',
+    title: ['获取单条数据', 'Get single data', '単一データ取得'],
+    propKeys: ['getData'],
+  },
+  GetBatchDataNode: {
+    processType: 'dataRetrieve',
+    title: ['获取多条数据', 'Get batch data', '複数データ取得'],
+    propKeys: ['getData'],
+  },
+  AddDataNode: {
+    processType: 'dataCreate',
+    title: ['新增数据', 'Add data', 'データ追加'],
+    propKeys: ['addDataRules'],
+  },
+  UpdateDataNode: {
+    processType: 'dataUpdate',
+    title: ['更新数据', 'Update data', 'データ更新'],
+    propKeys: ['updateDataRules'],
+  },
+  DeleteDataNode: {
+    processType: 'dataDelete',
+    title: ['删除数据', 'Delete data', 'データ削除'],
+    propKeys: ['deleteData'],
+  },
+  SendCardNode: {
+    processType: 'sendCard',
+    title: ['发送卡片', 'Send card', 'カード送信'],
+    propKeys: ['sendCardRules', 'cardRules'],
+  },
+  CardNode: {
+    processType: 'sendCard',
+    title: ['发送卡片', 'Send card', 'カード送信'],
+    propKeys: ['sendCardRules', 'cardRules'],
+  },
+  UpdateCardNode: {
+    processType: 'updateCard',
+    title: ['更新卡片', 'Update card', 'カード更新'],
+    propKeys: ['updateCardRules', 'cardUpdateRules'],
+  },
+  CardUpdateNode: {
+    processType: 'updateCard',
+    title: ['更新卡片', 'Update card', 'カード更新'],
+    propKeys: ['updateCardRules', 'cardUpdateRules'],
+  },
+  CycleContainer: {
+    processType: 'foreach',
+    title: ['循环', 'Loop', 'ループ'],
+    propKeys: ['cycleContainerRules'],
+    propAliases: { cycleRules: 'cycleContainerRules', foreachRules: 'cycleContainerRules' },
+  },
+  AINode: {
+    processType: 'AIExecutor',
+    title: ['AI 工作流', 'AI workflow', 'AI ワークフロー'],
+    propKeys: ['workFlowRules'],
+    propAliases: { workflowRules: 'workFlowRules' },
+  },
+};
+
 // ── 辅助函数 ─────────────────────────────────────────
 
 function generateUuid() {
@@ -95,9 +261,53 @@ function normalizeList(value) {
 }
 
 function clonePlain(value) {
+  if (value === undefined) {
+    return undefined;
+  }
   return JSON.parse(JSON.stringify(value));
 }
 
+function normalizeNodeType(node) {
+  if (!node) {
+    return '';
+  }
+  if (node.componentName && GENERIC_NODE_CONFIGS[node.componentName]) {
+    return node.componentName;
+  }
+  const rawType = pickFirstDefined(node.type, node.kind, node.nodeType, node.componentName);
+  if (!rawType) {
+    return '';
+  }
+  const raw = String(rawType).trim();
+  const normalized = raw.toLowerCase().replace(/[-_\s]/g, '');
+  return NODE_TYPE_ALIASES[normalized] || raw;
+}
+
+function getNodeName(node, fallback) {
+  const value = pickFirstDefined(
+    node && node.name,
+    node && node.title,
+    node && node.props && node.props.name,
+    fallback
+  );
+  if (isPlainObject(value)) {
+    return pickFirstDefined(value.zh_CN, value.en_US, value.ja_JP, fallback) || fallback;
+  }
+  return String(value || fallback || '');
+}
+
+function getNodeDescription(node) {
+  const value = pickFirstDefined(
+    node && node.description,
+    node && node.props && node.props.description,
+    ''
+  );
+  if (isPlainObject(value)) {
+    return pickFirstDefined(value.zh_CN, value.en_US, value.ja_JP, '') || '';
+  }
+  return String(value || '');
+}
+
 function pickFirstDefined() {
   for (let i = 0; i < arguments.length; i++) {
     if (arguments[i] !== undefined && arguments[i] !== null && arguments[i] !== '') {
@@ -621,7 +831,8 @@ function buildRouteRule(routeRuleDefs, currentNodeId, nodeNameToIdMap) {
 
 function assignNodeIdsRecursive(nodes, nameToIdMap) {
   nodes.forEach(function (node) {
-    if (node.type === 'route') {
+    const nodeType = normalizeNodeType(node);
+    if (nodeType === 'route') {
       node._nodeId = generateNodeId();
       const conditions = node.conditions || [];
       conditions.forEach(function (cond) {
@@ -630,7 +841,7 @@ function assignNodeIdsRecursive(nodes, nameToIdMap) {
           assignNodeIdsRecursive(cond.childNodes, nameToIdMap);
         }
       });
-    } else if (node.type === 'parallel') {
+    } else if (nodeType === 'parallel') {
       node._nodeId = generateNodeId();
       if (node.name) {
         nameToIdMap[node.name] = node._nodeId;
@@ -643,6 +854,15 @@ function assignNodeIdsRecursive(nodes, nameToIdMap) {
           assignNodeIdsRecursive(childNodes, nameToIdMap);
         }
       });
+    } else if (GENERIC_NODE_CONFIGS[nodeType]) {
+      node._nodeId = generateNodeId();
+      if (node.name) {
+        nameToIdMap[node.name] = node._nodeId;
+      }
+      const childNodes = getGenericChildNodes(node);
+      if (childNodes.length > 0) {
+        assignNodeIdsRecursive(childNodes, nameToIdMap);
+      }
     } else {
       node._nodeId = generateNodeId();
       if (node.name) {
@@ -661,23 +881,30 @@ function buildNodeListRecursive(nodes, exitNodeId, nameToIdMap) {
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
     const nextNodeId = i + 1 < nodes.length ? nodes[i + 1]._nodeId : exitNodeId;
+    const nodeType = normalizeNodeType(node);
 
-    if (node.type === 'route') {
+    if (nodeType === 'route') {
       const routeResult = buildRouteNode(node, nextNodeId, nameToIdMap);
       processNodes.push(routeResult.processNode);
       viewNodes.push(routeResult.viewNode);
-    } else if (node.type === 'parallel') {
+    } else if (nodeType === 'parallel') {
       const parallelResult = buildParallelNode(node, nextNodeId, nameToIdMap);
       processNodes.push(parallelResult.processNode);
       viewNodes.push(parallelResult.viewNode);
-    } else if (node.type === 'approval') {
-      const approvalResult = buildApprovalNode(node, nextNodeId, nameToIdMap);
+    } else if (nodeType === 'approval' || nodeType === 'operator' || nodeType === 'multiApproval') {
+      const approvalResult = buildApprovalNode(node, nextNodeId, nameToIdMap, nodeType);
       processNodes.push(approvalResult.processNode);
       viewNodes.push(approvalResult.viewNode);
-    } else if (node.type === 'carbon') {
+    } else if (nodeType === 'carbon') {
       const carbonResult = buildCarbonNode(node, nextNodeId);
       processNodes.push(carbonResult.processNode);
       viewNodes.push(carbonResult.viewNode);
+    } else if (GENERIC_NODE_CONFIGS[nodeType]) {
+      const genericResult = buildGenericNode(node, nextNodeId, nameToIdMap, nodeType);
+      processNodes.push(genericResult.processNode);
+      viewNodes.push(genericResult.viewNode);
+    } else {
+      throw new Error('不支持的流程节点类型: ' + (node.type || node.componentName || node.kind || JSON.stringify(node)));
     }
   }
 
@@ -697,12 +924,18 @@ function wireChildProcessNodes(childProcessNodes, parentNodeId) {
 // ── 构建审批节点 ─────────────────────────────────────
 
 function buildApproverConfig(node) {
-  const friendlyApprover = buildFriendlyApproverConfig(node, node.approverConfig || node.approver);
+  const approverInput = node.approverConfig
+    || node.approver
+    || node.executor
+    || node.operator
+    || node.receiver
+    || node.receivers;
+  const friendlyApprover = buildFriendlyApproverConfig(node, approverInput);
   if (friendlyApprover) {
     return friendlyApprover;
   }
 
-  const rawApprover = node.approverConfig || (node.approver && typeof node.approver === 'object' ? node.approver : null);
+  const rawApprover = node.approverConfig || (approverInput && typeof approverInput === 'object' ? approverInput : null);
   if (rawApprover) {
     return {
       approvalType: rawApprover.approvalType || rawApprover.type || 'ext_target_approval_originator',
@@ -742,10 +975,22 @@ function buildApproverConfig(node) {
   return buildOriginatorApproverConfig(node, {});
 }
 
-function buildApprovalNode(node, nextNodeId, nameToIdMap) {
+function buildApprovalNode(node, nextNodeId, nameToIdMap, nodeType) {
   const nodeId = node._nodeId;
   const routeRule = buildRouteRule(node.routeRules || [], nodeId, nameToIdMap);
   const approverConfig = buildApproverConfig(node);
+  const approvalNodeType = nodeType || normalizeNodeType(node);
+  const componentName = approvalNodeType === 'operator'
+    ? 'OperatorNode'
+    : (approvalNodeType === 'multiApproval' ? 'MultiApprovalNode' : 'ApprovalNode');
+  const titleText = approvalNodeType === 'operator'
+    ? ['办理人', 'Executor', '実行者']
+    : (approvalNodeType === 'multiApproval'
+      ? ['审批人', 'Approver', '承認者']
+      : ['审批人', 'Approver', '承認者']);
+  const defaultName = approvalNodeType === 'operator' ? '办理人' : '审批人';
+  const displayName = getNodeName(node, defaultName);
+  const nodeDescription = approverConfig.description || getNodeDescription(node) || '请选择审批人';
 
   // 构建字段权限（formConfig.behaviorList）
   // 兼容两种输入格式：
@@ -787,8 +1032,8 @@ function buildApprovalNode(node, nextNodeId, nameToIdMap) {
   }
 
   const processNode = {
-    name: i18n(node.name || '审批人', 'Approver', node.name || '承認者'),
-    description: approverConfig.description,
+    name: i18n(displayName, titleText[1], displayName),
+    description: nodeDescription,
     type: 'approval',
     approvalType: approverConfig.approvalType,
     nodeId: nodeId,
@@ -799,9 +1044,9 @@ function buildApprovalNode(node, nextNodeId, nameToIdMap) {
   };
 
   const viewNodeProps = {
-    nodeName: 'ApprovalNode',
-    name: i18n(node.name || '审批人', 'Approver', node.name || '承認者'),
-    description: approverConfig.description,
+    nodeName: componentName,
+    name: i18n(displayName, titleText[1], displayName),
+    description: nodeDescription,
     approverRules: approverConfig.approverRules,
     actions: {
       normalActions: buildActions(),
@@ -814,10 +1059,10 @@ function buildApprovalNode(node, nextNodeId, nameToIdMap) {
   }
 
   const viewNode = {
-    componentName: 'ApprovalNode',
+    componentName: componentName,
     id: nodeId,
     props: viewNodeProps,
-    title: i18n('审批人', 'Approver', '承認者'),
+    title: i18n(titleText[0], titleText[1], titleText[2]),
   };
 
   return { processNode, viewNode };
@@ -829,9 +1074,11 @@ function buildCarbonNode(node, nextNodeId) {
   const nodeId = node._nodeId;
   const approverConfig = buildApproverConfig(node);
   const carbonReceiver = approverConfig.carbonReceiver || { type: 'VARIABLE', value: approverConfig.approvals || [['originator']] };
+  const displayName = getNodeName(node, '抄送人');
+  const nodeDescription = getNodeDescription(node) || '请选择抄送人';
 
   const processNode = {
-    name: i18n(node.name || '抄送人', 'CC', node.name || '共有先'),
+    name: i18n(displayName, 'CC', displayName),
     description: '',
     type: 'carbon',
     approvalType: approverConfig.approvalType,
@@ -856,8 +1103,8 @@ function buildCarbonNode(node, nextNodeId) {
     id: nodeId,
     props: {
       nodeName: 'CarbonNode',
-      name: i18n(node.name || '抄送人', 'CC', node.name || '共有先'),
-      description: node.description || '请选择抄送人',
+      name: i18n(displayName, 'CC', displayName),
+      description: nodeDescription,
       approverRules: approverConfig.approverRules,
     },
     title: i18n('抄送人', 'CC', '共有先'),
@@ -866,6 +1113,291 @@ function buildCarbonNode(node, nextNodeId) {
   return { processNode, viewNode };
 }
 
+// ── 构建真实组件节点（连接器、数据、消息、代码、子流程等）──
+
+function getGenericChildNodes(node) {
+  const childNodes = node.childNodes || node.children || node.nodes || [];
+  return Array.isArray(childNodes) ? childNodes : [];
+}
+
+function buildGenericNodeProps(node, componentName) {
+  const config = GENERIC_NODE_CONFIGS[componentName] || {};
+  const props = Object.assign({}, node.props || {});
+  const displayName = getNodeName(node, config.title ? config.title[0] : componentName);
+  const description = getNodeDescription(node);
+
+  if (!props.name) {
+    props.name = i18n(displayName, config.title ? config.title[1] : displayName, displayName);
+  }
+  if (!props.nodeName) {
+    props.nodeName = componentName;
+  }
+  if (!props.description && description) {
+    props.description = description;
+  }
+
+  Object.keys(config.propAliases || {}).forEach(function (sourceKey) {
+    const targetKey = config.propAliases[sourceKey];
+    if (node[sourceKey] !== undefined && props[targetKey] === undefined) {
+      props[targetKey] = clonePlain(node[sourceKey]);
+    }
+  });
+
+  (config.propKeys || []).forEach(function (key) {
+    if (node[key] !== undefined && props[key] === undefined) {
+      props[key] = clonePlain(node[key]);
+    }
+  });
+
+  if (node.viewProps && isPlainObject(node.viewProps)) {
+    Object.assign(props, clonePlain(node.viewProps));
+  }
+
+  return props;
+}
+
+function getGenericProcessType(componentName, node, props) {
+  if (node.processType || node.processNodeType) {
+    return node.processType || node.processNodeType;
+  }
+
+  if (componentName === 'ConnectorNode') {
+    const connectorRules = props.connectorRules || {};
+    const connector = connectorRules.connector || {};
+    const mode = connector.mode || connectorRules.mode;
+    return CONNECTOR_MODE_TO_PROCESS_TYPE[mode] || GENERIC_NODE_CONFIGS[componentName].processType;
+  }
+
+  return GENERIC_NODE_CONFIGS[componentName].processType;
+}
+
+function pickRuleAssignments(ruleContainer) {
+  if (!ruleContainer) {
+    return [];
+  }
+  if (Array.isArray(ruleContainer.assignments)) {
+    return clonePlain(ruleContainer.assignments);
+  }
+  if (ruleContainer.inputs && Array.isArray(ruleContainer.inputs.assignments)) {
+    return clonePlain(ruleContainer.inputs.assignments);
+  }
+  if (Array.isArray(ruleContainer.rules)) {
+    return ruleContainer.rules
+      .map(function (rule) {
+        if (Array.isArray(rule && rule.rules)) {
+          return clonePlain(rule.rules);
+        }
+        return null;
+      })
+      .filter(Boolean)
+      .reduce(function (all, rules) {
+        return all.concat(rules);
+      }, []);
+  }
+  return [];
+}
+
+function buildConnectorProcessProps(props) {
+  const connectorRules = props.connectorRules || {};
+  const inputs = Object.assign({}, clonePlain(connectorRules.inputs || {}), {
+    url: connectorRules.url,
+    method: connectorRules.method,
+    body: connectorRules.body,
+    connection: connectorRules.connectionId || connectorRules.connection,
+    connectorId: connectorRules.connectorId,
+    actionId: connectorRules.actionId,
+  });
+  const assignments = pickRuleAssignments(connectorRules);
+
+  if (assignments.length > 0) {
+    inputs.assignments = assignments;
+  }
+  if (connectorRules.openDevSchemaType === 'integrationObject') {
+    inputs.openDevSchemaType = 'integrationObject';
+    inputs.connectorOrgId = connectorRules.connector && connectorRules.connector.orgId;
+    inputs.integrationObject = connectorRules.integrationObject;
+    inputs.integrationObjectPath = connectorRules.integrationObjectPath;
+  }
+
+  Object.keys(inputs).forEach(function (key) {
+    if (inputs[key] === undefined) {
+      delete inputs[key];
+    }
+  });
+
+  return { inputs };
+}
+
+function buildCodeExecutorProcessProps(props, componentName) {
+  const codeConfig = componentName === 'GroovyNode' ? props.groovy : props.JavaScript;
+  if (!codeConfig) {
+    return {};
+  }
+  const outputs = Array.isArray(codeConfig.outputs)
+    ? codeConfig.outputs.map(function (output) {
+      return {
+        description: output.desc || output.description,
+        name: output.name,
+        type: output.type,
+        valueType: output.valueType,
+      };
+    })
+    : undefined;
+  return {
+    inputs: clonePlain(codeConfig.inputs),
+    action: clonePlain(codeConfig.action),
+    scriptType: codeConfig.scriptType,
+    outputsSchema: outputs,
+  };
+}
+
+function buildGetDataProcessProps(props) {
+  const getData = props.getData || {};
+  return {
+    type: props.type,
+    filterType: getData.filterType,
+    sort: clonePlain(getData.sort),
+    sourceId: getData.sourceId,
+    appType: getData.appType,
+    originalType: getData.originalType,
+    subSourceId: getData.subSourceId,
+    condition: clonePlain(getData.condition),
+    quantity: getData.quantity === undefined ? undefined : String(getData.quantity),
+    dataRules: clonePlain(getData.dataRules),
+    assignments: clonePlain(getData.assignments),
+  };
+}
+
+function buildAddDataProcessProps(props) {
+  const addDataRules = props.addDataRules || {};
+  return {
+    formUuid: addDataRules.formUuid || '',
+    appType: addDataRules.appType || '',
+    subFormUuid: addDataRules.subFormUuid || '',
+    insertType: addDataRules.insertType || '',
+    type: addDataRules.type || '',
+    sourceId: addDataRules.sourceId || '',
+    assignments: pickRuleAssignments(addDataRules),
+  };
+}
+
+function buildAIProcessProps(props) {
+  const workFlowRules = props.workFlowRules || {};
+  return {
+    type: 'aiFlow',
+    action: workFlowRules.flowId ? { flowId: workFlowRules.flowId } : undefined,
+    outputs: clonePlain(workFlowRules.outputs),
+    yidaFieldIdList: clonePlain(workFlowRules.yidaFieldIdList),
+  };
+}
+
+function pruneUndefined(value) {
+  if (!isPlainObject(value)) {
+    return value;
+  }
+  Object.keys(value).forEach(function (key) {
+    if (value[key] === undefined) {
+      delete value[key];
+    }
+  });
+  return value;
+}
+
+function buildGenericProcessProps(props, node, componentName) {
+  let processProps;
+
+  if (componentName === 'ConnectorNode') {
+    processProps = buildConnectorProcessProps(props);
+  } else if (componentName === 'GroovyNode' || componentName === 'JavaScriptNode') {
+    processProps = buildCodeExecutorProcessProps(props, componentName);
+  } else if (componentName === 'InitiateApprovalNode') {
+    processProps = clonePlain(props.initiateApprovalRules || {});
+  } else if (componentName === 'SendMessageNode') {
+    processProps = clonePlain(props.sendMessageRules || {});
+    delete processProps.description;
+  } else if (componentName === 'SendEmailNode') {
+    processProps = clonePlain(props.sendEmailRules || {});
+  } else if (componentName === 'GetSingleDataNode' || componentName === 'GetBatchDataNode') {
+    processProps = buildGetDataProcessProps(props);
+  } else if (componentName === 'AddDataNode') {
+    processProps = buildAddDataProcessProps(props);
+  } else if (componentName === 'UpdateDataNode') {
+    processProps = clonePlain(props.updateDataRules || {});
+  } else if (componentName === 'DeleteDataNode') {
+    processProps = clonePlain(props.deleteData || {});
+  } else if (componentName === 'SendCardNode') {
+    processProps = clonePlain(props.sendCardRules || {});
+  } else if (componentName === 'UpdateCardNode') {
+    processProps = clonePlain(props.updateCardRules || {});
+  } else if (componentName === 'CardNode') {
+    processProps = clonePlain(props.cardRules || {});
+  } else if (componentName === 'CardUpdateNode') {
+    processProps = clonePlain(props.cardUpdateRules || {});
+  } else if (componentName === 'CycleContainer') {
+    processProps = clonePlain(props.cycleContainerRules || {});
+  } else if (componentName === 'AINode') {
+    processProps = buildAIProcessProps(props);
+  } else {
+    processProps = clonePlain(props);
+  }
+
+  delete processProps.name;
+  delete processProps.nodeName;
+  delete processProps.description;
+  delete processProps.title;
+  pruneUndefined(processProps);
+  if (node.processProps && isPlainObject(node.processProps)) {
+    Object.assign(processProps, clonePlain(node.processProps));
+  }
+  return processProps;
+}
+
+function buildGenericNode(node, nextNodeId, nameToIdMap, componentName) {
+  const nodeId = node._nodeId;
+  const config = GENERIC_NODE_CONFIGS[componentName];
+  const props = buildGenericNodeProps(node, componentName);
+  const displayName = getNodeName(node, config.title[0]);
+  const description = getNodeDescription(node);
+  const childNodes = getGenericChildNodes(node);
+  let childProcessNodes = [];
+  let childViewNodes = [];
+
+  if (childNodes.length > 0) {
+    const childResult = buildNodeListRecursive(childNodes, nextNodeId, nameToIdMap);
+    childProcessNodes = childResult.processNodes;
+    childViewNodes = childResult.viewNodes;
+    wireChildProcessNodes(childProcessNodes, nodeId);
+  }
+
+  const processNode = {
+    name: i18n(displayName, config.title[1], displayName),
+    description: description,
+    type: getGenericProcessType(componentName, node, props),
+    nodeId: nodeId,
+    prevId: '',
+    nextId: childProcessNodes.length > 0 ? [childProcessNodes[0].nodeId] : [nextNodeId],
+    props: buildGenericProcessProps(props, node, componentName),
+    childNodes: childProcessNodes.map(clonePlain),
+  };
+
+  if (node.approvalType) {
+    processNode.approvalType = node.approvalType;
+  }
+
+  const viewNode = {
+    componentName: componentName,
+    id: nodeId,
+    props: props,
+    title: i18n(config.title[0], config.title[1], config.title[2]),
+  };
+
+  if (childViewNodes.length > 0) {
+    viewNode.children = childViewNodes;
+  }
+
+  return { processNode, viewNode };
+}
+
 // ── 构建条件分支路由节点 ─────────────────────────────
 
 function buildRouteNode(node, exitNodeId, nameToIdMap) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openyida",
-  "version": "2026.5.21",
+  "version": "2026.5.25",
   "description": "OpenYida CLI - 宜搭低代码 AI 开发工具（安装即用，零配置）",
   "bin": {
     "openyida": "bin/yida.js",