openxiangda 1.0.7 → 1.0.9

package/lib/cli.js

@@ -743,6 +743,8 @@ async function menu(args) {
       fail('用法: openxiangda menu create <menuCode> --name <text>');
     }
     const target = getWorkspaceTarget(config, profileName, flags);
+    const formUuid = flags['form-uuid'] || resolveOptionalFormUuid(target.bound, flags['form-code']);
+    const pageId = flags['page-id'] || resolveOptionalPageId(target.bound, flags['page-code']);
     const data = await requestWithAuth(
       config,
       target.profileName,
@@ -752,14 +754,21 @@ async function menu(args) {
         body: {
           name,
           type: flags.type || 'nav',
-          formUuid: flags['form-uuid'] || resolveOptionalFormUuid(target.bound, flags['form-code']),
-          pageId: flags['page-id'] || resolveOptionalPageId(target.bound, flags['page-code']),
+          formUuid,
+          pageId,
           parentId: flags['parent-id'] || null,
           icon: flags.icon || null,
         },
       }
     );
-    if (data?.id) saveMenuResource(target, menuCode, data.id, { name });
+    if (data?.id) {
+      saveMenuResource(target, menuCode, data.id, {
+        name,
+        type: flags.type || 'nav',
+        ...(formUuid ? { formUuid } : {}),
+        ...(pageId ? { pageId } : {}),
+      });
+    }
     if (flags.json) return writeJson(data);
     print(JSON.stringify(data, null, 2));
     return;
