@decocms/blocks 7.66.6 → 7.66.7

package/package.json

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

package/src/cms/loader.test.ts

@@ -222,6 +222,79 @@ describe("findPageByPath specificity", () => {
   });
 });
 
+describe("getAllPages — page blocks without the `pages-` prefix", () => {
+  afterEach(() => {
+    setBlocks({});
+  });
+
+  it("routes a page block whose key lacks the prefix", () => {
+    // Decofiles carried over from Deco on Fresh hold page blocks under
+    // arbitrary keys: renaming a page in the CMS renames its snapshot file,
+    // and the key follows the filename. Fresh enumerated pages by
+    // __resolveType, so these routed fine there.
+    setBlocks({
+      "plp-verao": {
+        name: "Verão",
+        path: "/verao",
+        sections: [],
+        __resolveType: "website/pages/Page.tsx",
+      },
+    });
+
+    const match = findPageByPath("/verao");
+    expect(match?.blockKey).toBe("plp-verao");
+  });
+
+  it("still ranks by path specificity across both key shapes", () => {
+    setBlocks({
+      "pages-catch-all": {
+        name: "Catch all",
+        path: "/*",
+        sections: [],
+      },
+      "plp-inverno": {
+        name: "Inverno",
+        path: "/inverno",
+        sections: [],
+        __resolveType: "website/pages/Page.tsx",
+      },
+    });
+
+    // The literal must win over the catch-all regardless of which one
+    // carries the prefix.
+    expect(findPageByPath("/inverno")?.blockKey).toBe("plp-inverno");
+    expect(findPageByPath("/qualquer-outra")?.blockKey).toBe("pages-catch-all");
+  });
+
+  it("ignores non-page blocks that happen to carry a path", () => {
+    // A loader block is not a page: no __resolveType match, no prefix.
+    setBlocks({
+      "some-loader": {
+        name: "Not a page",
+        path: "/not-a-page",
+        sections: [],
+        __resolveType: "site/loaders/whatever.ts",
+      },
+    });
+
+    expect(findPageByPath("/not-a-page")).toBeNull();
+  });
+
+  it("keeps honouring the prefix when there is no __resolveType", () => {
+    // The admin emits prefixed keys and does not always write a
+    // __resolveType onto the snapshot — the fast path must still apply.
+    setBlocks({
+      "pages-sem-tipo": {
+        name: "Sem tipo",
+        path: "/sem-tipo",
+        sections: [],
+      },
+    });
+
+    expect(findPageByPath("/sem-tipo")?.blockKey).toBe("pages-sem-tipo");
+  });
+});
+
 describe("loadBlocks draft override — key percent-encoding", () => {
   // The published decofile encodes special characters in block keys
   // (`pages-Home%20(principal)-1`); the Studio draft emits them raw

package/src/cms/loader.ts

@@ -282,6 +282,36 @@ function pathSpecificityKey(path: string): [number, number, number] {
   return [hasWildcard ? 0 : 1, literals, params];
 }
 
+// Literal rather than WELL_KNOWN_TYPES.PAGE: resolve.ts already imports from
+// this module, so importing back would close a cycle.
+const PAGE_RESOLVE_TYPE = "website/pages/Page.tsx";
+
+/**
+ * Is this block a page?
+ *
+ * The `pages-` prefix is kept as a fast path because it is what the admin
+ * emits and it short-circuits the vast majority of blocks without a property
+ * read. But it cannot be the *only* test: a decofile carried over from Deco on
+ * Fresh can hold page blocks under any key — renaming one in the CMS renames
+ * its snapshot file, and `loadDecofileDirectory` preserves whatever key the
+ * filename already had.
+ *
+ * Those blocks are pages in every way that matters (`website/pages/Page.tsx`,
+ * a `path`, `sections`), and on Fresh they routed fine: `website/loaders/pages.ts`
+ * enumerated by `__resolveType`, not by key. Filtering on the prefix alone makes
+ * them invisible, so every one of their URLs falls through to whatever catch-all
+ * the site has — usually a 404 — and they disappear from the CMS sitemap too.
+ * One storefront in this state has 205 such blocks against 107 prefixed ones.
+ */
+function isPageBlock(key: string, block: unknown): boolean {
+  if (key.startsWith("pages-")) return true;
+  return (
+    typeof block === "object" &&
+    block !== null &&
+    (block as Resolvable).__resolveType === PAGE_RESOLVE_TYPE
+  );
+}
+
 export function getAllPages(): Array<{ key: string; page: DecoPage }> {
   const blocks = loadBlocks();
   const pages: Array<{
@@ -291,7 +321,7 @@ export function getAllPages(): Array<{ key: string; page: DecoPage }> {
   }> = [];
 
   for (const [key, block] of Object.entries(blocks)) {
-    if (!key.startsWith("pages-")) continue;
+    if (!isPageBlock(key, block)) continue;
     const page = block as DecoPage;
     if (!page.sections) continue;
     if (!page.path) continue;