@decocms/blocks 7.68.0 → 7.69.1

package/package.json

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

package/src/sdk/abTesting.test.ts

@@ -48,6 +48,61 @@ describe("proxyToFallback", () => {
     vi.unstubAllGlobals();
   });
 
+  it("streams the hostname rewrite instead of buffering the body", async () => {
+    fetchSpy.mockResolvedValue(
+      new Response(`<a href="https://${FALLBACK_HOST}/x">go</a>`, {
+        status: 200,
+        headers: { "content-type": "text/html", "content-length": "999" },
+      }),
+    );
+
+    const res = await proxyToFallback(
+      new Request(`https://${REAL_HOST}/foo`),
+      makeUrl("/foo"),
+      FALLBACK_HOST,
+    );
+
+    await expect(res.text()).resolves.toBe(`<a href="https://${REAL_HOST}/x">go</a>`);
+    // The rewrite changes the body length, so the upstream content-length is a
+    // lie and a streamed body has none to state.
+    expect(res.headers.get("content-length")).toBeNull();
+  });
+
+  it("still rewrites when content-encoding is retained (workerd keeps the header but yields decoded bytes)", async () => {
+    fetchSpy.mockResolvedValue(
+      new Response(`see ${FALLBACK_HOST}`, {
+        status: 200,
+        headers: { "content-type": "text/html", "content-encoding": "gzip" },
+      }),
+    );
+
+    const res = await proxyToFallback(
+      new Request(`https://${REAL_HOST}/foo`),
+      makeUrl("/foo"),
+      FALLBACK_HOST,
+    );
+
+    await expect(res.text()).resolves.toBe(`see ${REAL_HOST}`);
+    expect(res.headers.get("content-encoding")).toBe("gzip");
+  });
+
+  it("leaves a non-2xx body alone", async () => {
+    fetchSpy.mockResolvedValue(
+      new Response(`moved to ${FALLBACK_HOST}`, {
+        status: 302,
+        headers: { "content-type": "text/html" },
+      }),
+    );
+
+    const res = await proxyToFallback(
+      new Request(`https://${REAL_HOST}/foo`),
+      makeUrl("/foo"),
+      FALLBACK_HOST,
+    );
+
+    await expect(res.text()).resolves.toBe(`moved to ${FALLBACK_HOST}`);
+  });
+
   it("always sets redirect:'manual' to avoid replaying streamed bodies on 3xx", async () => {
     fetchSpy.mockResolvedValue(new Response("ok", { status: 200 }));
 

package/src/sdk/abTesting.ts

@@ -272,6 +272,53 @@ export function tagBucket(
 	return res;
 }
 
+/**
+ * A `TransformStream` that rewrites every occurrence of `search` in a UTF-8 text
+ * stream, without ever holding the whole body in memory.
+ *
+ * Two hazards it exists to handle:
+ *
+ * - **A match straddling a chunk boundary.** Each pass holds back the last
+ *   `search.length - 1` characters and prepends them to the next chunk. The
+ *   held-back slice is taken from the RAW input, never from already-replaced
+ *   output — otherwise a replacement ending in a prefix of `search` could join
+ *   the next chunk and be replaced a second time.
+ * - **A multi-byte character split across chunks.** `TextDecoder` with
+ *   `{ stream: true }` carries the partial code point across `decode` calls.
+ *
+ * Peak memory is one chunk plus `search.length - 1` characters, not the body.
+ */
+export function createReplaceStream(search: string, replace: string): TransformStream<Uint8Array, Uint8Array> {
+	const decoder = new TextDecoder("utf-8");
+	const encoder = new TextEncoder();
+	if (!search) return new TransformStream<Uint8Array, Uint8Array>();
+	const keep = search.length - 1;
+	let tail = "";
+
+	return new TransformStream<Uint8Array, Uint8Array>({
+		transform(chunk, controller) {
+			const buffer = tail + decoder.decode(chunk, { stream: true });
+			// Consume complete matches first (left to right, non-overlapping — same
+			// as replaceAll), then hold back only the last `search.length - 1` chars
+			// of what follows the last match: a not-yet-complete match can only
+			// start there. Cutting before consuming matches can slice a complete,
+			// self-overlapping match ("aaa" in "xaaaa") in half.
+			let end = 0;
+			for (let i = buffer.indexOf(search); i !== -1; i = buffer.indexOf(search, end)) {
+				end = i + search.length;
+			}
+			const cut = Math.max(end, buffer.length - keep);
+			tail = buffer.slice(cut);
+			const head = buffer.slice(0, cut);
+			if (head) controller.enqueue(encoder.encode(head.replaceAll(search, replace)));
+		},
+		flush(controller) {
+			const rest = tail + decoder.decode();
+			if (rest) controller.enqueue(encoder.encode(rest.replaceAll(search, replace)));
+		},
+	});
+}
+
 /**
  * Proxy a request to the fallback origin with full hostname rewriting.
  *
@@ -330,18 +377,28 @@ export async function proxyToFallback(
 	// would consume the stream needlessly and could throw on non-text
 	// content. The Location header is rewritten separately further down.
 	let body: BodyInit | null = response.body;
+	let rewrote = false;
 	if (
 		isText &&
 		response.body &&
 		response.status >= 200 &&
-		response.status < 300
+		response.status < 300 &&
+		fallbackOrigin.length > 0
 	) {
-		const text = await response.text();
-		body = text.replaceAll(fallbackOrigin, url.hostname);
+		// Streamed, not buffered. `response.text()` held the entire body as a
+		// JS string (two bytes per character) plus the replaced copy — multiple
+		// megabytes of a 128MB isolate budget for a hostname substitution.
+		body = response.body.pipeThrough(createReplaceStream(fallbackOrigin, url.hostname));
+		rewrote = true;
 	}
 
 	const rewritten = new Response(body, response);
 
+	// The rewrite changes the body length, so the upstream `content-length` is
+	// now a lie — and a streamed body has no length to state. (This was already
+	// wrong on the buffered path; it just never had to be chunked.)
+	if (rewrote) rewritten.headers.delete("content-length");
+
 	const setCookies = response.headers.getSetCookie?.() ?? [];
 	if (setCookies.length > 0) {
 		rewritten.headers.delete("set-cookie");

package/src/sdk/replaceStream.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, it } from "vitest";
+import { createReplaceStream } from "./abTesting";
+
+/**
+ * The A/B fallback proxy used to buffer the whole upstream body into a JS
+ * string (two bytes per character) plus the replaced copy, just to swap a
+ * hostname — megabytes of a 128MB isolate budget. This streams it instead,
+ * which is only correct if two hazards are handled: a match straddling a chunk
+ * boundary, and a multi-byte character split across chunks.
+ */
+
+const enc = new TextEncoder();
+
+/** Push `chunks` through the transform and read the whole output back. */
+async function run(search: string, replace: string, chunks: string[] | Uint8Array[]) {
+  const source = new ReadableStream<Uint8Array>({
+    start(controller) {
+      for (const c of chunks) {
+        controller.enqueue(typeof c === "string" ? enc.encode(c) : c);
+      }
+      controller.close();
+    },
+  });
+  const out = source.pipeThrough(createReplaceStream(search, replace));
+  return await new Response(out).text();
+}
+
+describe("createReplaceStream", () => {
+  it("replaces within a single chunk", async () => {
+    await expect(run("old.site", "new.site", ["go to old.site now"])).resolves.toBe(
+      "go to new.site now",
+    );
+  });
+
+  it("replaces every occurrence, not just the first", async () => {
+    await expect(run("a", "X", ["banana"])).resolves.toBe("bXnXnX");
+  });
+
+  it("replaces a match split across a chunk boundary", async () => {
+    // The hazard the hold-back exists for.
+    await expect(run("old.site", "new.site", ["go to old.", "site now"])).resolves.toBe(
+      "go to new.site now",
+    );
+  });
+
+  it("replaces a match split one character at a time", async () => {
+    await expect(run("abc", "X", [..."1abc2"])).resolves.toBe("1X2");
+  });
+
+  it("does not re-replace when the replacement ends in a prefix of the search", async () => {
+    // Held-back text is taken from the RAW input, never from replaced output.
+    // Otherwise "abc"->"xab" would leave "ab", join the next chunk's "c", and
+    // be replaced a second time.
+    await expect(run("abc", "xab", ["abc", "c"])).resolves.toBe("xabc");
+  });
+
+  it("carries a multi-byte character split across chunks", async () => {
+    // "ã" is two bytes in UTF-8 — split them.
+    const bytes = enc.encode("promoção");
+    const mid = bytes.indexOf(0xc3); // first byte of "ç"
+    const out = await run("x", "y", [bytes.slice(0, mid + 1), bytes.slice(mid + 1)]);
+    expect(out).toBe("promoção");
+  });
+
+  it("passes a body through untouched when nothing matches", async () => {
+    await expect(run("nope", "!", ["hello ", "world"])).resolves.toBe("hello world");
+  });
+
+  it("handles an empty body", async () => {
+    await expect(run("a", "b", [])).resolves.toBe("");
+  });
+
+  it("handles a match at the very end of the stream", async () => {
+    // Lands entirely in the held-back tail, so only `flush` can emit it.
+    await expect(run("end", "END", ["the ", "end"])).resolves.toBe("the END");
+  });
+
+  it("handles a match at the very start", async () => {
+    await expect(run("go", "GO", ["go home"])).resolves.toBe("GO home");
+  });
+
+  it("holds back at most search.length - 1 characters", async () => {
+    // Peak memory must be one chunk plus a bounded tail, never the body.
+    const big = "z".repeat(10_000);
+    await expect(run("old.site", "new.site", [big, "old.site", big])).resolves.toBe(
+      `${big}new.site${big}`,
+    );
+  });
+
+  it("replaces a self-overlapping match that straddles the hold-back cut", async () => {
+    await expect(run("aaa", "Y", ["xaaaa"])).resolves.toBe("xYa");
+    await expect(run("aa", "Y", ["aaa", "a"])).resolves.toBe("aaaa".replaceAll("aa", "Y"));
+    await expect(run("abab", "Y", ["ababab", "ab"])).resolves.toBe("abababab".replaceAll("abab", "Y"));
+  });
+
+  it("matches native replaceAll over random chunkings", async () => {
+    let seed = 1;
+    const rnd = (n: number) => ((seed = (seed * 1103515245 + 12345) & 0x7fffffff) % n);
+    for (let iter = 0; iter < 500; iter++) {
+      const alpha = "ab\u00e7";
+      const str = (n: number) => Array.from({ length: n }, () => alpha[rnd(alpha.length)]).join("");
+      const search = str(1 + rnd(4));
+      const replace = str(rnd(4));
+      const text = str(rnd(40));
+      const bytes = enc.encode(text);
+      const chunks: Uint8Array[] = [];
+      for (let p = 0; p < bytes.length; ) {
+        const n = 1 + rnd(6);
+        chunks.push(bytes.slice(p, p + n));
+        p += n;
+      }
+      expect(await run(search, replace, chunks), JSON.stringify({ search, replace, text })).toBe(
+        text.replaceAll(search, replace),
+      );
+    }
+  });
+});