openxiangda 1.0.162 → 1.0.164

package/templates/sy-lowcode-app-workspace/scripts/build-js-code.mjs

@@ -19,13 +19,29 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { build } from "vite";
 
-const rootDir = fileURLToPath(new URL("..", import.meta.url));
 const scriptFile = fileURLToPath(import.meta.url);
+const defaultRootDir = fileURLToPath(new URL("..", import.meta.url));
+const rootDir = path.resolve(process.env.OPENXIANGDA_WORKSPACE_ROOT || defaultRootDir);
 const args = process.argv.slice(2);
 const require = createRequire(import.meta.url);
-const CACHE_VERSION = 2;
-const CACHE_FILE = path.join(rootDir, ".openxiangda", "build-cache.json");
+const ts = require("typescript");
+const CACHE_VERSION = 3;
+const builderFingerprint = crypto
+  .createHash("sha256")
+  .update(readFileSync(scriptFile))
+  .digest("hex");
+const workspaceBuilderFile = path.join(rootDir, "scripts", "build-js-code.mjs");
+const workspaceBuilderMatches =
+  existsSync(workspaceBuilderFile) &&
+  crypto.createHash("sha256").update(readFileSync(workspaceBuilderFile)).digest("hex") ===
+    builderFingerprint;
+const cacheFileName =
+  path.resolve(defaultRootDir) !== rootDir && !workspaceBuilderMatches
+    ? "build-cache.cli-v3.json"
+    : "build-cache.json";
+const CACHE_FILE = path.join(rootDir, ".openxiangda", cacheFileName);
 const CACHE_LOCK_FILE = `${CACHE_FILE}.lock`;
