openxiangda 1.0.229 → 1.0.231

package/lib/cli.js

@@ -14212,18 +14212,36 @@ async function resource(args) {
         .map(item => item.formCode || item.form)
         .filter(Boolean)
     );
+    const scopeGrantSourceNeedsInitialSync = (
+      manifest.scopeGrantSources || []
+    ).some(item => item.sync === true);
     const stagedChangeId =
       readStringFlag(flags, 'change') ||
       getStoredChangeBaseline(target, { access: 'reconciliation-read' })
         ?.changeId ||
       '';
-    if (workflowFormCodes.length > 0 && stagedChangeId) {
+    const scopeGrantSourceFormCodes =
+      scopeGrantSourceNeedsInitialSync && stagedChangeId
+        ? await resolveScopeGrantSourceFormCodes(
+            config,
+            target,
+            manifest.scopeGrantSources || []
+          )
+        : [];
+    const stagedContractFormCodes = unique([
+      ...workflowFormCodes,
+      ...scopeGrantSourceFormCodes,
+    ]).sort();
+    if (
+      stagedContractFormCodes.length > 0 &&
+      stagedChangeId
+    ) {
       stagedFormBindingOverlays =
         await resolveReusableStagedFormReleaseOverlays(
           config,
           target,
           stagedChangeId,
-          { formCodes: workflowFormCodes }
+          { formCodes: stagedContractFormCodes }
         );
     }
     validateWorkspaceResourceBindings(
@@ -14381,6 +14399,7 @@ async function resource(args) {
           replaceManifest: Boolean(flags['replace-manifest']),
           changeId:
             flags.change || getStoredChangeBaseline(target)?.changeId || null,
+          stagedFormBindingOverlays,
           activateFormBundles: Boolean(flags.activate),
           stageBackendReleaseOnly:
             Boolean(flags['stage-only']) &&
@@ -16290,7 +16309,12 @@ function removeDirectStateResource(target, resourceType, code) {
 function normalizeMenuDirectBody(bound, menuItem) {
   const formUuid = resolveManifestFormUuid(bound, menuItem);
   const pageId = resolveManifestPageId(bound, menuItem);
-  const parentId = resolveManifestMenuId(bound, menuItem.parentCode) || menuItem.parentId || null;
+  const parentId = requireResolvedMenuParentId(
+    bound,
+    menuItem,
+    new Map(),
+    'direct menu mutation'
+  );
   return stripUndefinedValues({
     resourceCode: menuItem.code || menuItem.resourceCode,
     name: menuItem.name || menuItem.code,
@@ -19068,7 +19092,19 @@ async function buildResourcePlan(
   ]);
   const actions = [];
   addPlanActions(actions, 'role', manifest.roles, existing.roles, roleEquals);
-  addPlanActions(actions, 'menu', manifest.menus, existing.menus, (item, current) => menuEquals(target.bound, item, current));
+  const orderedMenus = orderMenuResourcesForPublish(
+    manifest.menus,
+    target.bound,
+    existing.menus
+  );
+  addPlanActions(
+    actions,
+    'menu',
+    orderedMenus,
+    existing.menus,
+    (item, current) =>
+      menuEquals(target.bound, item, current, existing.menus)
+  );
   addPlanActions(actions, 'connector', manifest.connectors, existing.connectors, connectorEquals);
   addNotificationPlanActions(target, actions, manifest.notifications || [], existing);
   await addWorkflowPlanActions(config, target, actions, manifest.workflows, existing.workflows);
@@ -22575,21 +22611,61 @@ async function publishFormSettingsResources(
 }
 
 async function publishMenuResources(config, target, menus, result, options = {}) {
-  for (const menuItem of menus) {
-    if (shouldSkipNoopResource(options, 'menu', menuItem.code)) {
-      recordNoopResource(result, 'menu', menuItem.code, options);
+  if (menus.length === 0) return;
+  const existingMenus = await fetchExistingMenusByCode(config, target);
+  const orderedMenus = orderMenuResourcesForPublish(
+    menus,
+    target.bound,
+    existingMenus
+  );
+  for (const menuItem of orderedMenus) {
+    const code = menuResourceCode(menuItem);
+    const plannedAction = getPlannedResourceAction(options, 'menu', code);
+    const existing = existingMenus.get(code);
+    if (existing && !menuPlatformId(existing)) {
+      const error = new Error(
+        `MENU_ONLINE_ID_REQUIRED: 在线 menu ${code} 缺少 menuId，禁止执行恢复发布`
+      );
+      error.code = 'MENU_ONLINE_ID_REQUIRED';
+      throw error;
+    }
+    if (
+      ['noop', 'update'].includes(plannedAction?.action) &&
+      !menuPlatformId(existing)
+    ) {
+      const error = new Error(
+        `MENU_PLAN_TARGET_MISSING: menu ${code} 的冻结计划为 ${plannedAction.action}，但写入前在线菜单已不存在`
+      );
+      error.code = 'MENU_PLAN_TARGET_MISSING';
+      throw error;
+    }
+  }
+  for (const menuItem of orderedMenus) {
+    const code = menuResourceCode(menuItem);
+    const existing = existingMenus.get(code);
+    if (shouldSkipNoopResource(options, 'menu', code)) {
+      const existingId = menuPlatformId(existing);
+      saveMenuResource(target, code, existingId, {
+        formUuid: existing.formUuid,
+        pageId: existing.pageId,
+        parentId: existing.parentId,
+        routeCode: existing.routeCode,
+        path: existing.path,
+      });
+      recordNoopResource(result, 'menu', code, options);
       continue;
     }
-    const existing = await findExistingMenu(config, target, menuItem.code);
     const formUuid = resolveManifestFormUuid(target.bound, menuItem);
     const pageId = resolveManifestPageId(target.bound, menuItem);
-    const parentId =
-      resolveManifestMenuId(target.bound, menuItem.parentCode) ||
-      menuItem.parentId ||
-      null;
+    const parentId = requireResolvedMenuParentId(
+      target.bound,
+      menuItem,
+      existingMenus,
+      `resource publish menu ${code}`
+    );
     const body = {
-      resourceCode: menuItem.code,
-      name: menuItem.name || menuItem.code,
+      resourceCode: code,
+      name: menuItem.name || code,
       type: menuItem.type || 'nav',
       formUuid,
       pageId,
@@ -22600,11 +22676,12 @@ async function publishMenuResources(config, target, menus, result, options = {})
       routeCode: menuItem.routeCode || null,
       path: menuItem.path || null,
     };
+    const existingId = menuPlatformId(existing);
     let data = existing
       ? await requestWithAuth(
           config,
           target.profileName,
-          `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/menus/${encodeURIComponent(existing.id)}`,
+          `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/menus/${encodeURIComponent(existingId)}`,
           { method: 'POST', body }
         )
       : await requestWithAuth(
@@ -22613,37 +22690,54 @@ async function publishMenuResources(config, target, menus, result, options = {})
           `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/menus`,
           { method: 'POST', body }
         );
-    if (data?.id) {
-      saveMenuResource(target, menuItem.code, data.id, {
-        resourceCode: menuItem.code,
-        name: data.name,
-        type: data.type,
-        ...(formUuid ? { formUuid } : {}),
-        ...(pageId ? { pageId } : {}),
-        ...(menuItem.pageCode ? { pageCode: menuItem.pageCode } : {}),
-        ...(menuItem.routeCode || data.routeCode
-          ? { routeCode: data.routeCode || menuItem.routeCode }
-          : {}),
-        ...(menuItem.path || data.path ? { path: data.path || menuItem.path } : {}),
-      });
+    if (!data?.id) {
+      const error = new Error(
+        `MENU_WRITE_ID_REQUIRED: menu ${code} 写入成功响应缺少 menuId，禁止继续发布子菜单`
+      );
+      error.code = 'MENU_WRITE_ID_REQUIRED';
+      throw error;
     }
-    result.published.push({ kind: 'menu', code: menuItem.code, action: existing ? 'update' : 'create', id: data?.id });
+    saveMenuResource(target, code, data.id, {
+      resourceCode: code,
+      name: data.name,
+      type: data.type,
+      ...(formUuid ? { formUuid } : {}),
+      ...(pageId ? { pageId } : {}),
+      ...(menuItem.pageCode ? { pageCode: menuItem.pageCode } : {}),
+      ...(menuItem.routeCode || data.routeCode
+        ? { routeCode: data.routeCode || menuItem.routeCode }
+        : {}),
+      ...(menuItem.path || data.path ? { path: data.path || menuItem.path } : {}),
+      parentId: data.parentId || parentId,
+    });
+    existingMenus.set(code, {
+      ...(existing || {}),
+      ...body,
+      ...data,
+      id: data.id,
+    });
+    result.published.push({
+      kind: 'menu',
+      code,
+      action: existing ? 'update' : 'create',
+      id: data?.id,
+    });
   }
 }
 
-async function findExistingMenu(config, target, code) {
+async function fetchExistingMenusByCode(config, target) {
   const data = await requestWithAuth(
     config,
     target.profileName,
     `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/menus`
   );
-  const items = flattenItems(normalizeItems(data));
-  const stateId = target.bound.resources?.menus?.[code]?.menuId;
-  if (stateId) {
-    const byState = items.find(item => item.id === stateId);
-    if (byState) return byState;
-  }
-  return items.find(item => item.resourceCode === code);
+  const menus = new Map();
+  indexByCode(
+    menus,
+    flattenItems(normalizeItems(data)),
+    item => item.resourceCode
+  );
+  return menus;
 }
 
 async function publishConnectorResources(config, target, connectors, result, options = {}) {
@@ -23293,7 +23387,84 @@ async function publishScopeDimensionResources(config, target, dimensions, result
   }
 }
 
+async function resolveScopeGrantSourceFormCodes(
+  config,
+  target,
+  sources = []
+) {
+  const formCodes = [];
+  const appendFormCode = value => {
+    const candidate = String(value || '').trim();
+    if (!candidate) return;
+    if (target.bound.resources?.forms?.[candidate]?.formUuid) {
+      formCodes.push(candidate);
+      return;
+    }
+    for (const [code, entry] of Object.entries(
+      target.bound.resources?.forms || {}
+    )) {
+      if (String(entry?.formUuid || '').trim() === candidate) {
+        formCodes.push(code);
+        return;
+      }
+    }
+  };
+  const dimensionCodes = new Set();
+  for (const source of sources || []) {
+    appendFormCode(
+      source.sourceFormCode ||
+        source.formCode ||
+        source.sourceFormUuid ||
+        source.formUuid
+    );
+    for (const mapping of source.dimensionMappings || source.dimensions || []) {
+      const code = String(
+        mapping?.dimensionCode || mapping?.dimension || ''
+      ).trim();
+      if (code) dimensionCodes.add(code);
+    }
+  }
+  if (dimensionCodes.size > 0) {
+    const dimensions = await requestWithAuth(
+      config,
+      target.profileName,
+      `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/scope/dimensions`
+    );
+    for (const dimension of normalizeItems(dimensions)) {
+      const code = String(
+        dimension?.code || dimension?.resourceCode || ''
+      ).trim();
+      if (!dimensionCodes.has(code)) continue;
+      appendFormCode(dimension.sourceFormUuid || dimension.formUuid);
+    }
+  }
+  return unique(formCodes).sort();
+}
+
 async function publishScopeGrantSourceResources(config, target, sources, result, options = {}) {
+  const stagedFormBindingOverlays =
+    options.stagedFormBindingOverlays instanceof Map
+      ? options.stagedFormBindingOverlays
+      : new Map();
+  let dimensionMap = new Map();
+  if (
+    stagedFormBindingOverlays.size > 0 &&
+    (sources || []).some(item => item.sync === true)
+  ) {
+    const dimensions = await requestWithAuth(
+      config,
+      target.profileName,
+      `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/scope/dimensions`
+    );
+    dimensionMap = new Map(
+      normalizeItems(dimensions)
+        .map(item => [
+          String(item.code || item.resourceCode || '').trim(),
+          item,
+        ])
+        .filter(([code]) => Boolean(code))
+    );
+  }
   for (const item of sources) {
     const code = item.code || item.resourceCode;
     if (shouldSkipNoopResource(options, 'scopeGrantSource', code)) {
@@ -23316,17 +23487,88 @@ async function publishScopeGrantSourceResources(config, target, sources, result,
       id: data?.id,
     };
     if (item.sync === true) {
-      published.sync = await requestWithAuth(
-        config,
-        target.profileName,
-        `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/scope/grant-sources/${encodeURIComponent(code)}/sync`,
-        { method: 'POST', body: { dryRun: false } }
-      );
+      const syncDecision = buildScopeGrantSourceSyncDecision({
+        source: body,
+        dimensionMap,
+        stagedFormBindingOverlays,
+      });
+      if (syncDecision.defer) {
+        published.sync = {
+          status: 'deferred-until-form-activation',
+          reason: syncDecision.reason,
+          formUuids: syncDecision.formUuids,
+          formCodes: syncDecision.formCodes,
+          resumeTrigger: 'on_write_after_app_finalize',
+        };
+        result.warnings.push(
+          `scopeGrantSource:${code}: 初始同步依赖同一 deployment 的新 staged FormRelease，当前尚无 active 数据表；已保存 on_write 配置，App finalize 后首次表单写入会自动物化`
+        );
+      } else {
+        published.sync = await requestWithAuth(
+          config,
+          target.profileName,
+          `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/scope/grant-sources/${encodeURIComponent(code)}/sync`,
+          { method: 'POST', body: { dryRun: false } }
+        );
+      }
     }
     result.published.push(published);
   }
 }
 
+function buildScopeGrantSourceSyncDecision({
+  source,
+  dimensionMap = new Map(),
+  stagedFormBindingOverlays = new Map(),
+} = {}) {
+  const stagedNewForms = new Map(
+    Array.from(stagedFormBindingOverlays.values())
+      .filter(item => item?.parentReleaseId === null && item?.formUuid)
+      .map(item => [
+        String(item.formUuid).trim(),
+        String(item.formCode || '').trim(),
+      ])
+  );
+  if (stagedNewForms.size === 0) {
+    return {
+      defer: false,
+      reason: null,
+      formUuids: [],
+      formCodes: [],
+    };
+  }
+  const referencedFormUuids = [
+    source?.sourceFormUuid,
+    ...(source?.dimensionMappings || []).map(mapping => {
+      const code = String(
+        mapping?.dimensionCode || mapping?.dimension || ''
+      ).trim();
+      const dimension = dimensionMap.get(code);
+      return dimension?.sourceFormUuid || dimension?.formUuid;
+    }),
+  ]
+    .map(value => String(value || '').trim())
+    .filter(Boolean);
+  const formUuids = unique(
+    referencedFormUuids.filter(formUuid =>
+      stagedNewForms.has(formUuid)
+    )
+  ).sort();
+  return {
+    defer: formUuids.length > 0,
+    reason:
+      formUuids.length > 0
+        ? 'staged_new_form_has_no_active_data_table'
+        : null,
+    formUuids,
+    formCodes: unique(
+      formUuids
+        .map(formUuid => stagedNewForms.get(formUuid))
+        .filter(Boolean)
+    ).sort(),
+  };
+}
+
 async function publishDataScopePolicyResources(config, target, policies, result, options = {}) {
   for (const item of policies) {
     const code = item.code || item.resourceCode;
@@ -25859,7 +26101,123 @@ function resolveManifestPageId(bound, item) {
 
 function resolveManifestMenuId(bound, menuCode) {
   if (!menuCode) return undefined;
-  return bound.resources?.menus?.[menuCode]?.menuId || menuCode;
+  return bound.resources?.menus?.[menuCode]?.menuId;
+}
+
+function menuResourceCode(menuItem) {
+  return String(menuItem?.code || menuItem?.resourceCode || '').trim();
+}
+
+function menuPlatformId(menuItem) {
+  const value = menuItem?.id || menuItem?.menuId;
+  return value ? String(value) : undefined;
+}
+
+function resolveMenuParentId(bound, menuItem, existingMenus = new Map()) {
+  const parentCode = String(menuItem?.parentCode || '').trim();
+  if (!parentCode) return menuItem?.parentId || null;
+  const boundId = resolveManifestMenuId(bound, parentCode);
+  const onlineId = menuPlatformId(existingMenus.get(parentCode));
+  return onlineId || boundId || menuItem?.parentId;
+}
+
+function menuParentResolutionError(code, parentCode, label) {
+  const error = new Error(
+    `MENU_PARENT_UNRESOLVED: ${label || `menu ${code}`} 无法将 parentCode ${parentCode} 解析为在线 menuId`
+  );
+  error.code = 'MENU_PARENT_UNRESOLVED';
+  return error;
+}
+
+function requireResolvedMenuParentId(
+  bound,
+  menuItem,
+  existingMenus = new Map(),
+  label
+) {
+  const parentId = resolveMenuParentId(bound, menuItem, existingMenus);
+  if (menuItem?.parentCode && !parentId) {
+    throw menuParentResolutionError(
+      menuResourceCode(menuItem),
+      menuItem.parentCode,
+      label
+    );
+  }
+  return parentId || null;
+}
+
+function orderMenuResourcesForPublish(
+  menus = [],
+  bound = {},
+  existingMenus = new Map()
+) {
+  const items = Array.isArray(menus) ? menus : [];
+  const byCode = new Map();
+  const sourceIndex = new Map();
+  for (const [index, menuItem] of items.entries()) {
+    const code = menuResourceCode(menuItem);
+    if (!code) {
+      const error = new Error('MENU_CODE_REQUIRED: menu resource 缺少 code');
+      error.code = 'MENU_CODE_REQUIRED';
+      throw error;
+    }
+    if (byCode.has(code)) {
+      const error = new Error(`MENU_CODE_DUPLICATE: menu code ${code} 重复`);
+      error.code = 'MENU_CODE_DUPLICATE';
+      throw error;
+    }
+    byCode.set(code, menuItem);
+    sourceIndex.set(code, index);
+  }
+
+  const children = new Map();
+  const indegree = new Map([...byCode.keys()].map(code => [code, 0]));
+  for (const [code, menuItem] of byCode) {
+    const parentCode = String(menuItem.parentCode || '').trim();
+    if (!parentCode) continue;
+    if (!byCode.has(parentCode)) {
+      if (!resolveMenuParentId(bound, menuItem, existingMenus)) {
+        throw menuParentResolutionError(code, parentCode, `menu ${code}`);
+      }
+      continue;
+    }
+    indegree.set(code, indegree.get(code) + 1);
+    const siblings = children.get(parentCode) || [];
+    siblings.push(code);
+    children.set(parentCode, siblings);
+  }
+
+  const bySourceOrder = (left, right) =>
+    sourceIndex.get(left) - sourceIndex.get(right);
+  const ready = [...indegree.entries()]
+    .filter(([, count]) => count === 0)
+    .map(([code]) => code)
+    .sort(bySourceOrder);
+  const ordered = [];
+  while (ready.length > 0) {
+    const code = ready.shift();
+    ordered.push(byCode.get(code));
+    for (const childCode of (children.get(code) || []).sort(bySourceOrder)) {
+      const next = indegree.get(childCode) - 1;
+      indegree.set(childCode, next);
+      if (next === 0) {
+        ready.push(childCode);
+        ready.sort(bySourceOrder);
+      }
+    }
+  }
+  if (ordered.length !== items.length) {
+    const cycleCodes = [...indegree.entries()]
+      .filter(([, count]) => count > 0)
+      .map(([code]) => code)
+      .sort(bySourceOrder);
+    const error = new Error(
+      `MENU_PARENT_CYCLE: menu parentCode 存在循环依赖: ${cycleCodes.join(' -> ')}`
+    );
+    error.code = 'MENU_PARENT_CYCLE';
+    throw error;
+  }
+  return ordered;
 }
 
 function resolveAutomationManifestPayload(target, automationItem) {
@@ -26011,12 +26369,16 @@ function unwrapFormSettingPlanValue(value, key) {
   return value;
 }
 
-function menuEquals(bound, desired, existing) {
+function menuEquals(bound, desired, existing, existingMenus = new Map()) {
   if (!existing) return false;
   const desiredFormUuid = resolveManifestFormUuid(bound, desired);
   const desiredPageId = resolveManifestPageId(bound, desired);
-  const desiredParentId =
-    resolveManifestMenuId(bound, desired.parentCode) || desired.parentId || null;
+  const desiredParentId = resolveMenuParentId(
+    bound,
+    desired,
+    existingMenus
+  );
+  if (desired.parentCode && !desiredParentId) return false;
   return (
     String(existing.name || '') === String(desired.name || desired.code || '') &&
     String(existing.type || '') === String(desired.type || 'nav') &&
@@ -29263,6 +29625,7 @@ function buildWorkspacePublishEnv(
 
 module.exports = {
   buildResourceManifestSddTargets,
+  buildScopeGrantSourceSyncDecision,
   main,
   satisfiedFormCodesFromContext,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openxiangda",
-  "version": "1.0.229",
+  "version": "1.0.231",
   "description": "OpenXiangda CLI, workspace build tools, runtime SDK, and form components.",
   "private": false,
   "bin": {