cdk-nextjs 0.5.16 → 0.6.0

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

@@ -37,7 +37,7 @@ describe("fetchFromS3", () => {
             Key: "base/foo.png",
         });
     });
-    it("keeps a single basePath prefix when the url already includes it", async () => {
+    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",
@@ -46,11 +46,11 @@ describe("fetchFromS3", () => {
         // 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");
+        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("adds the basePath prefix when the url omits it", async () => {
+    it("applies the key prefix when the url omits the app basePath", async () => {
         mockSend.mockResolvedValue({
             Body: asyncIterableFrom([Buffer.from("data")]),
             ContentType: "image/png",
@@ -59,7 +59,7 @@ describe("fetchFromS3", () => {
         // 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");
+        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");
     });
@@ -71,10 +71,46 @@ describe("fetchFromS3", () => {
         });
         // "/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");
+        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")]),
@@ -139,4 +175,4 @@ describe("resolveErrorResponse", () => {
         });
     });
 });
-//# 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"]}
+//# 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"]}

package/lib/image-optimization/handler.mjs

@@ -55838,10 +55838,22 @@ import { readFileSync } from "node:fs";
 var import_client_s3 = __toESM(require_dist_cjs16());
 var import_image_optimizer = __toESM(require_image_optimizer());
 var import_serve_static = __toESM(require_serve_static());
-async function fetchFromS3(s32, bucket, url, basePath) {
-  const hasBasePath = !!basePath && (url === basePath || url.startsWith(`${basePath}/`));
-  const withoutBasePath = hasBasePath ? url.slice(basePath.length) : url;
-  const key = `${basePath}${withoutBasePath}`.replace(/^\//, "");
+
+// src/utils/base-path.ts
+function normalizeBasePath(basePath) {
+  return (basePath || "").replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function joinPath(...parts) {
+  return parts.map(normalizeBasePath).filter(Boolean).join("/");
+}
+
+// src/image-optimization/handler-utils.ts
+async function fetchFromS3(s32, bucket, url, nextBasePath, staticAssetsKeyPrefix = "") {
+  const hasNextBasePath = !!nextBasePath && (url === nextBasePath || url.startsWith(`${nextBasePath}/`));
+  const key = joinPath(
+    staticAssetsKeyPrefix,
+    hasNextBasePath ? url.slice(nextBasePath.length) : url
+  );
   const response = await s32.send(
     new import_client_s3.GetObjectCommand({
       Bucket: bucket,
@@ -55889,6 +55901,7 @@ function resolveErrorResponse(error2) {
 var debug = (0, import_debug5.default)("cdk-nextjs:image-optimization");
 var s3 = new import_client_s32.S3Client({});
 var STATIC_ASSETS_BUCKET = process.env.CDK_NEXTJS_STATIC_ASSETS_BUCKET_NAME || "";
+var STATIC_ASSETS_KEY_PREFIX = process.env.CDK_NEXTJS_STATIC_ASSETS_KEY_PREFIX || "";
 var requiredServerFiles = JSON.parse(
   readFileSync("required-server-files.json", "utf-8")
 );
@@ -55940,7 +55953,8 @@ var handler = awslambda.streamifyResponse(
         s3,
         STATIC_ASSETS_BUCKET,
         href,
-        nextConfig.basePath
+        nextConfig.basePath,
+        STATIC_ASSETS_KEY_PREFIX
       ).then((result) => ({
         buffer: result.buffer,
         contentType: result.contentType,

package/lib/nextjs-api.d.ts

@@ -46,6 +46,17 @@ export interface NextjsApiProps {
      * The S3 bucket containing static assets
      */
     readonly staticAssetsBucket: IBucket;
+    /**
+     * S3 key prefix the static assets were uploaded under, i.e.
+     * `NextjsStaticAssets.keyPrefix`, which namespaces a shared bucket.
+     *
+     * Independent of `basePath` above: that one is the URL prefix the REST API
+     * serves the app at (commonly the API Gateway stage), while this one is where
+     * the objects live in the bucket. `_next/static` and public directory
+     * requests are mapped to S3 keys directly, so they 404 unless this prefix is
+     * applied.
+     */
+    readonly staticAssetsKeyPrefix?: string;
     /**
      * [Future] Required if `NextjsRegionalContainers`. VPC to create VPC Link and ECS Service Discovery
      */
@@ -59,6 +70,16 @@ export declare class NextjsApi extends Construct {
      * The API Gateway REST API
      */
     readonly api: RestApi;
+    /**
+     * Public URL of the app, including every path segment the API nests it under.
+     * Prefers a custom domain configured through `overrides.restApiProps.domainName`
+     * over the execute-api endpoint.
+     *
+     * A domain attached after this construct is created (`api.addDomainName()`) is
+     * still used for the host, but CDK keeps its base path mappings private, so a
+     * mapping added that way won't show up here.
+     */
+    get url(): string;
     private readonly baseResource;
     private readonly nextResource;
     private readonly props;
@@ -72,6 +93,11 @@ export declare class NextjsApi extends Construct {
     private createBaseResource;
     private createStaticIntegrationRole;
     private createStaticIntegrations;
+    /**
+     * Prefixes a request path with the key prefix the assets were uploaded under,
+     * since the S3 integrations address objects by key rather than by URL.
+     */
+    private s3Key;
     /**
      * Maps API request to S3 request.
      * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-parameter-mapping-sources.html

package/lib/nextjs-api.js

@@ -6,15 +6,40 @@ const aws_cdk_lib_1 = require("aws-cdk-lib");
 const aws_apigateway_1 = require("aws-cdk-lib/aws-apigateway");
 const aws_iam_1 = require("aws-cdk-lib/aws-iam");
 const constructs_1 = require("constructs");
+const base_path_1 = require("./utils/base-path");
 /**
  * Creates an API Gateway REST API for Next.js applications
  */
 class NextjsApi extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsApi", version: "0.5.16" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsApi", version: "0.6.0" };
     /**
      * The API Gateway REST API
      */
     api;
+    /**
+     * Public URL of the app, including every path segment the API nests it under.
+     * Prefers a custom domain configured through `overrides.restApiProps.domainName`
+     * over the execute-api endpoint.
+     *
+     * A domain attached after this construct is created (`api.addDomainName()`) is
+     * still used for the host, but CDK keeps its base path mappings private, so a
+     * mapping added that way won't show up here.
+     */
+    get url() {
+        const customDomain = this.api.domainName;
+        // A custom domain reaches the stage through a base path mapping, so the
+        // stage name isn't in the path there; the mapping may be, when set.
+        const [origin, prefix] = customDomain
+            ? [
+                `https://${customDomain.domainName}`,
+                this.props.overrides?.restApiProps?.domainName?.basePath,
+            ]
+            : [
+                `https://${this.api.restApiId}.execute-api.${aws_cdk_lib_1.Stack.of(this).region}.amazonaws.com`,
+                this.api.deploymentStage.stageName,
+            ];
+        return (0, base_path_1.joinPath)(origin, prefix, this.props.basePath);
+    }
     baseResource;
     nextResource;
     props;
@@ -59,14 +84,8 @@ class NextjsApi extends constructs_1.Construct {
      */
     createBaseResource(basePath) {
         // Create base resource path if needed
-        let baseResource = this.api.root;
-        if (basePath) {
-            const _basePath = basePath.startsWith("/")
-                ? basePath.substring(1)
-                : basePath;
-            baseResource = this.api.root.addResource(_basePath);
-        }
-        return baseResource;
+        const normalized = (0, base_path_1.normalizeBasePath)(basePath);
+        return normalized ? this.api.root.addResource(normalized) : this.api.root;
     }
     createStaticIntegrationRole() {
         // Create S3 integration role
@@ -86,22 +105,31 @@ class NextjsApi extends constructs_1.Construct {
         this.nextResource
             .addResource("static")
             .addResource("{proxy+}")
-            .addMethod("GET", this.createS3Integration({ key: "_next/static/{key}" }), this.getStaticMethodOptions({ proxy: true }));
+            .addMethod("GET", this.createS3Integration({ key: this.s3Key("_next/static/{key}") }), this.getStaticMethodOptions({ proxy: true }));
         // add public directory files/directories that exist at top level but need to go to S3.
         for (const publicDirEntry of this.props.publicDirEntries) {
             if (publicDirEntry.isDirectory) {
                 this.baseResource
                     .addResource(publicDirEntry.name)
                     .addResource("{proxy+}")
-                    .addMethod("GET", this.createS3Integration({ key: `${publicDirEntry.name}/{key}` }), this.getStaticMethodOptions({ proxy: true }));
+                    .addMethod("GET", this.createS3Integration({
+                    key: this.s3Key(`${publicDirEntry.name}/{key}`),
+                }), this.getStaticMethodOptions({ proxy: true }));
             }
             else {
                 this.baseResource
                     .addResource(publicDirEntry.name)
-                    .addMethod("GET", this.createS3Integration({ key: publicDirEntry.name }), this.getStaticMethodOptions());
+                    .addMethod("GET", this.createS3Integration({ key: this.s3Key(publicDirEntry.name) }), this.getStaticMethodOptions());
             }
         }
     }
+    /**
+     * Prefixes a request path with the key prefix the assets were uploaded under,
+     * since the S3 integrations address objects by key rather than by URL.
+     */
+    s3Key(key) {
+        return (0, base_path_1.joinPath)(this.props.staticAssetsKeyPrefix, key);
+    }
     /**
      * Maps API request to S3 request.
      * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-parameter-mapping-sources.html
@@ -201,4 +229,4 @@ class NextjsApi extends constructs_1.Construct {
     }
 }
 exports.NextjsApi = NextjsApi;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-api.js","sourceRoot":"","sources":["../src/nextjs-api.ts"],"names":[],"mappings":"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","sourcesContent":["import { Size, Stack } from \"aws-cdk-lib\";\nimport {\n  RestApi,\n  LambdaIntegration,\n  AwsIntegration,\n  MethodOptions,\n  IResource,\n  EndpointType,\n  RestApiProps,\n  AwsIntegrationProps,\n  LambdaIntegrationOptions,\n  PassthroughBehavior,\n  ResponseTransferMode,\n} from \"aws-cdk-lib/aws-apigateway\";\nimport { IVpc } from \"aws-cdk-lib/aws-ec2\";\nimport {\n  Role,\n  ServicePrincipal,\n  PolicyStatement,\n  IRole,\n} from \"aws-cdk-lib/aws-iam\";\nimport { IFunction } from \"aws-cdk-lib/aws-lambda\";\nimport { IBucket } from \"aws-cdk-lib/aws-s3\";\nimport { Construct } from \"constructs\";\nimport { PublicDirEntry } from \"./nextjs-build/nextjs-build\";\n\nexport interface NextjsApiOverrides {\n  readonly restApiProps?: RestApiProps;\n  readonly staticIntegrationProps?: AwsIntegrationProps;\n  readonly s3MethodOptions?: MethodOptions;\n  readonly dynamicIntegrationProps?: LambdaIntegrationOptions;\n  readonly imageIntegrationProps?: LambdaIntegrationOptions;\n}\n\nexport interface NextjsApiProps {\n  /**\n   * Optional base path for the application\n   */\n  readonly basePath?: string;\n  /**\n   * Override props for every construct.\n   */\n  readonly overrides?: NextjsApiOverrides;\n  /**\n   * Path to directory of Next.js app's public directory. Used to add resources\n   * to API Gateway REST API for public directory to go directly to S3.\n   */\n  readonly publicDirEntries: PublicDirEntry[];\n  /**\n   * Required if `NextjsRegionalFunctions`. The Lambda function for server-side rendering\n   */\n  readonly serverFunction?: IFunction;\n  /**\n   * Dedicated image optimization Lambda for the `_next/image` route. When\n   * omitted, no `_next/image` resource is created and those requests fall\n   * through to `serverFunction` via the `{proxy+}` catch-all.\n   *\n   * When provided, it is assumed to support Lambda response streaming (as the\n   * dedicated image Lambda this package builds does) and is invoked with\n   * `ResponseTransferMode.STREAM` accordingly. If you supply a custom\n   * `imageFunction` that doesn't support streaming, override\n   * `responseTransferMode` to `BUFFERED` via `overrides.imageIntegrationProps`,\n   * otherwise API Gateway returns a 502.\n   */\n  readonly imageFunction?: IFunction;\n  /**\n   * The S3 bucket containing static assets\n   */\n  readonly staticAssetsBucket: IBucket;\n  /**\n   * [Future] Required if `NextjsRegionalContainers`. VPC to create VPC Link and ECS Service Discovery\n   */\n  readonly vpc?: IVpc;\n}\n\n/**\n * Creates an API Gateway REST API for Next.js applications\n */\nexport class NextjsApi extends Construct {\n  /**\n   * The API Gateway REST API\n   */\n  public readonly api: RestApi;\n\n  private readonly baseResource: IResource;\n  private readonly nextResource: IResource;\n  private readonly props: NextjsApiProps;\n  private staticIntegrationRole: IRole;\n\n  constructor(scope: Construct, id: string, props: NextjsApiProps) {\n    super(scope, id);\n    this.props = props;\n\n    this.validateProps(props);\n    this.api = this.createRestApi();\n    this.baseResource = this.createBaseResource(props.basePath);\n    this.nextResource = this.baseResource.addResource(\"_next\");\n    this.staticIntegrationRole = this.createStaticIntegrationRole();\n    this.createStaticIntegrations();\n    if (props.serverFunction) {\n      // Without a dedicated image function, `_next/image` falls through to the\n      // `{proxy+}` catch-all on the server function.\n      if (props.imageFunction) {\n        this.createImageIntegration(props.imageFunction);\n      }\n      this.createDynamicIntegration(props.serverFunction);\n    } else if (props.vpc) {\n      // [Future] create integration with ECS via VPC Link and ECS Service Discovery\n    }\n  }\n\n  private validateProps(props: NextjsApiProps) {\n    if (!props.serverFunction && !props.vpc) {\n      throw new Error(\"serverFunction or vpc must be set in NextjsApiProps\");\n    }\n  }\n\n  private createRestApi(): RestApi {\n    return new RestApi(this, \"RestApi\", {\n      binaryMediaTypes: [\"*/*\"],\n      description: `cdk-nextjs REST API for ${Stack.of(this).stackName}`,\n      endpointTypes: [EndpointType.REGIONAL],\n      minCompressionSize: Size.bytes(0), // compress all responses for better perf\n      ...this.props.overrides?.restApiProps,\n    });\n  }\n\n  /**\n   * Create base resource path if needed. Important if `basePath` is set.\n   */\n  private createBaseResource(basePath?: string): IResource {\n    // Create base resource path if needed\n    let baseResource = this.api.root;\n    if (basePath) {\n      const _basePath = basePath.startsWith(\"/\")\n        ? basePath.substring(1)\n        : basePath;\n\n      baseResource = this.api.root.addResource(_basePath);\n    }\n    return baseResource;\n  }\n\n  private createStaticIntegrationRole() {\n    // Create S3 integration role\n    const staticIntegrationRole = new Role(this, \"StaticIntegrationRole\", {\n      assumedBy: new ServicePrincipal(\"apigateway.amazonaws.com\"),\n    });\n\n    staticIntegrationRole.addToPolicy(\n      new PolicyStatement({\n        actions: [\"s3:GetObject\", \"s3:ListBucket\"],\n        resources: [\n          this.props.staticAssetsBucket.bucketArn,\n          `${this.props.staticAssetsBucket.bucketArn}/*`,\n        ],\n      }),\n    );\n    return staticIntegrationRole;\n  }\n\n  private createStaticIntegrations() {\n    this.nextResource\n      .addResource(\"static\")\n      .addResource(\"{proxy+}\")\n      .addMethod(\n        \"GET\",\n        this.createS3Integration({ key: \"_next/static/{key}\" }),\n        this.getStaticMethodOptions({ proxy: true }),\n      );\n    // add public directory files/directories that exist at top level but need to go to S3.\n    for (const publicDirEntry of this.props.publicDirEntries) {\n      if (publicDirEntry.isDirectory) {\n        this.baseResource\n          .addResource(publicDirEntry.name)\n          .addResource(\"{proxy+}\")\n          .addMethod(\n            \"GET\",\n            this.createS3Integration({ key: `${publicDirEntry.name}/{key}` }),\n            this.getStaticMethodOptions({ proxy: true }),\n          );\n      } else {\n        this.baseResource\n          .addResource(publicDirEntry.name)\n          .addMethod(\n            \"GET\",\n            this.createS3Integration({ key: publicDirEntry.name }),\n            this.getStaticMethodOptions(),\n          );\n      }\n    }\n  }\n\n  /**\n   * Maps API request to S3 request.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-parameter-mapping-sources.html\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/integrating-api-with-aws-services-s3.html#api-items-in-folder-as-s3-objects-in-bucket\n   */\n  private createS3Integration({ key }: { key: string }) {\n    const s3Integration = new AwsIntegration({\n      service: \"s3\",\n      integrationHttpMethod: \"GET\",\n      path: `${this.props.staticAssetsBucket.bucketName}/${key}`,\n      options: {\n        credentialsRole: this.staticIntegrationRole,\n        passthroughBehavior: PassthroughBehavior.WHEN_NO_TEMPLATES, // recommended\n        requestParameters: key.includes(\"{key}\")\n          ? {\n              \"integration.request.path.key\": \"method.request.path.proxy\",\n            }\n          : undefined,\n        integrationResponses: [\n          {\n            statusCode: \"200\",\n            responseParameters: {\n              \"method.response.header.Content-Type\":\n                \"integration.response.header.Content-Type\",\n              \"method.response.header.Content-Length\":\n                \"integration.response.header.Content-Length\",\n              \"method.response.header.Cache-Control\":\n                \"integration.response.header.Cache-Control\",\n              \"method.response.header.ETag\": \"integration.response.header.ETag\",\n              \"method.response.header.Last-Modified\":\n                \"integration.response.header.Last-Modified\",\n            },\n          },\n          {\n            statusCode: \"404\",\n            selectionPattern: \"404\",\n          },\n        ],\n      },\n      ...this.props.overrides?.staticIntegrationProps,\n    });\n    return s3Integration;\n  }\n\n  private getStaticMethodOptions({ proxy } = { proxy: false }): MethodOptions {\n    return {\n      requestParameters: proxy\n        ? {\n            \"method.request.path.proxy\": true,\n          }\n        : undefined,\n      methodResponses: [\n        {\n          statusCode: \"200\",\n          responseParameters: {\n            \"method.response.header.Content-Type\": true,\n            \"method.response.header.Content-Length\": true,\n            \"method.response.header.Cache-Control\": true,\n            \"method.response.header.ETag\": true,\n            \"method.response.header.Last-Modified\": true,\n          },\n        },\n        {\n          statusCode: \"404\",\n        },\n      ],\n      ...this.props.overrides?.s3MethodOptions,\n    };\n  }\n\n  /**\n   * Create Lambda Proxy integration for the `_next/image` route.\n   */\n  private createImageIntegration(imageFunction: IFunction) {\n    // imageFunction is assumed to be the dedicated, streaming-capable image\n    // Lambda (see its doc comment); override responseTransferMode via\n    // imageIntegrationProps if that assumption doesn't hold for a custom\n    // imageFunction, otherwise API Gateway returns a 502. Deliberately\n    // doesn't inherit dynamicIntegrationProps: that's for serverFunction,\n    // a different Lambda with different (and possibly conflicting, e.g.\n    // BUFFERED for a non-streaming Lambda Web Adapter setup) streaming\n    // requirements than the always-streaming dedicated image Lambda.\n    const imageIntegration = new LambdaIntegration(imageFunction, {\n      responseTransferMode: ResponseTransferMode.STREAM,\n      ...this.props.overrides?.imageIntegrationProps,\n    });\n    const imageResource = this.nextResource.addResource(\"image\");\n    imageResource.addMethod(\"ANY\", imageIntegration);\n  }\n\n  /**\n   * Create Lambda Proxy integration for all other routes\n   */\n  private createDynamicIntegration(serverFunction: IFunction) {\n    // All other routes use streaming for better performance\n    const streamingIntegration = new LambdaIntegration(serverFunction, {\n      responseTransferMode: ResponseTransferMode.STREAM,\n      ...this.props.overrides?.dynamicIntegrationProps,\n    });\n\n    // Add catch-all routes with streaming integration for server-side rendering\n    this.baseResource.addMethod(\"ANY\", streamingIntegration);\n    const proxyResource = this.baseResource.addResource(\"{proxy+}\");\n    proxyResource.addMethod(\"ANY\", streamingIntegration);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-api.js","sourceRoot":"","sources":["../src/nextjs-api.ts"],"names":[],"mappings":"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","sourcesContent":["import { Size, Stack } from \"aws-cdk-lib\";\nimport {\n  RestApi,\n  LambdaIntegration,\n  AwsIntegration,\n  MethodOptions,\n  IResource,\n  EndpointType,\n  RestApiProps,\n  AwsIntegrationProps,\n  LambdaIntegrationOptions,\n  PassthroughBehavior,\n  ResponseTransferMode,\n} from \"aws-cdk-lib/aws-apigateway\";\nimport { IVpc } from \"aws-cdk-lib/aws-ec2\";\nimport {\n  Role,\n  ServicePrincipal,\n  PolicyStatement,\n  IRole,\n} from \"aws-cdk-lib/aws-iam\";\nimport { IFunction } from \"aws-cdk-lib/aws-lambda\";\nimport { IBucket } from \"aws-cdk-lib/aws-s3\";\nimport { Construct } from \"constructs\";\nimport { PublicDirEntry } from \"./nextjs-build/nextjs-build\";\nimport { joinPath, normalizeBasePath } from \"./utils/base-path\";\n\nexport interface NextjsApiOverrides {\n  readonly restApiProps?: RestApiProps;\n  readonly staticIntegrationProps?: AwsIntegrationProps;\n  readonly s3MethodOptions?: MethodOptions;\n  readonly dynamicIntegrationProps?: LambdaIntegrationOptions;\n  readonly imageIntegrationProps?: LambdaIntegrationOptions;\n}\n\nexport interface NextjsApiProps {\n  /**\n   * Optional base path for the application\n   */\n  readonly basePath?: string;\n  /**\n   * Override props for every construct.\n   */\n  readonly overrides?: NextjsApiOverrides;\n  /**\n   * Path to directory of Next.js app's public directory. Used to add resources\n   * to API Gateway REST API for public directory to go directly to S3.\n   */\n  readonly publicDirEntries: PublicDirEntry[];\n  /**\n   * Required if `NextjsRegionalFunctions`. The Lambda function for server-side rendering\n   */\n  readonly serverFunction?: IFunction;\n  /**\n   * Dedicated image optimization Lambda for the `_next/image` route. When\n   * omitted, no `_next/image` resource is created and those requests fall\n   * through to `serverFunction` via the `{proxy+}` catch-all.\n   *\n   * When provided, it is assumed to support Lambda response streaming (as the\n   * dedicated image Lambda this package builds does) and is invoked with\n   * `ResponseTransferMode.STREAM` accordingly. If you supply a custom\n   * `imageFunction` that doesn't support streaming, override\n   * `responseTransferMode` to `BUFFERED` via `overrides.imageIntegrationProps`,\n   * otherwise API Gateway returns a 502.\n   */\n  readonly imageFunction?: IFunction;\n  /**\n   * The S3 bucket containing static assets\n   */\n  readonly staticAssetsBucket: IBucket;\n  /**\n   * S3 key prefix the static assets were uploaded under, i.e.\n   * `NextjsStaticAssets.keyPrefix`, which namespaces a shared bucket.\n   *\n   * Independent of `basePath` above: that one is the URL prefix the REST API\n   * serves the app at (commonly the API Gateway stage), while this one is where\n   * the objects live in the bucket. `_next/static` and public directory\n   * requests are mapped to S3 keys directly, so they 404 unless this prefix is\n   * applied.\n   */\n  readonly staticAssetsKeyPrefix?: string;\n  /**\n   * [Future] Required if `NextjsRegionalContainers`. VPC to create VPC Link and ECS Service Discovery\n   */\n  readonly vpc?: IVpc;\n}\n\n/**\n * Creates an API Gateway REST API for Next.js applications\n */\nexport class NextjsApi extends Construct {\n  /**\n   * The API Gateway REST API\n   */\n  public readonly api: RestApi;\n\n  /**\n   * Public URL of the app, including every path segment the API nests it under.\n   * Prefers a custom domain configured through `overrides.restApiProps.domainName`\n   * over the execute-api endpoint.\n   *\n   * A domain attached after this construct is created (`api.addDomainName()`) is\n   * still used for the host, but CDK keeps its base path mappings private, so a\n   * mapping added that way won't show up here.\n   */\n  get url(): string {\n    const customDomain = this.api.domainName;\n    // A custom domain reaches the stage through a base path mapping, so the\n    // stage name isn't in the path there; the mapping may be, when set.\n    const [origin, prefix] = customDomain\n      ? [\n          `https://${customDomain.domainName}`,\n          this.props.overrides?.restApiProps?.domainName?.basePath,\n        ]\n      : [\n          `https://${this.api.restApiId}.execute-api.${Stack.of(this).region}.amazonaws.com`,\n          this.api.deploymentStage.stageName,\n        ];\n    return joinPath(origin, prefix, this.props.basePath);\n  }\n\n  private readonly baseResource: IResource;\n  private readonly nextResource: IResource;\n  private readonly props: NextjsApiProps;\n  private staticIntegrationRole: IRole;\n\n  constructor(scope: Construct, id: string, props: NextjsApiProps) {\n    super(scope, id);\n    this.props = props;\n\n    this.validateProps(props);\n    this.api = this.createRestApi();\n    this.baseResource = this.createBaseResource(props.basePath);\n    this.nextResource = this.baseResource.addResource(\"_next\");\n    this.staticIntegrationRole = this.createStaticIntegrationRole();\n    this.createStaticIntegrations();\n    if (props.serverFunction) {\n      // Without a dedicated image function, `_next/image` falls through to the\n      // `{proxy+}` catch-all on the server function.\n      if (props.imageFunction) {\n        this.createImageIntegration(props.imageFunction);\n      }\n      this.createDynamicIntegration(props.serverFunction);\n    } else if (props.vpc) {\n      // [Future] create integration with ECS via VPC Link and ECS Service Discovery\n    }\n  }\n\n  private validateProps(props: NextjsApiProps) {\n    if (!props.serverFunction && !props.vpc) {\n      throw new Error(\"serverFunction or vpc must be set in NextjsApiProps\");\n    }\n  }\n\n  private createRestApi(): RestApi {\n    return new RestApi(this, \"RestApi\", {\n      binaryMediaTypes: [\"*/*\"],\n      description: `cdk-nextjs REST API for ${Stack.of(this).stackName}`,\n      endpointTypes: [EndpointType.REGIONAL],\n      minCompressionSize: Size.bytes(0), // compress all responses for better perf\n      ...this.props.overrides?.restApiProps,\n    });\n  }\n\n  /**\n   * Create base resource path if needed. Important if `basePath` is set.\n   */\n  private createBaseResource(basePath?: string): IResource {\n    // Create base resource path if needed\n    const normalized = normalizeBasePath(basePath);\n    return normalized ? this.api.root.addResource(normalized) : this.api.root;\n  }\n\n  private createStaticIntegrationRole() {\n    // Create S3 integration role\n    const staticIntegrationRole = new Role(this, \"StaticIntegrationRole\", {\n      assumedBy: new ServicePrincipal(\"apigateway.amazonaws.com\"),\n    });\n\n    staticIntegrationRole.addToPolicy(\n      new PolicyStatement({\n        actions: [\"s3:GetObject\", \"s3:ListBucket\"],\n        resources: [\n          this.props.staticAssetsBucket.bucketArn,\n          `${this.props.staticAssetsBucket.bucketArn}/*`,\n        ],\n      }),\n    );\n    return staticIntegrationRole;\n  }\n\n  private createStaticIntegrations() {\n    this.nextResource\n      .addResource(\"static\")\n      .addResource(\"{proxy+}\")\n      .addMethod(\n        \"GET\",\n        this.createS3Integration({ key: this.s3Key(\"_next/static/{key}\") }),\n        this.getStaticMethodOptions({ proxy: true }),\n      );\n    // add public directory files/directories that exist at top level but need to go to S3.\n    for (const publicDirEntry of this.props.publicDirEntries) {\n      if (publicDirEntry.isDirectory) {\n        this.baseResource\n          .addResource(publicDirEntry.name)\n          .addResource(\"{proxy+}\")\n          .addMethod(\n            \"GET\",\n            this.createS3Integration({\n              key: this.s3Key(`${publicDirEntry.name}/{key}`),\n            }),\n            this.getStaticMethodOptions({ proxy: true }),\n          );\n      } else {\n        this.baseResource\n          .addResource(publicDirEntry.name)\n          .addMethod(\n            \"GET\",\n            this.createS3Integration({ key: this.s3Key(publicDirEntry.name) }),\n            this.getStaticMethodOptions(),\n          );\n      }\n    }\n  }\n\n  /**\n   * Prefixes a request path with the key prefix the assets were uploaded under,\n   * since the S3 integrations address objects by key rather than by URL.\n   */\n  private s3Key(key: string): string {\n    return joinPath(this.props.staticAssetsKeyPrefix, key);\n  }\n\n  /**\n   * Maps API request to S3 request.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-parameter-mapping-sources.html\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/integrating-api-with-aws-services-s3.html#api-items-in-folder-as-s3-objects-in-bucket\n   */\n  private createS3Integration({ key }: { key: string }) {\n    const s3Integration = new AwsIntegration({\n      service: \"s3\",\n      integrationHttpMethod: \"GET\",\n      path: `${this.props.staticAssetsBucket.bucketName}/${key}`,\n      options: {\n        credentialsRole: this.staticIntegrationRole,\n        passthroughBehavior: PassthroughBehavior.WHEN_NO_TEMPLATES, // recommended\n        requestParameters: key.includes(\"{key}\")\n          ? {\n              \"integration.request.path.key\": \"method.request.path.proxy\",\n            }\n          : undefined,\n        integrationResponses: [\n          {\n            statusCode: \"200\",\n            responseParameters: {\n              \"method.response.header.Content-Type\":\n                \"integration.response.header.Content-Type\",\n              \"method.response.header.Content-Length\":\n                \"integration.response.header.Content-Length\",\n              \"method.response.header.Cache-Control\":\n                \"integration.response.header.Cache-Control\",\n              \"method.response.header.ETag\": \"integration.response.header.ETag\",\n              \"method.response.header.Last-Modified\":\n                \"integration.response.header.Last-Modified\",\n            },\n          },\n          {\n            statusCode: \"404\",\n            selectionPattern: \"404\",\n          },\n        ],\n      },\n      ...this.props.overrides?.staticIntegrationProps,\n    });\n    return s3Integration;\n  }\n\n  private getStaticMethodOptions({ proxy } = { proxy: false }): MethodOptions {\n    return {\n      requestParameters: proxy\n        ? {\n            \"method.request.path.proxy\": true,\n          }\n        : undefined,\n      methodResponses: [\n        {\n          statusCode: \"200\",\n          responseParameters: {\n            \"method.response.header.Content-Type\": true,\n            \"method.response.header.Content-Length\": true,\n            \"method.response.header.Cache-Control\": true,\n            \"method.response.header.ETag\": true,\n            \"method.response.header.Last-Modified\": true,\n          },\n        },\n        {\n          statusCode: \"404\",\n        },\n      ],\n      ...this.props.overrides?.s3MethodOptions,\n    };\n  }\n\n  /**\n   * Create Lambda Proxy integration for the `_next/image` route.\n   */\n  private createImageIntegration(imageFunction: IFunction) {\n    // imageFunction is assumed to be the dedicated, streaming-capable image\n    // Lambda (see its doc comment); override responseTransferMode via\n    // imageIntegrationProps if that assumption doesn't hold for a custom\n    // imageFunction, otherwise API Gateway returns a 502. Deliberately\n    // doesn't inherit dynamicIntegrationProps: that's for serverFunction,\n    // a different Lambda with different (and possibly conflicting, e.g.\n    // BUFFERED for a non-streaming Lambda Web Adapter setup) streaming\n    // requirements than the always-streaming dedicated image Lambda.\n    const imageIntegration = new LambdaIntegration(imageFunction, {\n      responseTransferMode: ResponseTransferMode.STREAM,\n      ...this.props.overrides?.imageIntegrationProps,\n    });\n    const imageResource = this.nextResource.addResource(\"image\");\n    imageResource.addMethod(\"ANY\", imageIntegration);\n  }\n\n  /**\n   * Create Lambda Proxy integration for all other routes\n   */\n  private createDynamicIntegration(serverFunction: IFunction) {\n    // All other routes use streaming for better performance\n    const streamingIntegration = new LambdaIntegration(serverFunction, {\n      responseTransferMode: ResponseTransferMode.STREAM,\n      ...this.props.overrides?.dynamicIntegrationProps,\n    });\n\n    // Add catch-all routes with streaming integration for server-side rendering\n    this.baseResource.addMethod(\"ANY\", streamingIntegration);\n    const proxyResource = this.baseResource.addResource(\"{proxy+}\");\n    proxyResource.addMethod(\"ANY\", streamingIntegration);\n  }\n}\n"]}

package/lib/nextjs-api.test.d.ts

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