cdk-nextjs 0.6.2 → 0.7.1

package/lib/runtime/image.test.js

@@ -0,0 +1,405 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+jest.mock("@aws-sdk/client-s3");
+// The real module, with the one step that needs `sharp` stubbed out: these tests
+// are about the response `handle` writes, not about optimizing an image.
+jest.mock("next/dist/server/image-optimizer.js", () => ({
+    ...jest.requireActual("next/dist/server/image-optimizer.js"),
+    imageOptimizer: jest.fn(),
+}));
+const node_fs_1 = require("node:fs");
+const node_http_1 = require("node:http");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_stream_1 = require("node:stream");
+const image_optimizer_js_1 = require("next/dist/server/image-optimizer.js");
+const image_config_js_1 = require("next/dist/shared/lib/image-config.js");
+const request_1 = require("./http/request");
+const response_1 = require("./http/response");
+const sink_1 = require("./http/sink");
+const image_1 = require("./image");
+const next_modules_1 = require("./next-modules");
+const PNG = Buffer.from("optimized-bytes");
+const ETAG = "abc123";
+/** Just what `loadImageRuntime` reads: where `required-server-files.json` is. */
+function stage(extraConfig = {}) {
+    const root = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "cdk-nextjs-image-"));
+    (0, node_fs_1.mkdirSync)((0, node_path_1.join)(root, ".next"));
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(root, ".next/required-server-files.json"), JSON.stringify({
+        config: {
+            basePath: "",
+            experimental: {},
+            images: { ...image_config_js_1.imageConfigDefault, localPatterns: undefined },
+            ...extraConfig,
+        },
+    }));
+    return root;
+}
+/** The app's `cacheHandler`, reduced to a map: what the S3 handler is to it. */
+class MapCacheHandler {
+    static entries = new Map();
+    static options;
+    constructor(options) {
+        MapCacheHandler.options = options;
+    }
+    async get(key) {
+        return MapCacheHandler.entries.get(key) ?? null;
+    }
+    async set(key, value) {
+        MapCacheHandler.entries.set(key, { value, lastModified: Date.now() });
+    }
+}
+let imported;
+const s3Hit = {
+    send: async () => ({
+        Body: [Buffer.from("upstream-bytes")],
+        ContentType: "image/png",
+        ETag: '"upstream"',
+    }),
+};
+/** An optimizer over {@link MapCacheHandler}, as the adapter configures one. */
+function optimizerFor(options = {}) {
+    const via = new image_1.RuntimeImageOptimizer({
+        deploymentRoot: stage({
+            cacheHandler: "../node_modules/cdk-nextjs/lib/adapter/cache-handler.mjs",
+            cacheMaxMemorySize: 0,
+            ...(options.images
+                ? {
+                    images: {
+                        ...image_config_js_1.imageConfigDefault,
+                        localPatterns: undefined,
+                        ...options.images,
+                    },
+                }
+                : {}),
+        }),
+        manifest: {
+            relativeProjectDir: "",
+            config: { distDir: ".next" },
+        },
+        bucket: options.bucket ?? "assets",
+        bucketKeyPrefix: "",
+        fetchInternal: options.fetchInternal ??
+            (async () => {
+                throw new Error("Unexpected fetchInternal");
+            }),
+        importModule: options.importModule ??
+            (async (url) => {
+                imported = url;
+                return { default: MapCacheHandler };
+            }),
+    });
+    via.s3 = options.s3 ?? s3Hit;
+    return via;
+}
+let optimizer;
+beforeAll(() => {
+    (0, next_modules_1.useNextFrom)((0, node_path_1.join)(__dirname, "../.."));
+    optimizer = optimizerFor();
+});
+beforeEach(() => {
+    MapCacheHandler.entries.clear();
+    imported = undefined;
+    image_optimizer_js_1.imageOptimizer.mockClear();
+    image_optimizer_js_1.imageOptimizer.mockResolvedValue({
+        buffer: PNG,
+        contentType: "image/webp",
+        maxAge: 60,
+        etag: ETAG,
+    });
+});
+async function request(src, init = {}) {
+    const url = new URL(`https://shop.example.test/_next/image?url=${encodeURIComponent(src)}&w=640&q=75`);
+    const req = new request_1.ShimIncomingMessage({
+        method: init.method ?? "GET",
+        url: `${url.pathname}${url.search}`,
+        headers: { accept: "image/webp", ...init.headers },
+    });
+    const res = new response_1.ShimServerResponse();
+    let head;
+    const chunks = [];
+    const done = (0, sink_1.pipeToSink)(req, res, {
+        begin(responseHead) {
+            head = responseHead;
+            return new node_stream_1.Writable({
+                write(chunk, _encoding, callback) {
+                    chunks.push(Buffer.from(chunk));
+                    callback();
+                },
+            });
+        },
+    }, { compress: false });
+    const pending = [];
+    await (init.via ?? optimizer).handle(req, res, url, init.waitUntil ?? ((promise) => pending.push(promise)));
+    await done;
+    // Settled, not awaited: the runtime logs a rejection rather than failing on it.
+    await Promise.allSettled(pending);
+    return { head: head, body: Buffer.concat(chunks).toString() };
+}
+describe("RuntimeImageOptimizer.isEnabled", () => {
+    const withImages = (images) => optimizerFor({ images });
+    // Where `next start` answers 404 rather than optimize.
+    it("is off for images.unoptimized and for a non-default loader", () => {
+        expect(withImages({}).isEnabled()).toBe(true);
+        expect(withImages({ unoptimized: true }).isEnabled()).toBe(false);
+        expect(withImages({ loader: "custom", loaderFile: "./loader.js" }).isEnabled()).toBe(false);
+    });
+});
+describe("RuntimeImageOptimizer response", () => {
+    it("answers with the headers next start sends", async () => {
+        const { head, body } = await request("/photos/logo.png");
+        expect(head.statusCode).toBe(200);
+        expect(head.headers).toMatchObject({
+            "cache-control": "public, max-age=60, must-revalidate",
+            "content-type": "image/webp",
+            "content-length": String(PNG.length),
+            "content-disposition": 'attachment; filename="logo.webp"',
+            "content-security-policy": image_config_js_1.imageConfigDefault.contentSecurityPolicy,
+            etag: ETAG,
+            vary: "Accept",
+            "x-nextjs-cache": "MISS",
+        });
+        expect(body).toBe(PNG.toString());
+    });
+    // Content-hashed, so the name changes whenever the bytes do.
+    it("caches a statically imported image for a year, immutable", async () => {
+        const { head } = await request("/_next/static/media/logo.3f2a1c.png");
+        expect(head.headers["cache-control"]).toBe("public, max-age=315360000, immutable");
+    });
+    // `writeHead` rejects a header value outside latin1 with ERR_INVALID_CHAR,
+    // and the Lambda sink writes the head through it.
+    it("encodes a non-latin1 filename rather than sending it raw", async () => {
+        const { head } = await request("/ümlaut-写真.png");
+        const disposition = head.headers["content-disposition"];
+        expect(disposition).toMatch(/^attachment; filename="[^"]*"; filename\*=/);
+        expect(disposition).toContain(`filename*=UTF-8''${encodeURIComponent("ümlaut-写真.webp")}`);
+        expect(() => (0, node_http_1.validateHeaderValue)("Content-Disposition", disposition)).not.toThrow();
+    });
+    it.each([
+        ["the exact tag", ETAG],
+        ["a weak form of it", `W/${ETAG}`],
+        ["a list containing it", `"other", ${ETAG}`],
+        ["a wildcard", "*"],
+    ])("answers 304 to If-None-Match with %s", async (_name, ifNoneMatch) => {
+        const { head, body } = await request("/logo.png", {
+            headers: { "if-none-match": ifNoneMatch },
+        });
+        expect(head.statusCode).toBe(304);
+        expect(head.headers.etag).toBe(ETAG);
+        expect(head.headers["cache-control"]).toBe("public, max-age=60, must-revalidate");
+        expect(body).toBe("");
+    });
+    it("answers 200 to an If-None-Match that does not match", async () => {
+        const { head } = await request("/logo.png", {
+            headers: { "if-none-match": '"other"' },
+        });
+        expect(head.statusCode).toBe(200);
+    });
+    it("sends the headers but no body to HEAD", async () => {
+        const { head, body } = await request("/logo.png", { method: "HEAD" });
+        expect(head.statusCode).toBe(200);
+        expect(head.headers["content-length"]).toBe(String(PNG.length));
+        expect(body).toBe("");
+    });
+});
+describe("RuntimeImageOptimizer sources", () => {
+    // `next start` fetches a remote source only when `remotePatterns` or `domains`
+    // allow it; the stage's config allows none. Anything else would make the
+    // optimizer an open proxy into whatever it can reach.
+    it.each([
+        ["another origin", "https://evil.example.test/x.png"],
+        ["instance metadata", "http://169.254.169.254/latest/meta-data/"],
+        ["a protocol-relative url", "//evil.example.test/x.png"],
+    ])("rejects a remote source that is not allowed: %s", async (_name, src) => {
+        const { head, body } = await request(src);
+        expect(head.statusCode).toBe(400);
+        expect(body).toMatch(/"url" parameter/);
+        expect(image_optimizer_js_1.imageOptimizer).not.toHaveBeenCalled();
+    });
+    function withS3Miss(fetchInternal) {
+        return optimizerFor({
+            fetchInternal,
+            s3: {
+                send: async () => {
+                    throw Object.assign(new Error("missing"), { name: "NoSuchKey" });
+                },
+            },
+        });
+    }
+    it("falls back to the app's routes for a source S3 has no file for", async () => {
+        const fetchInternal = jest.fn(async () => ({
+            statusCode: 200,
+            headers: {
+                "content-type": "image/png",
+                "cache-control": "public, max-age=120",
+            },
+            body: Buffer.from("route-bytes"),
+        }));
+        const { head } = await request("/api/avatar?id=42", {
+            via: withS3Miss(fetchInternal),
+        });
+        expect(head.statusCode).toBe(200);
+        expect(fetchInternal).toHaveBeenCalledWith("/api/avatar?id=42", expect.anything(), image_config_js_1.imageConfigDefault.maximumResponseBody);
+        expect(image_optimizer_js_1.imageOptimizer.mock.lastCall[0]).toMatchObject({
+            buffer: Buffer.from("route-bytes"),
+            contentType: "image/png",
+            cacheControl: "public, max-age=120",
+        });
+    });
+    // `NextjsRegionalContainers`: the file is on disk, and a GetObject for it is
+    // a wasted round trip.
+    it("goes straight to the app's routes when there is no bucket", async () => {
+        const send = jest.fn();
+        const fetchInternal = jest.fn(async () => ({
+            statusCode: 200,
+            headers: { "content-type": "image/png" },
+            body: Buffer.from("disk-bytes"),
+        }));
+        const { head } = await request("/logo.png", {
+            via: optimizerFor({
+                bucket: "",
+                fetchInternal,
+                s3: { send },
+            }),
+        });
+        expect(head.statusCode).toBe(200);
+        expect(send).not.toHaveBeenCalled();
+        expect(fetchInternal).toHaveBeenCalledWith("/logo.png", expect.anything(), image_config_js_1.imageConfigDefault.maximumResponseBody);
+    });
+    it("answers 400 when the route sends no body", async () => {
+        const { head } = await request("/api/avatar?id=42", {
+            via: withS3Miss(async () => ({
+                statusCode: 404,
+                headers: {},
+                body: Buffer.alloc(0),
+            })),
+        });
+        expect(head.statusCode).toBe(400);
+    });
+    it("answers an explicit 502 for a source served by another functionGroups group", async () => {
+        const error = jest.spyOn(console, "error").mockImplementation(() => { });
+        try {
+            const { head, body } = await request("/api/avatar?id=42", {
+                via: withS3Miss(async () => ({
+                    statusCode: 0,
+                    headers: {},
+                    body: Buffer.alloc(0),
+                    otherGroup: "avatars",
+                })),
+            });
+            expect(head.statusCode).toBe(502);
+            expect(body).toMatch(/another functionGroups group/);
+            expect(image_optimizer_js_1.imageOptimizer).not.toHaveBeenCalled();
+        }
+        finally {
+            error.mockRestore();
+        }
+    });
+    // `images.maximumResponseBody`, which `next start` enforces on local
+    // sources too: past it, the source is not read into memory.
+    it("answers 413 for a route response over maximumResponseBody", async () => {
+        const { head } = await request("/api/export", {
+            via: withS3Miss(async () => ({
+                statusCode: 0,
+                headers: {},
+                body: Buffer.alloc(0),
+                tooLarge: true,
+            })),
+        });
+        expect(head.statusCode).toBe(413);
+        expect(image_optimizer_js_1.imageOptimizer).not.toHaveBeenCalled();
+    });
+    it("answers 413 for an S3 object over maximumResponseBody", async () => {
+        const { head } = await request("/video.mp4", {
+            via: optimizerFor({
+                images: { maximumResponseBody: 10 },
+                s3: {
+                    send: async () => ({
+                        Body: [Buffer.from("never read")],
+                        ContentLength: 11,
+                    }),
+                },
+            }),
+        });
+        expect(head.statusCode).toBe(413);
+        expect(image_optimizer_js_1.imageOptimizer).not.toHaveBeenCalled();
+    });
+});
+describe("RuntimeImageOptimizer cache", () => {
+    it("optimizes once, then answers from the cache handler", async () => {
+        const via = optimizerFor();
+        const first = await request("/photos/cached.png", { via });
+        expect(first.head.headers["x-nextjs-cache"]).toBe("MISS");
+        expect(first.body).toBe(PNG.toString());
+        const second = await request("/photos/cached.png", { via });
+        expect(second.head.statusCode).toBe(200);
+        expect(second.head.headers["x-nextjs-cache"]).toBe("HIT");
+        expect(second.body).toBe(PNG.toString());
+        expect(second.head.headers.etag).toBe(ETAG);
+        expect(image_optimizer_js_1.imageOptimizer).toHaveBeenCalledTimes(1);
+        // The entry `next start` would have written.
+        const [entry] = [...MapCacheHandler.entries.values()];
+        expect(entry.value).toMatchObject({ kind: "IMAGE", extension: "webp" });
+    });
+    // Another instance: nothing in memory, so the hit is the cache handler's.
+    it("shares the optimized image across instances", async () => {
+        await request("/photos/shared.png", { via: optimizerFor() });
+        const other = await request("/photos/shared.png", { via: optimizerFor() });
+        expect(other.head.headers["x-nextjs-cache"]).toBe("HIT");
+        expect(image_optimizer_js_1.imageOptimizer).toHaveBeenCalledTimes(1);
+    });
+    // `required-server-files.json` names it relative to the dist dir.
+    it("loads the app's cacheHandler from where next start would", async () => {
+        await request("/photos/cached.png", { via: optimizerFor() });
+        expect(imported).toMatch(/^file:\/\/.*\/node_modules\/cdk-nextjs\/lib\/adapter\/cache-handler\.mjs$/);
+        expect(MapCacheHandler.options).toMatchObject({ dev: false });
+    });
+    // A transient failure loading the cacheHandler (EMFILE in a cold-start
+    // burst) must not fail every later image request on the instance.
+    it("retries loading the cacheHandler after a failed load", async () => {
+        const error = jest.spyOn(console, "error").mockImplementation(() => { });
+        try {
+            const importModule = jest
+                .fn()
+                .mockRejectedValueOnce(new Error("EMFILE"))
+                .mockResolvedValue({ default: MapCacheHandler });
+            const via = optimizerFor({ importModule });
+            expect((await request("/photos/retry.png", { via })).head.statusCode).toBe(500);
+            expect((await request("/photos/retry.png", { via })).head.statusCode).toBe(200);
+            expect(importModule).toHaveBeenCalledTimes(2);
+        }
+        finally {
+            error.mockRestore();
+        }
+    });
+    // The write of a fresh image goes to `waitUntil`, not in front of the
+    // response: the image is sent before the cache handler has it.
+    it("writes a miss to the cache after answering, through waitUntil", async () => {
+        // A write that can't finish until released: if the response waited on it,
+        // `request` would never return.
+        let release;
+        const gate = new Promise((resolve) => (release = resolve));
+        const set = MapCacheHandler.prototype.set;
+        MapCacheHandler.prototype.set = async function (key, value) {
+            await gate;
+            return set.call(this, key, value);
+        };
+        try {
+            const pending = [];
+            const first = await request("/photos/deferred.png", {
+                via: optimizerFor(),
+                waitUntil: (promise) => pending.push(promise),
+            });
+            expect(first.head.headers["x-nextjs-cache"]).toBe("MISS");
+            expect(MapCacheHandler.entries.size).toBe(0);
+            release();
+            await Promise.all(pending);
+            expect(MapCacheHandler.entries.size).toBe(1);
+        }
+        finally {
+            MapCacheHandler.prototype.set = set;
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image.test.js","sourceRoot":"","sources":["../../src/runtime/image.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\njest.mock(\"@aws-sdk/client-s3\");\n// The real module, with the one step that needs `sharp` stubbed out: these tests\n// are about the response `handle` writes, not about optimizing an image.\njest.mock(\"next/dist/server/image-optimizer.js\", () => ({\n  ...jest.requireActual(\"next/dist/server/image-optimizer.js\"),\n  imageOptimizer: jest.fn(),\n}));\n\nimport { mkdirSync, mkdtempSync, writeFileSync } from \"node:fs\";\nimport { validateHeaderValue } from \"node:http\";\nimport { tmpdir } from \"node:os\";\nimport { join } from \"node:path\";\nimport { Writable } from \"node:stream\";\nimport { S3Client } from \"@aws-sdk/client-s3\";\nimport { imageOptimizer } from \"next/dist/server/image-optimizer.js\";\nimport { imageConfigDefault } from \"next/dist/shared/lib/image-config.js\";\nimport { ShimIncomingMessage } from \"./http/request\";\nimport { ResponseHead, ShimServerResponse } from \"./http/response\";\nimport { pipeToSink } from \"./http/sink\";\nimport { ImageOptimizerOptions, RuntimeImageOptimizer } from \"./image\";\nimport { AdapterManifest } from \"./manifest\";\nimport { useNextFrom } from \"./next-modules\";\n\nconst PNG = Buffer.from(\"optimized-bytes\");\nconst ETAG = \"abc123\";\n\n/** Just what `loadImageRuntime` reads: where `required-server-files.json` is. */\nfunction stage(extraConfig: Record<string, unknown> = {}): string {\n  const root = mkdtempSync(join(tmpdir(), \"cdk-nextjs-image-\"));\n  mkdirSync(join(root, \".next\"));\n  writeFileSync(\n    join(root, \".next/required-server-files.json\"),\n    JSON.stringify({\n      config: {\n        basePath: \"\",\n        experimental: {},\n        images: { ...imageConfigDefault, localPatterns: undefined },\n        ...extraConfig,\n      },\n    }),\n  );\n  return root;\n}\n\n/** The app's `cacheHandler`, reduced to a map: what the S3 handler is to it. */\nclass MapCacheHandler {\n  public static readonly entries = new Map<string, unknown>();\n  public static options: Record<string, unknown> | undefined;\n  public constructor(options: Record<string, unknown>) {\n    MapCacheHandler.options = options;\n  }\n  public async get(key: string) {\n    return MapCacheHandler.entries.get(key) ?? null;\n  }\n  public async set(key: string, value: unknown) {\n    MapCacheHandler.entries.set(key, { value, lastModified: Date.now() });\n  }\n}\n\nlet imported: string | undefined;\n\nconst s3Hit = {\n  send: async () => ({\n    Body: [Buffer.from(\"upstream-bytes\")],\n    ContentType: \"image/png\",\n    ETag: '\"upstream\"',\n  }),\n} as unknown as S3Client;\n\n/** An optimizer over {@link MapCacheHandler}, as the adapter configures one. */\nfunction optimizerFor(\n  options: {\n    images?: Record<string, unknown>;\n    fetchInternal?: ImageOptimizerOptions[\"fetchInternal\"];\n    importModule?: ImageOptimizerOptions[\"importModule\"];\n    s3?: S3Client;\n    bucket?: string;\n  } = {},\n): RuntimeImageOptimizer {\n  const via = new RuntimeImageOptimizer({\n    deploymentRoot: stage({\n      cacheHandler: \"../node_modules/cdk-nextjs/lib/adapter/cache-handler.mjs\",\n      cacheMaxMemorySize: 0,\n      ...(options.images\n        ? {\n            images: {\n              ...imageConfigDefault,\n              localPatterns: undefined,\n              ...options.images,\n            },\n          }\n        : {}),\n    }),\n    manifest: {\n      relativeProjectDir: \"\",\n      config: { distDir: \".next\" },\n    } as unknown as AdapterManifest,\n    bucket: options.bucket ?? \"assets\",\n    bucketKeyPrefix: \"\",\n    fetchInternal:\n      options.fetchInternal ??\n      (async () => {\n        throw new Error(\"Unexpected fetchInternal\");\n      }),\n    importModule:\n      options.importModule ??\n      (async (url) => {\n        imported = url;\n        return { default: MapCacheHandler };\n      }),\n  });\n  (via as unknown as { s3: S3Client }).s3 = options.s3 ?? s3Hit;\n  return via;\n}\n\nlet optimizer: RuntimeImageOptimizer;\n\nbeforeAll(() => {\n  useNextFrom(join(__dirname, \"../..\"));\n  optimizer = optimizerFor();\n});\n\nbeforeEach(() => {\n  MapCacheHandler.entries.clear();\n  imported = undefined;\n  (imageOptimizer as jest.Mock).mockClear();\n  (imageOptimizer as jest.Mock).mockResolvedValue({\n    buffer: PNG,\n    contentType: \"image/webp\",\n    maxAge: 60,\n    etag: ETAG,\n  });\n});\n\ninterface Answer {\n  readonly head: ResponseHead;\n  readonly body: string;\n}\n\nasync function request(\n  src: string,\n  init: {\n    method?: string;\n    headers?: Record<string, string>;\n    via?: RuntimeImageOptimizer;\n    waitUntil?: (promise: Promise<unknown>) => void;\n  } = {},\n): Promise<Answer> {\n  const url = new URL(\n    `https://shop.example.test/_next/image?url=${encodeURIComponent(src)}&w=640&q=75`,\n  );\n  const req = new ShimIncomingMessage({\n    method: init.method ?? \"GET\",\n    url: `${url.pathname}${url.search}`,\n    headers: { accept: \"image/webp\", ...init.headers },\n  });\n  const res = new ShimServerResponse();\n  let head: ResponseHead | undefined;\n  const chunks: Buffer[] = [];\n  const done = pipeToSink(\n    req,\n    res,\n    {\n      begin(responseHead) {\n        head = responseHead;\n        return new Writable({\n          write(chunk, _encoding, callback) {\n            chunks.push(Buffer.from(chunk));\n            callback();\n          },\n        });\n      },\n    },\n    { compress: false },\n  );\n  const pending: Array<Promise<unknown>> = [];\n  await (init.via ?? optimizer).handle(\n    req,\n    res,\n    url,\n    init.waitUntil ?? ((promise) => pending.push(promise)),\n  );\n  await done;\n  // Settled, not awaited: the runtime logs a rejection rather than failing on it.\n  await Promise.allSettled(pending);\n  return { head: head!, body: Buffer.concat(chunks).toString() };\n}\n\ndescribe(\"RuntimeImageOptimizer.isEnabled\", () => {\n  const withImages = (images: Record<string, unknown>) =>\n    optimizerFor({ images });\n\n  // Where `next start` answers 404 rather than optimize.\n  it(\"is off for images.unoptimized and for a non-default loader\", () => {\n    expect(withImages({}).isEnabled()).toBe(true);\n    expect(withImages({ unoptimized: true }).isEnabled()).toBe(false);\n    expect(\n      withImages({ loader: \"custom\", loaderFile: \"./loader.js\" }).isEnabled(),\n    ).toBe(false);\n  });\n});\n\ndescribe(\"RuntimeImageOptimizer response\", () => {\n  it(\"answers with the headers next start sends\", async () => {\n    const { head, body } = await request(\"/photos/logo.png\");\n    expect(head.statusCode).toBe(200);\n    expect(head.headers).toMatchObject({\n      \"cache-control\": \"public, max-age=60, must-revalidate\",\n      \"content-type\": \"image/webp\",\n      \"content-length\": String(PNG.length),\n      \"content-disposition\": 'attachment; filename=\"logo.webp\"',\n      \"content-security-policy\": imageConfigDefault.contentSecurityPolicy,\n      etag: ETAG,\n      vary: \"Accept\",\n      \"x-nextjs-cache\": \"MISS\",\n    });\n    expect(body).toBe(PNG.toString());\n  });\n\n  // Content-hashed, so the name changes whenever the bytes do.\n  it(\"caches a statically imported image for a year, immutable\", async () => {\n    const { head } = await request(\"/_next/static/media/logo.3f2a1c.png\");\n    expect(head.headers[\"cache-control\"]).toBe(\n      \"public, max-age=315360000, immutable\",\n    );\n  });\n\n  // `writeHead` rejects a header value outside latin1 with ERR_INVALID_CHAR,\n  // and the Lambda sink writes the head through it.\n  it(\"encodes a non-latin1 filename rather than sending it raw\", async () => {\n    const { head } = await request(\"/ümlaut-写真.png\");\n    const disposition = head.headers[\"content-disposition\"];\n    expect(disposition).toMatch(/^attachment; filename=\"[^\"]*\"; filename\\*=/);\n    expect(disposition).toContain(\n      `filename*=UTF-8''${encodeURIComponent(\"ümlaut-写真.webp\")}`,\n    );\n    expect(() =>\n      validateHeaderValue(\"Content-Disposition\", disposition),\n    ).not.toThrow();\n  });\n\n  it.each([\n    [\"the exact tag\", ETAG],\n    [\"a weak form of it\", `W/${ETAG}`],\n    [\"a list containing it\", `\"other\", ${ETAG}`],\n    [\"a wildcard\", \"*\"],\n  ])(\"answers 304 to If-None-Match with %s\", async (_name, ifNoneMatch) => {\n    const { head, body } = await request(\"/logo.png\", {\n      headers: { \"if-none-match\": ifNoneMatch },\n    });\n    expect(head.statusCode).toBe(304);\n    expect(head.headers.etag).toBe(ETAG);\n    expect(head.headers[\"cache-control\"]).toBe(\n      \"public, max-age=60, must-revalidate\",\n    );\n    expect(body).toBe(\"\");\n  });\n\n  it(\"answers 200 to an If-None-Match that does not match\", async () => {\n    const { head } = await request(\"/logo.png\", {\n      headers: { \"if-none-match\": '\"other\"' },\n    });\n    expect(head.statusCode).toBe(200);\n  });\n\n  it(\"sends the headers but no body to HEAD\", async () => {\n    const { head, body } = await request(\"/logo.png\", { method: \"HEAD\" });\n    expect(head.statusCode).toBe(200);\n    expect(head.headers[\"content-length\"]).toBe(String(PNG.length));\n    expect(body).toBe(\"\");\n  });\n});\n\ndescribe(\"RuntimeImageOptimizer sources\", () => {\n  // `next start` fetches a remote source only when `remotePatterns` or `domains`\n  // allow it; the stage's config allows none. Anything else would make the\n  // optimizer an open proxy into whatever it can reach.\n  it.each([\n    [\"another origin\", \"https://evil.example.test/x.png\"],\n    [\"instance metadata\", \"http://169.254.169.254/latest/meta-data/\"],\n    [\"a protocol-relative url\", \"//evil.example.test/x.png\"],\n  ])(\"rejects a remote source that is not allowed: %s\", async (_name, src) => {\n    const { head, body } = await request(src);\n    expect(head.statusCode).toBe(400);\n    expect(body).toMatch(/\"url\" parameter/);\n    expect(imageOptimizer).not.toHaveBeenCalled();\n  });\n\n  function withS3Miss(\n    fetchInternal?: ImageOptimizerOptions[\"fetchInternal\"],\n  ): RuntimeImageOptimizer {\n    return optimizerFor({\n      fetchInternal,\n      s3: {\n        send: async () => {\n          throw Object.assign(new Error(\"missing\"), { name: \"NoSuchKey\" });\n        },\n      } as unknown as S3Client,\n    });\n  }\n\n  it(\"falls back to the app's routes for a source S3 has no file for\", async () => {\n    const fetchInternal = jest.fn(async () => ({\n      statusCode: 200,\n      headers: {\n        \"content-type\": \"image/png\",\n        \"cache-control\": \"public, max-age=120\",\n      },\n      body: Buffer.from(\"route-bytes\"),\n    }));\n    const { head } = await request(\"/api/avatar?id=42\", {\n      via: withS3Miss(fetchInternal),\n    });\n    expect(head.statusCode).toBe(200);\n    expect(fetchInternal).toHaveBeenCalledWith(\n      \"/api/avatar?id=42\",\n      expect.anything(),\n      imageConfigDefault.maximumResponseBody,\n    );\n    expect((imageOptimizer as jest.Mock).mock.lastCall[0]).toMatchObject({\n      buffer: Buffer.from(\"route-bytes\"),\n      contentType: \"image/png\",\n      cacheControl: \"public, max-age=120\",\n    });\n  });\n\n  // `NextjsRegionalContainers`: the file is on disk, and a GetObject for it is\n  // a wasted round trip.\n  it(\"goes straight to the app's routes when there is no bucket\", async () => {\n    const send = jest.fn();\n    const fetchInternal = jest.fn(async () => ({\n      statusCode: 200,\n      headers: { \"content-type\": \"image/png\" },\n      body: Buffer.from(\"disk-bytes\"),\n    }));\n    const { head } = await request(\"/logo.png\", {\n      via: optimizerFor({\n        bucket: \"\",\n        fetchInternal,\n        s3: { send } as unknown as S3Client,\n      }),\n    });\n    expect(head.statusCode).toBe(200);\n    expect(send).not.toHaveBeenCalled();\n    expect(fetchInternal).toHaveBeenCalledWith(\n      \"/logo.png\",\n      expect.anything(),\n      imageConfigDefault.maximumResponseBody,\n    );\n  });\n\n  it(\"answers 400 when the route sends no body\", async () => {\n    const { head } = await request(\"/api/avatar?id=42\", {\n      via: withS3Miss(async () => ({\n        statusCode: 404,\n        headers: {},\n        body: Buffer.alloc(0),\n      })),\n    });\n    expect(head.statusCode).toBe(400);\n  });\n\n  it(\"answers an explicit 502 for a source served by another functionGroups group\", async () => {\n    const error = jest.spyOn(console, \"error\").mockImplementation(() => {});\n    try {\n      const { head, body } = await request(\"/api/avatar?id=42\", {\n        via: withS3Miss(async () => ({\n          statusCode: 0,\n          headers: {},\n          body: Buffer.alloc(0),\n          otherGroup: \"avatars\",\n        })),\n      });\n      expect(head.statusCode).toBe(502);\n      expect(body).toMatch(/another functionGroups group/);\n      expect(imageOptimizer).not.toHaveBeenCalled();\n    } finally {\n      error.mockRestore();\n    }\n  });\n\n  // `images.maximumResponseBody`, which `next start` enforces on local\n  // sources too: past it, the source is not read into memory.\n  it(\"answers 413 for a route response over maximumResponseBody\", async () => {\n    const { head } = await request(\"/api/export\", {\n      via: withS3Miss(async () => ({\n        statusCode: 0,\n        headers: {},\n        body: Buffer.alloc(0),\n        tooLarge: true,\n      })),\n    });\n    expect(head.statusCode).toBe(413);\n    expect(imageOptimizer).not.toHaveBeenCalled();\n  });\n\n  it(\"answers 413 for an S3 object over maximumResponseBody\", async () => {\n    const { head } = await request(\"/video.mp4\", {\n      via: optimizerFor({\n        images: { maximumResponseBody: 10 },\n        s3: {\n          send: async () => ({\n            Body: [Buffer.from(\"never read\")],\n            ContentLength: 11,\n          }),\n        } as unknown as S3Client,\n      }),\n    });\n    expect(head.statusCode).toBe(413);\n    expect(imageOptimizer).not.toHaveBeenCalled();\n  });\n});\n\ndescribe(\"RuntimeImageOptimizer cache\", () => {\n  it(\"optimizes once, then answers from the cache handler\", async () => {\n    const via = optimizerFor();\n    const first = await request(\"/photos/cached.png\", { via });\n    expect(first.head.headers[\"x-nextjs-cache\"]).toBe(\"MISS\");\n    expect(first.body).toBe(PNG.toString());\n\n    const second = await request(\"/photos/cached.png\", { via });\n    expect(second.head.statusCode).toBe(200);\n    expect(second.head.headers[\"x-nextjs-cache\"]).toBe(\"HIT\");\n    expect(second.body).toBe(PNG.toString());\n    expect(second.head.headers.etag).toBe(ETAG);\n    expect(imageOptimizer).toHaveBeenCalledTimes(1);\n\n    // The entry `next start` would have written.\n    const [entry] = [...MapCacheHandler.entries.values()] as Array<{\n      value: { kind: string; extension: string };\n    }>;\n    expect(entry.value).toMatchObject({ kind: \"IMAGE\", extension: \"webp\" });\n  });\n\n  // Another instance: nothing in memory, so the hit is the cache handler's.\n  it(\"shares the optimized image across instances\", async () => {\n    await request(\"/photos/shared.png\", { via: optimizerFor() });\n    const other = await request(\"/photos/shared.png\", { via: optimizerFor() });\n    expect(other.head.headers[\"x-nextjs-cache\"]).toBe(\"HIT\");\n    expect(imageOptimizer).toHaveBeenCalledTimes(1);\n  });\n\n  // `required-server-files.json` names it relative to the dist dir.\n  it(\"loads the app's cacheHandler from where next start would\", async () => {\n    await request(\"/photos/cached.png\", { via: optimizerFor() });\n    expect(imported).toMatch(\n      /^file:\\/\\/.*\\/node_modules\\/cdk-nextjs\\/lib\\/adapter\\/cache-handler\\.mjs$/,\n    );\n    expect(MapCacheHandler.options).toMatchObject({ dev: false });\n  });\n\n  // A transient failure loading the cacheHandler (EMFILE in a cold-start\n  // burst) must not fail every later image request on the instance.\n  it(\"retries loading the cacheHandler after a failed load\", async () => {\n    const error = jest.spyOn(console, \"error\").mockImplementation(() => {});\n    try {\n      const importModule = jest\n        .fn()\n        .mockRejectedValueOnce(new Error(\"EMFILE\"))\n        .mockResolvedValue({ default: MapCacheHandler });\n      const via = optimizerFor({ importModule });\n      expect(\n        (await request(\"/photos/retry.png\", { via })).head.statusCode,\n      ).toBe(500);\n      expect(\n        (await request(\"/photos/retry.png\", { via })).head.statusCode,\n      ).toBe(200);\n      expect(importModule).toHaveBeenCalledTimes(2);\n    } finally {\n      error.mockRestore();\n    }\n  });\n\n  // The write of a fresh image goes to `waitUntil`, not in front of the\n  // response: the image is sent before the cache handler has it.\n  it(\"writes a miss to the cache after answering, through waitUntil\", async () => {\n    // A write that can't finish until released: if the response waited on it,\n    // `request` would never return.\n    let release!: () => void;\n    const gate = new Promise<void>((resolve) => (release = resolve));\n    const set = MapCacheHandler.prototype.set;\n    MapCacheHandler.prototype.set = async function (key, value) {\n      await gate;\n      return set.call(this, key, value);\n    };\n    try {\n      const pending: Array<Promise<unknown>> = [];\n      const first = await request(\"/photos/deferred.png\", {\n        via: optimizerFor(),\n        waitUntil: (promise) => pending.push(promise),\n      });\n      expect(first.head.headers[\"x-nextjs-cache\"]).toBe(\"MISS\");\n      expect(MapCacheHandler.entries.size).toBe(0);\n\n      release();\n      await Promise.all(pending);\n      expect(MapCacheHandler.entries.size).toBe(1);\n    } finally {\n      MapCacheHandler.prototype.set = set;\n    }\n  });\n});\n"]}

package/lib/runtime/lambda-event.d.ts

@@ -0,0 +1,4 @@
+import type { APIGatewayProxyEvent, LambdaFunctionURLEvent } from "aws-lambda";
+import type { RuntimeRequest } from "./core";
+export type LambdaEvent = LambdaFunctionURLEvent | APIGatewayProxyEvent;
+export declare function toRuntimeRequest(event: LambdaEvent, basePath: string): RuntimeRequest;

package/lib/runtime/lambda-event.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRuntimeRequest = toRuntimeRequest;
+const api_gateway_path_1 = require("./api-gateway-path");
+/** Only the REST API event carries `httpMethod`. */
+function isApiGatewayEvent(event) {
+    return "httpMethod" in event;
+}
+function toRuntimeRequest(event, basePath) {
+    const body = decodeBody(event.body, event.isBase64Encoded);
+    if (isApiGatewayEvent(event)) {
+        return {
+            method: event.httpMethod,
+            // With the stage API Gateway stripped put back, but only for an app whose
+            // `basePath` expects it; see `apiGatewayRequestPath`.
+            url: (0, api_gateway_path_1.apiGatewayRequestPath)(event, basePath) + formatQuery(event),
+            headers: restHeaders(event),
+            body,
+            remoteAddress: event.requestContext.identity?.sourceIp,
+        };
+    }
+    const { http } = event.requestContext;
+    return {
+        method: http.method,
+        // Raw, still percent-encoded, which is what Next.js's own normalization
+        // expects.
+        url: event.rawPath + (event.rawQueryString ? `?${event.rawQueryString}` : ""),
+        headers: functionUrlHeaders(event),
+        body,
+        remoteAddress: http.sourceIp,
+        // Trusted for any IAM-authorized invoker: in practice CloudFront's Origin
+        // Access Control, whose viewer-request function overwrites
+        // `x-forwarded-host` with the viewer's `Host` (see
+        // `RuntimeRequest.trustForwardedHost`; `NextjsDistribution` refuses an
+        // override that would replace that function,
+        // `withDynamicFunctionAssociations`), plus principals granted
+        // `lambda:InvokeFunctionUrl`, which are already trusted with the function.
+        // Gated on the signature Lambda verified, not assumed: a URL overridden to
+        // `authType: NONE` can be called by anyone, with any header.
+        trustForwardedHost: isIamAuthenticated(event),
+    };
+}
+/**
+ * Lambda sets `authorizer.iam` only for a request it verified the SigV4 of — by
+ * any principal allowed to invoke the URL, not only CloudFront.
+ */
+function isIamAuthenticated(event) {
+    const { authorizer } = event.requestContext;
+    return authorizer?.iam !== undefined;
+}
+function decodeBody(body, isBase64Encoded) {
+    if (body === null || body === undefined) {
+        return undefined;
+    }
+    return Buffer.from(body, isBase64Encoded ? "base64" : "utf-8");
+}
+/**
+ * Payload v2 lifts cookies out of the headers into their own array, so they have
+ * to be put back — Next.js reads `req.headers.cookie` for draft mode, the
+ * prerender bypass, and anything a route handler does with `cookies()`.
+ */
+function functionUrlHeaders(event) {
+    const headers = {};
+    for (const [name, value] of Object.entries(event.headers)) {
+        if (value !== undefined) {
+            headers[name.toLowerCase()] = value;
+        }
+    }
+    if (event.cookies?.length) {
+        headers.cookie = event.cookies.join("; ");
+    }
+    return headers;
+}
+/**
+ * `multiValueHeaders` only: API Gateway always sends it, as a superset of the
+ * single-valued map, which keeps only the last value of a repeated header.
+ *
+ * `cookie` is rejoined with `"; "` rather than the `", "` every other header uses,
+ * because that is the separator the field's own grammar uses (RFC 6265) and what
+ * every cookie parser splits on. Joining two `Cookie` fields with a comma produced
+ * `cookie: "a=1, b=2"`, which parses as the single cookie `a = "1, b=2"` — every
+ * cookie after the first is lost, including `__prerender_bypass` and
+ * `__next_preview_data`, so draft mode silently stopped working.
+ */
+function restHeaders(event) {
+    const headers = {};
+    for (const [name, values] of Object.entries(event.multiValueHeaders ?? {})) {
+        if (values?.length) {
+            const key = name.toLowerCase();
+            headers[key] =
+                values.length === 1
+                    ? values[0]
+                    : values.join(key === "cookie" ? "; " : ", ");
+        }
+    }
+    return headers;
+}
+/**
+ * Rebuilds the query string API Gateway already parsed (and decoded) for us.
+ * Re-encoding is required, not cosmetic: `?q=a%20b` arrives as `a b`, and passing
+ * that through unescaped produces a URL that `new URL()` mangles.
+ */
+function formatQuery(event) {
+    const search = new URLSearchParams();
+    for (const [name, values] of Object.entries(event.multiValueQueryStringParameters ?? {})) {
+        for (const value of values ?? []) {
+            search.append(name, value);
+        }
+    }
+    const query = search.toString();
+    return query ? `?${query}` : "";
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambda-event.js","sourceRoot":"","sources":["../../src/runtime/lambda-event.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\n/**\n * Lambda event → {@link RuntimeRequest}, for both event shapes the Functions\n * shell (`lambda.mts`) is reached with. Its own module so it can be tested:\n * `lambda.mts` starts loading the runtime, and needs the `awslambda` global, the\n * moment it is imported.\n */\nimport type { IncomingHttpHeaders } from \"node:http\";\nimport type { APIGatewayProxyEvent, LambdaFunctionURLEvent } from \"aws-lambda\";\nimport { apiGatewayRequestPath } from \"./api-gateway-path\";\nimport type { RuntimeRequest } from \"./core\";\n\nexport type LambdaEvent = LambdaFunctionURLEvent | APIGatewayProxyEvent;\n\n/** Only the REST API event carries `httpMethod`. */\nfunction isApiGatewayEvent(event: LambdaEvent): event is APIGatewayProxyEvent {\n  return \"httpMethod\" in event;\n}\n\nexport function toRuntimeRequest(\n  event: LambdaEvent,\n  basePath: string,\n): RuntimeRequest {\n  const body = decodeBody(event.body, event.isBase64Encoded);\n  if (isApiGatewayEvent(event)) {\n    return {\n      method: event.httpMethod,\n      // With the stage API Gateway stripped put back, but only for an app whose\n      // `basePath` expects it; see `apiGatewayRequestPath`.\n      url: apiGatewayRequestPath(event, basePath) + formatQuery(event),\n      headers: restHeaders(event),\n      body,\n      remoteAddress: event.requestContext.identity?.sourceIp,\n    };\n  }\n  const { http } = event.requestContext;\n  return {\n    method: http.method,\n    // Raw, still percent-encoded, which is what Next.js's own normalization\n    // expects.\n    url:\n      event.rawPath + (event.rawQueryString ? `?${event.rawQueryString}` : \"\"),\n    headers: functionUrlHeaders(event),\n    body,\n    remoteAddress: http.sourceIp,\n    // Trusted for any IAM-authorized invoker: in practice CloudFront's Origin\n    // Access Control, whose viewer-request function overwrites\n    // `x-forwarded-host` with the viewer's `Host` (see\n    // `RuntimeRequest.trustForwardedHost`; `NextjsDistribution` refuses an\n    // override that would replace that function,\n    // `withDynamicFunctionAssociations`), plus principals granted\n    // `lambda:InvokeFunctionUrl`, which are already trusted with the function.\n    // Gated on the signature Lambda verified, not assumed: a URL overridden to\n    // `authType: NONE` can be called by anyone, with any header.\n    trustForwardedHost: isIamAuthenticated(event),\n  };\n}\n\n/**\n * Lambda sets `authorizer.iam` only for a request it verified the SigV4 of — by\n * any principal allowed to invoke the URL, not only CloudFront.\n */\nfunction isIamAuthenticated(event: LambdaFunctionURLEvent): boolean {\n  const { authorizer } = event.requestContext as {\n    authorizer?: { iam?: unknown };\n  };\n  return authorizer?.iam !== undefined;\n}\n\nfunction decodeBody(\n  body: string | null | undefined,\n  isBase64Encoded: boolean,\n): Buffer | undefined {\n  if (body === null || body === undefined) {\n    return undefined;\n  }\n  return Buffer.from(body, isBase64Encoded ? \"base64\" : \"utf-8\");\n}\n\n/**\n * Payload v2 lifts cookies out of the headers into their own array, so they have\n * to be put back — Next.js reads `req.headers.cookie` for draft mode, the\n * prerender bypass, and anything a route handler does with `cookies()`.\n */\nfunction functionUrlHeaders(\n  event: LambdaFunctionURLEvent,\n): IncomingHttpHeaders {\n  const headers: IncomingHttpHeaders = {};\n  for (const [name, value] of Object.entries(event.headers)) {\n    if (value !== undefined) {\n      headers[name.toLowerCase()] = value;\n    }\n  }\n  if (event.cookies?.length) {\n    headers.cookie = event.cookies.join(\"; \");\n  }\n  return headers;\n}\n\n/**\n * `multiValueHeaders` only: API Gateway always sends it, as a superset of the\n * single-valued map, which keeps only the last value of a repeated header.\n *\n * `cookie` is rejoined with `\"; \"` rather than the `\", \"` every other header uses,\n * because that is the separator the field's own grammar uses (RFC 6265) and what\n * every cookie parser splits on. Joining two `Cookie` fields with a comma produced\n * `cookie: \"a=1, b=2\"`, which parses as the single cookie `a = \"1, b=2\"` — every\n * cookie after the first is lost, including `__prerender_bypass` and\n * `__next_preview_data`, so draft mode silently stopped working.\n */\nfunction restHeaders(event: APIGatewayProxyEvent): IncomingHttpHeaders {\n  const headers: IncomingHttpHeaders = {};\n  for (const [name, values] of Object.entries(event.multiValueHeaders ?? {})) {\n    if (values?.length) {\n      const key = name.toLowerCase();\n      headers[key] =\n        values.length === 1\n          ? values[0]\n          : values.join(key === \"cookie\" ? \"; \" : \", \");\n    }\n  }\n  return headers;\n}\n\n/**\n * Rebuilds the query string API Gateway already parsed (and decoded) for us.\n * Re-encoding is required, not cosmetic: `?q=a%20b` arrives as `a b`, and passing\n * that through unescaped produces a URL that `new URL()` mangles.\n */\nfunction formatQuery(event: APIGatewayProxyEvent): string {\n  const search = new URLSearchParams();\n  for (const [name, values] of Object.entries(\n    event.multiValueQueryStringParameters ?? {},\n  )) {\n    for (const value of values ?? []) {\n      search.append(name, value);\n    }\n  }\n  const query = search.toString();\n  return query ? `?${query}` : \"\";\n}\n"]}

package/lib/runtime/lambda-event.test.d.ts

@@ -0,0 +1 @@
+export {};