cdk-nextjs 0.6.2 → 0.7.0

package/lib/nextjs-build/patch-fetch.test.js

@@ -8,9 +8,32 @@ function sha256(input) {
         : Buffer.from(new Uint8Array(input));
     return (0, node_crypto_1.createHash)("sha256").update(buffer).digest("hex");
 }
+class FakeXMLHttpRequest {
+    open(_method, _url) { }
+    send(_body) { }
+    setRequestHeader(_name, _value) { }
+}
+/**
+ * The patch runs in a browser *and* in a web worker, where `window` does not
+ * exist — so the stub goes on `globalThis`, which is what both scopes are. Tests
+ * that want the main-thread scope also set `globalThis.window`, since real
+ * browser code reaches the patched `fetch` through it and `window === globalThis`
+ * there.
+ */
+function installScope({ withWindow = true, withXhr = true } = {}) {
+    global.location = {
+        href: "https://example.com/",
+        hostname: "example.com",
+    };
+    if (withXhr)
+        global.XMLHttpRequest = FakeXMLHttpRequest;
+    if (withWindow)
+        global.window = global;
+}
 describe("patch-fetch", () => {
     let originalFetch;
     let capturedInit;
+    const realFetch = global.fetch;
     beforeEach(() => {
         jest.resetModules();
         capturedInit = undefined;
@@ -18,20 +41,16 @@ describe("patch-fetch", () => {
             capturedInit = init;
             return Promise.resolve(new Response("ok"));
         });
-        global.window = {
-            location: { href: "https://example.com/", hostname: "example.com" },
-            fetch: originalFetch,
-            XMLHttpRequest: class {
-                open(_method, _url) { }
-                send(_body) { }
-                setRequestHeader(_name, _value) { }
-            },
-        };
-        // eslint-disable-next-line @typescript-eslint/no-require-imports -- must re-execute against the fresh `window` stub each test
+        global.fetch = originalFetch;
+        installScope();
+        // eslint-disable-next-line @typescript-eslint/no-require-imports -- must re-execute against the fresh global stub each test
         require("./patch-fetch.js");
     });
     afterEach(() => {
         delete global.window;
+        delete global.location;
+        delete global.XMLHttpRequest;
+        global.fetch = realFetch;
     });
     describe("fetch", () => {
         test("hashes URLSearchParams via toString(), not JSON.stringify", async () => {
@@ -94,6 +113,37 @@ describe("patch-fetch", () => {
             const headers = capturedInit.headers;
             expect(headers.get("x-amz-content-sha256")).toBe(sha256(buffer));
         });
+        test("hashes a typed array body over the bytes it views", async () => {
+            const bytes = new TextEncoder().encode("xxtyped array contents");
+            const view = bytes.subarray(2);
+            await global.window.fetch("https://example.com/api", {
+                method: "POST",
+                body: view,
+            });
+            const headers = capturedInit.headers;
+            expect(headers.get("x-amz-content-sha256")).toBe(sha256("typed array contents"));
+        });
+        test("wraps fetch once when a second patched chunk loads in the same scope", async () => {
+            // Every entrypoint chunk carries a copy. Wrapped twice, the outer wrapper
+            // re-encoded a FormData body to bytes and the inner one overwrote the
+            // right hash with one of those bytes as JSON.
+            const patchedOnce = global.fetch;
+            const patchedXhr = global.XMLHttpRequest;
+            jest.resetModules();
+            // eslint-disable-next-line @typescript-eslint/no-require-imports -- the second chunk's copy
+            require("./patch-fetch.js");
+            expect(global.fetch).toBe(patchedOnce);
+            expect(global.XMLHttpRequest).toBe(patchedXhr);
+            const formData = new FormData();
+            formData.append("field", "value");
+            await global.window.fetch("https://example.com/api", {
+                method: "POST",
+                body: formData,
+            });
+            expect(originalFetch).toHaveBeenCalledTimes(1);
+            const headers = capturedInit.headers;
+            expect(headers.get("x-amz-content-sha256")).toBe(sha256(capturedInit.body));
+        });
         test("hashes an empty byte array when no body is present", async () => {
             await global.window.fetch("https://example.com/api", {
                 method: "POST",
@@ -101,6 +151,36 @@ describe("patch-fetch", () => {
             const headers = capturedInit.headers;
             expect(headers.get("x-amz-content-sha256")).toBe(sha256(new Uint8Array(0)));
         });
+        test("hashes a Request's own body when init is omitted", async () => {
+            const request = new Request("https://example.com/api", {
+                method: "POST",
+                body: "request body",
+                headers: { "content-type": "text/plain" },
+            });
+            await global.window.fetch(request);
+            const [sentInput] = originalFetch.mock.calls[0];
+            expect(sentInput).toBe(request);
+            // The body was read from a clone, so the request still has it to send.
+            expect(await sentInput.text()).toBe("request body");
+            const headers = capturedInit.headers;
+            expect(headers.get("x-amz-content-sha256")).toBe(sha256("request body"));
+            // `init.headers` replaces the request's own, so they must carry over.
+            expect(headers.get("content-type")).toBe("text/plain");
+        });
+        test("hashes init's body over a Request's own when both are set", async () => {
+            const request = new Request("https://example.com/api", {
+                method: "POST",
+                body: "request body",
+            });
+            await global.window.fetch(request, { body: "init body" });
+            const headers = capturedInit.headers;
+            expect(headers.get("x-amz-content-sha256")).toBe(sha256("init body"));
+        });
+        test("passes a GET Request through without hashing", async () => {
+            const request = new Request("https://example.com/api");
+            await global.window.fetch(request);
+            expect(originalFetch).toHaveBeenCalledWith(request, undefined);
+        });
         test("passes through untouched when init is omitted", async () => {
             await global.window.fetch("https://example.com/api");
             expect(originalFetch).toHaveBeenCalledWith("https://example.com/api", undefined);
@@ -155,6 +235,35 @@ describe("patch-fetch", () => {
             await xhr.send("should not be hashed");
             expect(setRequestHeader).not.toHaveBeenCalled();
         });
+        test("hashes the bytes of a typed-array or Blob body, not their JSON", async () => {
+            const bytes = new Uint8Array([1, 2, 3, 250]);
+            for (const body of [bytes, new Blob([bytes])]) {
+                const setRequestHeader = jest.fn();
+                const xhr = new global.window.XMLHttpRequest();
+                xhr.setRequestHeader = setRequestHeader;
+                xhr.open("POST", "https://example.com/api");
+                await xhr.send(body);
+                expect(setRequestHeader).toHaveBeenCalledWith("x-amz-content-sha256", sha256(bytes));
+            }
+        });
+        test("sends a FormData body as the encoding it hashed, with its boundary", async () => {
+            const send = jest.spyOn(FakeXMLHttpRequest.prototype, "send");
+            const setRequestHeader = jest.fn();
+            const form = new FormData();
+            form.append("name", "value");
+            form.append("file", new Blob(["file-bytes"]), "a.txt");
+            const xhr = new global.window.XMLHttpRequest();
+            xhr.setRequestHeader = setRequestHeader;
+            xhr.open("POST", "https://example.com/api");
+            await xhr.send(form);
+            const sent = send.mock.calls[0][0];
+            expect(sent).toBeInstanceOf(Uint8Array);
+            expect(setRequestHeader).toHaveBeenCalledWith("x-amz-content-sha256", sha256(sent));
+            const contentType = setRequestHeader.mock.calls.find(([name]) => name === "content-type")?.[1];
+            expect(contentType).toMatch(/^multipart\/form-data; boundary=/);
+            expect(Buffer.from(sent).toString()).toContain(contentType.split("boundary=")[1]);
+            send.mockRestore();
+        });
         test("does not hash when there is no body", async () => {
             const setRequestHeader = jest.fn();
             const xhr = new global.window.XMLHttpRequest();
@@ -165,4 +274,50 @@ describe("patch-fetch", () => {
         });
     });
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"patch-fetch.test.js","sourceRoot":"","sources":["../../src/nextjs-build/patch-fetch.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport { createHash } from \"node:crypto\";\n\nfunction sha256(input: string | ArrayBuffer | Uint8Array) {\n  const buffer =\n    typeof input === \"string\"\n      ? Buffer.from(input)\n      : Buffer.from(new Uint8Array(input));\n  return createHash(\"sha256\").update(buffer).digest(\"hex\");\n}\n\ndescribe(\"patch-fetch\", () => {\n  let originalFetch: jest.Mock;\n  let capturedInit: RequestInit | undefined;\n\n  beforeEach(() => {\n    jest.resetModules();\n    capturedInit = undefined;\n\n    originalFetch = jest.fn((_input: unknown, init?: RequestInit) => {\n      capturedInit = init;\n      return Promise.resolve(new Response(\"ok\"));\n    });\n\n    (global as any).window = {\n      location: { href: \"https://example.com/\", hostname: \"example.com\" },\n      fetch: originalFetch,\n      XMLHttpRequest: class {\n        open(_method: string, _url: string) {}\n        send(_body?: unknown) {}\n        setRequestHeader(_name: string, _value: string) {}\n      },\n    };\n\n    // eslint-disable-next-line @typescript-eslint/no-require-imports -- must re-execute against the fresh `window` stub each test\n    require(\"./patch-fetch.js\");\n  });\n\n  afterEach(() => {\n    delete (global as any).window;\n  });\n\n  describe(\"fetch\", () => {\n    test(\"hashes URLSearchParams via toString(), not JSON.stringify\", async () => {\n      const params = new URLSearchParams({ a: \"1\", b: \"2\" });\n\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"POST\",\n        body: params,\n      });\n\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(\n        sha256(params.toString()),\n      );\n      expect(headers.get(\"x-amz-content-sha256\")).not.toBe(sha256(\"{}\"));\n    });\n\n    test(\"hashes a plain string body\", async () => {\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"POST\",\n        body: \"raw text body\",\n      });\n\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(sha256(\"raw text body\"));\n    });\n\n    test(\"hashes a FormData body over its exact encoded bytes and sets content-type\", async () => {\n      const formData = new FormData();\n      formData.append(\"field\", \"value\");\n      formData.append(\n        \"file\",\n        new Blob([\"file contents\"], { type: \"text/plain\" }),\n        \"file.txt\",\n      );\n\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"POST\",\n        body: formData,\n      });\n\n      // the body sent to the real fetch must be the re-encoded bytes, not the original FormData\n      const sentBytes = capturedInit!.body as Uint8Array;\n      expect(sentBytes).toBeInstanceOf(Uint8Array);\n\n      const headers = capturedInit!.headers as Headers;\n      const contentType = headers.get(\"content-type\")!;\n      expect(contentType).toMatch(/^multipart\\/form-data; boundary=/);\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(sha256(sentBytes));\n\n      // the hashed/sent bytes must round-trip back to the original fields\n      const roundTripped = await new Response(sentBytes, {\n        headers: { \"content-type\": contentType },\n      }).formData();\n      expect(roundTripped.get(\"field\")).toBe(\"value\");\n      const file = roundTripped.get(\"file\") as File;\n      expect(file.name).toBe(\"file.txt\");\n      expect(await file.text()).toBe(\"file contents\");\n    });\n\n    test(\"hashes a Blob body over its raw bytes\", async () => {\n      const blob = new Blob([\"blob contents\"], { type: \"text/plain\" });\n\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"POST\",\n        body: blob,\n      });\n\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(\n        sha256(await blob.arrayBuffer()),\n      );\n    });\n\n    test(\"hashes an ArrayBuffer body over its raw bytes\", async () => {\n      const buffer = new TextEncoder().encode(\"array buffer contents\").buffer;\n\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"PUT\",\n        body: buffer,\n      });\n\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(sha256(buffer));\n    });\n\n    test(\"hashes an empty byte array when no body is present\", async () => {\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"POST\",\n      });\n\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(\n        sha256(new Uint8Array(0)),\n      );\n    });\n\n    test(\"passes through untouched when init is omitted\", async () => {\n      await (global as any).window.fetch(\"https://example.com/api\");\n\n      expect(originalFetch).toHaveBeenCalledWith(\n        \"https://example.com/api\",\n        undefined,\n      );\n    });\n\n    test(\"passes through without hashing for non-PUT/POST methods\", async () => {\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"GET\",\n        body: \"should not be hashed\",\n      });\n\n      expect(capturedInit!.headers).toBeUndefined();\n    });\n\n    test(\"passes through without hashing for cross-origin requests\", async () => {\n      await (global as any).window.fetch(\"https://other-origin.com/api\", {\n        method: \"POST\",\n        body: \"should not be hashed\",\n      });\n\n      expect(capturedInit!.headers).toBeUndefined();\n    });\n  });\n\n  describe(\"XMLHttpRequest\", () => {\n    test(\"hashes URLSearchParams via toString(), not JSON.stringify\", async () => {\n      const params = new URLSearchParams({ a: \"1\", b: \"2\" });\n      const setRequestHeader = jest.fn();\n\n      const xhr = new (global as any).window.XMLHttpRequest();\n      xhr.setRequestHeader = setRequestHeader;\n      xhr.open(\"POST\", \"https://example.com/api\");\n      await xhr.send(params);\n\n      expect(setRequestHeader).toHaveBeenCalledWith(\n        \"x-amz-content-sha256\",\n        sha256(params.toString()),\n      );\n      expect(setRequestHeader).not.toHaveBeenCalledWith(\n        \"x-amz-content-sha256\",\n        sha256(\"{}\"),\n      );\n    });\n\n    test(\"hashes a plain string body\", async () => {\n      const setRequestHeader = jest.fn();\n\n      const xhr = new (global as any).window.XMLHttpRequest();\n      xhr.setRequestHeader = setRequestHeader;\n      xhr.open(\"PUT\", \"https://example.com/api\");\n      await xhr.send(\"raw text body\");\n\n      expect(setRequestHeader).toHaveBeenCalledWith(\n        \"x-amz-content-sha256\",\n        sha256(\"raw text body\"),\n      );\n    });\n\n    test(\"does not hash for non-PUT/POST methods\", async () => {\n      const setRequestHeader = jest.fn();\n\n      const xhr = new (global as any).window.XMLHttpRequest();\n      xhr.setRequestHeader = setRequestHeader;\n      xhr.open(\"GET\", \"https://example.com/api\");\n      await xhr.send(\"should not be hashed\");\n\n      expect(setRequestHeader).not.toHaveBeenCalled();\n    });\n\n    test(\"does not hash for cross-origin requests\", async () => {\n      const setRequestHeader = jest.fn();\n\n      const xhr = new (global as any).window.XMLHttpRequest();\n      xhr.setRequestHeader = setRequestHeader;\n      xhr.open(\"POST\", \"https://other-origin.com/api\");\n      await xhr.send(\"should not be hashed\");\n\n      expect(setRequestHeader).not.toHaveBeenCalled();\n    });\n\n    test(\"does not hash when there is no body\", async () => {\n      const setRequestHeader = jest.fn();\n\n      const xhr = new (global as any).window.XMLHttpRequest();\n      xhr.setRequestHeader = setRequestHeader;\n      xhr.open(\"POST\", \"https://example.com/api\");\n      await xhr.send();\n\n      expect(setRequestHeader).not.toHaveBeenCalled();\n    });\n  });\n});\n"]}
+/**
+ * Turbopack's web-worker bootstrap is `static/chunks/turbopack-worker-*.js`,
+ * which `patchFetchInClientJs`'s `turbopack-` selector matches — so this file is
+ * prepended to a script that runs off the main thread. Reading `window` there
+ * threw before the worker's own module could run, which took out every
+ * `new Worker(new URL(…))` app (`worker-module-url`, `worker-relay-compiler`).
+ */
+describe("patch-fetch in a worker scope", () => {
+    let originalFetch;
+    let capturedInit;
+    const realFetch = global.fetch;
+    beforeEach(() => {
+        jest.resetModules();
+        capturedInit = undefined;
+        originalFetch = jest.fn((_input, init) => {
+            capturedInit = init;
+            return Promise.resolve(new Response("ok"));
+        });
+        global.fetch = originalFetch;
+        // No `window`, and no `XMLHttpRequest`: the narrowest scope the patch can
+        // land in.
+        installScope({ withWindow: false, withXhr: false });
+    });
+    afterEach(() => {
+        delete global.window;
+        delete global.location;
+        global.fetch = realFetch;
+    });
+    test("loads without a window and still signs a same-origin POST", async () => {
+        expect(() => {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports -- the point of the test is that requiring it does not throw
+            require("./patch-fetch.js");
+        }).not.toThrow();
+        await global.fetch("https://example.com/api", {
+            method: "POST",
+            body: "worker body",
+        });
+        const headers = capturedInit.headers;
+        expect(headers.get("x-amz-content-sha256")).toBe(sha256("worker body"));
+    });
+    test("leaves XMLHttpRequest alone when the scope has none", () => {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports -- re-executed against this scope
+        require("./patch-fetch.js");
+        expect(global.XMLHttpRequest).toBeUndefined();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"patch-fetch.test.js","sourceRoot":"","sources":["../../src/nextjs-build/patch-fetch.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport { createHash } from \"node:crypto\";\n\nfunction sha256(input: string | ArrayBuffer | Uint8Array) {\n  const buffer =\n    typeof input === \"string\"\n      ? Buffer.from(input)\n      : Buffer.from(new Uint8Array(input));\n  return createHash(\"sha256\").update(buffer).digest(\"hex\");\n}\n\nclass FakeXMLHttpRequest {\n  open(_method: string, _url: string) {}\n  send(_body?: unknown) {}\n  setRequestHeader(_name: string, _value: string) {}\n}\n\n/**\n * The patch runs in a browser *and* in a web worker, where `window` does not\n * exist — so the stub goes on `globalThis`, which is what both scopes are. Tests\n * that want the main-thread scope also set `globalThis.window`, since real\n * browser code reaches the patched `fetch` through it and `window === globalThis`\n * there.\n */\nfunction installScope({ withWindow = true, withXhr = true } = {}) {\n  (global as any).location = {\n    href: \"https://example.com/\",\n    hostname: \"example.com\",\n  };\n  if (withXhr) (global as any).XMLHttpRequest = FakeXMLHttpRequest;\n  if (withWindow) (global as any).window = global;\n}\n\ndescribe(\"patch-fetch\", () => {\n  let originalFetch: jest.Mock;\n  let capturedInit: RequestInit | undefined;\n  const realFetch = global.fetch;\n\n  beforeEach(() => {\n    jest.resetModules();\n    capturedInit = undefined;\n\n    originalFetch = jest.fn((_input: unknown, init?: RequestInit) => {\n      capturedInit = init;\n      return Promise.resolve(new Response(\"ok\"));\n    });\n    (global as any).fetch = originalFetch;\n\n    installScope();\n\n    // eslint-disable-next-line @typescript-eslint/no-require-imports -- must re-execute against the fresh global stub each test\n    require(\"./patch-fetch.js\");\n  });\n\n  afterEach(() => {\n    delete (global as any).window;\n    delete (global as any).location;\n    delete (global as any).XMLHttpRequest;\n    global.fetch = realFetch;\n  });\n\n  describe(\"fetch\", () => {\n    test(\"hashes URLSearchParams via toString(), not JSON.stringify\", async () => {\n      const params = new URLSearchParams({ a: \"1\", b: \"2\" });\n\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"POST\",\n        body: params,\n      });\n\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(\n        sha256(params.toString()),\n      );\n      expect(headers.get(\"x-amz-content-sha256\")).not.toBe(sha256(\"{}\"));\n    });\n\n    test(\"hashes a plain string body\", async () => {\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"POST\",\n        body: \"raw text body\",\n      });\n\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(sha256(\"raw text body\"));\n    });\n\n    test(\"hashes a FormData body over its exact encoded bytes and sets content-type\", async () => {\n      const formData = new FormData();\n      formData.append(\"field\", \"value\");\n      formData.append(\n        \"file\",\n        new Blob([\"file contents\"], { type: \"text/plain\" }),\n        \"file.txt\",\n      );\n\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"POST\",\n        body: formData,\n      });\n\n      // the body sent to the real fetch must be the re-encoded bytes, not the original FormData\n      const sentBytes = capturedInit!.body as Uint8Array;\n      expect(sentBytes).toBeInstanceOf(Uint8Array);\n\n      const headers = capturedInit!.headers as Headers;\n      const contentType = headers.get(\"content-type\")!;\n      expect(contentType).toMatch(/^multipart\\/form-data; boundary=/);\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(sha256(sentBytes));\n\n      // the hashed/sent bytes must round-trip back to the original fields\n      const roundTripped = await new Response(sentBytes, {\n        headers: { \"content-type\": contentType },\n      }).formData();\n      expect(roundTripped.get(\"field\")).toBe(\"value\");\n      const file = roundTripped.get(\"file\") as File;\n      expect(file.name).toBe(\"file.txt\");\n      expect(await file.text()).toBe(\"file contents\");\n    });\n\n    test(\"hashes a Blob body over its raw bytes\", async () => {\n      const blob = new Blob([\"blob contents\"], { type: \"text/plain\" });\n\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"POST\",\n        body: blob,\n      });\n\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(\n        sha256(await blob.arrayBuffer()),\n      );\n    });\n\n    test(\"hashes an ArrayBuffer body over its raw bytes\", async () => {\n      const buffer = new TextEncoder().encode(\"array buffer contents\").buffer;\n\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"PUT\",\n        body: buffer,\n      });\n\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(sha256(buffer));\n    });\n\n    test(\"hashes a typed array body over the bytes it views\", async () => {\n      const bytes = new TextEncoder().encode(\"xxtyped array contents\");\n      const view = bytes.subarray(2);\n\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"POST\",\n        body: view,\n      });\n\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(\n        sha256(\"typed array contents\"),\n      );\n    });\n\n    test(\"wraps fetch once when a second patched chunk loads in the same scope\", async () => {\n      // Every entrypoint chunk carries a copy. Wrapped twice, the outer wrapper\n      // re-encoded a FormData body to bytes and the inner one overwrote the\n      // right hash with one of those bytes as JSON.\n      const patchedOnce = (global as any).fetch;\n      const patchedXhr = (global as any).XMLHttpRequest;\n      jest.resetModules();\n      // eslint-disable-next-line @typescript-eslint/no-require-imports -- the second chunk's copy\n      require(\"./patch-fetch.js\");\n      expect((global as any).fetch).toBe(patchedOnce);\n      expect((global as any).XMLHttpRequest).toBe(patchedXhr);\n\n      const formData = new FormData();\n      formData.append(\"field\", \"value\");\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"POST\",\n        body: formData,\n      });\n\n      expect(originalFetch).toHaveBeenCalledTimes(1);\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(\n        sha256(capturedInit!.body as Uint8Array),\n      );\n    });\n\n    test(\"hashes an empty byte array when no body is present\", async () => {\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"POST\",\n      });\n\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(\n        sha256(new Uint8Array(0)),\n      );\n    });\n\n    test(\"hashes a Request's own body when init is omitted\", async () => {\n      const request = new Request(\"https://example.com/api\", {\n        method: \"POST\",\n        body: \"request body\",\n        headers: { \"content-type\": \"text/plain\" },\n      });\n\n      await (global as any).window.fetch(request);\n\n      const [sentInput] = originalFetch.mock.calls[0];\n      expect(sentInput).toBe(request);\n      // The body was read from a clone, so the request still has it to send.\n      expect(await (sentInput as Request).text()).toBe(\"request body\");\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(sha256(\"request body\"));\n      // `init.headers` replaces the request's own, so they must carry over.\n      expect(headers.get(\"content-type\")).toBe(\"text/plain\");\n    });\n\n    test(\"hashes init's body over a Request's own when both are set\", async () => {\n      const request = new Request(\"https://example.com/api\", {\n        method: \"POST\",\n        body: \"request body\",\n      });\n\n      await (global as any).window.fetch(request, { body: \"init body\" });\n\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(sha256(\"init body\"));\n    });\n\n    test(\"passes a GET Request through without hashing\", async () => {\n      const request = new Request(\"https://example.com/api\");\n\n      await (global as any).window.fetch(request);\n\n      expect(originalFetch).toHaveBeenCalledWith(request, undefined);\n    });\n\n    test(\"passes through untouched when init is omitted\", async () => {\n      await (global as any).window.fetch(\"https://example.com/api\");\n\n      expect(originalFetch).toHaveBeenCalledWith(\n        \"https://example.com/api\",\n        undefined,\n      );\n    });\n\n    test(\"passes through without hashing for non-PUT/POST methods\", async () => {\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"GET\",\n        body: \"should not be hashed\",\n      });\n\n      expect(capturedInit!.headers).toBeUndefined();\n    });\n\n    test(\"passes through without hashing for cross-origin requests\", async () => {\n      await (global as any).window.fetch(\"https://other-origin.com/api\", {\n        method: \"POST\",\n        body: \"should not be hashed\",\n      });\n\n      expect(capturedInit!.headers).toBeUndefined();\n    });\n  });\n\n  describe(\"XMLHttpRequest\", () => {\n    test(\"hashes URLSearchParams via toString(), not JSON.stringify\", async () => {\n      const params = new URLSearchParams({ a: \"1\", b: \"2\" });\n      const setRequestHeader = jest.fn();\n\n      const xhr = new (global as any).window.XMLHttpRequest();\n      xhr.setRequestHeader = setRequestHeader;\n      xhr.open(\"POST\", \"https://example.com/api\");\n      await xhr.send(params);\n\n      expect(setRequestHeader).toHaveBeenCalledWith(\n        \"x-amz-content-sha256\",\n        sha256(params.toString()),\n      );\n      expect(setRequestHeader).not.toHaveBeenCalledWith(\n        \"x-amz-content-sha256\",\n        sha256(\"{}\"),\n      );\n    });\n\n    test(\"hashes a plain string body\", async () => {\n      const setRequestHeader = jest.fn();\n\n      const xhr = new (global as any).window.XMLHttpRequest();\n      xhr.setRequestHeader = setRequestHeader;\n      xhr.open(\"PUT\", \"https://example.com/api\");\n      await xhr.send(\"raw text body\");\n\n      expect(setRequestHeader).toHaveBeenCalledWith(\n        \"x-amz-content-sha256\",\n        sha256(\"raw text body\"),\n      );\n    });\n\n    test(\"does not hash for non-PUT/POST methods\", async () => {\n      const setRequestHeader = jest.fn();\n\n      const xhr = new (global as any).window.XMLHttpRequest();\n      xhr.setRequestHeader = setRequestHeader;\n      xhr.open(\"GET\", \"https://example.com/api\");\n      await xhr.send(\"should not be hashed\");\n\n      expect(setRequestHeader).not.toHaveBeenCalled();\n    });\n\n    test(\"does not hash for cross-origin requests\", async () => {\n      const setRequestHeader = jest.fn();\n\n      const xhr = new (global as any).window.XMLHttpRequest();\n      xhr.setRequestHeader = setRequestHeader;\n      xhr.open(\"POST\", \"https://other-origin.com/api\");\n      await xhr.send(\"should not be hashed\");\n\n      expect(setRequestHeader).not.toHaveBeenCalled();\n    });\n\n    test(\"hashes the bytes of a typed-array or Blob body, not their JSON\", async () => {\n      const bytes = new Uint8Array([1, 2, 3, 250]);\n      for (const body of [bytes, new Blob([bytes])]) {\n        const setRequestHeader = jest.fn();\n        const xhr = new (global as any).window.XMLHttpRequest();\n        xhr.setRequestHeader = setRequestHeader;\n        xhr.open(\"POST\", \"https://example.com/api\");\n        await xhr.send(body);\n\n        expect(setRequestHeader).toHaveBeenCalledWith(\n          \"x-amz-content-sha256\",\n          sha256(bytes),\n        );\n      }\n    });\n\n    test(\"sends a FormData body as the encoding it hashed, with its boundary\", async () => {\n      const send = jest.spyOn(FakeXMLHttpRequest.prototype, \"send\");\n      const setRequestHeader = jest.fn();\n      const form = new FormData();\n      form.append(\"name\", \"value\");\n      form.append(\"file\", new Blob([\"file-bytes\"]), \"a.txt\");\n\n      const xhr = new (global as any).window.XMLHttpRequest();\n      xhr.setRequestHeader = setRequestHeader;\n      xhr.open(\"POST\", \"https://example.com/api\");\n      await xhr.send(form);\n\n      const sent = send.mock.calls[0][0] as Uint8Array;\n      expect(sent).toBeInstanceOf(Uint8Array);\n      expect(setRequestHeader).toHaveBeenCalledWith(\n        \"x-amz-content-sha256\",\n        sha256(sent),\n      );\n      const contentType = setRequestHeader.mock.calls.find(\n        ([name]) => name === \"content-type\",\n      )?.[1];\n      expect(contentType).toMatch(/^multipart\\/form-data; boundary=/);\n      expect(Buffer.from(sent).toString()).toContain(\n        contentType.split(\"boundary=\")[1],\n      );\n      send.mockRestore();\n    });\n\n    test(\"does not hash when there is no body\", async () => {\n      const setRequestHeader = jest.fn();\n\n      const xhr = new (global as any).window.XMLHttpRequest();\n      xhr.setRequestHeader = setRequestHeader;\n      xhr.open(\"POST\", \"https://example.com/api\");\n      await xhr.send();\n\n      expect(setRequestHeader).not.toHaveBeenCalled();\n    });\n  });\n});\n\n/**\n * Turbopack's web-worker bootstrap is `static/chunks/turbopack-worker-*.js`,\n * which `patchFetchInClientJs`'s `turbopack-` selector matches — so this file is\n * prepended to a script that runs off the main thread. Reading `window` there\n * threw before the worker's own module could run, which took out every\n * `new Worker(new URL(…))` app (`worker-module-url`, `worker-relay-compiler`).\n */\ndescribe(\"patch-fetch in a worker scope\", () => {\n  let originalFetch: jest.Mock;\n  let capturedInit: RequestInit | undefined;\n  const realFetch = global.fetch;\n\n  beforeEach(() => {\n    jest.resetModules();\n    capturedInit = undefined;\n    originalFetch = jest.fn((_input: unknown, init?: RequestInit) => {\n      capturedInit = init;\n      return Promise.resolve(new Response(\"ok\"));\n    });\n    (global as any).fetch = originalFetch;\n    // No `window`, and no `XMLHttpRequest`: the narrowest scope the patch can\n    // land in.\n    installScope({ withWindow: false, withXhr: false });\n  });\n\n  afterEach(() => {\n    delete (global as any).window;\n    delete (global as any).location;\n    global.fetch = realFetch;\n  });\n\n  test(\"loads without a window and still signs a same-origin POST\", async () => {\n    expect(() => {\n      // eslint-disable-next-line @typescript-eslint/no-require-imports -- the point of the test is that requiring it does not throw\n      require(\"./patch-fetch.js\");\n    }).not.toThrow();\n\n    await global.fetch(\"https://example.com/api\", {\n      method: \"POST\",\n      body: \"worker body\",\n    });\n\n    const headers = capturedInit!.headers as Headers;\n    expect(headers.get(\"x-amz-content-sha256\")).toBe(sha256(\"worker body\"));\n  });\n\n  test(\"leaves XMLHttpRequest alone when the scope has none\", () => {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports -- re-executed against this scope\n    require(\"./patch-fetch.js\");\n\n    expect((global as any).XMLHttpRequest).toBeUndefined();\n  });\n});\n"]}

package/lib/nextjs-build/regional-containers.Dockerfile

@@ -1,4 +1,7 @@
 # ~~ Generated by cdk-nextjs ~~
+# cdk-nextjs rewrites any Dockerfile carrying the line above, so that an
+# upgrade does not leave a stale one behind. To own this file yourself, delete
+# that line and cdk-nextjs will leave the rest of it alone.
 # Modified from: https://github.com/vercel/next.js/blob/canary/examples/with-docker/Dockerfile
 
 # Production image, copy all the files and run next
@@ -14,13 +17,17 @@ ENV NODE_ENV=production
 RUN addgroup --system --gid 1001 nodejs
 RUN adduser --system --uid 1001 nextjs
 
-ARG RELATIVE_PATH_TO_PACKAGE
-# Copy from local build output instead of builder image
-COPY --chown=nextjs:nodejs .next/standalone ./
-# static assets needed b/c we don't have cloudfront to serve them from s3
-COPY --chown=nextjs:nodejs .next/static ./$RELATIVE_PATH_TO_PACKAGE/.next/static
-# Copy public directory for image optimization (Next.js needs source images)
-COPY --chown=nextjs:nodejs public ./$RELATIVE_PATH_TO_PACKAGE/public
+ARG RELATIVE_PROJECT_DIR
+# The deployment root cdk-nextjs staged during `next build`: the traced assets of
+# every built output, keyed by repo-root-relative path, plus cdk-nextjs's own
+# request-handling server under cdk-nextjs-runtime/. Replaces `.next/standalone`.
+COPY --chown=nextjs:nodejs .next/cdk-nextjs-adapter/app ./
+# There is no CloudFront in front of this deployment type, so the server answers
+# every static request itself: the manifest lists `.next/static`, the runtime
+# lists `public` when it starts, and it serves both off disk. (Image optimization
+# reads its sources from here too, through the runtime's in-process routing.)
+COPY --chown=nextjs:nodejs .next/static ./$RELATIVE_PROJECT_DIR/.next/static
+COPY --chown=nextjs:nodejs public ./$RELATIVE_PROJECT_DIR/public
 
 USER nextjs
 
@@ -28,8 +35,8 @@ EXPOSE 3000
 
 ENV PORT=3000
 
-# server.js is created by next build from the standalone output
-# https://nextjs.org/docs/pages/api-reference/next-config-js/output
+# cdk-nextjs's own server, staged above. It invokes the entrypoints `next build`
+# produced in-process; there is no `next start` and no server.js.
 # CMD will be overwritten by ECS Task Definition
 ENV HOSTNAME="0.0.0.0"
-CMD ["node" "server.js"]
+CMD ["node", "cdk-nextjs-runtime/server.mjs"]

package/lib/nextjs-cache.d.ts

@@ -11,8 +11,12 @@ export interface NextjsCacheProps {
     readonly buildId: string;
     /**
      * Bring your own S3 bucket for cache storage. When provided, cdk-nextjs
-     * will skip creating a new bucket. Cache objects are prefixed with `buildId`
-     * so multiple deployments can safely share one bucket.
+     * will skip creating a new bucket.
+     *
+     * The bucket must be dedicated to this one deployment. Don't share it with
+     * another deployment (another branch, stage, or app): every deploy's
+     * post-deploy step deletes every object under a top-level prefix other than
+     * the current `buildId/`, which includes every other deployment's cache.
      */
     readonly cacheBucket?: IBucket;
     /**
@@ -24,8 +28,16 @@ export interface NextjsCacheProps {
     /**
      * Bring your own DynamoDB table for revalidation metadata. When provided,
      * cdk-nextjs will skip creating a new table. The table must have `pk` (String)
-     * as partition key and `sk` (String) as sort key. Entries are partitioned by
-     * `buildId` so multiple deployments can safely share one table.
+     * as partition key and `sk` (String) as sort key.
+     * Enabling TTL on its `ttl` attribute is recommended: each tag revalidation
+     * writes a revalidation log row that expires through it after 15 minutes.
+     * Without TTL those rows are kept until a deploy replaces their build, whose
+     * post-deploy step deletes them.
+     *
+     * The table must be dedicated to this one deployment. Don't share it with
+     * another deployment (another branch, stage, or app): every deploy's
+     * post-deploy step deletes the entries of the build it last recorded in the
+     * table, which with a shared table is another deployment's live build.
      */
     readonly revalidationTable?: ITableV2;
 }
@@ -46,10 +58,76 @@ export declare class NextjsCache extends Construct {
     /**
      * Creates DynamoDB table for revalidation metadata
      * Schema: pk (buildId or "METADATA"), sk (tag#cacheKey or "CURRENT_BUILD"), createdAt, revalidatedAt
+     *
+     * Also the `'use cache'` revalidation log (pk "<buildId>#log",
+     * sk "<epoch-ms>#<tag>"), whose rows expire through the `ttl` attribute.
      */
     private createRevalidationTable;
     /**
      * Deploy pre-built cache files from .next/cdk-nextjs-init-cache to S3
      */
     private createDeployment;
+    /**
+     * `/tmp` and memory for `BucketDeployment`'s unzip Lambda, scaled to the init
+     * cache it has to unpack.
+     *
+     * That Lambda downloads the asset zip into `/tmp` and then extracts it
+     * alongside, so it needs room for both at once. CDK defaults it to 512 MiB of
+     * ephemeral storage and 128 MB of memory — fine for a small app, and a hard
+     * failure for one whose prerendered payloads are large. A fixture with 60
+     * statically generated pages carrying ~1 MB of RSC each produced a 664 MiB
+     * seed directory and the handler died on
+     * `OSError: [Errno 28] No space left on device` inside `zip.extractall`.
+     * Worse, `cdk deploy --hotswap` invokes the custom resource directly with a
+     * placeholder response URL, so the `Status: FAILED` it sends goes nowhere: the
+     * CLI prints "Contents of AWS::S3::Bucket … hotswapped!", exits 0, and the app
+     * comes up serving a *partially* seeded cache. Every route whose entry did not
+     * make it is then a miss that re-renders — which, for a
+     * `cacheComponents: true` app, means a postponed shell where the prerender
+     * should have been.
+     *
+     * The zip's compressed size is not known at synth time (CDK archives the asset
+     * later), so the worst case — an incompressible payload — is what gets
+     * budgeted: twice the directory, plus headroom, rounded up to a
+     * {@link storageStep}. Memory is only raised past
+     * CDK's default for caches big enough that 128 MB's slice of a vCPU would make
+     * the unzip and upload race the custom resource's 15-minute timeout; small
+     * apps keep the cheaper default and their existing template.
+     *
+     * Above the 10 GiB ephemeral-storage ceiling there is nothing left to ask for,
+     * so this warns and lets the deployment fail loudly rather than pretend.
+     * `overrides.bucketDeploymentProps` wins over everything here, including
+     * `useEfs: true`, which is the supported way out.
+     */
+    private sizeDeploymentLambda;
+    /**
+     * Stage the init cache under a `buildId` directory, so that the objects land
+     * at `<buildId>/<key>` without a `destinationKeyPrefix`.
+     *
+     * The keys have to carry the build ID — that is how the runtime cache handler
+     * and the post-deploy pruner namespace one deployment's entries from the next
+     * (`src/adapter/s3-cache-handler.ts`). Asking `BucketDeployment` for it, as
+     * this used to, is what costs: it unconditionally tags the *destination
+     * bucket* with `aws-cdk:cr-owned:<destinationKeyPrefix>:<hash>`, so a prefix
+     * that changes per build makes the bucket's `Tags` change per build.
+     * `AWS::S3::Bucket` `Tags` are not hotswappable, so `cdk deploy
+     * --hotswap-fallback` rejected the diff and fell back to a full CloudFormation
+     * deployment every single time — measured at 19 of 22 deploys in one harness
+     * run, ~110s each against a ~52s hotswap.
+     *
+     * Putting the build ID in the asset's own paths instead leaves the S3 keys
+     * byte-identical and the tag key constant (`aws-cdk:cr-owned:<hash>`, derived
+     * from the construct path). Nothing else read the prefix: `prune` is already
+     * `false`, and the two handler branches that do scope work to it — emptying
+     * the prefix on delete, and deleting the old prefix when the destination
+     * changes — are both gated on `retainOnDelete`, which `BucketDeployment`
+     * defaults to `true`.
+     *
+     * A copy rather than the directory itself because the build ID is only known
+     * *after* `next build`, so the adapter cannot write into a nested directory in
+     * the first place, and because `.next/cdk-nextjs-init-cache` has to stay where
+     * it is for the local cache handler to read it (`CDK_NEXTJS_INIT_CACHE_DIR`).
+     * CDK is about to read every byte of this to zip it regardless.
+     */
+    private createStagingDirectory;
 }