+const TSCONFIG_FILE = path.join(rootDir, "tsconfig.js-code-nodes.json");
 const forceBuild = args.includes("--force") || args.includes("--no-cache");
 
 const sourceKinds = {
@@ -84,11 +100,24 @@ function assertScriptCode(scriptCode) {
 function listScriptCodes(kind) {
   if (!existsSync(kind.sourceRoot)) return [];
   return readdirSync(kind.sourceRoot, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory() && existsSync(path.join(kind.sourceRoot, entry.name, "index.ts")))
+    .filter(
+      (entry) =>
+        entry.isDirectory() &&
+        ["index.ts", "index.tsx"].some((name) =>
+          existsSync(path.join(kind.sourceRoot, entry.name, name)),
+        ),
+    )
     .map((entry) => entry.name)
     .sort();
 }
 
+function targetEntryFile(target) {
+  const base = path.join(target.kind.sourceRoot, target.scriptCode);
+  return ["index.ts", "index.tsx"]
+    .map((name) => path.join(base, name))
+    .find((file) => existsSync(file)) || path.join(base, "index.ts");
+}
+
 function parseScriptSpec(rawSpec, defaultKind) {
   const prefixed = String(rawSpec).match(/^(js-code-nodes|automations|functions)[:/](.+)$/);
   const requestedKind = prefixed?.[1] || defaultKind?.name;
@@ -101,7 +130,9 @@ function parseScriptSpec(rawSpec, defaultKind) {
   if (requestedKind) return { kind: sourceKinds[requestedKind], scriptCode };
 
   const matches = Object.values(sourceKinds).filter((kind) =>
-    existsSync(path.join(kind.sourceRoot, scriptCode, "index.ts")),
+    ["index.ts", "index.tsx"].some((name) =>
+      existsSync(path.join(kind.sourceRoot, scriptCode, name)),
+    ),
   );
   if (matches.length > 1) {
     console.warn(
@@ -111,7 +142,7 @@ function parseScriptSpec(rawSpec, defaultKind) {
   return { kind: matches[0] || sourceKinds["js-code-nodes"], scriptCode };
 }
 
-function resolveBuildTargets() {
+function resolveBuildSelection() {
   const sourceArgs = readArgs("source");
   const sourceNames = [...new Set(sourceArgs)];
   if (sourceNames.length > 1) throw new Error("--source may only select one source kind");
@@ -128,7 +159,10 @@ function resolveBuildTargets() {
     : (selectedKind ? [selectedKind] : Object.values(sourceKinds)).flatMap((kind) =>
         listScriptCodes(kind).map((scriptCode) => ({ kind, scriptCode })),
       );
-  return [...new Map(targets.map((target) => [`${target.kind.name}/${target.scriptCode}`, target])).values()];
+  return {
+    scoped: specs.length > 0,
+    targets: [...new Map(targets.map((target) => [`${target.kind.name}/${target.scriptCode}`, target])).values()],
+  };
 }
 
 function packageVersion(name) {
@@ -144,6 +178,7 @@ const toolFingerprint = crypto
   .update(
     JSON.stringify({
       cacheVersion: CACHE_VERSION,
+      builder: builderFingerprint,
       node: process.version,
       platform: process.platform,
       arch: process.arch,
@@ -157,14 +192,25 @@ const toolFingerprint = crypto
   .digest("hex");
 
 function emptyCache() {
-  return { version: CACHE_VERSION, toolFingerprint, typecheck: null, targets: {} };
+  return {
+    version: CACHE_VERSION,
+    toolFingerprint,
+    typecheck: null,
+    typechecks: {},
+    targets: {},
+  };
 }
 
 function readCache(file = CACHE_FILE) {
   try {
     const cache = JSON.parse(readFileSync(file, "utf8"));
     if (cache.version !== CACHE_VERSION) return emptyCache();
-    return { ...emptyCache(), ...cache, targets: cache.targets || {} };
+    return {
+      ...emptyCache(),
+      ...cache,
+      typechecks: cache.typechecks || {},
+      targets: cache.targets || {},
+    };
   } catch {
     return emptyCache();
   }
@@ -231,7 +277,7 @@ function typecheckInputHash() {
 }
 
 function targetInputHash(target, dependencies) {
-  const entry = relativeWorkspaceFile(path.join(target.kind.sourceRoot, target.scriptCode, "index.ts"));
+  const entry = relativeWorkspaceFile(targetEntryFile(target));
   return hashFileSet(
     [...configInputFiles(), entry, ...(dependencies || [])].filter(Boolean),
     `target:${target.kind.name}/${target.scriptCode}`,
@@ -258,11 +304,94 @@ function isTargetCacheHit(cache, target) {
   );
 }
 
-function typecheckScripts(cache) {
+function formatTypeScriptDiagnostics(diagnostics) {
+  return ts.formatDiagnosticsWithColorAndContext(diagnostics, {
+    getCanonicalFileName: (file) => file,
+    getCurrentDirectory: () => rootDir,
+    getNewLine: () => "\n",
+  });
+}
+
+function scopedTypecheckKey(targets) {
+  return targets
+    .map((target) => `${target.kind.name}/${target.scriptCode}`)
+    .sort()
+    .join(",");
+}
+
+function scopedAmbientDeclarationFiles() {
+  return walkFiles(path.join(rootDir, "src"))
+    .filter((file) => file.endsWith(".d.ts"))
+    .map(relativeWorkspaceFile)
+    .filter(Boolean);
+}
+
+function createScopedTypecheckProgram(targets) {
+  const loaded = ts.readConfigFile(TSCONFIG_FILE, ts.sys.readFile);
+  if (loaded.error) {
+    process.stderr.write(formatTypeScriptDiagnostics([loaded.error]));
+    throw new Error("JS_CODE scoped TypeScript config validation failed");
+  }
+  const files = [
+    ...targets.map((target) =>
+      relativeWorkspaceFile(targetEntryFile(target)),
+    ),
+    ...scopedAmbientDeclarationFiles(),
+  ].filter(Boolean);
+  const parsed = ts.parseJsonConfigFileContent(
+    { ...loaded.config, files, include: [] },
+    ts.sys,
+    rootDir,
+    { noEmit: true },
+    TSCONFIG_FILE,
+  );
+  if (parsed.errors.length > 0) {
+    process.stderr.write(formatTypeScriptDiagnostics(parsed.errors));
+    throw new Error("JS_CODE scoped TypeScript config validation failed");
+  }
+  return ts.createProgram({
+    rootNames: parsed.fileNames,
+    options: parsed.options,
+    projectReferences: parsed.projectReferences,
+  });
+}
+
+function scopedTypecheckInputHash(program, cacheKey) {
+  const sourceFiles = program
+    .getSourceFiles()
+    .map((sourceFile) => relativeWorkspaceFile(sourceFile.fileName))
+    .filter(Boolean);
+  return hashFileSet([...configInputFiles(), ...sourceFiles], `typecheck:${cacheKey}`);
+}
+
+function typecheckSelectedScripts(cache, targets) {
+  const cacheKey = scopedTypecheckKey(targets);
+  const program = createScopedTypecheckProgram(targets);
+  const inputHash = scopedTypecheckInputHash(program, cacheKey);
+  if (
+    !forceBuild &&
+    cache.toolFingerprint === toolFingerprint &&
+    cache.typechecks?.[cacheKey]?.inputHash === inputHash
+  ) {
+    console.log(`[build-js-code] scoped TypeScript validation cache hit (${targets.length} selected)`);
+    return { cacheHit: true, cacheKey, inputHash, mode: "scoped" };
+  }
+
+  console.log(`[build-js-code] validating TypeScript for ${targets.length} selected target(s)...`);
+  const diagnostics = ts.getPreEmitDiagnostics(program);
+  if (diagnostics.length > 0) {
+    process.stderr.write(formatTypeScriptDiagnostics(diagnostics));
+    throw new Error("JS_CODE scoped TypeScript validation failed");
+  }
+  console.log("[build-js-code] scoped TypeScript validation passed");
+  return { cacheHit: false, cacheKey, inputHash, mode: "scoped" };
+}
+
+function typecheckAllScripts(cache) {
   const inputHash = typecheckInputHash();
   if (!forceBuild && cache.toolFingerprint === toolFingerprint && cache.typecheck?.inputHash === inputHash) {
     console.log("[build-js-code] TypeScript validation cache hit");
-    return { cacheHit: true, inputHash };
+    return { cacheHit: true, inputHash, mode: "full" };
   }
 
   console.log("[build-js-code] validating TypeScript once for this batch...");
@@ -275,7 +404,13 @@ function typecheckScripts(cache) {
   console.log("[build-js-code] TypeScript validation passed");
   // pnpm may materialize/update a lockfile on the first invocation. Record the
   // post-validation inputs so the next process can reuse this successful tsc.
-  return { cacheHit: false, inputHash: typecheckInputHash() };
+  return { cacheHit: false, inputHash: typecheckInputHash(), mode: "full" };
+}
+
+function typecheckScripts(cache, targets, scoped) {
+  return scoped
+    ? typecheckSelectedScripts(cache, targets)
+    : typecheckAllScripts(cache);
 }
 
 function collectBuildDependencies(buildResult, entry) {
@@ -296,7 +431,7 @@ function collectBuildDependencies(buildResult, entry) {
 
 async function buildScript(target) {
   const { kind, scriptCode } = target;
-  const entry = path.join(kind.sourceRoot, scriptCode, "index.ts");
+  const entry = targetEntryFile(target);
   if (!existsSync(entry)) throw new Error(`${kind.label} script not found: ${entry}`);
   const outDir = path.join(kind.outputRoot, scriptCode);
   const external = Array.from(
@@ -361,14 +496,31 @@ function saveCache(typecheck, updatedTargets) {
   if (typecheck.cacheHit && updatedTargets.size === 0) return;
   const lockFd = acquireCacheLock();
   try {
-    const latest = readCache();
+    const stored = readCache();
+    // A scoped build updates only part of the cache. Never carry metadata from
+    // a different compiler/builder fingerprint into the new cache, otherwise
+    // untouched targets could become false hits after this process stamps the
+    // cache with the current fingerprint.
+    const latest = stored.toolFingerprint === toolFingerprint
+      ? stored
+      : emptyCache();
+    const validatedAt = new Date().toISOString();
+    const mergedTypechecks = { ...latest.typechecks };
+    if (!typecheck.cacheHit && typecheck.mode === "scoped") {
+      mergedTypechecks[typecheck.cacheKey] = {
+        inputHash: typecheck.inputHash,
+        validatedAt,
+      };
+    }
     const merged = {
       ...latest,
       version: CACHE_VERSION,
       toolFingerprint,
-      typecheck: typecheck.cacheHit
-        ? latest.typecheck
-        : { inputHash: typecheck.inputHash, validatedAt: new Date().toISOString() },
+      typecheck:
+        !typecheck.cacheHit && typecheck.mode === "full"
+          ? { inputHash: typecheck.inputHash, validatedAt }
+          : latest.typecheck,
+      typechecks: mergedTypechecks,
       targets: { ...latest.targets, ...Object.fromEntries(updatedTargets) },
     };
     const tempFile = `${CACHE_FILE}.${process.pid}.${crypto.randomBytes(6).toString("hex")}.tmp`;
@@ -398,7 +550,7 @@ function saveCache(typecheck, updatedTargets) {
   }
 }
 
-const targets = resolveBuildTargets();
+const { scoped, targets } = resolveBuildSelection();
 if (targets.length === 0) {
   console.log(
     "no JS_CODE scripts found under src/js-code-nodes/<scriptCode>/index.ts, src/automations/<scriptCode>/index.ts, or src/functions/<functionCode>/index.ts",
@@ -407,7 +559,7 @@ if (targets.length === 0) {
 }
 
 const cache = readCache();
-const typecheck = typecheckScripts(cache);
+const typecheck = typecheckScripts(cache, targets, scoped);
 const updatedTargets = new Map();
 let builtCount = 0;
 let cachedCount = 0;

package/templates/sy-lowcode-app-workspace/scripts/guard-publish.mjs

@@ -7,17 +7,16 @@
 if (!process.env.OPENXIANGDA_PROFILE) {
   const lines = [
     '',
-    '❌ 错误：请使用 openxiangda workspace publish --profile <name>',
+    '❌ 错误：请使用带 change 与精确 scope 的 openxiangda workspace publish',
     '',
     '此 npm script（publish:all / publish:oss / register / publish:changed / openxiangda:publish 等）',
     '是工作区内部实现，直接调用会缺少 token / profile / appType / OSS 密钥的注入，',
     '可能发到错误的环境，或彻底发不出去。',
     '',
     '正确入口：',
-    '  openxiangda workspace publish --profile <name>            # 全量',
-    '  openxiangda workspace publish --profile <name> --changed  # 增量（推荐）',
-    '  openxiangda workspace publish --profile <name> --page X   # 单页',
-    '  openxiangda workspace publish --profile <name> --form Y   # 单表',
+    '  openxiangda workspace publish --change <change> --profile <name> --only pages/X,forms/Y --dry-run',
+    '  openxiangda workspace publish --change <change> --profile <name> --only pages/X,forms/Y',
+    '  发布后 merge/fast-forward 并 push 冻结 SHA，再运行 release integration-status 与 release end',
     '',
     '更多说明详见工作区根目录的 AGENTS.md。',
     '',