openxiangda 1.0.7 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openxiangda",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "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");
   });
 });