cdk-nextjs 0.5.15 → 0.6.0

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

@@ -0,0 +1,178 @@
+"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("applies the key prefix once when the url already includes the app basePath", 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", "/base");
+        const params = client_s3_1.GetObjectCommand.mock.calls[0][0];
+        expect(params.Key).toBe("base/_next/static/media/a.png");
+    });
+    it("applies the key prefix when the url omits the app basePath", 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", "/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", "/base");
+        const params = client_s3_1.GetObjectCommand.mock.calls[0][0];
+        expect(params.Key).toBe("base/basement/logo.png");
+    });
+    // regression test: the Next.js app's own `basePath` (e.g. set to match an
+    // API Gateway stage) and the CDK `NextjsStaticAssets` `basePath` prop (key
+    // namespacing) are unrelated and don't have to match. A deployment that
+    // only sets the former must not leak it into the S3 key.
+    it("doesn't apply nextBasePath as a key prefix when the key prefix differs", async () => {
+        mockSend.mockResolvedValue({
+            Body: asyncIterableFrom([Buffer.from("data")]),
+            ContentType: "image/png",
+            ETag: '"abc123"',
+        });
+        await (0, handler_utils_1.fetchFromS3)(s3, "my-bucket", "/static/nextjs-icon-light-background.png", "/prod", "");
+        const params = client_s3_1.GetObjectCommand.mock.calls[0][0];
+        expect(params.Key).toBe("static/nextjs-icon-light-background.png");
+    });
+    it("strips nextBasePath from a baked-in href before applying a different key prefix", async () => {
+        mockSend.mockResolvedValue({
+            Body: asyncIterableFrom([Buffer.from("data")]),
+            ContentType: "image/png",
+            ETag: '"abc123"',
+        });
+        await (0, handler_utils_1.fetchFromS3)(s3, "my-bucket", "/prod/_next/static/media/imported-logo.png", "/prod", "");
+        const params = client_s3_1.GetObjectCommand.mock.calls[0][0];
+        expect(params.Key).toBe("_next/static/media/imported-logo.png");
+    });
+    it("doesn't double the separator when the key prefix has a trailing slash", async () => {
+        mockSend.mockResolvedValue({
+            Body: asyncIterableFrom([Buffer.from("data")]),
+            ContentType: "image/png",
+            ETag: '"abc123"',
+        });
+        // BucketDeployment collapses the trailing slash when uploading, so the
+        // object is at "base/static/foo.jpg", not "base//static/foo.jpg".
+        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("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(\"applies the key prefix once when the url already includes the app basePath\", 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      \"/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(\"applies the key prefix when the url omits the app basePath\", 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\", \"/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\", \"/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  // regression test: the Next.js app's own `basePath` (e.g. set to match an\n  // API Gateway stage) and the CDK `NextjsStaticAssets` `basePath` prop (key\n  // namespacing) are unrelated and don't have to match. A deployment that\n  // only sets the former must not leak it into the S3 key.\n  it(\"doesn't apply nextBasePath as a key prefix when the key prefix differs\", async () => {\n    mockSend.mockResolvedValue({\n      Body: asyncIterableFrom([Buffer.from(\"data\")]),\n      ContentType: \"image/png\",\n      ETag: '\"abc123\"',\n    });\n\n    await fetchFromS3(\n      s3,\n      \"my-bucket\",\n      \"/static/nextjs-icon-light-background.png\",\n      \"/prod\",\n      \"\",\n    );\n\n    const params = (GetObjectCommand as unknown as jest.Mock).mock.calls[0][0];\n    expect(params.Key).toBe(\"static/nextjs-icon-light-background.png\");\n  });\n\n  it(\"strips nextBasePath from a baked-in href before applying a different key prefix\", async () => {\n    mockSend.mockResolvedValue({\n      Body: asyncIterableFrom([Buffer.from(\"data\")]),\n      ContentType: \"image/png\",\n      ETag: '\"abc123\"',\n    });\n\n    await fetchFromS3(\n      s3,\n      \"my-bucket\",\n      \"/prod/_next/static/media/imported-logo.png\",\n      \"/prod\",\n      \"\",\n    );\n\n    const params = (GetObjectCommand as unknown as jest.Mock).mock.calls[0][0];\n    expect(params.Key).toBe(\"_next/static/media/imported-logo.png\");\n  });\n\n  it(\"doesn't double the separator when the key prefix has a trailing slash\", async () => {\n    mockSend.mockResolvedValue({\n      Body: asyncIterableFrom([Buffer.from(\"data\")]),\n      ContentType: \"image/png\",\n      ETag: '\"abc123\"',\n    });\n\n    // BucketDeployment collapses the trailing slash when uploading, so the\n    // object is at \"base/static/foo.jpg\", not \"base//static/foo.jpg\".\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(\"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"]}