@decocms/blocks-cli 7.31.7 → 7.32.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/blocks-cli",
-  "version": "7.31.7",
+  "version": "7.32.1",
   "type": "module",
   "description": "Deco codegen (generate-blocks, generate-schema, generate-invoke) and Fresh-to-TanStack migration tooling",
   "repository": {
@@ -31,7 +31,7 @@
     "lint:unused": "knip"
   },
   "dependencies": {
-    "@decocms/blocks": "7.31.7",
+    "@decocms/blocks": "7.32.1",
     "ts-morph": "^27.0.0",
     "tsx": "^4.22.5"
   },

package/scripts/generate-blocks.test.ts

@@ -1,9 +1,22 @@
+import * as cp from "node:child_process";
+import * as fs from "node:fs";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import * as os from "node:os";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { readBlockDelta } from "./generate-blocks";
 
+const SCRIPT = path.resolve(__dirname, "generate-blocks.ts");
+
+function runGenerator(
+  args: string[],
+  opts: { cwd?: string } = {},
+): { stdout: string; stderr: string; code: number } {
+  const r = cp.spawnSync("npx", ["tsx", SCRIPT, ...args], { encoding: "utf8", cwd: opts.cwd });
+  return { stdout: r.stdout || "", stderr: r.stderr || "", code: r.status ?? 0 };
+}
+
 describe("readBlockDelta", () => {
   let dir: string;
 
@@ -92,3 +105,66 @@ describe("readBlockDelta", () => {
     expect(delta).toEqual({});
   });
 });
+
+describe("generate-blocks legacy artifact sync", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "generate-blocks-legacy-"));
+    // Minimal .deco/blocks/ dir with one block so output is non-empty.
+    fs.mkdirSync(path.join(tmpDir, ".deco", "blocks"), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, ".deco", "blocks", "pages-Home.json"),
+      JSON.stringify({ path: "/" }),
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("syncs .ts and .json to the old path when legacy file is detected", () => {
+    const oldDir = path.join(tmpDir, "src", "server", "cms");
+    fs.mkdirSync(oldDir, { recursive: true });
+    fs.writeFileSync(path.join(oldDir, "blocks.gen.ts"), "// stale\n");
+
+    const { code, stderr } = runGenerator([], { cwd: tmpDir });
+    expect(code).toBe(0);
+
+    expect(stderr).toContain("src/server/cms/blocks.gen.ts");
+    expect(stderr).toContain(".deco/blocks.gen.ts");
+    expect(stderr).toContain("Update importers to use the new path");
+
+    // New path must exist.
+    expect(fs.existsSync(path.join(tmpDir, ".deco", "blocks.gen.ts"))).toBe(true);
+    expect(fs.existsSync(path.join(tmpDir, ".deco", "blocks.gen.json"))).toBe(true);
+
+    // Old .ts must be synced (stub content, not the stale placeholder).
+    const oldTs = fs.readFileSync(path.join(oldDir, "blocks.gen.ts"), "utf-8");
+    expect(oldTs).not.toBe("// stale\n");
+
+    // Old .json sibling must be synced — the Vite plugin reads it by suffix.
+    const oldJson = path.join(oldDir, "blocks.gen.json");
+    expect(fs.existsSync(oldJson)).toBe(true);
+    const oldContent = JSON.parse(fs.readFileSync(oldJson, "utf-8"));
+    const newContent = JSON.parse(
+      fs.readFileSync(path.join(tmpDir, ".deco", "blocks.gen.json"), "utf-8"),
+    );
+    expect(oldContent).toEqual(newContent);
+  }, 30_000);
+
+  it("does not warn and does not sync when an explicit --out-file is passed", () => {
+    const oldDir = path.join(tmpDir, "src", "server", "cms");
+    fs.mkdirSync(oldDir, { recursive: true });
+    fs.writeFileSync(path.join(oldDir, "blocks.gen.ts"), "// stale\n");
+
+    const explicitOut = path.join(tmpDir, "custom", "blocks.gen.ts");
+    const { code, stderr } = runGenerator(["--out-file", explicitOut], { cwd: tmpDir });
+    expect(code).toBe(0);
+
+    expect(stderr).not.toContain("Generator default output moved");
+    expect(fs.existsSync(explicitOut)).toBe(true);
+    // Old file must be untouched.
+    expect(fs.readFileSync(path.join(oldDir, "blocks.gen.ts"), "utf-8")).toBe("// stale\n");
+  }, 30_000);
+});

package/scripts/generate-blocks.ts

@@ -49,7 +49,7 @@ import {
   singleDecodeBlockName,
 } from "./lib/blocks-dedupe";
 import { buildCsvRedirectBlocks } from "./lib/csv-redirects";
