sy-lowcode-workspace-tools 0.1.0

package/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");
+  });
+});

package/src/cli.mjs

@@ -0,0 +1,382 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const managedScriptDir = join(packageRoot, "scripts");
+const managedCommands = new Map([
+  ["build", "build-workspace.mjs"],
+  ["build-forms", "build-forms.mjs"],
+  ["build-pages", "build-pages.mjs"],
+  ["sync-schema", "sync-schema.mjs"],
+  ["publish-oss", "publish-oss.mjs"],
+  ["register", "register.mjs"],
+  ["publish-all", "publish-all.mjs"],
+]);
+const wrapperScripts = new Map([
+  ["build-workspace.mjs", "build"],
+  ["build-forms.mjs", "build-forms"],
+  ["build-pages.mjs", "build-pages"],
+  ["sync-schema.mjs", "sync-schema"],
+  ["publish-oss.mjs", "publish-oss"],
+  ["register.mjs", "register"],
+  ["publish-all.mjs", "publish-all"],
+]);
+const textExtensions = new Set([
+  ".js",
+  ".jsx",
+  ".ts",
+  ".tsx",
+  ".mjs",
+  ".cjs",
+  ".json",
+  ".md",
+  ".css",
+  ".scss",
+  ".yml",
+  ".yaml",
+]);
+const ignoredDirs = new Set([".git", "node_modules", "dist", "build", "coverage", ".vite"]);
+
+function usage() {
+  return `
+lowcode-workspace <command> [options]
+
+Commands:
+  build | build-forms | build-pages | sync-schema | publish-oss | register | publish-all
+  update   Update workspace runtime dependencies and managed wrappers
+  migrate  Convert old local SDK workspace to npm package mode
+
+Update options:
+  --workspace <path>       Workspace root, defaults to cwd
+  --channel <tag>          npm dist-tag, defaults to latest
+  --check                  Validate only; do not mutate
+  --commit                 Commit update changes
+  --push                   Push after commit
+  --no-commit              Do not commit, even if changes exist
+  --allow-dirty            Allow updates with existing worktree changes
+  --skip-install           Do not run pnpm install/update
+  --skip-gate              Do not run typecheck smoke gate
+`;
+}
+
+function parseArgs(argv) {
+  const result = { _: [] };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg.startsWith("--")) {
+      result._.push(arg);
+      continue;
+    }
+    const key = arg.slice(2);
+    if (["workspace", "channel"].includes(key)) {
+      result[key] = argv[index + 1];
+      index += 1;
+    } else {
+      result[key] = true;
+    }
+  }
+  return result;
+}
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd,
+    env: options.env || process.env,
+    stdio: options.capture ? "pipe" : "inherit",
+    encoding: "utf-8",
+  });
+  if (result.status !== 0) {
+    const output = [result.stdout, result.stderr].filter(Boolean).join("\n");
+    throw new Error(
+      `command failed: ${[command, ...args].join(" ")}${output ? `\n${output}` : ""}`,
+    );
+  }
+  return result;
+}
+
+function runManagedScript(command, args, workspaceRoot) {
+  const scriptName = managedCommands.get(command);
+  if (!scriptName) throw new Error(`unknown managed command: ${command}`);
+  const scriptPath = join(managedScriptDir, scriptName);
+  const tsxCli = require.resolve("tsx/cli");
+  run(process.execPath, [tsxCli, scriptPath, ...args], {
+    cwd: workspaceRoot,
+    env: {
+      ...process.env,
+      LOWCODE_WORKSPACE_ROOT: workspaceRoot,
+    },
+  });
+}
+
+function readJson(path) {
+  return JSON.parse(readFileSync(path, "utf-8"));
+}
+
+function writeJson(path, value) {
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+}
+
+function gitStatus(workspaceRoot) {
+  const result = run("git", ["status", "--porcelain"], {
+    cwd: workspaceRoot,
+    capture: true,
+  });
+  return String(result.stdout || "").trim();
+}
+
+function hasGit(workspaceRoot) {
+  return existsSync(join(workspaceRoot, ".git")) || existsSync(join(workspaceRoot, "..", ".git"));
+}
+
+function updatePackageJson(workspaceRoot, channel) {
+  const packagePath = join(workspaceRoot, "package.json");
+  if (!existsSync(packagePath)) throw new Error(`package.json not found: ${packagePath}`);
+  const pkg = readJson(packagePath);
+  pkg.scripts = {
+    ...(pkg.scripts || {}),
+    build: "lowcode-workspace build",
+    "build:forms": "lowcode-workspace build-forms",
+    "build:pages": "lowcode-workspace build-pages",
+    "sync-schema": "lowcode-workspace sync-schema",
+    "publish:oss": "lowcode-workspace publish-oss",
+    register: "lowcode-workspace register",
+    "register-bundle": "lowcode-workspace register",
+    "publish:all": "lowcode-workspace publish-all",
+    "ai:update": `pnpm dlx sy-lowcode-workspace-tools@${channel} update --channel ${channel}`,
+    "ai:migrate": `pnpm dlx sy-lowcode-workspace-tools@${channel} migrate`,
+  };
+  pkg.dependencies = pkg.dependencies || {};
+  delete pkg.dependencies["@sy/page-sdk"];
+  pkg.dependencies["sy-form-components"] = channel;
+  pkg.dependencies["sy-page-sdk"] = channel;
+  pkg.dependencies["sy-lowcode-workspace-tools"] = channel;
+  writeJson(packagePath, pkg);
+}
+
+function wrapperContent(command) {
+  return `#!/usr/bin/env node
+import { main } from "sy-lowcode-workspace-tools";
+
+await main([${JSON.stringify(command)}, ...process.argv.slice(2)]);
+`;
+}
+
+function ensureWrapperScripts(workspaceRoot) {
+  const scriptsDir = join(workspaceRoot, "scripts");
+  mkdirSync(scriptsDir, { recursive: true });
+  for (const [fileName, command] of wrapperScripts) {
+    writeFileSync(join(scriptsDir, fileName), wrapperContent(command), "utf-8");
+  }
+}
+
+function replaceInFile(path, replacer) {
+  const before = readFileSync(path, "utf-8");
+  const after = replacer(before);
+  if (after !== before) writeFileSync(path, after, "utf-8");
+}
+
+function rewriteImports(workspaceRoot) {
+  walkFiles(workspaceRoot, (filePath) => {
+    if (!textExtensions.has(filePath.slice(filePath.lastIndexOf(".")))) return;
+    replaceInFile(filePath, (content) =>
+      content.replaceAll("@sy/page-sdk", "sy-page-sdk"),
+    );
+  });
+}
+
+function rewriteLocalSdkConfig(workspaceRoot) {
+  const viteConfig = join(workspaceRoot, "vite.config.ts");
+  if (existsSync(viteConfig)) {
+    replaceInFile(viteConfig, (content) =>
+      content
+        .replace(/\s*\{[^{}]*packages\/page-sdk[^{}]*\},?/g, "")
+        .replace(/\s*\{\s*find:\s*["']sy-page-sdk\/react["'][\s\S]*?\n\s*\},\n/g, "")
+        .replace(/\s*\{\s*find:\s*["']sy-page-sdk["'][\s\S]*?\n\s*\},\n/g, ""),
+    );
+  }
+  const vitestConfig = join(workspaceRoot, "vitest.config.ts");
+  if (existsSync(vitestConfig)) {
+    replaceInFile(vitestConfig, (content) =>
+      content
+        .replace(/\s*\{[^{}]*packages\/page-sdk[^{}]*\},?/g, "")
+        .replace(/\s*\{\s*find:\s*["']sy-page-sdk\/react["'][\s\S]*?\n\s*\},\n/g, "")
+        .replace(/\s*\{\s*find:\s*["']sy-page-sdk["'][\s\S]*?\n\s*\},\n/g, "")
+        .replace(/,\s*["']sy-page-sdk["']/g, ""),
+    );
+  }
+  const tsconfig = join(workspaceRoot, "tsconfig.app.json");
+  if (existsSync(tsconfig)) {
+    try {
+      const config = readJson(tsconfig);
+      if (config.compilerOptions?.paths) {
+        delete config.compilerOptions.paths["sy-page-sdk"];
+        delete config.compilerOptions.paths["sy-page-sdk/react"];
+      }
+      if (Array.isArray(config.include)) {
+        config.include = config.include.filter((item) => !String(item).includes("packages/page-sdk"));
+      }
+      writeJson(tsconfig, config);
+    } catch {
+      replaceInFile(tsconfig, (content) =>
+        content
+          .replace(/\s*["']sy-page-sdk["']:\s*\[[^\n]*\],?\n/g, "")
+          .replace(/\s*["']sy-page-sdk\/react["']:\s*\[[^\n]*\],?\n/g, "")
+          .replace(/,\s*["']packages\/page-sdk\/src["']/g, "")
+          .replace(/["']packages\/page-sdk\/src["'],?\s*/g, ""),
+      );
+    }
+  }
+  const tailwindConfig = join(workspaceRoot, "tailwind.config.cjs");
+  if (existsSync(tailwindConfig)) {
+    replaceInFile(tailwindConfig, (content) =>
+      content
+        .replace(/,\s*["'][^"']*packages\/page-sdk[^"']*["']/g, "")
+        .replace(/["'][^"']*packages\/page-sdk[^"']*["']\s*,?/g, ""),
+    );
+  }
+}
+
+function walkFiles(root, onFile) {
+  for (const entry of readdirSync(root)) {
+    if (ignoredDirs.has(entry)) continue;
+    const path = join(root, entry);
+    const stat = statSync(path);
+    if (stat.isDirectory()) {
+      walkFiles(path, onFile);
+    } else if (stat.isFile()) {
+      onFile(path);
+    }
+  }
+}
+
+function removeLocalSdk(workspaceRoot) {
+  const localSdkPath = join(workspaceRoot, "packages", "page-sdk");
+  if (existsSync(localSdkPath)) {
+    rmSync(localSdkPath, { recursive: true, force: true });
+  }
+}
+
+function validateWorkspace(workspaceRoot, channel = "latest") {
+  const errors = [];
+  const pkg = readJson(join(workspaceRoot, "package.json"));
+  const deps = pkg.dependencies || {};
+  if (deps["@sy/page-sdk"]) errors.push("package.json still depends on @sy/page-sdk");
+  for (const name of ["sy-form-components", "sy-page-sdk", "sy-lowcode-workspace-tools"]) {
+    if (deps[name] !== channel) errors.push(`package.json dependency ${name} must be ${channel}`);
+  }
+  if (existsSync(join(workspaceRoot, "packages", "page-sdk"))) {
+    errors.push("local packages/page-sdk must be removed from application workspaces");
+  }
+  walkFiles(workspaceRoot, (filePath) => {
+    if (!textExtensions.has(filePath.slice(filePath.lastIndexOf(".")))) return;
+    const content = readFileSync(filePath, "utf-8");
+    if (content.includes("@sy/page-sdk")) {
+      errors.push(`${filePath} still references @sy/page-sdk`);
+    }
+    if (content.includes("packages/page-sdk")) {
+      errors.push(`${filePath} still references packages/page-sdk`);
+    }
+  });
+  if (errors.length) {
+    throw new Error(`workspace update check failed:\n- ${errors.join("\n- ")}`);
+  }
+}
+
+function runUpdateInstall(workspaceRoot, channel) {
+  run("pnpm", ["install"], { cwd: workspaceRoot });
+  run("pnpm", [
+    "update",
+    "--latest",
+    "sy-form-components",
+    "sy-page-sdk",
+    "sy-lowcode-workspace-tools",
+  ], { cwd: workspaceRoot });
+  updatePackageJson(workspaceRoot, channel);
+  run("pnpm", ["install"], { cwd: workspaceRoot });
+}
+
+function runQuickGate(workspaceRoot) {
+  const pkg = readJson(join(workspaceRoot, "package.json"));
+  if (pkg.scripts?.typecheck) {
+    run("pnpm", ["typecheck"], { cwd: workspaceRoot });
+  }
+  runManagedScript("build-pages", ["--help"], workspaceRoot);
+}
+
+function commitAndMaybePush(workspaceRoot, push) {
+  if (!hasGit(workspaceRoot)) return;
+  run("git", ["add", "-A"], { cwd: workspaceRoot });
+  const status = gitStatus(workspaceRoot);
+  if (!status) return;
+  run("git", ["commit", "-m", "chore: update lowcode workspace runtime dependencies"], {
+    cwd: workspaceRoot,
+  });
+  if (push) {
+    run("git", ["push", "origin", "HEAD"], { cwd: workspaceRoot });
+  }
+}
+
+async function updateWorkspace(argv, { migrate = false } = {}) {
+  const args = parseArgs(argv);
+  const workspaceRoot = resolve(args.workspace || process.cwd());
+  const channel = String(args.channel || process.env.APP_WORKSPACE_UPDATE_CHANNEL || "latest");
+  const checkOnly = Boolean(args.check);
+  const allowDirty = Boolean(args["allow-dirty"]);
+  const shouldCommit = Boolean(args.commit) && !args["no-commit"];
+  const shouldPush = Boolean(args.push);
+
+  if (checkOnly) {
+    validateWorkspace(workspaceRoot, channel);
+    console.log("[lowcode-workspace] update check passed");
+    return;
+  }
+
+  if (hasGit(workspaceRoot) && !allowDirty) {
+    const before = gitStatus(workspaceRoot);
+    if (before) {
+      throw new Error(
+        "workspace has uncommitted changes; commit/stash them first or pass --allow-dirty",
+      );
+    }
+  }
+
+  updatePackageJson(workspaceRoot, channel);
+  ensureWrapperScripts(workspaceRoot);
+  rewriteImports(workspaceRoot);
+  rewriteLocalSdkConfig(workspaceRoot);
+  if (migrate || existsSync(join(workspaceRoot, "packages", "page-sdk"))) {
+    removeLocalSdk(workspaceRoot);
+  }
+
+  if (!args["skip-install"]) runUpdateInstall(workspaceRoot, channel);
+  validateWorkspace(workspaceRoot, channel);
+  if (!args["skip-gate"]) runQuickGate(workspaceRoot);
+  if (shouldCommit) commitAndMaybePush(workspaceRoot, shouldPush);
+  console.log("[lowcode-workspace] workspace update completed");
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const [command, ...rest] = argv;
+  if (!command || command === "--help" || command === "-h") {
+    console.log(usage());
+    return;
+  }
+  if (command === "update") {
+    await updateWorkspace(rest);
+    return;
+  }
+  if (command === "migrate") {
+    await updateWorkspace(rest, { migrate: true });
+    return;
+  }
+  if (managedCommands.has(command)) {
+    const args = parseArgs(rest);
+    runManagedScript(command, rest, resolve(args.workspace || process.cwd()));
+    return;
+  }
+  throw new Error(`unknown command: ${command}`);
+}