@decocms/blocks-cli 7.16.3 → 7.16.4

package/package.json

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

package/scripts/generate-blocks-manifest.test.ts

@@ -5,15 +5,16 @@
  * block filenames (the shapes found in production `.deco/blocks` corpora:
  * double-encoded `%2520`, single-encoded `%20`, parentheses, encoded slashes
  * `%2F`, raw UTF-8), then verifies the emitted module the way a site would
- * consume it: keys verbatim, `tsc` accepts it, and importing it (via a tsx
- * child process from the fixture dir, resolving the raw-filename JSON import
- * specifiers against the real files on disk) yields the parsed contents.
+ * consume it: keys URL-decoded once (parseBlockId), import specifiers raw,
+ * `tsc` accepts it, and importing it (via a tsx child process from the
+ * fixture dir, resolving the raw-filename JSON import specifiers against the
+ * real files on disk) yields the parsed contents.
  */
 import * as cp from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { generateBlocksManifest } from "./generate-blocks-manifest";
 
 const SCRIPT = path.resolve(__dirname, "generate-blocks-manifest.ts");
@@ -25,6 +26,14 @@ const HOSTILE_FIXTURE: Record<string, unknown> = {
   "pages-Calçados-42": { utf8: "çãé" },
 };
 
+// filename stem → emitted key: URL-decoded exactly once (parseBlockId).
+const DECODED_KEY: Record<string, string> = {
+  "pages-PDP%2520Box-102215": "pages-PDP%20Box-102215",
+  "pages-Home%20(principal)-287364": "pages-Home (principal)-287364",
+  "collections%2Fblog%2Fauthors%2Fx": "collections/blog/authors/x",
+  "pages-Calçados-42": "pages-Calçados-42",
+};
+
 describe("generate-blocks-manifest", () => {
   let tmpDir: string;
   let blocksDir: string;
@@ -47,7 +56,7 @@ describe("generate-blocks-manifest", () => {
     }
   };
 
-  it("emits verbatim keys and raw-filename import specifiers for hostile names", async () => {
+  it("emits once-decoded keys and raw-filename import specifiers for hostile names", async () => {
     writeFixture();
     const result = await generateBlocksManifest({ blocksDir, outFile, silent: true });
     expect(result.count).toBe(4);
@@ -55,16 +64,43 @@ describe("generate-blocks-manifest", () => {
     expect(result.written).toBe(true);
 
     const emitted = fs.readFileSync(outFile, "utf-8");
-    for (const key of Object.keys(HOSTILE_FIXTURE)) {
-      // Key: filename minus .json, verbatim — no decoding of %2520/%20/%2F.
-      expect(emitted).toContain(`${JSON.stringify(key)}: `);
-      // Specifier: the raw on-disk filename, relative to the emitted module.
-      expect(emitted).toContain(`from ${JSON.stringify(`./blocks/${key}.json`)};`);
+    for (const stem of Object.keys(HOSTILE_FIXTURE)) {
+      // Key: parseBlockId(<filename>) — the stem URL-decoded once.
+      expect(emitted).toContain(`${JSON.stringify(DECODED_KEY[stem])}: `);
+      // Specifier: the raw on-disk filename, relative to the emitted module —
+      // bundlers never URL-decode specifiers, so no normalizing there.
+      expect(emitted).toContain(`from ${JSON.stringify(`./blocks/${stem}.json`)};`);
     }
-    // Never URL-decoded anywhere in the module.
-    expect(emitted).not.toContain("pages-PDP%20Box");
-    expect(emitted).not.toContain("pages-Home (principal)");
-    expect(emitted).not.toContain("collections/blog");
+    // Raw stems must not leak into keys (only into import specifiers).
+    expect(emitted).not.toContain('"pages-PDP%2520Box-102215": ');
+    expect(emitted).not.toContain('"pages-Home%20(principal)-287364": ');
+    expect(emitted).not.toContain('"collections%2Fblog%2Fauthors%2Fx": ');
+  });
+
+  it("keeps a stem verbatim as key when it is not valid percent-encoding", async () => {
+    writeFixture({ "pages-50% off-7": { x: 1 } });
+    await generateBlocksManifest({ blocksDir, outFile, silent: true });
+
+    const emitted = fs.readFileSync(outFile, "utf-8");
+    expect(emitted).toContain('"pages-50% off-7": _b0');
+  });
+
+  it("dedupes filenames that decode to the same key (last sorted wins, warns)", async () => {
+    writeFixture({ "A B": { raw: true }, "A%20B": { encoded: true } });
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      await generateBlocksManifest({ blocksDir, outFile, silent: true });
+      expect(warn).toHaveBeenCalledWith(expect.stringContaining("A%20B.json"));
+    } finally {
+      warn.mockRestore();
+    }
+
+    const emitted = fs.readFileSync(outFile, "utf-8");
+    // One property only (duplicate object keys are a TS error), keyed "A B",
+    // bound to the LAST sorted filename ("A B.json" < "A%20B.json").
+    expect(emitted.match(/"A B": /g)).toHaveLength(1);
+    expect(emitted).not.toContain('from "./blocks/A B.json";');
+    expect(emitted).toContain('from "./blocks/A%20B.json";');
   });
 
   it("compiles under tsc (module esnext, bundler resolution, resolveJsonModule)", async () => {
@@ -105,7 +141,10 @@ describe("generate-blocks-manifest", () => {
     const r = cp.spawnSync("npx", ["tsx", runner], { encoding: "utf8", cwd: tmpDir });
     expect(r.stderr).toBe("");
     expect(r.status).toBe(0);
-    expect(JSON.parse(r.stdout)).toEqual(HOSTILE_FIXTURE);
+    const expected = Object.fromEntries(
+      Object.entries(HOSTILE_FIXTURE).map(([stem, v]) => [DECODED_KEY[stem], v]),
+    );
+    expect(JSON.parse(r.stdout)).toEqual(expected);
   }, 30_000);
 
   it("is idempotent: regeneration over an unchanged block set writes nothing", async () => {

package/scripts/generate-blocks-manifest.ts

@@ -8,10 +8,13 @@
  * Reads .deco/blocks/*.json and emits blocksManifest.gen.ts — a module that
  * STATICALLY imports every block file and re-exports them as one
  * `Record<string, unknown>` keyed exactly like
- * `@decocms/blocks/cms/loadDecofileDirectory`: filename minus the `.json`
- * extension, verbatim (no URL-decoding, no renaming — the `pages-` filename
- * prefix on page blocks is load-bearing, see loadDecofileDirectory's doc
- * comment).
+ * `@decocms/blocks/cms/loadDecofileDirectory`: `parseBlockId(<filename>)`,
+ * the filename stem URL-decoded ONCE (classic deco stores blocks as
+ * `encodeURIComponent(<block id>).json`; content references saved blocks by
+ * the decoded id, and the Studio editor writes back to
+ * `encodeURIComponent(<key>).json`). No renaming beyond that decode — the
+ * `pages-` filename prefix on page blocks is load-bearing, see
+ * loadDecofileDirectory's doc comment.
  *
  * Why static imports instead of the runtime fs read: a plain
  * `loadDecofileDirectory(".deco/blocks")` is invisible to the bundler, so in
@@ -44,6 +47,7 @@
  */
 import fs from "node:fs";
 import path from "node:path";
+import { parseBlockId } from "@decocms/blocks/cms/loadDecofileDirectory";
 
 // Header of the emitted module. Kept as line comments and deliberately free
 // of interpolated filenames: block filenames can contain almost any
@@ -55,9 +59,9 @@ const HEADER = [
   "// Auto-generated by @decocms/blocks-cli/scripts/generate-blocks-manifest.ts — do not edit.",
   "//",
   "// Static-import manifest of every JSON decofile in the blocks directory,",
-  "// keyed by filename minus the .json extension, VERBATIM — the same key",
-  "// format @decocms/blocks/cms/loadDecofileDirectory produces (page blocks",
-  "// keep their load-bearing `pages-` filename prefix).",
+  "// keyed by parseBlockId(<filename>) — the stem URL-decoded once — the same",
+  "// key format @decocms/blocks/cms/loadDecofileDirectory produces (page",
+  "// blocks keep their load-bearing `pages-` filename prefix).",
   "//",
   "// Because every block file is a static import, the bundler's module graph",
   "// owns them: in `next dev`, editing a block JSON re-evaluates the server",
@@ -95,7 +99,24 @@ function renderManifest(blocksDir: string, outFile: string, files: string[]): st
 
   const sorted = [...files].sort(); // code-unit sort — locale-independent, diff-stable
 
+  // Two filenames can decode to the same block id (`A B.json` + `A%20B.json`).
+  // Mirror loadDecofileDirectory: last sorted filename wins, warn about the
+  // shadowed one. Emitting both would also be a TS error (duplicate object
+  // key), so the shadowed file is not imported at all.
+  const keyToIndex = new Map<string, number>();
   for (let i = 0; i < sorted.length; i++) {
+    const key = parseBlockId(sorted[i]);
+    const prev = keyToIndex.get(key);
+    if (prev !== undefined) {
+      console.warn(
+        `generate-blocks-manifest: block id ${JSON.stringify(key)} maps to multiple files; ${JSON.stringify(sorted[i])} wins`,
+      );
+    }
+    keyToIndex.set(key, i);
+  }
+  const emitted = [...keyToIndex.entries()]; // insertion order = sorted order
+
+  for (const [, i] of emitted) {
     // Import specifier: the RAW filename, relative to the emitted module.
     // JSON.stringify provides all necessary escaping — bundlers do not
     // URL-decode specifiers, so no percent-escaping/normalizing here.
@@ -108,8 +129,7 @@ function renderManifest(blocksDir: string, outFile: string, files: string[]): st
 
   lines.push("");
   lines.push("const blocks: Record<string, unknown> = {");
-  for (let i = 0; i < sorted.length; i++) {
-    const key = sorted[i].slice(0, -".json".length);
+  for (const [key, i] of emitted) {
     lines.push(`  ${JSON.stringify(key)}: _b${i},`);
   }
   lines.push("};");