-import { warnLegacyArtifact } from "./lib/legacyArtifact";
+import { syncLegacyArtifact, warnLegacyArtifact } from "./lib/legacyArtifact";
 
 const TS_STUB = [
   "// Auto-generated — thin wrapper around blocks.gen.json.",
@@ -325,11 +325,20 @@ if (isMainModule()) {
   const NEW_DEFAULT_OUT_FILE = ".deco/blocks.gen.ts";
   const OLD_DEFAULT_OUT_FILE = "src/server/cms/blocks.gen.ts";
   const outFile = path.resolve(process.cwd(), arg("out-file", NEW_DEFAULT_OUT_FILE));
-  if (!OUT_FILE_EXPLICIT && fs.existsSync(path.resolve(process.cwd(), OLD_DEFAULT_OUT_FILE))) {
+  const oldFilePath = path.resolve(process.cwd(), OLD_DEFAULT_OUT_FILE);
+  const hasLegacy = !OUT_FILE_EXPLICIT && fs.existsSync(oldFilePath);
+  if (hasLegacy) {
     warnLegacyArtifact(OLD_DEFAULT_OUT_FILE, NEW_DEFAULT_OUT_FILE);
   }
 
-  generateBlocks({ blocksDir, outFile }).catch((err) => {
+  generateBlocks({ blocksDir, outFile }).then((result) => {
+    if (hasLegacy) {
+      syncLegacyArtifact(oldFilePath, result.outFile);
+      // The .ts is a Vite stub — the plugin reads the .json sibling by suffix.
+      // Sync the JSON too so the Vite interceptor at the old path finds it.
+      syncLegacyArtifact(oldFilePath.replace(/\.ts$/, ".json"), result.jsonFile);
+    }
+  }).catch((err) => {
     console.error(err);
     process.exit(1);
   });

package/scripts/generate-loaders.test.ts

@@ -14,8 +14,8 @@ import { afterAll, beforeAll, describe, expect, it } from "vitest";
 
 const SCRIPT = path.resolve(__dirname, "generate-loaders.ts");
 
-function run(cwd: string): { stdout: string; stderr: string; code: number } {
-  const r = cp.spawnSync("npx", ["tsx", SCRIPT], { encoding: "utf8", cwd });
+function run(cwd: string, args: string[] = []): { stdout: string; stderr: string; code: number } {
+  const r = cp.spawnSync("npx", ["tsx", SCRIPT, ...args], { encoding: "utf8", cwd });
   return { stdout: r.stdout || "", stderr: r.stderr || "", code: r.status ?? -1 };
 }
 
@@ -62,3 +62,56 @@ describe("generate-loaders — loader vs action emit", () => {
     expect(out).not.toContain('createLoaderEntry("site/actions/addToCart"');
   });
 });
+
+describe("generate-loaders legacy artifact sync", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "generate-loaders-legacy-"));
+    const write = (rel: string, content: string) => {
+      const abs = path.join(tmpDir, rel);
+      fs.mkdirSync(path.dirname(abs), { recursive: true });
+      fs.writeFileSync(abs, content);
+    };
+    write("src/loaders/related.ts", "export default async () => [];\n");
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("syncs to the old path when legacy file is detected", () => {
+    const oldDir = path.join(tmpDir, "src", "server", "cms");
+    fs.mkdirSync(oldDir, { recursive: true });
+    fs.writeFileSync(path.join(oldDir, "loaders.gen.ts"), "// stale\n");
+
+    const { code, stderr } = run(tmpDir);
+    expect(code).toBe(0);
+
+    expect(stderr).toContain("src/server/cms/loaders.gen.ts");
+    expect(stderr).toContain(".deco/loaders.gen.ts");
+    expect(stderr).toContain("Update importers to use the new path");
+
+    // New path must exist.
+    expect(fs.existsSync(path.join(tmpDir, ".deco", "loaders.gen.ts"))).toBe(true);
+
+    // Old file must be synced (not stale placeholder).
+    const oldContent = fs.readFileSync(path.join(oldDir, "loaders.gen.ts"), "utf-8");
+    expect(oldContent).not.toBe("// stale\n");
+    expect(oldContent).toContain("site/loaders/related");
+  }, 30_000);
+
+  it("does not warn and does not sync when an explicit --out-file is passed", () => {
+    const oldDir = path.join(tmpDir, "src", "server", "cms");
+    fs.mkdirSync(oldDir, { recursive: true });
+    fs.writeFileSync(path.join(oldDir, "loaders.gen.ts"), "// stale\n");
+
+    const explicitOut = path.join(tmpDir, "custom", "loaders.gen.ts");
+    const { code, stderr } = run(tmpDir, ["--out-file", explicitOut]);
+    expect(code).toBe(0);
+
+    expect(stderr).not.toContain("Generator default output moved");
+    expect(fs.existsSync(explicitOut)).toBe(true);
+    expect(fs.readFileSync(path.join(oldDir, "loaders.gen.ts"), "utf-8")).toBe("// stale\n");
+  }, 30_000);
+});

package/scripts/generate-loaders.ts

@@ -50,7 +50,7 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { warnLegacyArtifact } from "./lib/legacyArtifact";
+import { syncLegacyArtifact, warnLegacyArtifact } from "./lib/legacyArtifact";
 
 const args = process.argv.slice(2);
 function arg(name: string, fallback: string): string {
@@ -64,7 +64,9 @@ const OUT_FILE_EXPLICIT = args.includes("--out-file");
 const NEW_DEFAULT_OUT_FILE = ".deco/loaders.gen.ts";
 const OLD_DEFAULT_OUT_FILE = "src/server/cms/loaders.gen.ts";
 const outFile = path.resolve(process.cwd(), arg("out-file", NEW_DEFAULT_OUT_FILE));
-if (!OUT_FILE_EXPLICIT && fs.existsSync(path.resolve(process.cwd(), OLD_DEFAULT_OUT_FILE))) {
+const oldLoadersPath = path.resolve(process.cwd(), OLD_DEFAULT_OUT_FILE);
+const hasLegacy = !OUT_FILE_EXPLICIT && fs.existsSync(oldLoadersPath);
+if (hasLegacy) {
   warnLegacyArtifact(OLD_DEFAULT_OUT_FILE, NEW_DEFAULT_OUT_FILE);
 }
 const excludeRaw = arg("exclude", "");
@@ -254,6 +256,7 @@ lines.push("");
 
 fs.mkdirSync(path.dirname(outFile), { recursive: true });
 fs.writeFileSync(outFile, lines.join("\n"));
+if (hasLegacy) syncLegacyArtifact(oldLoadersPath, outFile);
 
 const filterNote = cmsReferences
   ? ` (filtered against ${cmsReferences.size} CMS __resolveType references; pruned ${prunedCount} dead entries)`

package/scripts/generate-schema.test.ts

@@ -323,10 +323,17 @@ describe("generate-schema default output path (.deco/)", () => {
 
     expect(stderr).toContain("src/server/admin/meta.gen.json");
     expect(stderr).toContain(".deco/meta.gen.json");
-    expect(stderr).toContain("Move the file and update its importers");
+    expect(stderr).toContain("Update importers to use the new path");
 
     const newDefault = path.join(tmpDir, ".deco", "meta.gen.json");
     expect(fs.existsSync(newDefault)).toBe(true);
+
+    // Old file must be kept in sync so mid-migration imports still work.
+    const oldDefault = path.join(tmpDir, "src", "server", "admin", "meta.gen.json");
+    expect(fs.existsSync(oldDefault)).toBe(true);
+    const oldContent = JSON.parse(fs.readFileSync(oldDefault, "utf-8"));
+    const newContent = JSON.parse(fs.readFileSync(newDefault, "utf-8"));
+    expect(oldContent).toEqual(newContent);
   }, 30_000);
 
   it("does not warn when an explicit --out is passed, even if the OLD default file exists", () => {

package/scripts/generate-schema.ts

@@ -47,7 +47,7 @@ import {
   type Type,
 } from "ts-morph";
 import { isExcludedCodegenFile } from "./lib/codegenExclusions";
-import { warnLegacyArtifact } from "./lib/legacyArtifact";
+import { syncLegacyArtifact, warnLegacyArtifact } from "./lib/legacyArtifact";
 
 // ---------------------------------------------------------------------------
 // CLI arg parsing
@@ -90,6 +90,8 @@ let COMPOSE = false;
 // Value written to the composed meta's `framework` field (only used with
 // --compose). Defaults to composeMeta's historical "tanstack-start".
 let FRAMEWORK = "tanstack-start";
+let _hasLegacySchema = false;
+let _oldSchemaPath = "";
 
 if (isMainModule()) {
   SITE_NAMESPACE = arg("namespace", SITE_NAMESPACE);
@@ -104,7 +106,9 @@ if (isMainModule()) {
   PLATFORM = arg("platform", PLATFORM);
   COMPOSE = argv.includes("--compose");
   FRAMEWORK = arg("framework", FRAMEWORK);
-  if (!outFileExplicit && fs.existsSync(path.resolve(process.cwd(), OLD_DEFAULT_OUT_REL))) {
+  _oldSchemaPath = path.resolve(process.cwd(), OLD_DEFAULT_OUT_REL);
+  _hasLegacySchema = !outFileExplicit && fs.existsSync(_oldSchemaPath);
+  if (_hasLegacySchema) {
     warnLegacyArtifact(OLD_DEFAULT_OUT_REL, NEW_DEFAULT_OUT_REL);
   }
 }
@@ -1537,6 +1541,7 @@ if (isMainModule()) {
     const outPath = path.resolve(process.cwd(), OUT_REL);
     fs.mkdirSync(path.dirname(outPath), { recursive: true });
     fs.writeFileSync(outPath, JSON.stringify(meta, null, 2));
+    if (_hasLegacySchema) syncLegacyArtifact(_oldSchemaPath, outPath);
 
     const defCount = Object.keys(meta.schema.definitions).length;
     const secCount = Object.keys(meta.manifest.blocks.sections || {}).length;

package/scripts/generate-sections.test.ts

@@ -113,11 +113,15 @@ describe("generate-sections default output path (.deco/)", () => {
 
     expect(stderr).toContain("src/server/cms/sections.gen.ts");
     expect(stderr).toContain(".deco/sections.gen.ts");
-    expect(stderr).toContain("Move the file and update its importers");
+    expect(stderr).toContain("Update importers to use the new path");
 
     const newDefault = path.join(tmpDir, ".deco", "sections.gen.ts");
     expect(fs.existsSync(newDefault)).toBe(true);
     expect(fs.readFileSync(newDefault, "utf-8")).toContain("site/sections/Hero.tsx");
+
+    // Old file must be kept in sync so mid-migration imports still work.
+    const oldDefault = path.join(tmpDir, "src", "server", "cms", "sections.gen.ts");
+    expect(fs.readFileSync(oldDefault, "utf-8")).toContain("site/sections/Hero.tsx");
   }, 30_000);
 
   it("does not warn when an explicit --out-file is passed, even if the OLD default file exists", () => {

package/scripts/generate-sections.ts

@@ -36,7 +36,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { isExcludedCodegenFile } from "./lib/codegenExclusions";
-import { warnLegacyArtifact } from "./lib/legacyArtifact";
+import { syncLegacyArtifact, warnLegacyArtifact } from "./lib/legacyArtifact";
 
 const args = process.argv.slice(2);
 function arg(name: string, fallback: string): string {
@@ -49,7 +49,9 @@ const OUT_FILE_EXPLICIT = args.includes("--out-file");
 const NEW_DEFAULT_OUT_FILE = ".deco/sections.gen.ts";
 const OLD_DEFAULT_OUT_FILE = "src/server/cms/sections.gen.ts";
 const outFile = path.resolve(process.cwd(), arg("out-file", NEW_DEFAULT_OUT_FILE));
-if (!OUT_FILE_EXPLICIT && fs.existsSync(path.resolve(process.cwd(), OLD_DEFAULT_OUT_FILE))) {
+const oldSectionsPath = path.resolve(process.cwd(), OLD_DEFAULT_OUT_FILE);
+const hasLegacy = !OUT_FILE_EXPLICIT && fs.existsSync(oldSectionsPath);
+if (hasLegacy) {
   warnLegacyArtifact(OLD_DEFAULT_OUT_FILE, NEW_DEFAULT_OUT_FILE);
 }
 const EMIT_REGISTRY = args.includes("--registry");
@@ -291,6 +293,7 @@ fs.writeFileSync(
   outFile,
   lines.join("\n").replace(/\n{3,}/g, "\n\n").replace(/\n*$/, "\n"),
 );
+if (hasLegacy) syncLegacyArtifact(oldSectionsPath, outFile);
 
 console.log(
   `Generated section metadata for ${entries.length} sections → ${path.relative(process.cwd(), outFile)}`,

package/scripts/lib/legacyArtifact.ts

@@ -1,3 +1,6 @@
+import fs from "node:fs";
+import path from "node:path";
+
 /**
  * Generator default output paths flipped from `src/server/{cms,admin}/` to
  * `.deco/` (framework artifacts live in the framework's folder, not mixed
@@ -15,6 +18,17 @@
  */
 export function warnLegacyArtifact(oldPath: string, newPath: string): void {
   console.warn(
-    `[deco] Generator default output moved: ${oldPath} -> ${newPath}. Move the file and update its importers.`,
+    `[deco] Generator default output moved: ${oldPath} -> ${newPath}. Update importers to use the new path, then delete the old file.`,
   );
 }
+
+/**
+ * Copies the freshly-generated file at `newPath` back to `oldPath` so that
+ * sites mid-migration whose imports still point at the old location see
+ * up-to-date output without requiring a full migration first.
+ * Call this after generation completes, only when the old file was detected.
+ */
+export function syncLegacyArtifact(oldPath: string, newPath: string): void {
+  fs.mkdirSync(path.dirname(oldPath), { recursive: true });
+  fs.copyFileSync(newPath, oldPath);
+}