@decocms/blocks-cli 7.67.1 → 7.68.0

package/package.json

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

package/scripts/fast-deploy-kv.test.ts

@@ -9,6 +9,7 @@ import {
   revisionKey,
   snapshotKey,
 } from "@decocms/blocks/cms";
+import { splitExactRedirects } from "@decocms/blocks/sdk/redirects";
 import { createKvRestClient, type KvRestClient, kvConfigFromEnv } from "./lib/cf-kv-rest";
 import { readDecofileFromDir } from "./lib/read-decofile";
 import { kvNamespaceIdFromToml, kvNamespaceIdFromWrangler } from "./lib/wrangler-config";
@@ -16,6 +17,7 @@ import {
   buildSnapshot,
   recordAndGcDeployment,
   setLiveDeployment,
+  syncRedirectsToKv,
   verifySnapshotInKv,
   writeSnapshotToKv,
 } from "./lib/kv-snapshot";
@@ -46,6 +48,14 @@ function makeClient(initial: Record<string, string> = {}) {
       Promise.resolve(
         [...store.keys()].filter((k) => !prefix || k.startsWith(prefix)),
       ),
+    putMany: (entries) => {
+      for (const e of entries) store.set(e.key, e.value);
+      return Promise.resolve();
+    },
+    deleteMany: (keys) => {
+      for (const k of keys) store.delete(k);
+      return Promise.resolve();
+    },
   };
   return { client, store, putOrder };
 }
@@ -386,6 +396,24 @@ describe("readDecofileFromDir — CSV redirects", () => {
     expect(blocks.site).toBeDefined();
   });
 
