@decocms/blocks 7.16.2 → 7.16.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/blocks",
-  "version": "7.16.2",
+  "version": "7.16.4",
   "type": "module",
   "engines": {
     "node": ">=24"

package/src/cms/loadDecofileDirectory.test.ts

@@ -1,7 +1,7 @@
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { loadDecofileDirectory } from "./loadDecofileDirectory";
 
 describe("loadDecofileDirectory", () => {
@@ -49,4 +49,61 @@ describe("loadDecofileDirectory", () => {
     writeFileSync(join(dir, "broken.json"), "{not valid json");
     await expect(loadDecofileDirectory(dir)).rejects.toThrow(/broken\.json/);
   });
+
+  it("URL-decodes the filename stem once to produce the block key", async () => {
+    // Classic deco stores blocks as encodeURIComponent(<block id>).json and
+    // derives the id back with one decodeURIComponent (parseBlockId). Content
+    // references saved blocks by the DECODED id ("Cores dos preços"), so the
+    // map must be keyed by it or every such reference dangles.
+    writeFileSync(
+      join(dir, "Cores%20dos%20pre%C3%A7os.json"),
+      JSON.stringify({ __resolveType: "site/loaders/priceColors.ts" }),
+    );
+    // Double-encoded page snapshot (deco.cx corpus shape): decodes ONCE.
+    writeFileSync(
+      join(dir, "pages-Acess%25C3%25B3rios-421596.json"),
+      JSON.stringify({ __resolveType: "website/pages/Page.tsx" }),
+    );
+    // Encoded slash becomes a real slash in the id — ids are plain map keys.
+    writeFileSync(join(dir, "collections%2Fblog%2Fauthors.json"), JSON.stringify({ authors: [] }));
+
+    const blocks = await loadDecofileDirectory(dir);
+
+    expect(blocks["Cores dos preços"]).toEqual({
+      __resolveType: "site/loaders/priceColors.ts",
+    });
+    expect(blocks["pages-Acess%C3%B3rios-421596"]).toEqual({
+      __resolveType: "website/pages/Page.tsx",
+    });
+    expect(blocks["collections/blog/authors"]).toEqual({ authors: [] });
+    // The raw stems must NOT appear as keys.
+    expect(blocks["Cores%20dos%20pre%C3%A7os"]).toBeUndefined();
+    expect(blocks["pages-Acess%25C3%25B3rios-421596"]).toBeUndefined();
+  });
+
+  it("keeps a stem verbatim when it is not valid percent-encoding", async () => {
+    // A lone % (e.g. a page literally named "50% off") throws in
+    // decodeURIComponent — the stem is already the id, keep it.
+    writeFileSync(join(dir, "pages-50% off-7.json"), JSON.stringify({ x: 1 }));
+
+    const blocks = await loadDecofileDirectory(dir);
+    expect(blocks["pages-50% off-7"]).toEqual({ x: 1 });
+  });
+
+  it("resolves decoded-key collisions deterministically (last sorted filename wins) and warns", async () => {
+    writeFileSync(join(dir, "A B.json"), JSON.stringify({ raw: true }));
+    writeFileSync(join(dir, "A%20B.json"), JSON.stringify({ encoded: true }));
+
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const blocks = await loadDecofileDirectory(dir);
+      // Code-unit sort: " " (0x20) < "%" (0x25), so "A B.json" comes first
+      // and "A%20B.json" is processed last — the encoded file wins.
+      expect(blocks["A B"]).toEqual({ encoded: true });
+      expect(Object.keys(blocks)).toHaveLength(1);
+      expect(warn).toHaveBeenCalledWith(expect.stringContaining("A%20B.json"));
+    } finally {
+      warn.mockRestore();
+    }
+  });
 });

package/src/cms/loadDecofileDirectory.ts

@@ -1,21 +1,50 @@
 import * as fs from "node:fs/promises";
 import { join } from "node:path";
 
