cdk-nextjs 0.5.14 → 0.5.16

package/lib/image-optimization/handler-utils.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchFromS3 = fetchFromS3;
+exports.getFileNameWithExtension = getFileNameWithExtension;
+exports.resolveErrorResponse = resolveErrorResponse;
+/* eslint-disable import/no-extraneous-dependencies */
+const client_s3_1 = require("@aws-sdk/client-s3");
+const image_optimizer_js_1 = require("next/dist/server/image-optimizer.js");
+const serve_static_js_1 = require("next/dist/server/serve-static.js");
+/**
+ * Fetches a non-absolute (local) image referenced by an `<Image>` from S3.
+ *
+ * `NextjsStaticAssets` uploads under `basePath` as a key prefix, so every key
+ * includes it. `url` is inconsistent: next-image-loader bakes `basePath` into
+ * the href for statically imported images, while plain string paths are passed
+ * through as literally written by the app. So the prefix is normalized to
+ * exactly one occurrence rather than simply added or removed.
+ */
+async function fetchFromS3(s3, bucket, url, basePath) {
+    // Matching on a path boundary keeps a sibling like "/basement/logo.png"
+    // from being treated as basePath "/base" plus "ment/logo.png".
+    const hasBasePath = !!basePath && (url === basePath || url.startsWith(`${basePath}/`));
+    const withoutBasePath = hasBasePath ? url.slice(basePath.length) : url;
+    const key = `${basePath}${withoutBasePath}`.replace(/^\//, "");
+    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}`);
+    }
+    const chunks = [];
+    for await (const chunk of body) {
+        chunks.push(Buffer.from(chunk));
+    }
+    return {
+        buffer: Buffer.concat(chunks),
+        contentType: response.ContentType || null,
+        etag: response.ETag || "",
+    };
+}
+/** Mirrors Next.js's own `getFileNameWithExtension` in image-optimizer.js. */
+function getFileNameWithExtension(url, contentType) {
+    const [urlWithoutQueryParams] = url.split("?", 1);
+    const fileNameWithExtension = urlWithoutQueryParams.split("/").pop();
+    if (!contentType || !fileNameWithExtension) {
+        return "image.bin";
+    }
+    const [fileName] = fileNameWithExtension.split(".", 1);
+    const extension = (0, serve_static_js_1.getExtension)(contentType);
+    return `${fileName}.${extension}`;
+}
+/**
+ * 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 missing S3 object is mapped to
+ * the same 400 Next.js's own local-image fetch path (`fetchInternalImage` in
+ * image-optimizer.js) produces for a missing file: it never inspects the
+ * internal request's status code, so a 404 there just flows into the normal
+ * "not a valid image" content-type check as if it were malformed image
+ * bytes. This mirrors that behavior instead of surfacing a 404, so Functions
+ * and Containers deployments respond identically for this case.
+ */
+function resolveErrorResponse(error) {
+    if (error instanceof image_optimizer_js_1.ImageError) {
+        return { statusCode: error.statusCode, message: error.message };
+    }
+    if (error instanceof Error && error.name === "NoSuchKey") {
+        return {
+            statusCode: 400,
+            message: "The requested resource isn't a valid image.",
+        };
+    }
+    return { statusCode: 500, message: "Internal Server Error" };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/image-optimization/handler-utils.test.d.ts

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

package/lib/image-optimization/handler-utils.test.js

@@ -0,0 +1,142 @@
+"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 handler_utils_1 = require("./handler-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 },
+            };
+        },
+    };
+}
+describe("fetchFromS3", () => {
+    const mockSend = jest.fn();
+    const s3 = new client_s3_1.S3Client({});
+    beforeEach(() => {
+        s3.send = mockSend;
+        mockSend.mockReset();
+    });
+    it("strips the leading slash and uses url as-is for the S3 key", async () => {
+        mockSend.mockResolvedValue({
+            Body: asyncIterableFrom([Buffer.from("data")]),
+            ContentType: "image/png",
+            ETag: '"abc123"',
+        });
+        await (0, handler_utils_1.fetchFromS3)(s3, "my-bucket", "/base/foo.png", "");
+        const params = client_s3_1.GetObjectCommand.mock.calls[0][0];
+        expect(params).toEqual({
+            Bucket: "my-bucket",
+            Key: "base/foo.png",
+        });
+    });
+    it("keeps a single basePath prefix when the url already includes it", async () => {
+        mockSend.mockResolvedValue({
+            Body: asyncIterableFrom([Buffer.from("data")]),
+            ContentType: "image/png",
+            ETag: '"abc123"',
+        });
+        // next-image-loader bakes "/base" into the href for statically imported
+        // images, and NextjsStaticAssets uploads under the same prefix, so the
+        // key must carry it exactly once.
+        await (0, handler_utils_1.fetchFromS3)(s3, "my-bucket", "/base/_next/static/media/a.png", "/base");
+        const params = client_s3_1.GetObjectCommand.mock.calls[0][0];
+        expect(params.Key).toBe("base/_next/static/media/a.png");
+    });
+    it("adds the basePath prefix when the url omits it", async () => {
+        mockSend.mockResolvedValue({
+            Body: asyncIterableFrom([Buffer.from("data")]),
+            ContentType: "image/png",
+            ETag: '"abc123"',
+        });
+        // Plain string paths (e.g. `<Image src="/static/foo.jpg">`) are passed
+        // through by next/image as written, without basePath baked in, but the
+        // S3 key still has it.
+        await (0, handler_utils_1.fetchFromS3)(s3, "my-bucket", "/static/foo.jpg", "/base");
+        const params = client_s3_1.GetObjectCommand.mock.calls[0][0];
+        expect(params.Key).toBe("base/static/foo.jpg");
+    });
+    it("only matches basePath on a path boundary", async () => {
+        mockSend.mockResolvedValue({
+            Body: asyncIterableFrom([Buffer.from("data")]),
+            ContentType: "image/png",
+            ETag: '"abc123"',
+        });
+        // "/basement" merely shares a prefix with basePath "/base"; treating it
+        // as a match would produce the key "base/ment/logo.png".
+        await (0, handler_utils_1.fetchFromS3)(s3, "my-bucket", "/basement/logo.png", "/base");
+        const params = client_s3_1.GetObjectCommand.mock.calls[0][0];
+        expect(params.Key).toBe("base/basement/logo.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, handler_utils_1.fetchFromS3)(s3, "my-bucket", "/foo.jpg", "");
+        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, handler_utils_1.fetchFromS3)(s3, "my-bucket", "/foo.png", "");
+        expect(result.etag).toBe("");
+        expect(result.contentType).toBeNull();
+    });
+    it("throws when S3 returns no body", async () => {
+        mockSend.mockResolvedValue({ Body: undefined });
+        await expect((0, handler_utils_1.fetchFromS3)(s3, "my-bucket", "/missing.png", "")).rejects.toThrow(/Empty response from S3/);
+    });
+});
+describe("getFileNameWithExtension", () => {
+    it("derives filename and extension from the url and content type", () => {
+        expect((0, handler_utils_1.getFileNameWithExtension)("/foo/bar.png?w=100&q=75", "image/webp")).toBe("bar.webp");
+    });
+    it("falls back to image.bin when contentType is missing", () => {
+        expect((0, handler_utils_1.getFileNameWithExtension)("/foo/bar.png", null)).toBe("image.bin");
+    });
+    it("falls back to image.bin when the url has no filename segment", () => {
+        expect((0, handler_utils_1.getFileNameWithExtension)("/", "image/png")).toBe("image.bin");
+    });
+});
+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, handler_utils_1.resolveErrorResponse)(error)).toEqual({
+            statusCode: 400,
+            message: '"url" parameter is not allowed',
+        });
+    });
+    it("maps a missing S3 object to the same 400 Next.js's own local-image fetch produces", () => {
+        const error = new Error("NoSuchKey: does not exist");
+        error.name = "NoSuchKey";
+        expect((0, handler_utils_1.resolveErrorResponse)(error)).toEqual({
+            statusCode: 400,
+            message: "The requested resource isn't a valid image.",
+        });
+    });
+    it("falls back to 500 for unrecognized errors", () => {
+        expect((0, handler_utils_1.resolveErrorResponse)(new Error("boom"))).toEqual({
+            statusCode: 500,
+            message: "Internal Server Error",
+        });
+        expect((0, handler_utils_1.resolveErrorResponse)("not an error")).toEqual({
+            statusCode: 500,
+            message: "Internal Server Error",
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"handler-utils.test.js","sourceRoot":"","sources":["../../src/image-optimization/handler-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  getFileNameWithExtension,\n  resolveErrorResponse,\n} from \"./handler-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\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  it(\"strips the leading slash and uses url as-is for the S3 key\", async () => {\n    mockSend.mockResolvedValue({\n      Body: asyncIterableFrom([Buffer.from(\"data\")]),\n      ContentType: \"image/png\",\n      ETag: '\"abc123\"',\n    });\n\n    await fetchFromS3(s3, \"my-bucket\", \"/base/foo.png\", \"\");\n\n    const params = (GetObjectCommand as unknown as jest.Mock).mock.calls[0][0];\n    expect(params).toEqual({\n      Bucket: \"my-bucket\",\n      Key: \"base/foo.png\",\n    });\n  });\n\n  it(\"keeps a single basePath prefix when the url already includes it\", async () => {\n    mockSend.mockResolvedValue({\n      Body: asyncIterableFrom([Buffer.from(\"data\")]),\n      ContentType: \"image/png\",\n      ETag: '\"abc123\"',\n    });\n\n    // next-image-loader bakes \"/base\" into the href for statically imported\n    // images, and NextjsStaticAssets uploads under the same prefix, so the\n    // key must carry it exactly once.\n    await fetchFromS3(\n      s3,\n      \"my-bucket\",\n      \"/base/_next/static/media/a.png\",\n      \"/base\",\n    );\n\n    const params = (GetObjectCommand as unknown as jest.Mock).mock.calls[0][0];\n    expect(params.Key).toBe(\"base/_next/static/media/a.png\");\n  });\n\n  it(\"adds the basePath prefix when the url omits it\", async () => {\n    mockSend.mockResolvedValue({\n      Body: asyncIterableFrom([Buffer.from(\"data\")]),\n      ContentType: \"image/png\",\n      ETag: '\"abc123\"',\n    });\n\n    // Plain string paths (e.g. `<Image src=\"/static/foo.jpg\">`) are passed\n    // through by next/image as written, without basePath baked in, but the\n    // S3 key still has it.\n    await fetchFromS3(s3, \"my-bucket\", \"/static/foo.jpg\", \"/base\");\n\n    const params = (GetObjectCommand as unknown as jest.Mock).mock.calls[0][0];\n    expect(params.Key).toBe(\"base/static/foo.jpg\");\n  });\n\n  it(\"only matches basePath on a path boundary\", async () => {\n    mockSend.mockResolvedValue({\n      Body: asyncIterableFrom([Buffer.from(\"data\")]),\n      ContentType: \"image/png\",\n      ETag: '\"abc123\"',\n    });\n\n    // \"/basement\" merely shares a prefix with basePath \"/base\"; treating it\n    // as a match would produce the key \"base/ment/logo.png\".\n    await fetchFromS3(s3, \"my-bucket\", \"/basement/logo.png\", \"/base\");\n\n    const params = (GetObjectCommand as unknown as jest.Mock).mock.calls[0][0];\n    expect(params.Key).toBe(\"base/basement/logo.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(s3, \"my-bucket\", \"/foo.jpg\", \"\");\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(s3, \"my-bucket\", \"/foo.png\", \"\");\n\n    expect(result.etag).toBe(\"\");\n    expect(result.contentType).toBeNull();\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\", \"\"),\n    ).rejects.toThrow(/Empty response from S3/);\n  });\n});\n\ndescribe(\"getFileNameWithExtension\", () => {\n  it(\"derives filename and extension from the url and content type\", () => {\n    expect(\n      getFileNameWithExtension(\"/foo/bar.png?w=100&q=75\", \"image/webp\"),\n    ).toBe(\"bar.webp\");\n  });\n\n  it(\"falls back to image.bin when contentType is missing\", () => {\n    expect(getFileNameWithExtension(\"/foo/bar.png\", null)).toBe(\"image.bin\");\n  });\n\n  it(\"falls back to image.bin when the url has no filename segment\", () => {\n    expect(getFileNameWithExtension(\"/\", \"image/png\")).toBe(\"image.bin\");\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)).toEqual({\n      statusCode: 400,\n      message: '\"url\" parameter is not allowed',\n    });\n  });\n\n  it(\"maps a missing S3 object to the same 400 Next.js's own local-image fetch produces\", () => {\n    const error = new Error(\"NoSuchKey: does not exist\");\n    error.name = \"NoSuchKey\";\n\n    expect(resolveErrorResponse(error)).toEqual({\n      statusCode: 400,\n      message: \"The requested resource isn't a valid image.\",\n    });\n  });\n\n  it(\"falls back to 500 for unrecognized errors\", () => {\n    expect(resolveErrorResponse(new Error(\"boom\"))).toEqual({\n      statusCode: 500,\n      message: \"Internal Server Error\",\n    });\n    expect(resolveErrorResponse(\"not an error\")).toEqual({\n      statusCode: 500,\n      message: \"Internal Server Error\",\n    });\n  });\n});\n"]}