@@ -1308,7 +1317,7 @@ async function permission(args) {
     const [groupCode] = positional;
     const name = flags.name || positional.slice(1).join(' ') || groupCode;
     if (!groupCode || !name) {
-      fail('用法: openxiangda permission page-group-create <groupCode> --name <text>');
+      fail('用法: openxiangda permission page-group-create <groupCode> --name <text> [--menu-codes <menuCode...>|--page-codes <pageCode...>|--form-codes <formCode...>|--menu-ids <id...>]');
     }
     const target = getWorkspaceTarget(config, profileName, flags);
     const data = await requestWithAuth(
@@ -1320,7 +1329,7 @@ async function permission(args) {
         body: {
           name,
           roles: splitList(flags.roles),
-          menuFormUuids: resolveFormUuidList(target.bound, flags['menu-form-uuids'], flags['form-codes']),
+          menuFormUuids: resolvePagePermissionMenuTargets(target.bound, flags),
         },
       }
     );
@@ -1891,10 +1900,29 @@ function resolveRoleId(bound, roleKey, flags = {}) {
   return mapped || roleKey;
 }
 
-function resolveFormUuidList(bound, rawFormUuids, rawFormCodes) {
-  const direct = splitList(rawFormUuids);
-  const fromCodes = splitList(rawFormCodes).map(code => resolveOptionalFormUuid(bound, code));
-  return [...direct, ...fromCodes].filter(Boolean);
+function resolvePagePermissionMenuTargets(bound, flags = {}) {
+  const direct = [
+    ...splitList(flags['menu-form-uuids']),
+    ...splitList(flags['menu-ids']),
+  ];
+  const fromMenuCodes = splitList(flags['menu-codes']).map(code => resolveMenuId(bound, code));
+  const fromFormCodes = splitList(flags['form-codes']).map(code => resolveOptionalFormUuid(bound, code));
+  const fromPageCodes = splitList(flags['page-codes']).map(code => resolvePageMenuTarget(bound, code));
+  return unique([...direct, ...fromMenuCodes, ...fromFormCodes, ...fromPageCodes].filter(Boolean));
+}
+
+function resolvePageMenuTarget(bound, pageCode) {
+  const pageId = resolveOptionalPageId(bound, pageCode);
+  const menuEntry = findMenuEntry(bound, entry => {
+    if (!entry) return false;
+    return entry.pageId === pageId || entry.pageCode === pageCode || entry.routeKey === pageCode;
+  });
+  if (menuEntry?.menuId) return menuEntry.menuId;
+  fail(`页面 ${pageCode} 未找到已绑定菜单。请先发布/创建菜单，或直接传 --menu-codes/--menu-ids。`);
+}
+
+function findMenuEntry(bound, predicate) {
+  return Object.values(bound.resources?.menus || {}).find(predicate);
 }
 
 function resolveSettingsFormUuid(bound, formKey, flags = {}) {
@@ -2249,6 +2277,10 @@ function splitList(value) {
     .filter(Boolean);
 }
 
+function unique(values) {
+  return [...new Set(values)];
+}
+
 function renderTerminalQr(text) {
   try {
     require('qrcode-terminal').generate(text, { small: true });

package/openxiangda-skills/references/openxiangda-api.md

@@ -369,11 +369,11 @@ Body:
 {
   "name": "销售可见页面",
   "roles": ["sales"],
-  "menuFormUuids": ["FORM_XXX"]
+  "menuFormUuids": ["FORM_XXX", "MENU_ID_FOR_CODE_PAGE"]
 }
 ```
 
-An empty `menuFormUuids` array means all menus/pages are visible to the matched roles.
+An empty `menuFormUuids` array means all menus/pages are visible to the matched roles. For form menus this field can contain form UUIDs; for custom code page menus use the actual menu ID returned by `/apps/:appType/menus`, not the code page `PAGE_...` legacy form UUID.
 
 ### GET `/apps/:appType/page-permission-groups/:groupId`
 

package/openxiangda-skills/references/permissions-settings.md

@@ -24,7 +24,7 @@ Page permission groups map role codes to visible menu `formUuid` values:
 {
   "name": "销售页面",
   "roles": ["sales"],
-  "menuFormUuids": ["FORM_CUSTOMER", "FORM_ORDER"]
+  "menuFormUuids": ["FORM_CUSTOMER", "FORM_ORDER", "MENU_ID_FOR_CODE_PAGE"]
 }
 ```
 
@@ -32,7 +32,8 @@ Rules:
 
 - `roles: []` means all roles can match.
 - `menuFormUuids: []` means all menus/pages are visible to matched roles.
-- Prefer `--form-codes` in CLI so each profile resolves its own form UUIDs.
+- Prefer `--form-codes` in CLI for form menus so each profile resolves its own form UUIDs.
+- Prefer `--page-codes` or `--menu-codes` in CLI for custom code page menus so each profile resolves to real menu IDs.
 
 ## Form Permission Groups
 

package/openxiangda-skills/skills/openxiangda-permission-settings/SKILL.md

@@ -40,9 +40,10 @@ Page permission groups control menu/page visibility:
 
 ```bash
 openxiangda permission page-group-create sales_pages --name "销售页面" --roles sales --form-codes customer,orders --profile dev
+openxiangda permission page-group-create portal_pages --name "门户页面" --page-codes portal_pc,portal_mobile --profile dev
 ```
 
-Empty `--form-codes` and `--menu-form-uuids` means all menus/pages are visible to matched roles.
+Use `--page-codes` or `--menu-codes` for custom code page menus; the CLI resolves code pages to their published menu IDs. Use `--form-codes` for form menus; the CLI resolves forms to profile-local form UUIDs. Empty target lists mean all menus/pages are visible to matched roles.
 
 ## Form Permission Groups
 

package/package.json

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

package/packages/sdk/src/build-source/scripts/utils/form-api.mjs

@@ -1,6 +1,119 @@
 import fs from "node:fs";
 import path from "node:path";
-import { getApiBaseUrl } from "./load-config.mjs";
+import { getApiBaseUrl, rootDir } from "./load-config.mjs";
+
+const PROJECT_STATE_FILE = ".openxiangda/state.json";
+
+function readJson(filePath, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+
+function getWorkspaceRoot(config) {
+  return config.workspaceRoot || rootDir;
+}
+
+function getProjectStatePath(config) {
+  return path.join(getWorkspaceRoot(config), PROJECT_STATE_FILE);
+}
+
+function loadProjectState(config) {
+  return readJson(getProjectStatePath(config), {
+    version: 1,
+    profiles: {},
+  });
+}
+
+function saveProjectState(config, state) {
+  const statePath = getProjectStatePath(config);
+  fs.mkdirSync(path.dirname(statePath), { recursive: true });
+  const normalized = {
+    version: 1,
+    ...state,
+    profiles: state.profiles || {},
+  };
+  const tempPath = `${statePath}.${process.pid}.tmp`;
+  fs.writeFileSync(tempPath, `${JSON.stringify(normalized, null, 2)}\n`, "utf-8");
+  fs.renameSync(tempPath, statePath);
+}
+
+function normalizeBaseUrl(value) {
+  return String(value || "").replace(/\/+$/, "");
+}
+
+function ensureResourceBuckets(bound) {
+  bound.resources = bound.resources || {};
+  bound.resources.forms = bound.resources.forms || {};
+  bound.resources.pages = bound.resources.pages || {};
+  bound.resources.workflows = bound.resources.workflows || {};
+  bound.resources.automations = bound.resources.automations || {};
+  bound.resources.menus = bound.resources.menus || {};
+  bound.resources.roles = bound.resources.roles || {};
+  bound.resources.pagePermissionGroups = bound.resources.pagePermissionGroups || {};
+  bound.resources.formPermissionGroups = bound.resources.formPermissionGroups || {};
+}
+
+function resolveProjectProfileName(config, state) {
+  if (config.openXiangdaProfile) return config.openXiangdaProfile;
+
+  const profiles = Object.entries(state.profiles || {});
+  const platformUrl = normalizeBaseUrl(config.platformUrl);
+  const matched = profiles.find(([, bound]) => {
+    if (bound?.appType !== config.appType) return false;
+    const boundBaseUrl = normalizeBaseUrl(bound?.baseUrl);
+    return !platformUrl || !boundBaseUrl || platformUrl === boundBaseUrl;
+  });
+  return matched?.[0] || "";
+}
+
+function readWorkspaceFormBinding(config, formName) {
+  if (!isOpenXiangdaMode(config)) return null;
+  const state = loadProjectState(config);
+  const profileName = resolveProjectProfileName(config, state);
+  if (!profileName) return null;
+  const bound = state.profiles?.[profileName];
+  const form = bound?.resources?.forms?.[formName];
+  if (!form?.formUuid) return null;
+  return {
+    profileName,
+    bound,
+    form,
+  };
+}
+
+function saveWorkspaceFormBinding(config, formName, formUuid, extra = {}) {
+  if (!isOpenXiangdaMode(config) || !formUuid) return false;
+
+  const state = loadProjectState(config);
+  const profileName =
+    resolveProjectProfileName(config, state) ||
+    config.openXiangdaProfile ||
+    config.appType ||
+    "default";
+
+  state.profiles = state.profiles || {};
+  state.profiles[profileName] = {
+    ...(state.profiles[profileName] || {}),
+    baseUrl: config.platformUrl,
+    appType: config.appType,
+    updatedAt: new Date().toISOString(),
+  };
+
+  const bound = state.profiles[profileName];
+  ensureResourceBuckets(bound);
+  bound.resources.forms[formName] = {
+    ...(bound.resources.forms[formName] || {}),
+    ...extra,
+    formUuid,
+    updatedAt: new Date().toISOString(),
+  };
+
+  saveProjectState(config, state);
+  return true;
+}
 
 function readExportedStringConstant(filePath, exportName) {
   if (!filePath || !fs.existsSync(filePath)) return "";
@@ -520,42 +633,50 @@ export async function ensureSchemaFormUuid({
 }) {
   const meta = readSchemaMeta(schemaPath);
   const targetAppType = resolveTargetAppType(config, meta);
+  const workspaceBinding = readWorkspaceFormBinding(config, formName);
+  const effectiveMeta = workspaceBinding?.form?.formUuid
+    ? {
+        ...meta,
+        formUuid: workspaceBinding.form.formUuid,
+        appType: targetAppType,
+      }
+    : meta;
   const staleOpenXiangdaBinding = isStaleOpenXiangdaBinding(
     config,
-    meta,
+    effectiveMeta,
     targetAppType,
   );
 
-  if (meta.formUuid && !staleOpenXiangdaBinding) {
+  if (effectiveMeta.formUuid && !staleOpenXiangdaBinding) {
     let created = false;
     if (!dryRun) {
       const token = accessToken || (await getOpenApiAccessToken(config));
       const existingForm = await getOpenApiForm(config, token, {
         appType: targetAppType,
-        formUuid: meta.formUuid,
+        formUuid: effectiveMeta.formUuid,
       });
 
       if (!existingForm) {
         await createOpenApiForm(config, token, {
-          name: meta.title || formName,
+          name: effectiveMeta.title || formName,
           appType: targetAppType,
-          formType: meta.formType || "receipt",
-          relateUuid: meta.relateUuid,
-          formUuid: meta.formUuid,
+          formType: effectiveMeta.formType || "receipt",
+          relateUuid: effectiveMeta.relateUuid,
+          formUuid: effectiveMeta.formUuid,
           builderVersion: config.defaults?.formBuilderVersion || "2.0",
         });
         created = true;
         console.log(
-          `  ✓ ${formName}: 已按 schema formUuid 创建表单 ${meta.formUuid}`,
+          `  ✓ ${formName}: 已按已有 formUuid 创建表单 ${effectiveMeta.formUuid}`,
         );
       }
 
       if ((created || ensureMenu) && !isOpenXiangdaMode(config)) {
         const menuResult = await ensureOpenApiMenuForForm(config, token, {
           appType: targetAppType,
-          formUuid: meta.formUuid,
-          name: meta.title || formName,
-          formType: meta.formType || "receipt",
+          formUuid: effectiveMeta.formUuid,
+          name: effectiveMeta.title || formName,
+          formType: effectiveMeta.formType || "receipt",
           parentId: config.menu?.parentId,
           icon: config.menu?.icon,
         });
@@ -566,17 +687,21 @@ export async function ensureSchemaFormUuid({
           );
         }
       }
+
+      saveWorkspaceFormBinding(config, formName, effectiveMeta.formUuid, {
+        title: effectiveMeta.title || formName,
+      });
     }
 
     return {
-      ...meta,
+      ...effectiveMeta,
       appType: targetAppType,
       created,
       dryRunCreated: false,
     };
   }
 
-  if (!meta.hasFormUuidProp) {
+  if (!meta.hasFormUuidProp && !isOpenXiangdaMode(config)) {
     throw new Error(
       `${formName}: schema.ts 中未找到 formUuid 字段，无法自动创建并回写`,
     );
@@ -608,7 +733,13 @@ export async function ensureSchemaFormUuid({
 
   const token = accessToken || (await getOpenApiAccessToken(config));
   const createdForm = await createOpenApiForm(config, token, createOptions);
-  syncCreatedFormMeta(schemaPath, meta, targetAppType, createdForm.formUuid);
+  if (isOpenXiangdaMode(config)) {
+    saveWorkspaceFormBinding(config, formName, createdForm.formUuid, {
+      title: createOptions.name,
+    });
+  } else {
+    syncCreatedFormMeta(schemaPath, meta, targetAppType, createdForm.formUuid);
+  }
   console.log(`  ✓ ${formName}: 已创建表单 ${createdForm.formUuid}`);
 
   let menuResult = { created: false, menu: null };

package/packages/sdk/src/build-source/scripts/utils/form-api.test.ts

@@ -170,7 +170,77 @@ describe("form api provisioning helpers", () => {
     );
   });
 
-  it("uses the bound OpenXiangda appType and recreates stale imported form ids", async () => {
+  it("uses OpenXiangda workspace state bindings before schema literals", async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "form-api-"));
+    tempDirs.push(dir);
+    const schemaPath = path.join(dir, "schema.ts");
+    fs.mkdirSync(path.join(dir, ".openxiangda"), { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, ".openxiangda", "state.json"),
+      `${JSON.stringify(
+        {
+          version: 1,
+          profiles: {
+            dev: {
+              baseUrl: "https://platform.example.com/service",
+              appType: "APP_TEST",
+              resources: {
+                forms: {
+                  customer: {
+                    formUuid: "FORM_STATE",
+                    title: "客户表单",
+                  },
+                },
+              },
+            },
+          },
+        },
+        null,
+        2,
+      )}\n`,
+      "utf-8",
+    );
+    fs.writeFileSync(
+      schemaPath,
+      [
+        'const FORM_UUID = "";',
+        'const APP_TYPE = process.env.OPENXIANGDA_APP_TYPE || process.env.APP_TYPE || "";',
+        'export default { formMeta: { formUuid: FORM_UUID, appType: APP_TYPE, title: "客户表单", formType: "receipt" } };',
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const fetchMock = vi.fn(async (url: string) => {
+      if (String(url).endsWith("/forms")) {
+        return Response.json({
+          code: 200,
+          data: [{ formUuid: "FORM_STATE", appType: "APP_TEST" }],
+        });
+      }
+      throw new Error(`unexpected request: ${url}`);
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const result = await ensureSchemaFormUuid({
+      config: {
+        ...config,
+        workspaceRoot: dir,
+        openXiangdaAccessToken: "token",
+        openXiangdaProfile: "dev",
+      },
+      schemaPath,
+      formName: "customer",
+      accessToken: "token",
+    });
+
+    expect(result.formUuid).toBe("FORM_STATE");
+    expect(result.appType).toBe("APP_TEST");
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fs.readFileSync(schemaPath, "utf-8")).toContain('const FORM_UUID = "";');
+  });
+
+  it("uses the bound OpenXiangda appType and stores stale imported form ids in workspace state", async () => {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), "form-api-"));
     tempDirs.push(dir);
     const schemaPath = path.join(dir, "schema.ts");
@@ -223,7 +293,9 @@ describe("form api provisioning helpers", () => {
     const result = await ensureSchemaFormUuid({
       config: {
         ...config,
+        workspaceRoot: dir,
         openXiangdaAccessToken: "token",
+        openXiangdaProfile: "dev",
       },
       schemaPath,
       formName: "customer",
@@ -235,10 +307,60 @@ describe("form api provisioning helpers", () => {
     expect(result.appType).toBe("APP_TEST");
     expect(fetchMock).toHaveBeenCalledTimes(1);
     expect(fs.readFileSync(metaPath, "utf-8")).toContain(
-      'CUSTOMER_INFO_FORM_UUID = "FORM_NEW"',
+      'CUSTOMER_INFO_FORM_UUID = "FORM_OLD"',
     );
     expect(fs.readFileSync(metaPath, "utf-8")).toContain(
-      'CUSTOMER_INFO_APP_TYPE = "APP_TEST"',
+      'CUSTOMER_INFO_APP_TYPE = "APP_OLD"',
+    );
+    expect(
+      JSON.parse(
+        fs.readFileSync(path.join(dir, ".openxiangda", "state.json"), "utf-8"),
+      ).profiles.dev.resources.forms.customer.formUuid,
+    ).toBe("FORM_NEW");
+  });
+
+  it("creates OpenXiangda forms without requiring schema formUuid writeback", async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "form-api-"));
+    tempDirs.push(dir);
+    const schemaPath = path.join(dir, "schema.ts");
+    fs.writeFileSync(
+      schemaPath,
+      `export default { formMeta: { appType: "", title: "客户表单", formType: "receipt" } };\n`,
+      "utf-8",
     );
+
+    const fetchMock = vi.fn(async (url: string, init?: RequestInit) => {
+      expect(String(url)).toBe(
+        "https://platform.example.com/service/openxiangda-api/v1/apps/APP_TEST/forms",
+      );
+      const body = JSON.parse(String(init?.body || "{}"));
+      expect(body.formUuid).toBeUndefined();
+      return Response.json({
+        code: 200,
+        data: { form: { formUuid: "FORM_CREATED" } },
+      });
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const result = await ensureSchemaFormUuid({
+      config: {
+        ...config,
+        workspaceRoot: dir,
+        openXiangdaAccessToken: "token",
+        openXiangdaProfile: "dev",
+      },
+      schemaPath,
+      formName: "customer",
+      accessToken: "token",
+    });
+
+    expect(result.created).toBe(true);
+    expect(result.formUuid).toBe("FORM_CREATED");
+    expect(fs.readFileSync(schemaPath, "utf-8")).not.toContain("FORM_CREATED");
+    expect(
+      JSON.parse(
+        fs.readFileSync(path.join(dir, ".openxiangda", "state.json"), "utf-8"),
+      ).profiles.dev.resources.forms.customer.formUuid,
+    ).toBe("FORM_CREATED");
   });
 });