openyida 2026.9.7 → 2026.9.8

package/lib/integration/integration-spec-builder.js

@@ -16,11 +16,33 @@ const {
   resolveConnectorMode,
   validateAssignments,
 } = require('./integration-process-builder');
-const { buildAddDataChildList, assertAssignmentFieldsExist } = require('./integration-view-builder');
+const {
+  buildAddDataChildList,
+  buildSubTableAddDataChildList,
+  resolveTableFieldLabel,
+  listTableFieldSummaries,
+  buildSubTableRelativeItem,
+  assertAssignmentFieldsExist,
+} = require('./integration-view-builder');
 const {
   lookupConnectorPreset,
   buildConnectorRulesFromInputs,
 } = require('./connector-presets');
+const {
+  normalizeSourceFormType,
+  resolveSourceFormUuid,
+  resolveDataSourceFormName,
+  resolveDataSourceFormType,
+  resolveDataOriginalType,
+  resolveDataFormItemType,
+  isSubTableOriginalType,
+  resolveDataQueryField,
+  toRuntimeDataQueryField,
+  toDesignerDataQueryField,
+  normalizeDataQueryFieldName,
+  resolveDesignerDataQueryField,
+  resolveDataQueryFieldName,
+} = require('./integration-form-metadata');
 const { t } = require('../core/i18n');
 
 function readIntegrationSpec(filePath) {
@@ -54,7 +76,7 @@ function mapSpecEventTypes(spec, fallbackEvents) {
   return mapEventTypes(getSpecEventInput(spec, fallbackEvents));
 }
 
-function validateIntegrationSpec(spec, fallbackEvents = ['insert']) {
+function validateIntegrationSpec(spec, fallbackEvents = ['insert'], options = {}) {
   if (!spec || typeof spec !== 'object' || Array.isArray(spec)) {
     throw new Error('--spec must point to a JSON object');
   }
@@ -81,14 +103,27 @@ function validateIntegrationSpec(spec, fallbackEvents = ['insert']) {
         }
         aliases.add(explicitAlias);
       }
-      if (type === 'dataRetrieve' && !(node.formUuid || node.sourceId)) {
-        throw new Error('dataRetrieve node formUuid is required');
+      if (type === 'dataRetrieve') {
+        if (isSubTableRetrieve(node)) {
+          if (!getSourceAlias(node) || !node.subSourceId) {
+            throw new Error('dataRetrieve sub_table node source and subSourceId are required');
+          }
+        } else if (!(node.formUuid || node.sourceId)) {
+          throw new Error('dataRetrieve node formUuid is required');
+        }
+      }
+      if (type === 'getSelf' || type === 'dataRetrieve') {
+        resolveDeclaredSourceFormType(node);
       }
       if (type === 'dataRetrieve' && asArray(node.conditions || node.dataConditions).length === 0) {
         throw new Error(t('integration.spec_data_retrieve_conditions_required'));
       }
       if (type === 'dataCreate') {
-        if (!(node.formUuid || node.targetFormUuid)) {
+        if (isSubTableInsert(node)) {
+          if (!getSourceAlias(node) || !node.subFormUuid) {
+            throw new Error('dataCreate sub_table node source and subFormUuid are required');
+          }
+        } else if (!(node.formUuid || node.targetFormUuid)) {
           throw new Error('dataCreate node formUuid is required');
         }
         validateAssignments(asArray(node.assignments), 'dataCreate assignment');
@@ -174,6 +209,7 @@ function validateIntegrationSpec(spec, fallbackEvents = ['insert']) {
     }
   }
   validateNodes(getSpecNodes(spec));
+  assertSubTableSources(spec, options.formUuid || options.triggerFormUuid);
 }
 
 function normalizeLogic(logic) {
@@ -188,6 +224,217 @@ function getNodeAlias(node, fallback) {
   return node.id || node.key || fallback;
 }
 
+function isSubTableValue(value) {
+  return String(value || '').trim().toLowerCase() === 'sub_table';
+}
+
+function isSubTableRetrieve(node = {}) {
+  return isSubTableValue(node.originalType);
+}
+
+function isSubTableInsert(node = {}) {
+  return isSubTableValue(node.insertType);
+}
+
+function getSourceAlias(node = {}) {
+  return node.source || node.from || '';
+}
+
+const SUB_TABLE_SOURCE_TYPES = new Set(['getSelf', 'dataRetrieve']);
+
+function getNodeType(node = {}) {
+  return normalizeNodeType(node.type || node.componentName);
+}
+
+function getDeclaredAlias(node = {}) {
+  return node.id || node.key || '';
+}
+
+function collectBranchNodes(branch) {
+  return branch && (branch.nodes || branch.childNodes || branch.children);
+}
+
+function indexSpecNodesByAlias(spec) {
+  const byAlias = new Map();
+  visitSpecNodes(spec, (node) => {
+    const alias = getDeclaredAlias(node);
+    if (alias && !byAlias.has(alias)) {
+      byAlias.set(alias, node);
+    }
+  });
+  return byAlias;
+}
+
+function collectUpstreamAliasMaps(spec) {
+  const upstreamByNode = new WeakMap();
+  function visit(nodes, inheritedUpstream) {
+    const seen = new Map(inheritedUpstream);
+    for (const node of asArray(nodes)) {
+      if (!node || typeof node !== 'object') {
+        continue;
+      }
+      upstreamByNode.set(node, new Map(seen));
+      const type = getNodeType(node);
+      if (type === 'route') {
+        const branchUpstream = new Map(seen);
+        const routeAlias = getDeclaredAlias(node);
+        if (routeAlias) {
+          branchUpstream.set(routeAlias, node);
+        }
+        for (const branch of asArray(node.branches || node.conditions)) {
+          visit(collectBranchNodes(branch), branchUpstream);
+        }
+      }
+      const alias = getDeclaredAlias(node);
+      if (alias) {
+        seen.set(alias, node);
+      }
+    }
+  }
+  visit(getSpecNodes(spec), new Map());
+  return upstreamByNode;
+}
+
+function assertSubTableSources(spec, triggerFormUuid) {
+  const nodesByAlias = indexSpecNodesByAlias(spec);
+  const upstreamByNode = collectUpstreamAliasMaps(spec);
+  visitSpecNodes(spec, (node) => {
+    if (!isSubTableRetrieve(node) && !isSubTableInsert(node)) {
+      return;
+    }
+    const sourceAlias = getSourceAlias(node);
+    if (!sourceAlias) {
+      return;
+    }
+    const sourceNode = nodesByAlias.get(sourceAlias);
+    if (!sourceNode) {
+      throw new Error(`Unknown integration spec node alias: ${sourceAlias}`);
+    }
+    const sourceType = getNodeType(sourceNode);
+    if (!SUB_TABLE_SOURCE_TYPES.has(sourceType)) {
+      throw new Error(
+        `sub_table source must be a getSelf or dataRetrieve node: ${sourceAlias}`
+      );
+    }
+    const upstream = upstreamByNode.get(node);
+    if (!upstream || !upstream.has(sourceAlias)) {
+      throw new Error(`sub_table source must be an upstream node: ${sourceAlias}`);
+    }
+    resolveSubTableParentFormUuidFromSource(node, sourceNode, triggerFormUuid);
+  });
+}
+
+function visitSpecNodes(spec, visitor) {
+  function visit(nodes) {
+    for (const node of asArray(nodes)) {
+      if (!node || typeof node !== 'object') {
+        continue;
+      }
+      visitor(node);
+      const type = normalizeNodeType(node.type || node.componentName);
+      if (type === 'route') {
+        for (const branch of asArray(node.branches || node.conditions)) {
+          visit(branch && (branch.nodes || branch.childNodes || branch.children));
+        }
+      }
+    }
+  }
+  visit(getSpecNodes(spec));
+}
+
+function findSpecNodeByAlias(spec, alias) {
+  if (!alias) {
+    return null;
+  }
+  let found = null;
+  visitSpecNodes(spec, (node) => {
+    if (!found && (node.id || node.key) === alias) {
+      found = node;
+    }
+  });
+  return found;
+}
+
+function inferSubTableParentFormUuid(sourceNode, triggerFormUuid) {
+  if (!sourceNode) {
+    return '';
+  }
+  if (getNodeType(sourceNode) === 'getSelf') {
+    return triggerFormUuid || '';
+  }
+  return sourceNode.formUuid || sourceNode.sourceId || sourceNode.targetFormUuid || '';
+}
+
+function resolveSubTableParentFormUuidFromSource(node, sourceNode, triggerFormUuid) {
+  const inferred = inferSubTableParentFormUuid(sourceNode, triggerFormUuid);
+  const explicit = node.parentFormUuid ? String(node.parentFormUuid) : '';
+  if (explicit && inferred && explicit !== String(inferred)) {
+    throw new Error(
+      `sub_table parentFormUuid must match the source form: ${explicit} != ${inferred}`
+    );
+  }
+  return explicit || inferred || '';
+}
+
+function resolveSubTableParentFormUuid(node, spec, triggerFormUuid) {
+  return resolveSubTableParentFormUuidFromSource(
+    node,
+    findSpecNodeByAlias(spec, getSourceAlias(node)),
+    triggerFormUuid
+  );
+}
+
+function resolveContextSourceNode(node, context) {
+  const sourceAlias = getSourceAlias(node);
+  if (!sourceAlias || !context.aliasToSpecNode) {
+    return null;
+  }
+  return context.aliasToSpecNode.get(sourceAlias) || null;
+}
+
+function resolveSubTableParentFormUuidFromContext(node, context) {
+  return resolveSubTableParentFormUuidFromSource(
+    node,
+    resolveContextSourceNode(node, context),
+    context.formUuid
+  );
+}
+
+function resolveDeclaredSourceFormType(node = {}) {
+  const declarations = [
+    ['formType', node.formType],
+    ['sourceFormType', node.sourceFormType],
+    ['originalType', node.originalType],
+  ].filter(([field, value]) => value !== undefined
+    && value !== null
+    && String(value).trim() !== ''
+    && !(field === 'originalType' && isSubTableOriginalType(value)))
+    .map(([field, value]) => ({
+      field,
+      rawValue: value,
+      normalized: normalizeSourceFormType(value),
+    }));
+  if (declarations.length === 0) {
+    return { rawValue: undefined, normalized: '' };
+  }
+  const unsupported = declarations.find((declaration) => !declaration.normalized);
+  if (unsupported) {
+    throw new Error(`Unsupported source form type: ${unsupported.rawValue}`);
+  }
+  const normalizedTypes = new Set(declarations.map((declaration) => declaration.normalized));
+  if (normalizedTypes.size > 1) {
+    throw new Error(
+      `Conflicting source form types on node: ${declarations.map((declaration) => (
+        `${declaration.field}=${declaration.rawValue}`
+      )).join(', ')}`
+    );
+  }
+  return {
+    rawValue: declarations[0].rawValue,
+    normalized: declarations[0].normalized,
+  };
+}
+
 function registerNodeId(node, context, prefix) {
   if (node._nodeId) {
     return node._nodeId;
@@ -201,6 +448,9 @@ function registerNodeId(node, context, prefix) {
   node._nodeId = nodeId;
   context.aliasToNodeId.set(alias, nodeId);
   context.nodeIdToAlias.set(nodeId, alias);
+  if (context.aliasToSpecNode) {
+    context.aliasToSpecNode.set(alias, node);
+  }
   return nodeId;
 }
 
@@ -273,7 +523,7 @@ function normalizeToUsers(value, fallback = []) {
   }).filter(Boolean);
 }
 
-function normalizeDataConditions(conditions, context) {
+function normalizeDataConditions(conditions, context, sourceFormType) {
   return asArray(conditions).map((condition) => {
     const bFieldId = condition.bFieldId || condition.fieldId || condition.id;
     const conditionValue = getFirstNonNullishOwnValue(condition, ['aFieldId', 'value', 'ruleValue']);
@@ -284,9 +534,11 @@ function normalizeDataConditions(conditions, context) {
     if (!['literal', 'processVar', 'column'].includes(valueType)) {
       throw new Error(`dataRetrieve condition valueType is unsupported: ${valueType}`);
     }
+    const bFieldName = condition.bFieldName || condition.fieldName || condition.name || condition.label || bFieldId;
+    const runtimeFieldId = toRuntimeDataQueryField(resolveNodeRefs(bFieldId, context), sourceFormType);
     return {
-      bFieldId: resolveNodeRefs(bFieldId, context),
-      bFieldName: condition.bFieldName || condition.fieldName || condition.name || condition.label || bFieldId,
+      bFieldId: runtimeFieldId,
+      bFieldName: normalizeDataQueryFieldName(runtimeFieldId, sourceFormType, bFieldName),
       aFieldId: resolveNodeRefs(conditionValue.value, context),
       componentType: condition.componentType || 'TextField',
       opCode: condition.opCode || condition.op || 'Contain',
@@ -473,19 +725,58 @@ function buildMessageViewNode(node, nodeId, context) {
   };
 }
 
+function resolveRetrieveSourceId(node, context) {
+  if (isSubTableRetrieve(node)) {
+    return resolveAlias(getSourceAlias(node), context);
+  }
+  return node.formUuid || node.sourceId || (node.type === 'getSelf' ? context.formUuid : undefined);
+}
+
+function resolveRetrieveSourceLabel(node, context, sourceId) {
+  if (isSubTableRetrieve(node)) {
+    const sourceNode = context.aliasToSpecNode && context.aliasToSpecNode.get(getSourceAlias(node));
+    return (sourceNode && (sourceNode.name || sourceNode.formName))
+      || node.formName
+      || getSourceAlias(node);
+  }
+  return resolveDataSourceFormName(node, context)
+    || node.formName
+    || (context.formNamesByUuid && context.formNamesByUuid.get(sourceId))
+    || sourceId;
+}
+
+function isUsedAsSubTableSource(node, context) {
+  const alias = node.id || node.key;
+  if (!alias || !context.aliasToSpecNode) {
+    return false;
+  }
+  for (const specNode of context.aliasToSpecNode.values()) {
+    if (getSourceAlias(specNode) !== alias) {
+      continue;
+    }
+    if (isSubTableRetrieve(specNode) || isSubTableInsert(specNode)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 function buildDataRetrieveProcessNode(node, nodeId, nextNodeId, context) {
-  const formUuid = node.formUuid || node.sourceId || (node.type === 'getSelf' ? context.formUuid : undefined);
-  const formName = node.formName || context.formNamesByUuid.get(formUuid) || formUuid;
+  const sourceId = resolveRetrieveSourceId(node, context);
+  const dataSourceFormType = isSubTableRetrieve(node)
+    ? ''
+    : resolveDataSourceFormType(node, context);
+  const formName = resolveRetrieveSourceLabel(node, context, sourceId);
   const rawConditions = node.type === 'getSelf' || node.getSelf
     ? [{
-      bFieldId: node.queryField || 'pid',
-      bFieldName: '表单实例ID',
+      bFieldId: resolveDataQueryField(node, dataSourceFormType),
+      bFieldName: resolveDataQueryFieldName(dataSourceFormType),
       aFieldId: node.triggerField || '__masterdata_form_inst_id',
       componentType: 'TextField',
       opCode: 'Equal',
       valueType: 'processVar',
     }]
-    : normalizeDataConditions(node.conditions || node.dataConditions, context);
+    : normalizeDataConditions(node.conditions || node.dataConditions, context, dataSourceFormType);
   const conditions = rawConditions.length > 0
     ? buildDataRetrieveCondition(rawConditions, node.logic || node.conditionLogic)
     : { condition: 'AND', rules: [], ruleId: generateRuleGroupId(), conditionCode: '&&' };
@@ -500,9 +791,11 @@ function buildDataRetrieveProcessNode(node, nodeId, nextNodeId, context) {
       type: 'single',
       filterType: 'condition',
       sort: node.sort || { type: 'none', column: '' },
-      sourceId: formUuid,
+      sourceId,
       appType: context.appType,
-      originalType: node.originalType || 'form',
+      originalType: isSubTableRetrieve(node)
+        ? 'sub_table'
+        : resolveDataOriginalType(dataSourceFormType),
       subSourceId: node.subSourceId || '',
       condition: conditions,
       quantity: String(node.quantity || '1'),
@@ -528,7 +821,78 @@ function buildDataRetrieveProcessNode(node, nodeId, nextNodeId, context) {
 function buildDataRetrieveViewNode(node, nodeId, context) {
   const processNode = buildDataRetrieveProcessNode(node, nodeId, nodeId, context);
   const props = processNode.props;
-  const formName = node.formName || context.formNamesByUuid.get(props.sourceId) || props.sourceId;
+  const dataSourceFormType = isSubTableRetrieve(node)
+    ? ''
+    : resolveDataSourceFormType(node, context);
+  const dataSourceFormName = isSubTableRetrieve(node)
+    ? ''
+    : resolveDataSourceFormName(node, context);
+  const formName = resolveRetrieveSourceLabel(node, context, props.sourceId);
+  let viewCondition;
+  if (node.type === 'getSelf' || node.getSelf) {
+    viewCondition = buildDataRetrieveCondition([{
+      bFieldId: resolveDesignerDataQueryField(node, dataSourceFormType),
+      bFieldName: resolveDataQueryFieldName(dataSourceFormType),
+      aFieldId: node.triggerField || '__masterdata_form_inst_id',
+      componentType: 'TextField',
+      opCode: 'Equal',
+      valueType: 'processVar',
+    }]);
+  } else if (isSubTableRetrieve(node)) {
+    viewCondition = props.condition;
+  } else {
+    viewCondition = {
+      ...props.condition,
+      rules: (props.condition.rules || []).map((rule) => {
+        const designerFieldId = toDesignerDataQueryField(rule.id, dataSourceFormType);
+        const designerFieldName = normalizeDataQueryFieldName(
+          rule.id,
+          dataSourceFormType,
+          rule.name,
+        );
+        return designerFieldId === rule.id && designerFieldName === rule.name
+          ? rule
+          : {
+            ...rule,
+            id: designerFieldId,
+            name: designerFieldName,
+          };
+      }),
+    };
+  }
+  let targetItem;
+  let relativeItem = {};
+  if (isSubTableRetrieve(node)) {
+    const parentFormUuid = resolveSubTableParentFormUuidFromContext(node, context);
+    const schemaComponents = parentFormUuid
+      ? (context.formSchemasByUuid.get(parentFormUuid) || [])
+      : [];
+    const subTableLabel = node.subSourceLabel
+      || resolveTableFieldLabel(schemaComponents, props.subSourceId, props.subSourceId);
+    targetItem = {
+      deep: 0,
+      value: props.sourceId,
+      label: formName,
+    };
+    relativeItem = buildSubTableRelativeItem(props.subSourceId, subTableLabel);
+  } else {
+    const schemaComponents = context.formSchemasByUuid.get(props.sourceId) || [];
+    const tableFields = isUsedAsSubTableSource(node, context)
+      ? listTableFieldSummaries(schemaComponents)
+      : [];
+    targetItem = {
+      appType: context.appType,
+      appName: '',
+      formItem: {
+        formType: resolveDataFormItemType(dataSourceFormType),
+        advanceProc: 'n',
+        formUuid: props.sourceId,
+        title: dataSourceFormName || formName,
+        fields: tableFields.length > 0 ? tableFields : null,
+        hasTableField: tableFields.length > 0 ? true : null,
+      },
+    };
+  }
   return {
     componentName: 'GetSingleDataNode',
     id: nodeId,
@@ -542,22 +906,11 @@ function buildDataRetrieveViewNode(node, nodeId, context) {
         originalType: props.originalType,
         appType: context.appType,
         sourceId: props.sourceId,
-        targetItem: {
-          appType: context.appType,
-          appName: '',
-          formItem: {
-            formType: 'receipt',
-            advanceProc: 'n',
-            formUuid: props.sourceId,
-            title: formName,
-            fields: null,
-            hasTableField: null,
-          },
-        },
+        targetItem,
         subSourceId: props.subSourceId,
-        relativeItem: {},
+        relativeItem,
         filterType: 'condition',
-        condition: props.condition,
+        condition: viewCondition,
         sort: props.sort,
         rulesFilter: [],
         outputs: [],
@@ -570,24 +923,63 @@ function buildDataRetrieveViewNode(node, nodeId, context) {
   };
 }
 
-function buildDataCreateProcessNode(node, nodeId, nextNodeId, context) {
+function resolveCreateTarget(node, context) {
+  if (isSubTableInsert(node)) {
+    const sourceAlias = getSourceAlias(node);
+    const sourceNodeId = resolveAlias(sourceAlias, context);
+    const sourceNode = resolveContextSourceNode(node, context) || {};
+    const parentFormUuid = resolveSubTableParentFormUuidFromContext(node, context);
+    const parentFormName = resolveDataSourceFormName(sourceNode, context)
+      || (parentFormUuid && context.formNamesByUuid.get(parentFormUuid))
+      || sourceNode.formName
+      || parentFormUuid;
+    const formName = sourceNode.name
+      || sourceNode.formName
+      || node.formName
+      || parentFormName
+      || sourceAlias;
+    return {
+      formUuid: sourceNodeId,
+      insertType: 'sub_table',
+      subFormUuid: node.subFormUuid,
+      sourceId: '',
+      parentFormUuid,
+      parentFormName,
+      parentFormType: resolveDataSourceFormType(sourceNode, context),
+      formName,
+      subFormLabel: node.subSourceLabel || node.subFormLabel || node.subFormUuid,
+      isSubTable: true,
+    };
+  }
   const formUuid = node.formUuid || node.targetFormUuid;
-  const formName = node.formName || context.formNamesByUuid.get(formUuid) || formUuid;
+  return {
+    formUuid,
+    insertType: node.insertType || 'form',
+    subFormUuid: node.subFormUuid || '',
+    sourceId: node.sourceId || '',
+    parentFormUuid: formUuid,
+    formName: node.formName || context.formNamesByUuid.get(formUuid) || formUuid,
+    isSubTable: false,
+  };
+}
+
+function buildDataCreateProcessNode(node, nodeId, nextNodeId, context) {
+  const target = resolveCreateTarget(node, context);
   const assignments = normalizeAssignments(node.assignments, context);
   return {
     name: { zh_CN: node.name || '新增数据', en_US: '' },
-    description: configuredDescription(node, t('integration.spec_desc_create', formName, assignments.length)),
+    description: configuredDescription(node, t('integration.spec_desc_create', target.formName, assignments.length)),
     type: 'dataCreate',
     nodeId,
     prevId: '',
     nextId: [nextNodeId],
     props: {
-      formUuid,
+      formUuid: target.formUuid,
       appType: context.appType,
-      subFormUuid: node.subFormUuid || '',
-      insertType: node.insertType || 'form',
+      subFormUuid: target.subFormUuid || '',
+      insertType: target.insertType,
       type: node.createType || 'single',
-      sourceId: node.sourceId || '',
+      sourceId: target.sourceId,
       assignments: buildDataCreateAssignments(assignments),
     },
     childNodes: [],
@@ -595,18 +987,25 @@ function buildDataCreateProcessNode(node, nodeId, nextNodeId, context) {
 }
 
 function buildDataCreateViewNode(node, nodeId, context) {
-  const formUuid = node.formUuid || node.targetFormUuid;
-  const formName = node.formName || context.formNamesByUuid.get(formUuid) || formUuid;
-  const schemaComponents = context.formSchemasByUuid.get(formUuid) || [];
-  const childList = buildAddDataChildList(schemaComponents);
+  const target = resolveCreateTarget(node, context);
+  const schemaComponents = context.formSchemasByUuid.get(target.parentFormUuid) || [];
+  const inputChildList = target.isSubTable
+    ? buildSubTableAddDataChildList(schemaComponents, target.subFormUuid)
+    : buildAddDataChildList(schemaComponents);
+  const columnList = inputChildList.filter((item) => item.componentName !== 'TableField');
   const normalizedAssignments = normalizeAssignments(node.assignments, context);
-  assertAssignmentFieldsExist(normalizedAssignments, childList);
-  const componentOptionMap = {};
-  childList.forEach((item) => {
-    componentOptionMap[item.fieldId] = '[]';
+  assertAssignmentFieldsExist(normalizedAssignments, columnList);
+  const inputOptionMap = {};
+  inputChildList.forEach((item) => {
+    inputOptionMap[item.fieldId] = item.componentOption || '[]';
+  });
+  const columnOptionMap = {};
+  columnList.forEach((item) => {
+    columnOptionMap[item.fieldId] = item.componentOption || '[]';
   });
   const assignmentRules = normalizedAssignments.map((assignment) => {
-    const matchedField = childList.find((item) => item.fieldId === assignment.column);
+    const matchedField = columnList.find((item) => item.fieldId === assignment.column);
+    const label = matchedField ? matchedField.label : assignment.column;
     return {
       name: assignment.column,
       componentName: matchedField ? matchedField.componentName : 'TextField',
@@ -614,8 +1013,9 @@ function buildDataCreateViewNode(node, nodeId, context) {
       value: assignment.value,
       required: false,
       ruleId: generateDataRuleId(),
-      componentOption: '[]',
-      label: matchedField ? matchedField.label : assignment.column,
+      componentOption: matchedField && matchedField.componentOption ? matchedField.componentOption : '[]',
+      label,
+      valueLabel: label,
       componentProps: {
         defaultDataSource: {},
         relateAppType: '',
@@ -624,7 +1024,58 @@ function buildDataCreateViewNode(node, nodeId, context) {
       },
     };
   });
-  const description = node.description || `在[${formName}]中新增 ${assignmentRules.length} 个字段`;
+  const description = node.description
+    || (target.isSubTable
+      ? `在 [${target.formName}] 中新增数据`
+      : `在[${target.formName}]中新增 ${assignmentRules.length} 个字段`);
+  const addDataRules = {
+    description,
+    formUuid: target.formUuid,
+    appType: context.appType,
+    insertType: target.insertType,
+    type: node.createType || 'single',
+    subFormUuid: target.subFormUuid || '',
+    sourceId: target.sourceId,
+    assignments: assignmentRules,
+    inputs: { childList: inputChildList, componentOptionMap: inputOptionMap },
+    rules: {
+      childList: columnList,
+      componentOptionMap: columnOptionMap,
+      ruleId: generateDataRuleId(),
+      rules: assignmentRules,
+    },
+  };
+  if (target.isSubTable) {
+    const tableFields = listTableFieldSummaries(schemaComponents);
+    const parentFormName = target.parentFormName || target.formName;
+    const targetItem = {
+      deep: 0,
+      value: target.formUuid,
+      label: target.formName,
+      appType: context.appType,
+      appName: '',
+    };
+    if (target.parentFormUuid) {
+      targetItem.formItem = {
+        formType: resolveDataFormItemType(target.parentFormType),
+        advanceProc: 'n',
+        formUuid: target.parentFormUuid,
+        title: parentFormName,
+        fields: null,
+        hasTableField: tableFields.length > 0 ? true : null,
+      };
+      addDataRules.formItem = targetItem.formItem;
+    }
+    addDataRules.targetItem = targetItem;
+    addDataRules.crossForm = targetItem;
+    addDataRules.relativeItem = buildSubTableRelativeItem(
+      target.subFormUuid,
+      resolveTableFieldLabel(schemaComponents, target.subFormUuid, target.subFormLabel)
+    );
+    addDataRules.relativeList = [addDataRules.relativeItem];
+    addDataRules.subFormItem = addDataRules.relativeItem;
+    addDataRules.subFormName = addDataRules.relativeItem.label;
+  }
   return {
     componentName: 'AddDataNode',
     id: nodeId,
@@ -632,23 +1083,7 @@ function buildDataCreateViewNode(node, nodeId, context) {
       nodeName: 'AddDataNode',
       name: node.name || '新增数据',
       description,
-      addDataRules: {
-        description,
-        formUuid,
-        appType: context.appType,
-        insertType: node.insertType || 'form',
-        type: node.createType || 'single',
-        subFormUuid: node.subFormUuid || '',
-        sourceId: node.sourceId || '',
-        assignments: assignmentRules,
-        inputs: { childList, componentOptionMap },
-        rules: {
-          childList,
-          componentOptionMap,
-          ruleId: generateDataRuleId(),
-          rules: assignmentRules,
-        },
-      },
+      addDataRules,
     },
     title: node.name || '新增数据',
   };
@@ -1172,14 +1607,24 @@ function buildFinishNodes(endNodeId) {
 
 function buildSpecProcessAndViewJson(options) {
   const spec = options.spec || {};
-  validateIntegrationSpec(spec, options.formEventTypes || ['insert']);
+  validateIntegrationSpec(spec, options.formEventTypes || ['insert'], {
+    formUuid: options.formUuid,
+  });
   const nodes = getSpecNodes(spec);
+  // Validate all source declarations, including duplicate UUIDs, before any
+  // caller can serialize the generated payload for a remote write.
+  collectDataSourceFormDescriptors(spec, options.formUuid);
 
   const context = {
     appType: options.appType,
     formUuid: options.formUuid,
     flowName: options.flowName || '',
     defaultFormEventTypes: options.formEventTypes || ['insert'],
+    formEventTypes: mapSpecEventTypes(spec, options.formEventTypes || ['insert']),
+    defaultFormType: options.dataFormType || options.formType || '',
+    defaultFormName: options.dataFormName || options.dataSourceFormName || options.formName || '',
+    dataSourceForm: options.dataSourceForm || null,
+    dataSourceFormsByUuid: options.dataSourceFormsByUuid || new Map(),
     defaultNotificationTitle: options.notificationTitle,
     defaultNotificationContent: options.notificationContent,
     defaultToUsers: options.toUsers || [],
@@ -1190,6 +1635,7 @@ function buildSpecProcessAndViewJson(options) {
     processCode: options.processCode,
     aliasToNodeId: new Map(),
     nodeIdToAlias: new Map(),
+    aliasToSpecNode: new Map(),
     generatedIndex: 1,
   };
   const canvasId = options.canvasId || generateNodeId();
@@ -1226,25 +1672,74 @@ function buildSpecProcessAndViewJson(options) {
   };
 }
 
-function collectAddDataFormUuids(spec) {
-  const result = new Set();
+function collectDataSourceFormDescriptors(spec, triggerFormUuid) {
+  const result = new Map();
+
   function visit(nodes) {
     for (const node of asArray(nodes)) {
+      if (!node || typeof node !== 'object') {
+        continue;
+      }
       const type = normalizeNodeType(node.type || node.componentName);
-      if (type === 'dataCreate') {
-        const formUuid = node.formUuid || node.targetFormUuid;
+      if (type === 'getSelf' || type === 'dataRetrieve') {
+        const declaredType = resolveDeclaredSourceFormType(node);
+        const formUuid = resolveSourceFormUuid({ ...node, type }, { formUuid: triggerFormUuid });
         if (formUuid) {
-          result.add(formUuid);
+          const key = String(formUuid);
+          const existing = result.get(key) || { formUuid: key };
+          if (declaredType.normalized) {
+            if (existing.formType
+              && normalizeSourceFormType(existing.formType) !== declaredType.normalized) {
+              throw new Error(
+                `Conflicting source form types for ${key}: ${existing.formType} and ${declaredType.rawValue}`
+              );
+            }
+            existing.formType = declaredType.normalized;
+          }
+          if (node.formName || node.sourceFormName || node.dataFormName) {
+            existing.formName = node.formName || node.sourceFormName || node.dataFormName;
+          }
+          result.set(key, existing);
         }
       }
       if (type === 'route') {
         for (const branch of asArray(node.branches || node.conditions)) {
-          visit(branch.nodes || branch.childNodes || branch.children);
+          visit(branch && (branch.nodes || branch.childNodes || branch.children));
         }
       }
     }
   }
+
   visit(getSpecNodes(spec));
+  return Array.from(result.values());
+}
+
+function collectAddDataFormUuids(spec, triggerFormUuid, options = {}) {
+  const kind = options.kind || 'all';
+  const result = new Set();
+  visitSpecNodes(spec, (node) => {
+    const type = normalizeNodeType(node.type || node.componentName);
+    if (type !== 'dataCreate') {
+      return;
+    }
+    if (isSubTableInsert(node)) {
+      if (kind === 'direct') {
+        return;
+      }
+      const parentFormUuid = resolveSubTableParentFormUuid(node, spec, triggerFormUuid);
+      if (parentFormUuid) {
+        result.add(parentFormUuid);
+      }
+      return;
+    }
+    if (kind === 'sub_table') {
+      return;
+    }
+    const formUuid = node.formUuid || node.targetFormUuid;
+    if (formUuid) {
+      result.add(formUuid);
+    }
+  });
   return Array.from(result);
 }
 
@@ -1294,6 +1789,7 @@ module.exports = {
   validateIntegrationSpec,
   buildSpecProcessAndViewJson,
   collectAddDataFormUuids,
+  collectDataSourceFormDescriptors,
   collectInitiateApprovalFormUuids,
   hasSpecNodeType,
   _private: {
@@ -1301,6 +1797,7 @@ module.exports = {
     mapSpecEventTypes,
     normalizeNodeType,
     resolveNodeRefs,
+    resolveDesignerSourceRefs,
     buildSpecNodeList,
     buildDataUpdateRules,
   },