+  it("splits CSV-derived exact redirects out of the snapshot", () => {
+    const blocksDir = makeSite(
+      {
+        "site.json": {
+          __resolveType: "site/apps/site.ts",
+          routes: [{ __resolveType: "website/loaders/redirectsFromCsv.ts", from: "static/r.csv" }],
+        },
+      },
+      { "r.csv": "from,to,type\n/old,/new,permanent\n/g/*,/h/*\n" },
+    );
+    const { blocks } = readDecofileFromDir(blocksDir, { silent: true });
+    const split = splitExactRedirects(blocks);
+
+    expect(split.exact).toEqual([{ path: "/old", to: "/new", status: 301 }]);
+    expect(JSON.stringify(split.blocks)).not.toContain('"/old"');
+    expect(split.blocks["__csv_redirects__r.csv"]).toMatchObject({ redirects: [{ from: "/g/*" }] });
+  });
+
   it("lets a real block win over the synthetic one on a key collision", () => {
     const blocksDir = makeSite(
       {
@@ -410,3 +438,78 @@ describe("readDecofileFromDir — CSV redirects", () => {
     expect(Object.keys(blocks)).toEqual(["site"]);
   });
 });
+
+describe("syncRedirectsToKv", () => {
+  /** In-memory client with the bulk ops the redirect sync uses. */
+  function makeBulkClient(initial: Record<string, string> = {}) {
+    const store = new Map(Object.entries(initial));
+    const client = {
+      get: (k: string) => Promise.resolve(store.get(k) ?? null),
+      put: (k: string, v: string) => {
+        store.set(k, v);
+        return Promise.resolve();
+      },
+      delete: (k: string) => {
+        store.delete(k);
+        return Promise.resolve();
+      },
+      list: (prefix?: string) =>
+        Promise.resolve([...store.keys()].filter((k) => !prefix || k.startsWith(prefix))),
+      putMany: (entries: Array<{ key: string; value: string }>) => {
+        for (const e of entries) store.set(e.key, e.value);
+        return Promise.resolve();
+      },
+      deleteMany: (keys: string[]) => {
+        for (const k of keys) store.delete(k);
+        return Promise.resolve();
+      },
+    };
+    return { client: client as unknown as KvRestClient, store };
+  }
+
+  const rule = (path: string, to: string, status: 301 | 302 = 301) => ({ path, to, status });
+
+  it("adds new rules under redirect:<id>:<path>", async () => {
+    const { client, store } = makeBulkClient();
+    const out = await syncRedirectsToKv(client, [rule("/old", "/new")], ID);
+
+    expect(out).toEqual({ written: 1, deleted: 0 });
+    expect(store.get(`redirect:${ID}:/old`)).toBe('{"to":"/new","status":301}');
+  });
+
+  it("updates a changed target in place", async () => {
+    const { client, store } = makeBulkClient({
+      [`redirect:${ID}:/old`]: '{"to":"/stale","status":302}',
+    });
+    await syncRedirectsToKv(client, [rule("/old", "/fresh")], ID);
+    expect(store.get(`redirect:${ID}:/old`)).toBe('{"to":"/fresh","status":301}');
+  });
+
+  it("removes rules that no longer exist", async () => {
+    // The reason this diffs against a prefix LIST: KV has no "replace
+    // everything under this prefix", so a deleted rule would redirect forever.
+    const { client, store } = makeBulkClient({
+      [`redirect:${ID}:/keep`]: '{"to":"/a","status":301}',
+      [`redirect:${ID}:/gone`]: '{"to":"/b","status":301}',
+    });
+    const out = await syncRedirectsToKv(client, [rule("/keep", "/a")], ID);
+
+    expect(out).toEqual({ written: 1, deleted: 1 });
+    expect(store.has(`redirect:${ID}:/gone`)).toBe(false);
+    expect(store.has(`redirect:${ID}:/keep`)).toBe(true);
+  });
+
+  it("never touches another deployment's keys", async () => {
+    const { client, store } = makeBulkClient({
+      "redirect:other-sha:/gone": '{"to":"/x","status":301}',
+    });
+    await syncRedirectsToKv(client, [], ID);
+    expect(store.has("redirect:other-sha:/gone")).toBe(true);
+  });
+
+  it("does not disturb the decofile keys", async () => {
+    const { client, store } = makeBulkClient({ [snapshotKey(ID)]: "{}" });
+    await syncRedirectsToKv(client, [rule("/a", "/b")], ID);
+    expect(store.has(snapshotKey(ID))).toBe(true);
+  });
+});

package/scripts/lib/cf-kv-rest.ts

@@ -3,7 +3,9 @@
  *
  * CI has no Worker KV binding, so the fast-deploy sync/migrate scripts write to
  * KV over the REST API instead. Only the operations the scripts need — single-key
- * GET/PUT/DELETE plus prefix LIST (for per-deployment GC) — are implemented.
+ * GET/PUT/DELETE, prefix LIST (for per-deployment GC), and BULK put/delete (for
+ * the per-path redirect keys, which number in the tens of thousands) — are
+ * implemented.
  *
  * Auth/config via env (read by the scripts, passed to `createKvRestClient`):
  *   - CF_ACCOUNT_ID       Cloudflare account id      (or CLOUDFLARE_ACCOUNT_ID)
@@ -37,6 +39,21 @@ export interface KvRestClient {
   delete(key: string): Promise<void>;
   /** List key names, optionally filtered by prefix. Follows pagination. */
   list(prefix?: string): Promise<string[]>;
+  /** Write many keys. Chunked to the API's per-request ceiling. A site can have
+   *  tens of thousands of redirects; one PUT each would be as many round trips. */
+  putMany(entries: Array<{ key: string; value: string }>): Promise<void>;
+  /** Delete many keys. Same chunking. */
+  deleteMany(keys: string[]): Promise<void>;
+}
+
+/** Cloudflare's per-request ceiling for the bulk KV endpoints. */
+const BULK_CHUNK = 10_000;
+
+/** Split `items` into chunks of at most `size`. */
+function chunk<T>(items: T[], size: number): T[][] {
+  const out: T[][] = [];
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+  return out;
 }
 
 const DEFAULT_BASE = "https://api.cloudflare.com/client/v4";
@@ -108,6 +125,37 @@ export function createKvRestClient(config: KvRestConfig): KvRestClient {
       }
     },
 
+    async putMany(entries) {
+      for (const batch of chunk(entries, BULK_CHUNK)) {
+        const res = await fetchImpl(`${root}/bulk`, {
+          method: "PUT",
+          headers: { ...authHeaders, "Content-Type": "application/json" },
+          body: JSON.stringify(batch),
+        });
+        if (!res.ok) {
+          throw new Error(
+            `KV bulk PUT (${batch.length} keys) failed: ${res.status} ${await res.text()}`,
+          );
+        }
+      }
+    },
+
+    async deleteMany(keys) {
+      for (const batch of chunk(keys, BULK_CHUNK)) {
+        const res = await fetchImpl(`${root}/bulk`, {
+          method: "DELETE",
+          headers: { ...authHeaders, "Content-Type": "application/json" },
+          body: JSON.stringify(batch),
+        });
+        // 404 is fine — the keys are already gone (idempotent delete).
+        if (!res.ok && res.status !== 404) {
+          throw new Error(
+            `KV bulk DELETE (${batch.length} keys) failed: ${res.status} ${await res.text()}`,
+          );
+        }
+      }
+    },
+
     async list(prefix) {
       const names: string[] = [];
       let cursor: string | undefined;

package/scripts/lib/kv-snapshot.ts

@@ -12,9 +12,12 @@ import {
   computeRevision,
   DEPLOYMENTS_KEY,
   LIVE_KEY,
+  redirectKey,
+  redirectPrefix,
   revisionKey,
   snapshotKey,
 } from "@decocms/blocks/cms";
+import type { ExactRedirect } from "@decocms/blocks/sdk/redirects";
 import type { KvRestClient } from "./cf-kv-rest";
 
 export interface Snapshot {
@@ -71,6 +74,42 @@ export async function verifySnapshotInKv(
   return { ok: true };
 }
 
+/**
+ * Reconcile deployment `id`'s exact redirects in KV: write the ones that are
+ * new or changed, delete the ones that no longer exist.
+ *
+ * KV has no "replace everything under this prefix" operation, so the desired
+ * set is diffed against what is actually stored. The source of truth for
+ * "what's there now" is a prefix LIST rather than a manifest key — a manifest
+ * is one more thing that can drift out of sync with reality, and the list is
+ * free enough at build time.
+ *
+ * Updates are not detected by value: re-PUTting an unchanged key is one bulk
+ * write, while reading every current value back to compare would be one GET per
+ * key. So every desired rule is written, and only deletions need the diff.
+ */
+export async function syncRedirectsToKv(
+  client: KvRestClient,
+  redirects: ExactRedirect[],
+  id: string,
+): Promise<{ written: number; deleted: number }> {
+  const desired = new Map(
+    redirects.map((r) => [redirectKey(id, r.path), JSON.stringify({ to: r.to, status: r.status })]),
+  );
+
+  const existing = await client.list(redirectPrefix(id));
+  const stale = existing.filter((key) => !desired.has(key));
+
+  if (desired.size > 0) {
+    await client.putMany([...desired].map(([key, value]) => ({ key, value })));
+  }
+  if (stale.length > 0) {
+    await client.deleteMany(stale);
+  }
+
+  return { written: desired.size, deleted: stale.length };
+}
+
 /** Point `index:live` at deployment `id` (post-activation, from the deploy step). */
 export async function setLiveDeployment(client: KvRestClient, id: string): Promise<void> {
   await client.put(LIVE_KEY, id);
@@ -121,6 +160,11 @@ export async function recordAndGcDeployment(
       }
       await client.delete(snapshotKey(entry.id));
       await client.delete(revisionKey(entry.id));
+      // The per-path redirect keys are keyed by deployment too, so they are
+      // part of this snapshot and must go with it — otherwise every deploy
+      // leaks tens of thousands of orphans into the namespace forever.
+      const staleRedirects = await client.list(redirectPrefix(entry.id));
+      if (staleRedirects.length > 0) await client.deleteMany(staleRedirects);
       pruned.push(entry.id);
     }
     await client.put(DEPLOYMENTS_KEY, JSON.stringify([...keptOld, ...recent]));

package/scripts/migrate-blocks-to-kv.ts

@@ -30,8 +30,14 @@
  */
 
 import * as path from "node:path";
+import { splitExactRedirects } from "@decocms/blocks/sdk/redirects";
 import { createKvRestClient, kvConfigFromEnv } from "./lib/cf-kv-rest";
-import { buildSnapshot, verifySnapshotInKv, writeSnapshotToKv } from "./lib/kv-snapshot";
+import {
+  buildSnapshot,
+  syncRedirectsToKv,
+  verifySnapshotInKv,
+  writeSnapshotToKv,
+} from "./lib/kv-snapshot";
 import { readDecofileFromDir } from "./lib/read-decofile";
 
 function parseArgs(argv: string[]) {
@@ -77,8 +83,15 @@ async function main() {
     process.exit(2);
   }
 
-  const snap = buildSnapshot(blocks);
+  // Exact redirects live under their own `redirect:<id>:<path>` keys, not in
+  // the decofile — see splitExactRedirects. Must match what sync-blocks-to-kv
+  // writes, or a one-shot seed and a CI sync would disagree on the snapshot.
+  const split = splitExactRedirects(blocks);
+  const snap = buildSnapshot(split.blocks);
   console.log(`decofile: ${snap.count} blocks, revision ${snap.revision}, ${snap.snapshot.length} bytes`);
+  if (split.exact.length > 0) {
+    console.log(`redirects: ${split.exact.length} exact rule(s) as individual keys`);
+  }
 
   if (!opts.write) {
     console.log("\nDry-run only. Re-run with --write to populate KV.");
@@ -94,6 +107,7 @@ async function main() {
   }
 
   try {
+    await syncRedirectsToKv(client, split.exact, opts.deploymentId);
     await writeSnapshotToKv(client, snap, opts.deploymentId);
     const verify = await verifySnapshotInKv(client, snap.revision, opts.deploymentId);
     if (!verify.ok) {

package/scripts/sync-blocks-to-kv.ts

@@ -46,11 +46,14 @@
 
 import { execSync } from "node:child_process";
 import * as path from "node:path";
+import { redirectPrefix } from "@decocms/blocks/cms";
+import { splitExactRedirects } from "@decocms/blocks/sdk/redirects";
 import { createKvRestClient, kvConfigFromEnv } from "./lib/cf-kv-rest";
 import {
   buildSnapshot,
   recordAndGcDeployment,
   setLiveDeployment,
+  syncRedirectsToKv,
   verifySnapshotInKv,
   writeSnapshotToKv,
 } from "./lib/kv-snapshot";
@@ -160,12 +163,20 @@ async function main() {
     process.exit(2);
   }
 
-  const snap = buildSnapshot(blocks);
+  // Exact redirects get ONE KV key each and are removed from the decofile. A
+  // bulk-migration site can carry tens of thousands; inside the snapshot they
+  // are resident in every isolate twice (parsed graph + RedirectMap) for data
+  // that usually matches nothing. Globs stay — they must be scanned in order.
+  const split = splitExactRedirects(blocks);
   const purgePaths = opts.all ? ["/"] : purgePathsForChangedKeys(blocks, changedKeys);
+  const snap = buildSnapshot(split.blocks);
   console.log(`decofile: ${snap.count} blocks, revision ${snap.revision} → deployment ${opts.deploymentId}`);
+  if (split.exact.length > 0) {
+    console.log(`redirects: ${split.exact.length} exact rule(s) → ${redirectPrefix(opts.deploymentId)}*`);
+  }
 
   if (!opts.write) {
-    console.log(`\nDry-run only. Would write decofile:${opts.deploymentId} + revision, GC to ${opts.retain}, purge: ${purgePaths.join(", ")}`);
+    console.log(`\nDry-run only. Would write decofile:${opts.deploymentId} + revision, ${split.exact.length} redirect key(s), GC to ${opts.retain}, purge: ${purgePaths.join(", ")}`);
     process.exit(0);
   }
 
@@ -178,6 +189,13 @@ async function main() {
   }
 
   try {
+    // Redirects FIRST: the decofile no longer carries them, so publishing the
+    // snapshot before the keys exist would leave a window where every migrated
+    // URL 404s instead of redirecting.
+    const red = await syncRedirectsToKv(client, split.exact, opts.deploymentId);
+    if (red.written || red.deleted) {
+      console.log(`redirects: ${red.written} written, ${red.deleted} removed.`);
+    }
     await writeSnapshotToKv(client, snap, opts.deploymentId);
     const verify = await verifySnapshotInKv(client, snap.revision, opts.deploymentId);
     if (!verify.ok) {