@decocms/blocks 7.67.0 → 7.68.0

package/package.json

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

package/src/cms/blockSource.ts

@@ -123,6 +123,7 @@ export interface KVNamespace {
 //   index:revision:<id>    DJB2 hex revision of that snapshot (polled)
 //   index:live             pointer to the currently-live <id> (set post-deploy)
 //   index:deployments      JSON [{id, ts}] (newest last) — GC bookkeeping
+//   redirect:<id>:<path>   ONE key per exact redirect (see below)
 // ---------------------------------------------------------------------------
 
 /** KV key holding the full decofile JSON for deployment `id`. */
@@ -144,6 +145,42 @@ export const LIVE_KEY = "index:live";
  * deployment snapshots so the sync script can GC all but the last N. */
 export const DEPLOYMENTS_KEY = "index:deployments";
 
+// ---------------------------------------------------------------------------
+// Exact redirects — one KV key each, deliberately NOT inside the decofile.
+//
+// A bulk-migration site can carry tens of thousands of rules. Inside the
+// decofile they are resident in every isolate twice over: once in the parsed
+// snapshot graph, once in the `RedirectMap` built from it — megabytes of a
+// 128MB budget, for data that is read at most once per request and usually
+// never. As their own keys they are looked up on demand and the list is never
+// loaded at all.
+//
+// Only EXACT rules move. Glob rules (`/old/*`) cannot be addressed by key and
+// must be scanned in order, so they stay in the decofile — there are tens of
+// them, not thousands.
+// ---------------------------------------------------------------------------
+
+/** Key prefix holding deployment `id`'s exact redirects (one key per path). */
+export function redirectPrefix(id: string): string {
+  return `redirect:${id}:`;
+}
+
+/**
+ * KV key for one exact redirect. `path` MUST already be normalized by
+ * `normalizePath` (`@decocms/blocks/sdk/redirects`) on both sides — the writer
+ * and the request-time lookup — or a rule is written under a key nothing ever
+ * asks for.
+ */
+export function redirectKey(id: string, path: string): string {
+  return `${redirectPrefix(id)}${path}`;
+}
+
+/** Value stored at a `redirect:<id>:<path>` key. */
+export interface StoredRedirect {
+  to: string;
+  status: 301 | 302;
+}
+
 // ---------------------------------------------------------------------------
 // Deployment id resolution
 //

package/src/cms/index.ts

@@ -3,7 +3,7 @@ export type {
   SectionMetaEntry,
 } from "./applySectionConventions";
 export { applySectionConventions } from "./applySectionConventions";
-export type { BlockSnapshot, BlockSource, KVNamespace } from "./blockSource";
+export type { BlockSnapshot, BlockSource, KVNamespace, StoredRedirect } from "./blockSource";
 export {
   BUILD_HASH_ENV,
   BundledBlockSource,
@@ -12,6 +12,8 @@ export {
   DEPLOYMENTS_KEY,
   getDeploymentId,
   LIVE_KEY,
+  redirectKey,
+  redirectPrefix,
   revisionKey,
   snapshotKey,
 } from "./blockSource";

package/src/sdk/redirects.ts

@@ -184,11 +184,23 @@ export function addRedirects(map: RedirectMap, redirects: Redirect[]): void {
  * typically few patterns exist).
  */
 export function matchRedirect(pathname: string, map: RedirectMap): Redirect | null {
-  const normalized = normalizePath(pathname);
+  return matchExactRedirect(pathname, map) ?? matchPatternRedirect(pathname, map);
+}
 
-  const exactMatch = map.exact.get(normalized);
-  if (exactMatch) return exactMatch;
+/**
+ * Exact half of `matchRedirect`. Split out because the KV-keyed path has to
+ * interleave a third source between the two halves: in-memory exact, then the
+ * `redirect:<id>:<path>` KV lookup, then patterns. Collapsing that to
+ * "matchRedirect, then KV" would let a glob win over an exact rule, inverting
+ * the precedence every other path has.
+ */
+export function matchExactRedirect(pathname: string, map: RedirectMap): Redirect | null {
+  return map.exact.get(normalizePath(pathname)) ?? null;
+}
 
+/** Pattern half of `matchRedirect` — ordered prefix scan, `*` suffix carried over. */
+export function matchPatternRedirect(pathname: string, map: RedirectMap): Redirect | null {
+  const normalized = normalizePath(pathname);
   for (const { prefix, redirect } of map.patterns) {
     if (normalized.startsWith(prefix)) {
       const suffix = normalized.slice(prefix.length);
@@ -196,15 +208,111 @@ export function matchRedirect(pathname: string, map: RedirectMap): Redirect | nu
       return { ...redirect, to };
     }
   }
-
   return null;
 }
 
+// -------------------------------------------------------------------------
+// Splitting exact rules out of the decofile (KV-keyed redirects)
+// -------------------------------------------------------------------------
+
+/** One exact rule, ready to be written to its own KV key. */
+export interface ExactRedirect {
+  /** Normalized path — the KV key suffix. */
+  path: string;
+  to: string;
+  status: 301 | 302;
+}
+
+export interface SplitRedirectsResult {
+  /** The blocks map with every EXACT rule removed. Glob rules stay (they can't
+   *  be addressed by key), and a redirect block left with no entries at all is
+   *  dropped entirely rather than left as an empty husk. */
+  blocks: Record<string, unknown>;
+  /** The extracted exact rules, deduped by path (last wins, matching
+   *  `loadRedirects`, which is last-write-wins over insertion order). */
+  exact: ExactRedirect[];
+}
+
+/**
+ * Split a decofile into "blocks without exact redirects" + "the exact rules".
+ *
+ * A bulk-migration site can carry tens of thousands of rules. Left inside the
+ * decofile they sit in every isolate twice — the parsed snapshot graph and the
+ * `RedirectMap` built from it — for data that is consulted at most once per
+ * request and usually matches nothing. Moved to one KV key each, the list is
+ * never loaded.
+ *
+ * Read-only over `blocks`: the returned map shares every untouched value and
+ * only clones the redirect blocks it had to rewrite.
+ */
+const MAX_KV_PATH_BYTES = 400;
+const utf8 = new TextEncoder();
+
+export function splitExactRedirects(blocks: Record<string, unknown>): SplitRedirectsResult {
+  const exact = new Map<string, ExactRedirect>();
+  const out: Record<string, unknown> = {};
+
+  for (const [key, block] of Object.entries(blocks)) {
+    const obj = block && typeof block === "object" ? (block as Record<string, unknown>) : null;
+    const resolveType = obj?.__resolveType as string | undefined;
+    if (!obj || !resolveType || !REDIRECT_RESOLVE_TYPES.has(resolveType)) {
+      out[key] = block;
+      continue;
+    }
+
+    const raw = (obj.redirects ?? obj.redirect) as
+      | BlockRedirectEntry[]
+      | BlockRedirectEntry
+      | undefined;
+    if (!raw) {
+      out[key] = block;
+      continue;
+    }
+
+    const kept: BlockRedirectEntry[] = [];
+    for (const entry of Array.isArray(raw) ? raw : [raw]) {
+      if (!entry?.from || !entry.to) continue;
+      const from = normalizePath(entry.from);
+      // Globs must be scanned in order against the request path, so they can
+      // never be a key lookup — they stay in the decofile.
+      // Paths too long for a KV key (512 bytes, minus `redirect:<id>:`) stay
+      // in memory too — loadRedirects still serves them from the exact map.
+      if (from.includes("*") || utf8.encode(from).length > MAX_KV_PATH_BYTES) {
+        kept.push(entry);
+        continue;
+      }
+      exact.set(from, {
+        path: from,
+        to: entry.to,
+        status: entry.type === "permanent" ? 301 : 302,
+      });
+    }
+
+    // Nothing left to scan ⇒ drop the block rather than ship an empty husk.
+    if (kept.length === 0) continue;
+    // Rebuild without `redirect` — a block may have carried the singular form,
+    // and leaving it would reintroduce the rule we just extracted.
+    const { redirect: _dropped, ...rest } = obj;
+    out[key] = { ...rest, redirects: kept };
+  }
+
+  return { blocks: out, exact: [...exact.values()] };
+}
+
 // -------------------------------------------------------------------------
 // Helpers
 // -------------------------------------------------------------------------
 
-function normalizePath(path: string): string {
+/**
+ * Canonical redirect-path form: origin stripped, leading slash forced, trailing
+ * slash dropped, lower-cased.
+ *
+ * Exported because it is the KV key contract for `redirect:<id>:<path>` — the
+ * sync script that WRITES the keys and the worker that READS them must agree
+ * byte for byte, or a rule is stored under a key nothing ever asks for. Never
+ * inline a different normalization on either side.
+ */
+export function normalizePath(path: string): string {
   let p = path.trim();
 
   // If the "from" is a full URL, extract just the pathname

package/src/sdk/splitExactRedirects.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, it } from "vitest";
+import {
+  loadRedirects,
+  matchExactRedirect,
+  matchPatternRedirect,
+  matchRedirect,
+  splitExactRedirects,
+} from "./redirects";
+
+/**
+ * Exact rules move to their own KV keys; globs stay in the decofile because
+ * they must be scanned in order and can never be a key lookup.
+ *
+ * The invariant that matters: whatever leaves the decofile must be recoverable
+ * from the extracted list, and whatever stays must still match the same way.
+ */
+describe("splitExactRedirects", () => {
+  it("extracts exact rules and drops them from the block", () => {
+    const { blocks, exact } = splitExactRedirects({
+      r: {
+        __resolveType: "website/loaders/redirects.ts",
+        redirects: [
+          { from: "/old", to: "/new", type: "permanent" },
+          { from: "/tmp", to: "/other" },
+        ],
+      },
+    });
+
+    expect(exact).toEqual([
+      { path: "/old", to: "/new", status: 301 },
+      { path: "/tmp", to: "/other", status: 302 },
+    ]);
+    // Block had nothing but exact rules ⇒ gone entirely, not an empty husk.
+    expect(blocks.r).toBeUndefined();
+  });
+
+  it("keeps a path too long for a KV key in the decofile, still matched in memory", () => {
+    const long = `/${"x".repeat(500)}`;
+    const { blocks, exact } = splitExactRedirects({
+      r: {
+        __resolveType: "website/loaders/redirects.ts",
+        redirects: [{ from: long, to: "/new", type: "permanent" }],
+      },
+    });
+
+    expect(exact).toEqual([]);
+    expect(matchExactRedirect(long, loadRedirects(blocks))?.to).toBe("/new");
+  });
+
+  it("keeps glob rules in the decofile", () => {
+    const { blocks, exact } = splitExactRedirects({
+      r: {
+        __resolveType: "website/loaders/redirects.ts",
+        redirects: [
+          { from: "/old/*", to: "/new/*" },
+          { from: "/exact", to: "/x" },
+        ],
+      },
+    });
+
+    expect(exact.map((e) => e.path)).toEqual(["/exact"]);
+    expect((blocks.r as { redirects: unknown[] }).redirects).toEqual([
+      { from: "/old/*", to: "/new/*" },
+    ]);
+  });
+
+  it("normalizes the path to the KV key contract", () => {
+    const { exact } = splitExactRedirects({
+      r: {
+        __resolveType: "website/loaders/redirect.ts",
+        redirect: { from: "https://site.com/Old/", to: "/new" },
+      },
+    });
+    // Origin stripped, trailing slash dropped, lower-cased — whatever the
+    // writer keys by, the request-time lookup must produce byte for byte.
+    expect(exact).toEqual([{ path: "/old", to: "/new", status: 302 }]);
+  });
+
+  it("drops the singular `redirect` field when rebuilding a block", () => {
+    // Otherwise the extracted rule would be silently reintroduced.
+    const { blocks } = splitExactRedirects({
+      r: {
+        __resolveType: "website/loaders/redirects.ts",
+        redirect: { from: "/a", to: "/b" },
+        redirects: [{ from: "/glob/*", to: "/g" }],
+      },
+    });
+    expect(blocks.r).not.toHaveProperty("redirect");
+  });
+
+  it("leaves non-redirect blocks untouched, by identity", () => {
+    const page = { __resolveType: "website/pages/Page.tsx", sections: [] };
+    const { blocks } = splitExactRedirects({ page });
+    expect(blocks.page).toBe(page);
+  });
+
+  it("dedupes by path, last rule winning — same as loadRedirects", () => {
+    const input = {
+      a: { __resolveType: "website/loaders/redirects.ts", redirects: [{ from: "/x", to: "/1" }] },
+      b: { __resolveType: "website/loaders/redirects.ts", redirects: [{ from: "/x", to: "/2" }] },
+    };
+    expect(splitExactRedirects(input).exact).toEqual([{ path: "/x", to: "/2", status: 302 }]);
+    expect(loadRedirects(input).exact.get("/x")?.to).toBe("/2");
+  });
+
+  it("round-trips: nothing matchable is lost", () => {
+    const input = {
+      r: {
+        __resolveType: "website/loaders/redirects.ts",
+        redirects: [
+          { from: "/a", to: "/1", type: "permanent" },
+          { from: "/b/*", to: "/2/*" },
+        ],
+      },
+    };
+    const before = loadRedirects(input);
+    const { blocks, exact } = splitExactRedirects(input);
+    const after = loadRedirects(blocks);
+
+    // Exact left the decofile...
+    expect(matchRedirect("/a", after)).toBeNull();
+    // ...into the extracted list, unchanged.
+    expect(exact).toContainEqual({ path: "/a", to: "/1", status: 301 });
+    // Globs still match exactly as before.
+    expect(matchRedirect("/b/deep", after)).toEqual(matchRedirect("/b/deep", before));
+  });
+});
+
+describe("matchExactRedirect / matchPatternRedirect", () => {
+  const map = loadRedirects({
+    r: {
+      __resolveType: "website/loaders/redirects.ts",
+      redirects: [
+        { from: "/shop/*", to: "/store/*" },
+        { from: "/shop/sale", to: "/promo", type: "permanent" },
+      ],
+    },
+  });
+
+  it("compose back into matchRedirect unchanged", () => {
+    for (const path of ["/shop/sale", "/shop/deep", "/nothing"]) {
+      expect(matchExactRedirect(path, map) ?? matchPatternRedirect(path, map)).toEqual(
+        matchRedirect(path, map),
+      );
+    }
+  });
+
+  it("splits the two halves so KV can be interleaved between them", () => {
+    // The whole reason for the split: with exact rules in KV, "matchRedirect
+    // then KV" would let /shop/* win over the exact /shop/sale.
+    expect(matchExactRedirect("/shop/sale", map)?.to).toBe("/promo");
+    expect(matchPatternRedirect("/shop/sale", map)?.to).toBe("/store/sale");
+  });
+});