openxiangda 1.0.0

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

@@ -0,0 +1,89 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+  getPageAssetBaseUrl,
+  getPageAssetUrl,
+  getPageRuntimeUrl,
+  rootDir,
+} from "./load-config.mjs";
+
+function readPageRuntimeManifest() {
+  const manifestPath = path.resolve(rootDir, "dist/page-runtime/manifest.json");
+  if (!fs.existsSync(manifestPath)) return null;
+  try {
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+    if (
+      manifest?.protocol !== "sy-page-runtime" ||
+      manifest?.majorVersion !== 1 ||
+      !manifest?.version ||
+      !manifest?.files?.entry
+    ) {
+      return null;
+    }
+    return manifest;
+  } catch {
+    return null;
+  }
+}
+
+export function buildPageMenuConfig(config, pageConfig) {
+  if (pageConfig.menu?.enabled === false) {
+    return { enabled: false };
+  }
+
+  return {
+    enabled: true,
+    name: pageConfig.menu?.name || pageConfig.name,
+    parentId:
+      pageConfig.menu && "parentId" in pageConfig.menu
+        ? pageConfig.menu.parentId
+        : config.defaults.pageMenuParentId || null,
+    icon:
+      pageConfig.menu && "icon" in pageConfig.menu
+        ? pageConfig.menu.icon
+        : config.defaults.pageMenuIcon || null,
+  };
+}
+
+export function buildDirectPagePublishPayload(config, pages) {
+  const pageRuntime = readPageRuntimeManifest();
+  return {
+    appType: config.appType,
+    userId: config.userId,
+    version: config.version,
+    buildId: config.buildId,
+    pages: pages.map((page) => {
+      const pageBaseUrl = getPageAssetBaseUrl(config, page.config.code);
+      const pageEntryUrl = getPageAssetUrl(config, page.config.code, "index.js");
+      const pageStyleUrl = getPageAssetUrl(config, page.config.code, "style.css");
+      const runtimeJsUrl = pageRuntime?.files?.entry
+        ? getPageRuntimeUrl(config, pageRuntime.files.entry)
+        : null;
+      const runtimeCssUrl = pageRuntime?.files?.css
+        ? getPageRuntimeUrl(config, pageRuntime.files.css)
+        : null;
+      return {
+        code: page.config.code,
+        name: page.config.name,
+        description: page.config.description || "",
+        route: page.config.route,
+        props: page.config.props || {},
+        dataSources: page.config.dataSources || [],
+        runtime: {
+          entryUrl: pageEntryUrl,
+          cssUrls: [runtimeCssUrl, pageStyleUrl].filter(Boolean),
+          jsUrls: runtimeJsUrl ? [runtimeJsUrl] : [pageEntryUrl],
+          cdnBaseUrl: pageBaseUrl,
+          framework: "react",
+          frameworkVersion: config.defaults.frameworkVersion,
+          protocolVersion: config.defaults.protocolVersion,
+          protocol: pageRuntime?.protocol || undefined,
+          version: config.version,
+          cssIsolation:
+            page.config.cssIsolation || config.defaults.cssIsolation,
+        },
+        menu: buildPageMenuConfig(config, page.config),
+      };
+    }),
+  };
+}