+/**
+ * Derive a block id (decofile map key) from a `.deco/blocks` filename.
+ *
+ * Classic deco stores each block as `encodeURIComponent(<block id>).json`
+ * and derives the id back with exactly one decodeURIComponent — this is
+ * upstream `parseBlockId` (deco-cx/deco, engine/decofile/fsFolder). Block
+ * CONTENT references saved blocks by the DECODED id (`"__resolveType":
+ * "Cores dos preços"`), and the Studio editor derives the write-back
+ * filename as `encodeURIComponent(<key>)`, so keying the map by the raw
+ * stem breaks both: references dangle at resolve time and editor saves
+ * land in a freshly-created double-encoded file.
+ *
+ * A stem that is not valid percent-encoding (e.g. a page literally named
+ * "50% off") throws in decodeURIComponent — such a stem IS the id already
+ * (classic deco would have stored it encoded), so it is kept verbatim,
+ * matching upstream behavior for pre-encoding-era files.
+ */
+export function parseBlockId(filename: string): string {
+  const stem = filename.endsWith(".json") ? filename.slice(0, -".json".length) : filename;
+  try {
+    return decodeURIComponent(stem);
+  } catch {
+    return stem;
+  }
+}
+
 /**
  * Loads a directory of legacy per-block JSON snapshot files (the format
  * produced by the pre-v2 Deco admin, e.g. `.deco/blocks/<name>.json`) into
  * a single blocks map suitable for setBlocks(). Each file becomes one
- * entry keyed by its filename minus the .json extension.
+ * entry keyed by `parseBlockId(<filename>)` — the filename stem URL-decoded
+ * once, matching the classic deco runtime's key convention.
+ *
+ * Beyond that single decode the key is not renamed or normalized: whatever
+ * prefix convention a block's filename already carries (e.g. real page
+ * block snapshots are named `pages-<slug>-<id>.json`) is preserved, because
+ * getAllPages() in loader.ts filters blocks by `key.startsWith("pages-")`
+ * before findPageByPath() matches on each page's own `.path` field. So the
+ * key format IS load-bearing for page blocks — decoding never touches the
+ * `pages-` prefix itself, only the percent-escapes after it.
  *
- * The key is not renamed or normalized beyond stripping the extension:
- * whatever prefix convention a block's filename already carries (e.g. real
- * page block snapshots are named `pages-<slug>-<id>.json`) is preserved
- * verbatim, because getAllPages() in loader.ts filters blocks by
- * `key.startsWith("pages-")` before findPageByPath() matches on each page's
- * own `.path` field. So the key format IS load-bearing for page blocks —
- * it must keep whatever prefix its source filename had — but this loader
- * never needs to invent or choose that prefix itself, since it simply
- * passes the on-disk filename through.
+ * Two filenames can decode to the same id (`A B.json` + `A%20B.json`).
+ * Files are processed in sorted filename order and the last one wins, so
+ * the outcome is deterministic; a console.warn names the shadowed file.
  *
  * Replaces the abandoned @decocms/start/node tier's loadAllDecofileBlocks,
  * which no longer exists on any reachable blocks version — ported
@@ -28,21 +57,33 @@ export async function loadDecofileDirectory(dir: string): Promise<Record<string,
   const entries = await fs.readdir(dir, { withFileTypes: true });
   const blocks: Record<string, unknown> = {};
 
-  await Promise.all(
-    entries
-      .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
-      .map(async (entry) => {
-        const key = entry.name.slice(0, -".json".length);
-        const content = await fs.readFile(join(dir, entry.name), "utf8");
-        try {
-          blocks[key] = JSON.parse(content);
-        } catch (error) {
-          throw new Error(
-            `loadDecofileDirectory: failed to parse ${entry.name}: ${(error as Error).message}`,
-          );
-        }
-      }),
+  const files = entries
+    .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+    .map((entry) => entry.name)
+    .sort();
+
+  const parsed = await Promise.all(
+    files.map(async (name) => {
+      const content = await fs.readFile(join(dir, name), "utf8");
+      try {
+        return { name, value: JSON.parse(content) as unknown };
+      } catch (error) {
+        throw new Error(
+          `loadDecofileDirectory: failed to parse ${name}: ${(error as Error).message}`,
+        );
+      }
+    }),
   );
 
+  for (const { name, value } of parsed) {
+    const key = parseBlockId(name);
+    if (key in blocks) {
+      console.warn(
+        `loadDecofileDirectory: block id ${JSON.stringify(key)} maps to multiple files; ${JSON.stringify(name)} wins`,
+      );
+    }
+    blocks[key] = value;
+  }
+
   return blocks;
 }