openxiangda 1.0.0

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

@@ -0,0 +1,244 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { ensureSchemaFormUuid } from "./form-api.mjs";
+
+const config = {
+  platformUrl: "https://platform.example.com",
+  servicePrefix: "/service",
+  appType: "APP_TEST",
+  appKey: "app-key",
+  appSecret: "app-secret",
+  userId: "user-1",
+  defaults: {
+    formBuilderVersion: "2.0",
+  },
+  menu: {
+    parentId: "",
+    icon: "",
+  },
+};
+
+let tempDirs: string[] = [];
+
+function createSchemaFile() {
+  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: { formUuid: "FORM_1", appType: "APP_TEST", title: "客户表单", formType: "receipt" } };\n`,
+    "utf-8",
+  );
+  return schemaPath;
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  for (const dir of tempDirs) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+  tempDirs = [];
+});
+
+describe("form api provisioning helpers", () => {
+  it("does not create a menu for an existing schema formUuid unless requested", async () => {
+    const schemaPath = createSchemaFile();
+    const fetchMock = vi.fn(async (url: string) => {
+      if (url.endsWith("/forms/getFormList")) {
+        return Response.json({
+          code: 200,
+          data: [{ formUuid: "FORM_1", appType: "APP_TEST" }],
+        });
+      }
+      if (url.endsWith("/forms/menu/create")) {
+        return Response.json({ code: 200, data: { id: "MENU_1" } });
+      }
+      throw new Error(`unexpected request: ${url}`);
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const result = await ensureSchemaFormUuid({
+      config,
+      schemaPath,
+      formName: "customer",
+      accessToken: "token",
+      ensureMenu: false,
+    });
+
+    expect(result.formUuid).toBe("FORM_1");
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(
+      fetchMock.mock.calls.map(([url]) => String(url)).join("\n"),
+    ).not.toContain("/forms/menu/create");
+  });
+
+  it("does not create a menu for an existing schema formUuid by default", async () => {
+    const schemaPath = createSchemaFile();
+    const fetchMock = vi.fn(async (url: string) => {
+      if (url.endsWith("/forms/getFormList")) {
+        return Response.json({
+          code: 200,
+          data: [{ formUuid: "FORM_1", appType: "APP_TEST" }],
+        });
+      }
+      if (url.endsWith("/forms/menu/create")) {
+        return Response.json({ code: 200, data: { id: "MENU_1" } });
+      }
+      throw new Error(`unexpected request: ${url}`);
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    await ensureSchemaFormUuid({
+      config,
+      schemaPath,
+      formName: "customer",
+      accessToken: "token",
+    });
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(
+      fetchMock.mock.calls.map(([url]) => String(url)).join("\n"),
+    ).not.toContain("/forms/menu/create");
+  });
+
+  it("creates a menu for an existing schema formUuid when explicitly requested", async () => {
+    const schemaPath = createSchemaFile();
+    const fetchMock = vi.fn(async (url: string) => {
+      if (url.endsWith("/forms/getFormList")) {
+        return Response.json({
+          code: 200,
+          data: [{ formUuid: "FORM_1", appType: "APP_TEST" }],
+        });
+      }
+      if (url.endsWith("/forms/getMenusByAppType")) {
+        return Response.json({ code: 200, data: [] });
+      }
+      if (url.endsWith("/forms/menu/create")) {
+        return Response.json({ code: 200, data: { id: "MENU_1" } });
+      }
+      throw new Error(`unexpected request: ${url}`);
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    await ensureSchemaFormUuid({
+      config,
+      schemaPath,
+      formName: "customer",
+      accessToken: "token",
+      ensureMenu: true,
+    });
+
+    expect(fetchMock.mock.calls.map(([url]) => String(url))).toContain(
+      "https://platform.example.com/service/dingtalk-api/v1.0/forms/menu/create",
+    );
+  });
+
+  it("creates a menu when a schema formUuid form is created this run", async () => {
+    const schemaPath = createSchemaFile();
+    const fetchMock = vi.fn(async (url: string) => {
+      if (url.endsWith("/forms/getFormList")) {
+        return Response.json({ code: 200, data: [] });
+      }
+      if (url.endsWith("/forms/createForm")) {
+        return Response.json({ code: 200, data: { formUuid: "FORM_1" } });
+      }
+      if (url.endsWith("/forms/getMenusByAppType")) {
+        return Response.json({ code: 200, data: [] });
+      }
+      if (url.endsWith("/forms/menu/create")) {
+        return Response.json({ code: 200, data: { id: "MENU_1" } });
+      }
+      throw new Error(`unexpected request: ${url}`);
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const result = await ensureSchemaFormUuid({
+      config,
+      schemaPath,
+      formName: "customer",
+      accessToken: "token",
+      ensureMenu: false,
+    });
+
+    expect(result.created).toBe(true);
+    expect(fetchMock.mock.calls.map(([url]) => String(url))).toContain(
+      "https://platform.example.com/service/dingtalk-api/v1.0/forms/menu/create",
+    );
+  });
+
+  it("uses the bound OpenXiangda appType and recreates stale imported form ids", async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "form-api-"));
+    tempDirs.push(dir);
+    const schemaPath = path.join(dir, "schema.ts");
+    const metaPath = path.join(dir, "meta.ts");
+    fs.writeFileSync(
+      metaPath,
+      [
+        'export const CUSTOMER_INFO_FORM_UUID = "FORM_OLD";',
+        'export const CUSTOMER_INFO_APP_TYPE = "APP_OLD";',
+        'export const CUSTOMER_INFO_TITLE = "客户表单";',
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+    fs.writeFileSync(
+      schemaPath,
+      [
+        "import {",
+        "  CUSTOMER_INFO_APP_TYPE,",
+        "  CUSTOMER_INFO_FORM_UUID,",
+        "  CUSTOMER_INFO_TITLE,",
+        '} from "./meta";',
+        "export default {",
+        "  formMeta: {",
+        "    formUuid: CUSTOMER_INFO_FORM_UUID,",
+        "    appType: CUSTOMER_INFO_APP_TYPE,",
+        "    title: CUSTOMER_INFO_TITLE,",
+        '    formType: "receipt",',
+        "  },",
+        "};",
+        "",
+      ].join("\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();
+      expect(body.name).toBe("客户表单");
+      return Response.json({
+        code: 200,
+        data: { form: { formUuid: "FORM_NEW" } },
+      });
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const result = await ensureSchemaFormUuid({
+      config: {
+        ...config,
+        openXiangdaAccessToken: "token",
+      },
+      schemaPath,
+      formName: "customer",
+      accessToken: "token",
+    });
+
+    expect(result.created).toBe(true);
+    expect(result.formUuid).toBe("FORM_NEW");
+    expect(result.appType).toBe("APP_TEST");
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fs.readFileSync(metaPath, "utf-8")).toContain(
+      'CUSTOMER_INFO_FORM_UUID = "FORM_NEW"',
+    );
+    expect(fs.readFileSync(metaPath, "utf-8")).toContain(
+      'CUSTOMER_INFO_APP_TYPE = "APP_TEST"',
+    );
+  });
+});

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

@@ -0,0 +1,57 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { getFormBundleUrl } from "./load-config.mjs";
+
+export const runtimeCssMarker = "/* sy-lowcode shared form runtime styles */";
+export const formCssMarker = "/* sy-lowcode form bundle styles */";
+
+export function isNonEmptyFile(filePath) {
+  return Boolean(
+    filePath && fs.existsSync(filePath) && fs.statSync(filePath).size > 0,
+  );
+}
+
+export function resolveRuntimeCssPath(runtimeDistDir, manifest) {
+  const cssFile = manifest?.files?.css;
+  if (!cssFile) return "";
+  return path.resolve(runtimeDistDir, cssFile);
+}
+
+export function mergeSharedRuntimeCssIntoFormCss({
+  runtimeCssPath,
+  formCssPath,
+}) {
+  if (!isNonEmptyFile(runtimeCssPath)) {
+    return { merged: false, reason: "missing-runtime-css" };
+  }
+
+  const runtimeCss = fs.readFileSync(runtimeCssPath, "utf-8").trimEnd();
+  const formCss = fs.existsSync(formCssPath)
+    ? fs.readFileSync(formCssPath, "utf-8")
+    : "";
+
+  if (formCss.includes(runtimeCssMarker)) {
+    return { merged: false, reason: "already-merged" };
+  }
+
+  const nextCss = formCss.trim()
+    ? `${runtimeCssMarker}\n${runtimeCss}\n\n${formCssMarker}\n${formCss.trimStart()}`
+    : `${runtimeCssMarker}\n${runtimeCss}\n`;
+
+  fs.mkdirSync(path.dirname(formCssPath), { recursive: true });
+  fs.writeFileSync(formCssPath, nextCss, "utf-8");
+  return { merged: true, reason: "merged" };
+}
+
+export function getRegisteredFormCssUrl(config, formName, options = {}) {
+  const formCssUrl = getFormBundleUrl(config, formName, "style.css");
+  if (
+    options.runtime?.cssUrl &&
+    options.formCssPath &&
+    !isNonEmptyFile(options.formCssPath)
+  ) {
+    return options.runtime.cssUrl;
+  }
+  return formCssUrl;
+}

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

@@ -0,0 +1,135 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+  formCssMarker,
+  getRegisteredFormCssUrl,
+  mergeSharedRuntimeCssIntoFormCss,
+  resolveRuntimeCssPath,
+  runtimeCssMarker,
+} from "./form-runtime-assets.mjs";
+
+const config = {
+  version: "1.2.3",
+  buildId: "BUILD_001",
+  oss: {
+    bucket: "bucket",
+    region: "oss-cn-hangzhou",
+    pathPrefix: "lowcode/app-workspace/dev",
+  },
+};
+
+let tempDirs: string[] = [];
+
+function createTempDir() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "form-runtime-assets-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of tempDirs) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+  tempDirs = [];
+});
+
+describe("form runtime asset helpers", () => {
+  it("resolves the runtime css path from the manifest", () => {
+    expect(
+      resolveRuntimeCssPath("/workspace/dist/form-runtime", {
+        files: { css: "style.css" },
+      }),
+    ).toBe("/workspace/dist/form-runtime/style.css");
+  });
+
+  it("copies shared runtime css into an empty form css file", () => {
+    const dir = createTempDir();
+    const runtimeCssPath = path.join(dir, "runtime.css");
+    const formCssPath = path.join(dir, "forms", "style.css");
+    fs.writeFileSync(
+      runtimeCssPath,
+      ".adm-button{display:inline-flex}",
+      "utf-8",
+    );
+
+    const result = mergeSharedRuntimeCssIntoFormCss({
+      runtimeCssPath,
+      formCssPath,
+    });
+
+    expect(result).toEqual({ merged: true, reason: "merged" });
+    expect(fs.readFileSync(formCssPath, "utf-8")).toContain(runtimeCssMarker);
+    expect(fs.readFileSync(formCssPath, "utf-8")).toContain(".adm-button");
+  });
+
+  it("keeps form css after the shared runtime css", () => {
+    const dir = createTempDir();
+    const runtimeCssPath = path.join(dir, "runtime.css");
+    const formCssPath = path.join(dir, "style.css");
+    fs.writeFileSync(runtimeCssPath, ".runtime{color:red}", "utf-8");
+    fs.writeFileSync(formCssPath, ".form{color:blue}", "utf-8");
+
+    mergeSharedRuntimeCssIntoFormCss({ runtimeCssPath, formCssPath });
+
+    const css = fs.readFileSync(formCssPath, "utf-8");
+    expect(css.indexOf(runtimeCssMarker)).toBeLessThan(
+      css.indexOf(formCssMarker),
+    );
+    expect(css).toContain(".runtime");
+    expect(css).toContain(".form");
+  });
+
+  it("does not duplicate runtime css when the file is already merged", () => {
+    const dir = createTempDir();
+    const runtimeCssPath = path.join(dir, "runtime.css");
+    const formCssPath = path.join(dir, "style.css");
+    fs.writeFileSync(runtimeCssPath, ".runtime{color:red}", "utf-8");
+    fs.writeFileSync(
+      formCssPath,
+      `${runtimeCssMarker}\n.runtime{color:red}\n`,
+      "utf-8",
+    );
+
+    const result = mergeSharedRuntimeCssIntoFormCss({
+      runtimeCssPath,
+      formCssPath,
+    });
+
+    expect(result).toEqual({ merged: false, reason: "already-merged" });
+    expect(
+      fs.readFileSync(formCssPath, "utf-8").match(/runtime/g),
+    ).toHaveLength(2);
+  });
+
+  it("falls back to runtime css for register when form css is empty", () => {
+    const dir = createTempDir();
+    const formCssPath = path.join(dir, "style.css");
+    fs.writeFileSync(formCssPath, "", "utf-8");
+
+    expect(
+      getRegisteredFormCssUrl(config, "customer-info", {
+        formCssPath,
+        runtime: { cssUrl: "https://cdn.example.com/form-runtime/style.css" },
+      }),
+    ).toBe("https://cdn.example.com/form-runtime/style.css");
+  });
+
+  it("keeps the form css url for register when form css has content", () => {
+    const dir = createTempDir();
+    const formCssPath = path.join(dir, "style.css");
+    fs.writeFileSync(formCssPath, ".form{color:blue}", "utf-8");
+
+    expect(
+      getRegisteredFormCssUrl(config, "customer-info", {
+        formCssPath,
+        runtime: { cssUrl: "https://cdn.example.com/form-runtime/style.css" },
+      }),
+    ).toBe(
+      "https://bucket.oss-cn-hangzhou.aliyuncs.com/lowcode/app-workspace/dev/1.2.3/BUILD_001/forms/customer-info/style.css",
+    );
+  });
+});

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

@@ -0,0 +1,210 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { rootDir } from "./load-config.mjs";
+
+const CACHE_VERSION = 1;
+export const CACHE_FILE = path.join(rootDir, ".openxiangda", "build-cache.json");
+
+function toPosix(filePath) {
+  return filePath.split(path.sep).join("/");
+}
+
+function hashContent(content) {
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+
+function readFileHash(filePath) {
+  try {
+    return hashContent(fs.readFileSync(filePath));
+  } catch {
+    return "missing";
+  }
+}
+
+function walkFiles(dirPath, files = []) {
+  if (!fs.existsSync(dirPath)) return files;
+  for (const entry of fs.readdirSync(dirPath, { withFileTypes: true })) {
+    const nextPath = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      if (["node_modules", "dist", ".openxiangda", ".git", ".tmp"].includes(entry.name)) {
+        continue;
+      }
+      walkFiles(nextPath, files);
+      continue;
+    }
+    if (entry.isFile()) files.push(nextPath);
+  }
+  return files;
+}
+
+export function computeDirectoryHash(dirPath) {
+  const files = walkFiles(dirPath).sort((left, right) =>
+    toPosix(path.relative(rootDir, left)).localeCompare(toPosix(path.relative(rootDir, right))),
+  );
+  const hash = crypto.createHash("sha256");
+  for (const file of files) {
+    const rel = toPosix(path.relative(rootDir, file));
+    hash.update(rel);
+    hash.update("\0");
+    hash.update(readFileHash(file));
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+
+export function computeLockfileHash() {
+  const hash = crypto.createHash("sha256");
+  for (const name of ["pnpm-lock.yaml", "package-lock.json", "yarn.lock"]) {
+    const filePath = path.join(rootDir, name);
+    hash.update(name);
+    hash.update("\0");
+    hash.update(readFileHash(filePath));
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+
+export function computeSharedHash() {
+  const sharedDir = path.join(rootDir, "src", "shared");
+  return fs.existsSync(sharedDir) ? computeDirectoryHash(sharedDir) : "no-shared";
+}
+
+export function computeConfigHash() {
+  const hash = crypto.createHash("sha256");
+  for (const name of [
+    "package.json",
+    "app-workspace.config.ts",
+    "tailwind.config.cjs",
+    "postcss.config.cjs",
+    "vite.config.ts",
+    "tsconfig.json",
+    "src/index.css",
+  ]) {
+    hash.update(name);
+    hash.update("\0");
+    hash.update(readFileHash(path.join(rootDir, name)));
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+
+export function loadBuildCache() {
+  try {
+    const cache = JSON.parse(fs.readFileSync(CACHE_FILE, "utf-8"));
+    return cache.version === CACHE_VERSION ? cache : null;
+  } catch {
+    return null;
+  }
+}
+
+export function cleanBuildCache() {
+  fs.rmSync(CACHE_FILE, { force: true });
+}
+
+export function normalizeOnly(value) {
+  if (!value) return [];
+  const raw = Array.isArray(value) ? value.join(",") : String(value);
+  return raw
+    .split(",")
+    .map((item) => item.trim().replace(/^src\//, ""))
+    .filter(Boolean);
+}
+
+export function planIncrementalBuild(modules, options = {}) {
+  const only = normalizeOnly(options.only);
+  const selected = only.length
+    ? modules.filter((item) => only.includes(item.key))
+    : modules;
+  const moduleHashes = Object.fromEntries(
+    modules.map((item) => [item.key, computeDirectoryHash(item.dirPath)]),
+  );
+  const snapshot = {
+    lockfileHash: computeLockfileHash(),
+    sharedHash: computeSharedHash(),
+    configHash: computeConfigHash(),
+    moduleHashes,
+  };
+  const cache = loadBuildCache();
+  const fullRebuild =
+    Boolean(options.force) ||
+    !cache ||
+    cache.lockfileHash !== snapshot.lockfileHash ||
+    cache.sharedHash !== snapshot.sharedHash ||
+    cache.configHash !== snapshot.configHash;
+  const changed = selected.filter(
+    (item) => fullRebuild || cache?.entries?.[item.key]?.contentHash !== moduleHashes[item.key],
+  );
+
+  return {
+    all: modules,
+    selected,
+    changed,
+    fullRebuild,
+    snapshot,
+  };
+}
+
+export function discoverWorkspaceModules() {
+  const modules = [];
+  for (const [kind, requiredFile] of [
+    ["forms", "schema.ts"],
+    ["pages", "page.config.ts"],
+  ]) {
+    const baseDir = path.join(rootDir, "src", kind);
+    if (!fs.existsSync(baseDir)) continue;
+    for (const entry of fs.readdirSync(baseDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const dirPath = path.join(baseDir, entry.name);
+      if (!fs.existsSync(path.join(dirPath, requiredFile))) continue;
+      modules.push({
+        key: `${kind}/${entry.name}`,
+        kind,
+        name: entry.name,
+        dirPath,
+      });
+    }
+  }
+  return modules.sort((left, right) => left.key.localeCompare(right.key));
+}
+
+export function commitIncrementalBuild(plan, builtModules) {
+  const previous = loadBuildCache();
+  const entries = { ...(previous?.entries || {}) };
+  const now = new Date().toISOString();
+  for (const item of builtModules) {
+    entries[item.key] = {
+      contentHash: plan.snapshot.moduleHashes[item.key],
+      lastBuildTime: now,
+      success: true,
+    };
+  }
+  fs.mkdirSync(path.dirname(CACHE_FILE), { recursive: true });
+  fs.writeFileSync(
+    CACHE_FILE,
+    `${JSON.stringify(
+      {
+        version: CACHE_VERSION,
+        lockfileHash: plan.snapshot.lockfileHash,
+        sharedHash: plan.snapshot.sharedHash,
+        configHash: plan.snapshot.configHash,
+        entries,
+      },
+      null,
+      2,
+    )}\n`,
+    "utf-8",
+  );
+}
+
+export function printPlan(plan, label) {
+  if (plan.changed.length === 0) {
+    console.log(`[build] ${label}: No changes detected`);
+    return;
+  }
+  const mode = plan.fullRebuild ? "full rebuild" : "incremental";
+  console.log(
+    `[build] ${label}: Building ${plan.changed.length}/${plan.all.length} module(s) (${mode})`,
+  );
+  for (const item of plan.changed) console.log(`  - ${item.key}`);
+}