package/packages/sdk/src/build-source/scripts/utils/register-payload.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+
+import { getFormBundleUrl, getPageAssetUrl } from "./load-config.mjs";
+import { discoverPages } from "./pages.mjs";
+import { buildDirectPagePublishPayload } from "./register-payload.mjs";
+
+const config = {
+  appType: "APP_TEST",
+  userId: "user-1",
+  version: "1.2.3",
+  buildId: "BUILD_001",
+  oss: {
+    bucket: "bucket",
+    region: "oss-cn-hangzhou",
+    pathPrefix: "lowcode/app-workspace/dev",
+  },
+  defaults: {
+    frameworkVersion: "19.0.0",
+    protocolVersion: "1.0",
+    cssIsolation: "namespace",
+    pageMenuParentId: "MENU_PARENT",
+    pageMenuIcon: "dashboard",
+  },
+};
+
+describe("register payload helpers", () => {
+  it("discovers publishable code pages", async () => {
+    const pages = await discoverPages("customer-dashboard");
+
+    expect(pages).toHaveLength(1);
+    expect(pages[0].config.code).toBe("customer-dashboard");
+  });
+
+  it("builds stable form and page asset URLs from one build id", () => {
+    expect(getFormBundleUrl(config, "customer-info", "index.js")).toBe(
+      "https://bucket.oss-cn-hangzhou.aliyuncs.com/lowcode/app-workspace/dev/1.2.3/BUILD_001/forms/customer-info/index.js",
+    );
+    expect(getPageAssetUrl(config, "customer-dashboard", "style.css")).toBe(
+      "https://bucket.oss-cn-hangzhou.aliyuncs.com/lowcode/app-workspace/dev/1.2.3/BUILD_001/pages/customer-dashboard/style.css",
+    );
+  });
+
+  it("builds direct custom page payloads without manifest fields", () => {
+    const payload = buildDirectPagePublishPayload(config, [
+      {
+        config: {
+          code: "customer-dashboard",
+          name: "客户经营看板",
+          route: { pathKey: "customer-dashboard" },
+          props: { title: "客户经营看板" },
+          dataSources: [],
+        },
+      },
+    ]);
+
+    expect(payload.pages[0].runtime.entryUrl).toBe(
+      "https://bucket.oss-cn-hangzhou.aliyuncs.com/lowcode/app-workspace/dev/1.2.3/BUILD_001/pages/customer-dashboard/index.js",
+    );
+    expect(JSON.stringify(payload)).not.toMatch(/manifest/i);
+  });
+
+  it("marks menu disabled pages so the backend skips menu upsert", () => {
+    const payload = buildDirectPagePublishPayload(config, [
+      {
+        config: {
+          code: "internal-dashboard",
+          name: "内部看板",
+          route: { pathKey: "internal-dashboard" },
+          menu: { enabled: false },
+        },
+      },
+    ]);
+
+    expect(payload.pages[0].menu).toEqual({ enabled: false });
+  });
+});

package/packages/sdk/src/build-source/scripts/utils/runtime-css-check.mjs

