cdk-nextjs 0.6.2 → 0.7.1

package/lib/runtime/image-utils.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageTooLargeError = void 0;
+exports.fetchFromS3 = fetchFromS3;
+exports.resolveErrorResponse = resolveErrorResponse;
+/* eslint-disable import/no-extraneous-dependencies */
+/**
+ * S3 fetching and error mapping for `/_next/image`, split out from
+ * {@link ./image.ts} so it is unit-testable without `next` present.
+ *
+ * The one value from `next` that this file needs is passed in rather than
+ * imported: `next` is external to the shell bundles, so a static `import` here
+ * would be hoisted into the bundle where it cannot resolve. `image.ts` requires
+ * it through `./next-modules` instead.
+ */
+const client_s3_1 = require("@aws-sdk/client-s3");
+const util_1 = require("./util");
+/**
+ * Fetches a non-absolute (local) image referenced by an `<Image>` from S3.
+ *
+ * `url` is inconsistent about the app's `basePath`: next-image-loader bakes it
+ * into the href for statically imported images, while plain string paths are
+ * passed through as literally written by the app. So it is stripped when present,
+ * leaving a path relative to the asset root, and the bucket's own key prefix is
+ * applied to that. Deriving the key from `basePath` instead is wrong whenever the
+ * two differ, which they do for every API Gateway deployment.
+ *
+ * The key is percent-decoded, because an S3 key is the file's real name while
+ * `url` is a URL path. `public/hello world.jpg` arrives here as
+ * `/hello%20world.jpg` — the `url` query value is double-encoded, so decoding the
+ * query string leaves one layer — and its object key is `hello world.jpg`.
+ * Next.js's own `fetchInternalImage` gets the decode for free, since it makes an
+ * HTTP subrequest and its static file server resolves the path against the
+ * filesystem; skipping it here 400'd that file
+ * (`next-image-legacy/unicode`). Unicode needs nothing: `äöüščří.png` survives
+ * the query decode as itself and is already the object's name.
+ *
+ * Throws {@link ImageTooLargeError} rather than read past `maximumBody`
+ * (`images.maximumResponseBody`), which `next start` enforces on local sources
+ * too: a large `public/` file would otherwise be read into memory whole.
+ */
+async function fetchFromS3(s3, bucket, url, location, maximumBody) {
+    const { urlBasePath, keyPrefix } = location;
+    // The key is the path alone. `/logo.png?v=2` is a cache-buster on a file
+    // named `logo.png`, and `next start` treats it as one: `fetchInternalImage`
+    // routes the href as a request, whose query and fragment never reach the
+    // static file lookup. Left on, they became part of the key, which missed.
+    // Cut before decoding, so a `?` that is part of the name (`%3F`) survives.
+    const path = withoutAssetPrefix(url.split(/[?#]/, 1)[0], location);
+    // Matching on a path boundary keeps a sibling like "/basement/logo.png" from
+    // being treated as basePath "/base" plus "ment/logo.png". It's still
+    // indistinguishable from a real `public/base/` directory, which loses; that's
+    // the right trade, since every statically imported image carries the prefix
+    // and the alternative costs an S3 round trip per request to detect it.
+    const assetPath = (0, util_1.withoutPathPrefix)(path, urlBasePath).replace(/^\/+/, "");
+    const prefix = keyPrefix.replace(/^\/+|\/+$/g, "");
+    // A malformed encoding that isn't a literal `%` just misses the key and gets
+    // the 400 an absent file gets.
+    const decoded = (0, util_1.safeDecode)(assetPath);
+    const key = prefix ? `${prefix}/${decoded}` : decoded;
+    const response = await s3.send(new client_s3_1.GetObjectCommand({
+        Bucket: bucket,
+        Key: key,
+    }));
+    const body = response.Body;
+    if (!body) {
+        throw new Error(`Empty response from S3 for key: ${key}`);
+    }
+    if ((response.ContentLength ?? 0) > maximumBody) {
+        body.destroy?.();
+        throw new ImageTooLargeError(key);
+    }
+    const chunks = [];
+    let size = 0;
+    // Counted as well, for an object without a `ContentLength`. Throwing out of
+    // the loop destroys the stream.
+    for await (const chunk of body) {
+        size += chunk.byteLength;
+        if (size > maximumBody) {
+            throw new ImageTooLargeError(key);
+        }
+        chunks.push(Buffer.from(chunk));
+    }
+    return {
+        buffer: Buffer.concat(chunks),
+        contentType: response.ContentType || null,
+        etag: response.ETag || "",
+    };
+}
+/**
+ * `/cdn/_next/static/media/logo.png` → `/_next/static/media/logo.png`, for a
+ * path `assetPrefix` of `/cdn`: only in front of `/_next/`, the one place
+ * Next.js puts it.
+ */
+function withoutAssetPrefix(path, location) {
+    const assetPrefix = location.assetPrefix?.replace(/\/+$/, "") ?? "";
+    if (!assetPrefix.startsWith("/"))
+        return path;
+    return path.startsWith(`${assetPrefix}/_next/`)
+        ? path.slice(assetPrefix.length)
+        : path;
+}
+/** A source over `images.maximumResponseBody`; see {@link fetchFromS3}. */
+class ImageTooLargeError extends Error {
+    constructor(key) {
+        super(`S3 object ${key} is over images.maximumResponseBody`);
+        this.name = "ImageTooLargeError";
+    }
+}
+exports.ImageTooLargeError = ImageTooLargeError;
+/**
+ * Maps an error thrown while processing an image request to the HTTP
+ * status/message it should produce, preserving the status Next.js's own
+ * `ImageError`/`fetchExternalImage` attach. A source over
+ * `images.maximumResponseBody` is the 413 `fetchInternalImage` answers.
+ */
+function resolveErrorResponse(error, ImageError) {
+    if (error instanceof ImageError) {
+        return { statusCode: error.statusCode, message: error.message };
+    }
+    if (error instanceof ImageTooLargeError) {
+        return {
+            statusCode: 413,
+            message: '"url" parameter is valid but internal response is invalid',
+        };
+    }
+    return { statusCode: 500, message: "Internal Server Error" };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-utils.js","sourceRoot":"","sources":["../../src/runtime/image-utils.ts"],"names":[],"mappings":";;;AA6DA,kCA2DC;AAiCD,oDAiBC;AA1KD,sDAAsD;AACtD;;;;;;;;GAQG;AACH,kDAAgE;AAChE,iCAAuD;AA0BvD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACI,KAAK,UAAU,WAAW,CAC/B,EAAY,EACZ,MAAc,EACd,GAAW,EACX,QAAyB,EACzB,WAAmB;IAEnB,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,GAAG,QAAQ,CAAC;IAC5C,yEAAyE;IACzE,4EAA4E;IAC5E,yEAAyE;IACzE,0EAA0E;IAC1E,2EAA2E;IAC3E,MAAM,IAAI,GAAG,kBAAkB,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;IACnE,6EAA6E;IAC7E,qEAAqE;IACrE,8EAA8E;IAC9E,4EAA4E;IAC5E,uEAAuE;IACvE,MAAM,SAAS,GAAG,IAAA,wBAAiB,EAAC,IAAI,EAAE,WAAW,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAC3E,MAAM,MAAM,GAAG,SAAS,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;IACnD,6EAA6E;IAC7E,+BAA+B;IAC/B,MAAM,OAAO,GAAG,IAAA,iBAAU,EAAC,SAAS,CAAC,CAAC;IACtC,MAAM,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,OAAO,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC;IAEtD,MAAM,QAAQ,GAAG,MAAM,EAAE,CAAC,IAAI,CAC5B,IAAI,4BAAgB,CAAC;QACnB,MAAM,EAAE,MAAM;QACd,GAAG,EAAE,GAAG;KACT,CAAC,CACH,CAAC;IAEF,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC;IAC3B,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CAAC,mCAAmC,GAAG,EAAE,CAAC,CAAC;IAC5D,CAAC;IAED,IAAI,CAAC,QAAQ,CAAC,aAAa,IAAI,CAAC,CAAC,GAAG,WAAW,EAAE,CAAC;QAC/C,IAAiC,CAAC,OAAO,EAAE,EAAE,CAAC;QAC/C,MAAM,IAAI,kBAAkB,CAAC,GAAG,CAAC,CAAC;IACpC,CAAC;IACD,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,4EAA4E;IAC5E,gCAAgC;IAChC,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,IAAiC,EAAE,CAAC;QAC5D,IAAI,IAAI,KAAK,CAAC,UAAU,CAAC;QACzB,IAAI,IAAI,GAAG,WAAW,EAAE,CAAC;YACvB,MAAM,IAAI,kBAAkB,CAAC,GAAG,CAAC,CAAC;QACpC,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAClC,CAAC;IAED,OAAO;QACL,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;QAC7B,WAAW,EAAE,QAAQ,CAAC,WAAW,IAAI,IAAI;QACzC,IAAI,EAAE,QAAQ,CAAC,IAAI,IAAI,EAAE;KAC1B,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,SAAS,kBAAkB,CAAC,IAAY,EAAE,QAAyB;IACjE,MAAM,WAAW,GAAG,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC;IACpE,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IAC9C,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,WAAW,SAAS,CAAC;QAC7C,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,CAAC;QAChC,CAAC,CAAC,IAAI,CAAC;AACX,CAAC;AAED,2EAA2E;AAC3E,MAAa,kBAAmB,SAAQ,KAAK;IAC3C,YAAmB,GAAW;QAC5B,KAAK,CAAC,aAAa,GAAG,qCAAqC,CAAC,CAAC;QAC7D,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;IACnC,CAAC;CACF;AALD,gDAKC;AAMD;;;;;GAKG;AACH,SAAgB,oBAAoB,CAClC,KAAc,EACd,UAA2B;IAK3B,IAAI,KAAK,YAAY,UAAU,EAAE,CAAC;QAChC,OAAO,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;IAClE,CAAC;IACD,IAAI,KAAK,YAAY,kBAAkB,EAAE,CAAC;QACxC,OAAO;YACL,UAAU,EAAE,GAAG;YACf,OAAO,EAAE,2DAA2D;SACrE,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,OAAO,EAAE,uBAAuB,EAAE,CAAC;AAC/D,CAAC","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\n/**\n * S3 fetching and error mapping for `/_next/image`, split out from\n * {@link ./image.ts} so it is unit-testable without `next` present.\n *\n * The one value from `next` that this file needs is passed in rather than\n * imported: `next` is external to the shell bundles, so a static `import` here\n * would be hoisted into the bundle where it cannot resolve. `image.ts` requires\n * it through `./next-modules` instead.\n */\nimport { GetObjectCommand, S3Client } from \"@aws-sdk/client-s3\";\nimport { safeDecode, withoutPathPrefix } from \"./util\";\n\n/** Where the app is served versus where its assets were uploaded. */\nexport interface S3AssetLocation {\n  /**\n   * The app's own `basePath` — the prefix of the *URL* it is served at. Only\n   * stripped from the href, never used to build a key: on the API Gateway\n   * deployment types this is the stage name, which never appears in S3.\n   */\n  readonly urlBasePath: string;\n  /**\n   * `NextjsStaticAssets.keyPrefix`: the S3 key prefix the assets were uploaded\n   * under, without a leading slash. Empty for a bucket-root deployment.\n   */\n  readonly keyPrefix: string;\n  /**\n   * The app's `assetPrefix`, when it is a path (`/cdn`). Next.js puts it in\n   * front of `/_next/` in place of `basePath`, so a statically imported image's\n   * href is `/cdn/_next/static/media/…`, and `next start` strips it again when\n   * it serves the file. An absolute `assetPrefix` makes the href absolute, which\n   * never reaches here.\n   * @default - none\n   */\n  readonly assetPrefix?: string;\n}\n\n/**\n * Fetches a non-absolute (local) image referenced by an `<Image>` from S3.\n *\n * `url` is inconsistent about the app's `basePath`: next-image-loader bakes it\n * into the href for statically imported images, while plain string paths are\n * passed through as literally written by the app. So it is stripped when present,\n * leaving a path relative to the asset root, and the bucket's own key prefix is\n * applied to that. Deriving the key from `basePath` instead is wrong whenever the\n * two differ, which they do for every API Gateway deployment.\n *\n * The key is percent-decoded, because an S3 key is the file's real name while\n * `url` is a URL path. `public/hello world.jpg` arrives here as\n * `/hello%20world.jpg` — the `url` query value is double-encoded, so decoding the\n * query string leaves one layer — and its object key is `hello world.jpg`.\n * Next.js's own `fetchInternalImage` gets the decode for free, since it makes an\n * HTTP subrequest and its static file server resolves the path against the\n * filesystem; skipping it here 400'd that file\n * (`next-image-legacy/unicode`). Unicode needs nothing: `äöüščří.png` survives\n * the query decode as itself and is already the object's name.\n *\n * Throws {@link ImageTooLargeError} rather than read past `maximumBody`\n * (`images.maximumResponseBody`), which `next start` enforces on local sources\n * too: a large `public/` file would otherwise be read into memory whole.\n */\nexport async function fetchFromS3(\n  s3: S3Client,\n  bucket: string,\n  url: string,\n  location: S3AssetLocation,\n  maximumBody: number,\n): Promise<{ buffer: Buffer; contentType: string | null; etag: string }> {\n  const { urlBasePath, keyPrefix } = location;\n  // The key is the path alone. `/logo.png?v=2` is a cache-buster on a file\n  // named `logo.png`, and `next start` treats it as one: `fetchInternalImage`\n  // routes the href as a request, whose query and fragment never reach the\n  // static file lookup. Left on, they became part of the key, which missed.\n  // Cut before decoding, so a `?` that is part of the name (`%3F`) survives.\n  const path = withoutAssetPrefix(url.split(/[?#]/, 1)[0], location);\n  // Matching on a path boundary keeps a sibling like \"/basement/logo.png\" from\n  // being treated as basePath \"/base\" plus \"ment/logo.png\". It's still\n  // indistinguishable from a real `public/base/` directory, which loses; that's\n  // the right trade, since every statically imported image carries the prefix\n  // and the alternative costs an S3 round trip per request to detect it.\n  const assetPath = withoutPathPrefix(path, urlBasePath).replace(/^\\/+/, \"\");\n  const prefix = keyPrefix.replace(/^\\/+|\\/+$/g, \"\");\n  // A malformed encoding that isn't a literal `%` just misses the key and gets\n  // the 400 an absent file gets.\n  const decoded = safeDecode(assetPath);\n  const key = prefix ? `${prefix}/${decoded}` : decoded;\n\n  const response = await s3.send(\n    new GetObjectCommand({\n      Bucket: bucket,\n      Key: key,\n    }),\n  );\n\n  const body = response.Body;\n  if (!body) {\n    throw new Error(`Empty response from S3 for key: ${key}`);\n  }\n\n  if ((response.ContentLength ?? 0) > maximumBody) {\n    (body as { destroy?: () => void }).destroy?.();\n    throw new ImageTooLargeError(key);\n  }\n  const chunks: Buffer[] = [];\n  let size = 0;\n  // Counted as well, for an object without a `ContentLength`. Throwing out of\n  // the loop destroys the stream.\n  for await (const chunk of body as AsyncIterable<Uint8Array>) {\n    size += chunk.byteLength;\n    if (size > maximumBody) {\n      throw new ImageTooLargeError(key);\n    }\n    chunks.push(Buffer.from(chunk));\n  }\n\n  return {\n    buffer: Buffer.concat(chunks),\n    contentType: response.ContentType || null,\n    etag: response.ETag || \"\",\n  };\n}\n\n/**\n * `/cdn/_next/static/media/logo.png` → `/_next/static/media/logo.png`, for a\n * path `assetPrefix` of `/cdn`: only in front of `/_next/`, the one place\n * Next.js puts it.\n */\nfunction withoutAssetPrefix(path: string, location: S3AssetLocation): string {\n  const assetPrefix = location.assetPrefix?.replace(/\\/+$/, \"\") ?? \"\";\n  if (!assetPrefix.startsWith(\"/\")) return path;\n  return path.startsWith(`${assetPrefix}/_next/`)\n    ? path.slice(assetPrefix.length)\n    : path;\n}\n\n/** A source over `images.maximumResponseBody`; see {@link fetchFromS3}. */\nexport class ImageTooLargeError extends Error {\n  public constructor(key: string) {\n    super(`S3 object ${key} is over images.maximumResponseBody`);\n    this.name = \"ImageTooLargeError\";\n  }\n}\n\n/** `ImageError` from `next/dist/server/image-optimizer.js`. */\nexport type ImageErrorClass =\n  (typeof import(\"next/dist/server/image-optimizer.js\"))[\"ImageError\"];\n\n/**\n * Maps an error thrown while processing an image request to the HTTP\n * status/message it should produce, preserving the status Next.js's own\n * `ImageError`/`fetchExternalImage` attach. A source over\n * `images.maximumResponseBody` is the 413 `fetchInternalImage` answers.\n */\nexport function resolveErrorResponse(\n  error: unknown,\n  ImageError: ImageErrorClass,\n): {\n  statusCode: number;\n  message: string;\n} {\n  if (error instanceof ImageError) {\n    return { statusCode: error.statusCode, message: error.message };\n  }\n  if (error instanceof ImageTooLargeError) {\n    return {\n      statusCode: 413,\n      message: '\"url\" parameter is valid but internal response is invalid',\n    };\n  }\n  return { statusCode: 500, message: \"Internal Server Error\" };\n}\n"]}

package/lib/runtime/image-utils.test.d.ts

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

package/lib/runtime/image-utils.test.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+jest.mock("@aws-sdk/client-s3");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const image_optimizer_js_1 = require("next/dist/server/image-optimizer.js");
+const image_utils_1 = require("./image-utils");
+function asyncIterableFrom(chunks) {
+    return {
+        [Symbol.asyncIterator]() {
+            let i = 0;
+            return {
+                next: async () => i < chunks.length
+                    ? { done: false, value: chunks[i++] }
+                    : { done: true, value: undefined },
+            };
+        },
+    };
+}
+/** No app `basePath`, assets at the root of the bucket: the default. */
+const ROOT = { urlBasePath: "", keyPrefix: "" };
+describe("fetchFromS3", () => {
+    const mockSend = jest.fn();
+    const s3 = new client_s3_1.S3Client({});
+    beforeEach(() => {
+        s3.send = mockSend;
+        mockSend.mockReset();
+    });
+    const ok = () => mockSend.mockResolvedValue({
+        Body: asyncIterableFrom([Buffer.from("data")]),
+        ContentType: "image/png",
+        ETag: '"abc123"',
+    });
+    const keyOf = () => client_s3_1.GetObjectCommand.mock.calls[0][0].Key;
+    it("strips the leading slash when the assets sit at the bucket root", async () => {
+        ok();
+        await (0, image_utils_1.fetchFromS3)(s3, "my-bucket", "/static/foo.png", {
+            urlBasePath: "",
+            keyPrefix: "",
+        }, Infinity);
+        expect(client_s3_1.GetObjectCommand.mock.calls[0][0]).toEqual({ Bucket: "my-bucket", Key: "static/foo.png" });
+    });
+    it("applies the bucket key prefix", async () => {
+        ok();
+        await (0, image_utils_1.fetchFromS3)(s3, "my-bucket", "/static/foo.jpg", {
+            urlBasePath: "/base",
+            keyPrefix: "base",
+        }, Infinity);
+        expect(keyOf()).toBe("base/static/foo.jpg");
+    });
+    it("does not repeat the prefix when the url already carries basePath", async () => {
+        ok();
+        // next-image-loader bakes `basePath` into the href of a statically imported
+        // image, unlike a plain string path.
+        await (0, image_utils_1.fetchFromS3)(s3, "my-bucket", "/base/_next/static/media/a.png", {
+            urlBasePath: "/base",
+            keyPrefix: "base",
+        }, Infinity);
+        expect(keyOf()).toBe("base/_next/static/media/a.png");
+    });
+    /**
+     * The API Gateway deployment types serve the app under the stage name, so the
+     * app's `basePath` is `/prod` while the assets were uploaded to the root of the
+     * bucket. Building the key from `basePath` asks S3 for `prod/...`, which does
+     * not exist, and every local `<Image>` 400s.
+     */
+    it("strips a basePath that is not part of the key", async () => {
+        ok();
+        await (0, image_utils_1.fetchFromS3)(s3, "my-bucket", "/prod/_next/static/media/a.png", {
+            urlBasePath: "/prod",
+            keyPrefix: "",
+        }, Infinity);
+        expect(keyOf()).toBe("_next/static/media/a.png");
+    });
+    it("leaves a url without basePath alone when there is no key prefix", async () => {
+        ok();
+        await (0, image_utils_1.fetchFromS3)(s3, "my-bucket", "/static/foo.jpg", {
+            urlBasePath: "/prod",
+            keyPrefix: "",
+        }, Infinity);
+        expect(keyOf()).toBe("static/foo.jpg");
+    });
+    // With `assetPrefix: "/cdn"`, a static import's href is
+    // `/cdn/_next/static/media/…`, with `basePath` nowhere in it.
+    it("strips a path assetPrefix in front of /_next/", async () => {
+        ok();
+        await (0, image_utils_1.fetchFromS3)(s3, "my-bucket", "/cdn/_next/static/media/a.png", {
+            urlBasePath: "/base",
+            keyPrefix: "",
+            assetPrefix: "/cdn/",
+        }, Infinity);
+        expect(keyOf()).toBe("_next/static/media/a.png");
+    });
+    it("leaves a public/ file under a directory named like the assetPrefix alone", async () => {
+        ok();
+        await (0, image_utils_1.fetchFromS3)(s3, "my-bucket", "/cdn/logo.png", {
+            urlBasePath: "",
+            keyPrefix: "",
+            assetPrefix: "/cdn",
+        }, Infinity);
+        expect(keyOf()).toBe("cdn/logo.png");
+    });
+    it("ignores an absolute assetPrefix", async () => {
+        ok();
+        await (0, image_utils_1.fetchFromS3)(s3, "my-bucket", "/_next/static/media/a.png", {
+            urlBasePath: "",
+            keyPrefix: "",
+            assetPrefix: "https://cdn.example.test",
+        }, Infinity);
+        expect(keyOf()).toBe("_next/static/media/a.png");
+    });
+    it("only matches basePath on a path boundary", async () => {
+        ok();
+        await (0, image_utils_1.fetchFromS3)(s3, "my-bucket", "/basement/logo.png", {
+            urlBasePath: "/base",
+            keyPrefix: "base",
+        }, Infinity);
+        expect(keyOf()).toBe("base/basement/logo.png");
+    });
+    // Carried over from #267, which fixed the same bug in the pre-adapter image
+    // handler: a `destinationKeyPrefix` override can arrive with a trailing slash.
+    it("doesn't double the separator when the key prefix has a trailing slash", async () => {
+        ok();
+        await (0, image_utils_1.fetchFromS3)(s3, "my-bucket", "/static/foo.jpg", {
+            urlBasePath: "",
+            keyPrefix: "base/",
+        }, Infinity);
+        expect(keyOf()).toBe("base/static/foo.jpg");
+    });
+    // `next-image-legacy/unicode`, whose `public/` holds both of these names. The
+    // space is what broke: the key is the file's real name, the url is a URL path.
+    it.each([
+        ["/hello%20world.jpg", "hello world.jpg"],
+        ["/äöüščří.png", "äöüščří.png"],
+        ["/%C3%A4%C3%B6.png", "äö.png"],
+    ])("decodes %s into the object's real name", async (url, key) => {
+        ok();
+        await (0, image_utils_1.fetchFromS3)(s3, "my-bucket", url, ROOT, Infinity);
+        expect(keyOf()).toBe(key);
+    });
+    // A cache-buster on a local src: `next start` routes the href as a request, so
+    // the query and fragment never reach the file lookup.
+    it.each([
+        ["/logo.png?v=2", "logo.png"],
+        ["/logo.png#top", "logo.png"],
+        ["/logo.png?v=2#top", "logo.png"],
+        ["/base/logo.png?v=2", "logo.png"],
+        // A `?` that is part of the name arrives encoded and is not a query.
+        ["/what%3F.png?v=2", "what?.png"],
+    ])("keys %s by its path alone", async (url, key) => {
+        ok();
+        await (0, image_utils_1.fetchFromS3)(s3, "my-bucket", url, {
+            urlBasePath: "/base",
+            keyPrefix: "",
+        }, Infinity);
+        expect(keyOf()).toBe(key);
+    });
+    it("leaves a name that isn't valid percent-encoding alone", async () => {
+        ok();
+        await (0, image_utils_1.fetchFromS3)(s3, "my-bucket", "/100%.png", ROOT, Infinity);
+        expect(keyOf()).toBe("100%.png");
+    });
+    it("returns the concatenated buffer, content type, and etag", async () => {
+        mockSend.mockResolvedValue({
+            Body: asyncIterableFrom([Buffer.from("hel"), Buffer.from("lo")]),
+            ContentType: "image/jpeg",
+            ETag: '"the-etag"',
+        });
+        const result = await (0, image_utils_1.fetchFromS3)(s3, "my-bucket", "/foo.jpg", ROOT, Infinity);
+        expect(result.buffer.toString()).toBe("hello");
+        expect(result.contentType).toBe("image/jpeg");
+        expect(result.etag).toBe('"the-etag"');
+    });
+    it("returns an empty etag when S3 doesn't provide one", async () => {
+        mockSend.mockResolvedValue({
+            Body: asyncIterableFrom([Buffer.from("data")]),
+            ContentType: null,
+            ETag: undefined,
+        });
+        const result = await (0, image_utils_1.fetchFromS3)(s3, "my-bucket", "/foo.png", ROOT, Infinity);
+        expect(result.etag).toBe("");
+        expect(result.contentType).toBeNull();
+    });
+    // `images.maximumResponseBody`, which `next start` enforces on local sources.
+    it("refuses an object whose ContentLength is over the limit, unread", async () => {
+        const destroy = jest.fn();
+        mockSend.mockResolvedValue({
+            Body: { ...asyncIterableFrom([Buffer.from("never read")]), destroy },
+            ContentLength: 11,
+        });
+        await expect((0, image_utils_1.fetchFromS3)(s3, "my-bucket", "/big.png", ROOT, 10)).rejects.toBeInstanceOf(image_utils_1.ImageTooLargeError);
+        expect(destroy).toHaveBeenCalled();
+    });
+    it("stops reading once the bytes read pass the limit", async () => {
+        mockSend.mockResolvedValue({
+            Body: asyncIterableFrom([Buffer.from("hel"), Buffer.from("lo")]),
+        });
+        await expect((0, image_utils_1.fetchFromS3)(s3, "my-bucket", "/big.png", ROOT, 4)).rejects.toBeInstanceOf(image_utils_1.ImageTooLargeError);
+        // At the limit exactly is fine.
+        mockSend.mockResolvedValue({
+            Body: asyncIterableFrom([Buffer.from("hel"), Buffer.from("lo")]),
+            ContentLength: 5,
+        });
+        const result = await (0, image_utils_1.fetchFromS3)(s3, "my-bucket", "/ok.png", ROOT, 5);
+        expect(result.buffer.toString()).toBe("hello");
+    });
+    it("throws when S3 returns no body", async () => {
+        mockSend.mockResolvedValue({ Body: undefined });
+        await expect((0, image_utils_1.fetchFromS3)(s3, "my-bucket", "/missing.png", ROOT, Infinity)).rejects.toThrow(/Empty response from S3/);
+    });
+});
+describe("resolveErrorResponse", () => {
+    it("preserves the status code and message from an ImageError", () => {
+        const error = new image_optimizer_js_1.ImageError(400, '"url" parameter is not allowed');
+        expect((0, image_utils_1.resolveErrorResponse)(error, image_optimizer_js_1.ImageError)).toEqual({
+            statusCode: 400,
+            message: '"url" parameter is not allowed',
+        });
+    });
+    it("maps a source over images.maximumResponseBody to next start's 413", () => {
+        expect((0, image_utils_1.resolveErrorResponse)(new image_utils_1.ImageTooLargeError("big.png"), image_optimizer_js_1.ImageError)).toEqual({
+            statusCode: 413,
+            message: '"url" parameter is valid but internal response is invalid',
+        });
+    });
+    it("falls back to 500 for unrecognized errors", () => {
+        expect((0, image_utils_1.resolveErrorResponse)(new Error("boom"), image_optimizer_js_1.ImageError)).toEqual({
+            statusCode: 500,
+            message: "Internal Server Error",
+        });
+        expect((0, image_utils_1.resolveErrorResponse)("not an error", image_optimizer_js_1.ImageError)).toEqual({
+            statusCode: 500,
+            message: "Internal Server Error",
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-utils.test.js","sourceRoot":"","sources":["../../src/runtime/image-utils.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\njest.mock(\"@aws-sdk/client-s3\");\n\nimport { GetObjectCommand, S3Client } from \"@aws-sdk/client-s3\";\nimport { ImageError } from \"next/dist/server/image-optimizer.js\";\nimport {\n  fetchFromS3,\n  ImageTooLargeError,\n  resolveErrorResponse,\n} from \"./image-utils\";\n\nfunction asyncIterableFrom(chunks: Uint8Array[]): AsyncIterable<Uint8Array> {\n  return {\n    [Symbol.asyncIterator]() {\n      let i = 0;\n      return {\n        next: async () =>\n          i < chunks.length\n            ? { done: false, value: chunks[i++] }\n            : { done: true, value: undefined },\n      };\n    },\n  };\n}\n\n/** No app `basePath`, assets at the root of the bucket: the default. */\nconst ROOT = { urlBasePath: \"\", keyPrefix: \"\" };\n\ndescribe(\"fetchFromS3\", () => {\n  const mockSend = jest.fn();\n  const s3 = new S3Client({}) as unknown as S3Client;\n\n  beforeEach(() => {\n    (s3 as unknown as { send: typeof mockSend }).send = mockSend;\n    mockSend.mockReset();\n  });\n\n  const ok = () =>\n    mockSend.mockResolvedValue({\n      Body: asyncIterableFrom([Buffer.from(\"data\")]),\n      ContentType: \"image/png\",\n      ETag: '\"abc123\"',\n    });\n  const keyOf = () =>\n    (GetObjectCommand as unknown as jest.Mock).mock.calls[0][0].Key;\n\n  it(\"strips the leading slash when the assets sit at the bucket root\", async () => {\n    ok();\n\n    await fetchFromS3(\n      s3,\n      \"my-bucket\",\n      \"/static/foo.png\",\n      {\n        urlBasePath: \"\",\n        keyPrefix: \"\",\n      },\n      Infinity,\n    );\n\n    expect((GetObjectCommand as unknown as jest.Mock).mock.calls[0][0]).toEqual(\n      { Bucket: \"my-bucket\", Key: \"static/foo.png\" },\n    );\n  });\n\n  it(\"applies the bucket key prefix\", async () => {\n    ok();\n\n    await fetchFromS3(\n      s3,\n      \"my-bucket\",\n      \"/static/foo.jpg\",\n      {\n        urlBasePath: \"/base\",\n        keyPrefix: \"base\",\n      },\n      Infinity,\n    );\n\n    expect(keyOf()).toBe(\"base/static/foo.jpg\");\n  });\n\n  it(\"does not repeat the prefix when the url already carries basePath\", async () => {\n    ok();\n\n    // next-image-loader bakes `basePath` into the href of a statically imported\n    // image, unlike a plain string path.\n    await fetchFromS3(\n      s3,\n      \"my-bucket\",\n      \"/base/_next/static/media/a.png\",\n      {\n        urlBasePath: \"/base\",\n        keyPrefix: \"base\",\n      },\n      Infinity,\n    );\n\n    expect(keyOf()).toBe(\"base/_next/static/media/a.png\");\n  });\n\n  /**\n   * The API Gateway deployment types serve the app under the stage name, so the\n   * app's `basePath` is `/prod` while the assets were uploaded to the root of the\n   * bucket. Building the key from `basePath` asks S3 for `prod/...`, which does\n   * not exist, and every local `<Image>` 400s.\n   */\n  it(\"strips a basePath that is not part of the key\", async () => {\n    ok();\n\n    await fetchFromS3(\n      s3,\n      \"my-bucket\",\n      \"/prod/_next/static/media/a.png\",\n      {\n        urlBasePath: \"/prod\",\n        keyPrefix: \"\",\n      },\n      Infinity,\n    );\n\n    expect(keyOf()).toBe(\"_next/static/media/a.png\");\n  });\n\n  it(\"leaves a url without basePath alone when there is no key prefix\", async () => {\n    ok();\n\n    await fetchFromS3(\n      s3,\n      \"my-bucket\",\n      \"/static/foo.jpg\",\n      {\n        urlBasePath: \"/prod\",\n        keyPrefix: \"\",\n      },\n      Infinity,\n    );\n\n    expect(keyOf()).toBe(\"static/foo.jpg\");\n  });\n\n  // With `assetPrefix: \"/cdn\"`, a static import's href is\n  // `/cdn/_next/static/media/…`, with `basePath` nowhere in it.\n  it(\"strips a path assetPrefix in front of /_next/\", async () => {\n    ok();\n\n    await fetchFromS3(\n      s3,\n      \"my-bucket\",\n      \"/cdn/_next/static/media/a.png\",\n      {\n        urlBasePath: \"/base\",\n        keyPrefix: \"\",\n        assetPrefix: \"/cdn/\",\n      },\n      Infinity,\n    );\n\n    expect(keyOf()).toBe(\"_next/static/media/a.png\");\n  });\n\n  it(\"leaves a public/ file under a directory named like the assetPrefix alone\", async () => {\n    ok();\n\n    await fetchFromS3(\n      s3,\n      \"my-bucket\",\n      \"/cdn/logo.png\",\n      {\n        urlBasePath: \"\",\n        keyPrefix: \"\",\n        assetPrefix: \"/cdn\",\n      },\n      Infinity,\n    );\n\n    expect(keyOf()).toBe(\"cdn/logo.png\");\n  });\n\n  it(\"ignores an absolute assetPrefix\", async () => {\n    ok();\n\n    await fetchFromS3(\n      s3,\n      \"my-bucket\",\n      \"/_next/static/media/a.png\",\n      {\n        urlBasePath: \"\",\n        keyPrefix: \"\",\n        assetPrefix: \"https://cdn.example.test\",\n      },\n      Infinity,\n    );\n\n    expect(keyOf()).toBe(\"_next/static/media/a.png\");\n  });\n\n  it(\"only matches basePath on a path boundary\", async () => {\n    ok();\n\n    await fetchFromS3(\n      s3,\n      \"my-bucket\",\n      \"/basement/logo.png\",\n      {\n        urlBasePath: \"/base\",\n        keyPrefix: \"base\",\n      },\n      Infinity,\n    );\n\n    expect(keyOf()).toBe(\"base/basement/logo.png\");\n  });\n\n  // Carried over from #267, which fixed the same bug in the pre-adapter image\n  // handler: a `destinationKeyPrefix` override can arrive with a trailing slash.\n  it(\"doesn't double the separator when the key prefix has a trailing slash\", async () => {\n    ok();\n\n    await fetchFromS3(\n      s3,\n      \"my-bucket\",\n      \"/static/foo.jpg\",\n      {\n        urlBasePath: \"\",\n        keyPrefix: \"base/\",\n      },\n      Infinity,\n    );\n\n    expect(keyOf()).toBe(\"base/static/foo.jpg\");\n  });\n\n  // `next-image-legacy/unicode`, whose `public/` holds both of these names. The\n  // space is what broke: the key is the file's real name, the url is a URL path.\n  it.each([\n    [\"/hello%20world.jpg\", \"hello world.jpg\"],\n    [\"/äöüščří.png\", \"äöüščří.png\"],\n    [\"/%C3%A4%C3%B6.png\", \"äö.png\"],\n  ])(\"decodes %s into the object's real name\", async (url, key) => {\n    ok();\n\n    await fetchFromS3(s3, \"my-bucket\", url, ROOT, Infinity);\n\n    expect(keyOf()).toBe(key);\n  });\n\n  // A cache-buster on a local src: `next start` routes the href as a request, so\n  // the query and fragment never reach the file lookup.\n  it.each([\n    [\"/logo.png?v=2\", \"logo.png\"],\n    [\"/logo.png#top\", \"logo.png\"],\n    [\"/logo.png?v=2#top\", \"logo.png\"],\n    [\"/base/logo.png?v=2\", \"logo.png\"],\n    // A `?` that is part of the name arrives encoded and is not a query.\n    [\"/what%3F.png?v=2\", \"what?.png\"],\n  ])(\"keys %s by its path alone\", async (url, key) => {\n    ok();\n\n    await fetchFromS3(\n      s3,\n      \"my-bucket\",\n      url,\n      {\n        urlBasePath: \"/base\",\n        keyPrefix: \"\",\n      },\n      Infinity,\n    );\n\n    expect(keyOf()).toBe(key);\n  });\n\n  it(\"leaves a name that isn't valid percent-encoding alone\", async () => {\n    ok();\n\n    await fetchFromS3(s3, \"my-bucket\", \"/100%.png\", ROOT, Infinity);\n\n    expect(keyOf()).toBe(\"100%.png\");\n  });\n\n  it(\"returns the concatenated buffer, content type, and etag\", async () => {\n    mockSend.mockResolvedValue({\n      Body: asyncIterableFrom([Buffer.from(\"hel\"), Buffer.from(\"lo\")]),\n      ContentType: \"image/jpeg\",\n      ETag: '\"the-etag\"',\n    });\n\n    const result = await fetchFromS3(\n      s3,\n      \"my-bucket\",\n      \"/foo.jpg\",\n      ROOT,\n      Infinity,\n    );\n\n    expect(result.buffer.toString()).toBe(\"hello\");\n    expect(result.contentType).toBe(\"image/jpeg\");\n    expect(result.etag).toBe('\"the-etag\"');\n  });\n\n  it(\"returns an empty etag when S3 doesn't provide one\", async () => {\n    mockSend.mockResolvedValue({\n      Body: asyncIterableFrom([Buffer.from(\"data\")]),\n      ContentType: null,\n      ETag: undefined,\n    });\n\n    const result = await fetchFromS3(\n      s3,\n      \"my-bucket\",\n      \"/foo.png\",\n      ROOT,\n      Infinity,\n    );\n\n    expect(result.etag).toBe(\"\");\n    expect(result.contentType).toBeNull();\n  });\n\n  // `images.maximumResponseBody`, which `next start` enforces on local sources.\n  it(\"refuses an object whose ContentLength is over the limit, unread\", async () => {\n    const destroy = jest.fn();\n    mockSend.mockResolvedValue({\n      Body: { ...asyncIterableFrom([Buffer.from(\"never read\")]), destroy },\n      ContentLength: 11,\n    });\n\n    await expect(\n      fetchFromS3(s3, \"my-bucket\", \"/big.png\", ROOT, 10),\n    ).rejects.toBeInstanceOf(ImageTooLargeError);\n    expect(destroy).toHaveBeenCalled();\n  });\n\n  it(\"stops reading once the bytes read pass the limit\", async () => {\n    mockSend.mockResolvedValue({\n      Body: asyncIterableFrom([Buffer.from(\"hel\"), Buffer.from(\"lo\")]),\n    });\n\n    await expect(\n      fetchFromS3(s3, \"my-bucket\", \"/big.png\", ROOT, 4),\n    ).rejects.toBeInstanceOf(ImageTooLargeError);\n    // At the limit exactly is fine.\n    mockSend.mockResolvedValue({\n      Body: asyncIterableFrom([Buffer.from(\"hel\"), Buffer.from(\"lo\")]),\n      ContentLength: 5,\n    });\n    const result = await fetchFromS3(s3, \"my-bucket\", \"/ok.png\", ROOT, 5);\n    expect(result.buffer.toString()).toBe(\"hello\");\n  });\n\n  it(\"throws when S3 returns no body\", async () => {\n    mockSend.mockResolvedValue({ Body: undefined });\n\n    await expect(\n      fetchFromS3(s3, \"my-bucket\", \"/missing.png\", ROOT, Infinity),\n    ).rejects.toThrow(/Empty response from S3/);\n  });\n});\n\ndescribe(\"resolveErrorResponse\", () => {\n  it(\"preserves the status code and message from an ImageError\", () => {\n    const error = new ImageError(400, '\"url\" parameter is not allowed');\n\n    expect(resolveErrorResponse(error, ImageError)).toEqual({\n      statusCode: 400,\n      message: '\"url\" parameter is not allowed',\n    });\n  });\n\n  it(\"maps a source over images.maximumResponseBody to next start's 413\", () => {\n    expect(\n      resolveErrorResponse(new ImageTooLargeError(\"big.png\"), ImageError),\n    ).toEqual({\n      statusCode: 413,\n      message: '\"url\" parameter is valid but internal response is invalid',\n    });\n  });\n\n  it(\"falls back to 500 for unrecognized errors\", () => {\n    expect(resolveErrorResponse(new Error(\"boom\"), ImageError)).toEqual({\n      statusCode: 500,\n      message: \"Internal Server Error\",\n    });\n    expect(resolveErrorResponse(\"not an error\", ImageError)).toEqual({\n      statusCode: 500,\n      message: \"Internal Server Error\",\n    });\n  });\n});\n"]}

package/lib/runtime/image.d.ts

@@ -0,0 +1,76 @@
+import type { ShimIncomingMessage } from "./http/request";
+import { ShimServerResponse } from "./http/response";
+import { AdapterManifest } from "./manifest";
+export interface ImageOptimizerOptions {
+    readonly deploymentRoot: string;
+    readonly manifest: AdapterManifest;
+    /**
+     * `CDK_NEXTJS_STATIC_ASSETS_BUCKET_NAME`. Empty when the sources are on disk
+     * (`NextjsRegionalContainers`), which sends every one to `fetchInternal`.
+     */
+    readonly bucket: string;
+    /**
+     * `CDK_NEXTJS_STATIC_ASSETS_KEY_PREFIX`. Empty when the assets sit at the root
+     * of the bucket, which is the default.
+     */
+    readonly bucketKeyPrefix: string;
+    /**
+     * Requests a local source from the app's own routes, for one S3 has no file
+     * for: `<Image src="/api/avatar?id=42">`, served by a route handler. `next
+     * start` fetches every local source that way (`fetchInternalImage`); here it
+     * is the fallback, since nearly every source is a file, and a `GetObject` is
+     * far cheaper than a route invocation.
+     *
+     * Given the request being optimized, for its authority; like `next start`,
+     * the viewer's cookies and other headers are not the implementation's to
+     * forward. And given `images.maximumResponseBody`, past which it stops
+     * reading and answers {@link InternalImageResponse.tooLarge}.
+     */
+    readonly fetchInternal: (href: string, req: ShimIncomingMessage, maximumResponseBody: number) => Promise<InternalImageResponse>;
+    /**
+     * Loads the `cacheHandler` module from its file URL. A seam for tests, which
+     * run as CommonJS and cannot `import()` a URL.
+     * @default - `import()`
+     */
+    readonly importModule?: (url: string) => Promise<unknown>;
+}
+/** The response {@link ImageOptimizerOptions.fetchInternal} got. */
+export interface InternalImageResponse {
+    readonly statusCode: number;
+    readonly headers: Readonly<Record<string, string | string[] | undefined>>;
+    readonly body: Buffer;
+    /**
+     * The `functionGroups` group whose package has the route that serves the
+     * source, when it is not this function's: there is no response to use, and
+     * the optimizer answers an explicit 502 rather than a "not a valid image".
+     */
+    readonly otherGroup?: string;
+    /**
+     * The body passed `images.maximumResponseBody`, so it was cut off: a 413, as
+     * `next start` answers.
+     */
+    readonly tooLarge?: boolean;
+}
+export declare class RuntimeImageOptimizer {
+    private readonly options;
+    private readonly s3;
+    private loaded?;
+    private imageCache?;
+    constructor(options: ImageOptimizerOptions);
+    /**
+     * Whether the app serves `/_next/image` at all. `next start` answers 404
+     * when `images.unoptimized` is set or a non-default `loader` is configured
+     * (`next-server.js`), and so does the runtime: otherwise anyone can make the
+     * compute run sharp and write the image cache on an endpoint the app turned
+     * off.
+     */
+    isEnabled(): boolean;
+    handle(req: ShimIncomingMessage, res: ShimServerResponse, url: URL, waitUntil: (promise: Promise<unknown>) => void): Promise<void>;
+    /**
+     * Evicted on failure, as `EntrypointRegistry.load` evicts a failed module load:
+     * a transient failure importing the `cacheHandler` (EMFILE under a cold-start
+     * burst) would otherwise 500 every image request until the sandbox recycles.
+     */
+    private loadCache;
+    private fetchLocal;
+}