@@ -0,0 +1,44 @@
+import fs from "node:fs";
+
+export const requiredRuntimeCssSelectors = [
+  ".flex",
+  ".grid",
+  ".rounded-lg",
+  ".bg-ant-bg-layout",
+  ".sy-form-layout",
+  ".sy-layout-field",
+  ".sy-field-wrapper",
+  ".sy-field-control",
+  ".sy-subform",
+];
+
+function selectorPattern(selector) {
+  const escaped = selector.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(^|[^A-Za-z0-9_-])${escaped}([^A-Za-z0-9_-]|$)`);
+}
+
+export function getMissingRuntimeCssSelectors(
+  css,
+  selectors = requiredRuntimeCssSelectors,
+) {
+  return selectors.filter((selector) => !selectorPattern(selector).test(css));
+}
+
+export function validateRuntimeCssFile(
+  cssPath,
+  { label = "runtime", selectors = requiredRuntimeCssSelectors } = {},
+) {
+  if (!cssPath || !fs.existsSync(cssPath) || fs.statSync(cssPath).size === 0) {
+    throw new Error(
+      `${label} style.css is empty or missing; run lowcode-workspace update to refresh Tailwind config and ensure src/index.css keeps Tailwind base in its own layer`,
+    );
+  }
+
+  const css = fs.readFileSync(cssPath, "utf-8");
+  const missing = getMissingRuntimeCssSelectors(css, selectors);
+  if (missing.length) {
+    throw new Error(
+      `${label} style.css is missing required runtime utility selectors: ${missing.join(", ")}; run lowcode-workspace update to refresh Tailwind preset/content scanning, then rebuild without stale runtime cache`,
+    );
+  }
+}

package/packages/sdk/src/build-source/scripts/utils/runtime-css-check.test.ts

@@ -0,0 +1,54 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+  getMissingRuntimeCssSelectors,
+  validateRuntimeCssFile,
+} from "./runtime-css-check.mjs";
+
+let tempDirs: string[] = [];
+
+function createTempDir() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "runtime-css-check-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of tempDirs) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+  tempDirs = [];
+});
+
+describe("runtime CSS checks", () => {
+  it("accepts runtime CSS with required lowcode layout selectors", () => {
+    const dir = createTempDir();
+    const cssPath = path.join(dir, "style.css");
+    fs.writeFileSync(
+      cssPath,
+      ".flex{display:flex}.grid{display:grid}.rounded-lg{border-radius:.5rem}.bg-ant-bg-layout{background:var(--ant-color-bg-layout)}.sy-form-layout{display:flex}.sy-layout-field{width:100%}.sy-field-wrapper{display:flex}.sy-field-control .ant-input{width:100%}.sy-subform{display:flex}",
+      "utf-8",
+    );
+
+    expect(() => validateRuntimeCssFile(cssPath)).not.toThrow();
+    expect(
+      getMissingRuntimeCssSelectors(fs.readFileSync(cssPath, "utf-8")),
+    ).toEqual([]);
+  });
+
+  it("fails when Tailwind runtime utility selectors are missing", () => {
+    const dir = createTempDir();
+    const cssPath = path.join(dir, "style.css");
+    fs.writeFileSync(cssPath, ".ant-btn{display:inline-flex}", "utf-8");
+
+    expect(() =>
+      validateRuntimeCssFile(cssPath, { label: "代码页共享 runtime" }),
+    ).toThrow(
+      /代码页共享 runtime style\.css is missing required runtime utility selectors/,
+    );
+  });
+});

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

@@ -0,0 +1,130 @@
+export function normalizeComponentName(componentName) {
+  if (componentName === "TextAreaField") return "TextareaField";
+  return componentName;
+}
+
+export function getObjectSize(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return 0;
+  return Object.keys(value).length;
+}
+
+export function isValidTableName(value) {
+  const normalized = String(value || "").trim();
+  return Boolean(normalized) && normalized.toLowerCase() !== "null";
+}
+
+export function validateFormSchema(schema, formName = "unknown") {
+  if (!schema || typeof schema !== "object") {
+    throw new Error(`${formName}: schema 必须是对象`);
+  }
+  if (!schema.formMeta || typeof schema.formMeta !== "object") {
+    throw new Error(`${formName}: schema.formMeta 缺失`);
+  }
+  if (!Array.isArray(schema.fields) || schema.fields.length === 0) {
+    throw new Error(`${formName}: schema.fields 不能为空`);
+  }
+
+  const seenFieldIds = new Set();
+  schema.fields.forEach((field, index) => {
+    const fieldLabel = `${formName}: fields[${index}]`;
+    if (!field || typeof field !== "object") {
+      throw new Error(`${fieldLabel} 必须是对象`);
+    }
+    const fieldId = String(field.fieldId || "").trim();
+    if (!fieldId) {
+      throw new Error(`${fieldLabel}.fieldId 不能为空`);
+    }
+    if (seenFieldIds.has(fieldId)) {
+      throw new Error(`${formName}: fieldId 重复: ${fieldId}`);
+    }
+    seenFieldIds.add(fieldId);
+    if (!String(field.componentName || "").trim()) {
+      throw new Error(`${fieldLabel}.componentName 不能为空`);
+    }
+  });
+}
+
+export function createFormComponentNode(field, index) {
+  const componentName = normalizeComponentName(field.componentName);
+
+  return {
+    componentName,
+    id: field.id || `${field.fieldId || componentName}_${index + 1}`,
+    title: field.label || field.fieldId || componentName,
+    hidden: false,
+    isLocked: false,
+    condition: true,
+    conditionGroup: "",
+    props: {
+      ...field,
+      componentName,
+      isFormComponent: true,
+      fieldId: field.fieldId,
+      label: field.label || field.fieldId,
+      tips: field.tips || "",
+      value: field.value || "",
+      placeholder: field.placeholder || "",
+    },
+  };
+}
+
+export function transformToApiFormat(schema, formName = "unknown") {
+  validateFormSchema(schema, formName);
+
+  const { formMeta, fields } = schema;
+  const componentNodes = fields.map(createFormComponentNode);
+  const pageSchema = {
+    version: "2.0",
+    componentsTree: [
+      {
+        componentName: "Page",
+        id: `${formMeta.formUuid || "form"}_page`,
+        props: {},
+        children: componentNodes,
+      },
+    ],
+  };
+
+  return {
+    formUuid: formMeta.formUuid,
+    appType: formMeta.appType,
+    fieldCount: componentNodes.length,
+    schema: JSON.stringify(pageSchema),
+    packages: JSON.stringify({}),
+  };
+}
+
+export function assertSchemaSyncResult(body, expectedFieldCount) {
+  if (body?.code !== 200) {
+    throw new Error(
+      `API 业务失败: ${body?.code || "unknown"} ${body?.message || ""}`,
+    );
+  }
+
+  if (!isValidTableName(body?.data?.tableName)) {
+    throw new Error("API 同步后未返回有效 tableName，表结构可能未创建");
+  }
+
+  const actualFieldCount = getObjectSize(body?.data?.formFields);
+  if (actualFieldCount !== expectedFieldCount) {
+    throw new Error(
+      `API 同步后 formFields 数量不匹配，期望 ${expectedFieldCount}，实际 ${actualFieldCount}`,
+    );
+  }
+}
+
+export function assertFormReadyForBundle(formMeta, formName = "unknown") {
+  if (!formMeta) {
+    throw new Error(`${formName}: 平台未找到表单定义`);
+  }
+  if (!isValidTableName(formMeta.tableName)) {
+    throw new Error(
+      `${formName}: 平台表单缺少 tableName，请先运行 pnpm sync-schema --form ${formName}`,
+    );
+  }
+  if (getObjectSize(formMeta.formFields) === 0) {
+    throw new Error(
+      `${formName}: 平台表单缺少 formFields，请先运行 pnpm sync-schema --form ${formName}`,
+    );
+  }
+}

package/packages/sdk/src/build-source/scripts/utils/schema-transform.test.ts

@@ -0,0 +1,141 @@
+// @ts-nocheck
+import { describe, expect, it } from "vitest";
+
+import {
+  assertFormReadyForBundle,
+  assertSchemaSyncResult,
+  transformToApiFormat,
+} from "./schema-transform.mjs";
+
+describe("schema-transform", () => {
+  it("builds form component nodes with stable field metadata", () => {
+    const payload = transformToApiFormat(
+      {
+        formMeta: {
+          formUuid: "FORM_1",
+          appType: "APP_1",
+          title: "客户信息登记",
+        },
+        fields: [
+          {
+            fieldId: "customer_name",
+            componentName: "TextField",
+            label: "客户名称",
+          },
+          {
+            fieldId: "remark",
+            componentName: "TextAreaField",
+            label: "备注",
+          },
+        ],
+      },
+      "customer-info",
+    );
+
+    const schema = JSON.parse(payload.schema);
+    const nodes = schema.componentsTree[0].children;
+
+    expect(payload.fieldCount).toBe(2);
+    expect(nodes[0].props).toMatchObject({
+      fieldId: "customer_name",
+      componentName: "TextField",
+      isFormComponent: true,
+    });
+    expect(nodes[1].props).toMatchObject({
+      fieldId: "remark",
+      componentName: "TextareaField",
+      isFormComponent: true,
+    });
+  });
+
+  it("rejects duplicate field ids and empty fields", () => {
+    expect(() =>
+      transformToApiFormat(
+        {
+          formMeta: { formUuid: "FORM_1", appType: "APP_1", title: "表单" },
+          fields: [],
+        },
+        "empty-form",
+      ),
+    ).toThrow("schema.fields 不能为空");
+
+    expect(() =>
+      transformToApiFormat(
+        {
+          formMeta: { formUuid: "FORM_1", appType: "APP_1", title: "表单" },
+          fields: [
+            { fieldId: "name", componentName: "TextField", label: "姓名" },
+            { fieldId: "name", componentName: "TextField", label: "姓名2" },
+          ],
+        },
+        "duplicate-form",
+      ),
+    ).toThrow("fieldId 重复: name");
+  });
+
+  it("validates schema sync response before treating publish as ready", () => {
+    expect(() =>
+      assertSchemaSyncResult(
+        {
+          code: 200,
+          data: {
+            tableName: "form_app_1",
+            formFields: {
+              customer_name: {},
+              remark: {},
+            },
+          },
+        },
+        2,
+      ),
+    ).not.toThrow();
+
+    expect(() =>
+      assertSchemaSyncResult(
+        {
+          code: 200,
+          data: {
+            tableName: "null",
+            formFields: { customer_name: {} },
+          },
+        },
+        1,
+      ),
+    ).toThrow("有效 tableName");
+
+    expect(() =>
+      assertSchemaSyncResult(
+        {
+          code: 200,
+          data: {
+            tableName: "form_app_1",
+            formFields: { customer_name: {} },
+          },
+        },
+        2,
+      ),
+    ).toThrow("formFields 数量不匹配");
+  });
+
+  it("rejects bundle registration before backend schema is initialized", () => {
+    expect(() =>
+      assertFormReadyForBundle(
+        {
+          tableName: "",
+          formFields: { customer_name: {} },
+        },
+        "customer-info",
+      ),
+    ).toThrow("缺少 tableName");
+
+    expect(() =>
+      assertFormReadyForBundle(
+        {
+          tableName: "form_app_1",
+          formFields: {},
+        },
+        "customer-info",
+      ),
+    ).toThrow("缺少 formFields");
+  });
+});