cdk-nextjs 0.5.2 → 0.5.4

package/lib/nextjs-build/patch-fetch.test.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+const node_crypto_1 = require("node:crypto");
+function sha256(input) {
+    const buffer = typeof input === "string"
+        ? Buffer.from(input)
+        : Buffer.from(new Uint8Array(input));
+    return (0, node_crypto_1.createHash)("sha256").update(buffer).digest("hex");
+}
+describe("patch-fetch", () => {
+    let originalFetch;
+    let capturedInit;
+    beforeEach(() => {
+        jest.resetModules();
+        capturedInit = undefined;
+        originalFetch = jest.fn((_input, init) => {
+            capturedInit = init;
+            return Promise.resolve(new Response("ok"));
+        });
+        global.window = {
+            location: { href: "https://example.com/", hostname: "example.com" },
+            fetch: originalFetch,
+            XMLHttpRequest: class {
+                open(_method, _url) { }
+                send(_body) { }
+                setRequestHeader(_name, _value) { }
+            },
+        };
+        // eslint-disable-next-line @typescript-eslint/no-require-imports -- must re-execute against the fresh `window` stub each test
+        require("./patch-fetch.js");
+    });
+    afterEach(() => {
+        delete global.window;
+    });
+    describe("fetch", () => {
+        test("hashes URLSearchParams via toString(), not JSON.stringify", async () => {
+            const params = new URLSearchParams({ a: "1", b: "2" });
+            await global.window.fetch("https://example.com/api", {
+                method: "POST",
+                body: params,
+            });
+            const headers = capturedInit.headers;
+            expect(headers.get("x-amz-content-sha256")).toBe(sha256(params.toString()));
+            expect(headers.get("x-amz-content-sha256")).not.toBe(sha256("{}"));
+        });
+        test("hashes a plain string body", async () => {
+            await global.window.fetch("https://example.com/api", {
+                method: "POST",
+                body: "raw text body",
+            });
+            const headers = capturedInit.headers;
+            expect(headers.get("x-amz-content-sha256")).toBe(sha256("raw text body"));
+        });
+        test("hashes a FormData body over its exact encoded bytes and sets content-type", async () => {
+            const formData = new FormData();
+            formData.append("field", "value");
+            formData.append("file", new Blob(["file contents"], { type: "text/plain" }), "file.txt");
+            await global.window.fetch("https://example.com/api", {
+                method: "POST",
+                body: formData,
+            });
+            // the body sent to the real fetch must be the re-encoded bytes, not the original FormData
+            const sentBytes = capturedInit.body;
+            expect(sentBytes).toBeInstanceOf(Uint8Array);
+            const headers = capturedInit.headers;
+            const contentType = headers.get("content-type");
+            expect(contentType).toMatch(/^multipart\/form-data; boundary=/);
+            expect(headers.get("x-amz-content-sha256")).toBe(sha256(sentBytes));
+            // the hashed/sent bytes must round-trip back to the original fields
+            const roundTripped = await new Response(sentBytes, {
+                headers: { "content-type": contentType },
+            }).formData();
+            expect(roundTripped.get("field")).toBe("value");
+            const file = roundTripped.get("file");
+            expect(file.name).toBe("file.txt");
+            expect(await file.text()).toBe("file contents");
+        });
+        test("hashes a Blob body over its raw bytes", async () => {
+            const blob = new Blob(["blob contents"], { type: "text/plain" });
+            await global.window.fetch("https://example.com/api", {
+                method: "POST",
+                body: blob,
+            });
+            const headers = capturedInit.headers;
+            expect(headers.get("x-amz-content-sha256")).toBe(sha256(await blob.arrayBuffer()));
+        });
+        test("hashes an ArrayBuffer body over its raw bytes", async () => {
+            const buffer = new TextEncoder().encode("array buffer contents").buffer;
+            await global.window.fetch("https://example.com/api", {
+                method: "PUT",
+                body: buffer,
+            });
+            const headers = capturedInit.headers;
+            expect(headers.get("x-amz-content-sha256")).toBe(sha256(buffer));
+        });
+        test("hashes an empty byte array when no body is present", async () => {
+            await global.window.fetch("https://example.com/api", {
+                method: "POST",
+            });
+            const headers = capturedInit.headers;
+            expect(headers.get("x-amz-content-sha256")).toBe(sha256(new Uint8Array(0)));
+        });
+        test("passes through untouched when init is omitted", async () => {
+            await global.window.fetch("https://example.com/api");
+            expect(originalFetch).toHaveBeenCalledWith("https://example.com/api", undefined);
+        });
+        test("passes through without hashing for non-PUT/POST methods", async () => {
+            await global.window.fetch("https://example.com/api", {
+                method: "GET",
+                body: "should not be hashed",
+            });
+            expect(capturedInit.headers).toBeUndefined();
+        });
+        test("passes through without hashing for cross-origin requests", async () => {
+            await global.window.fetch("https://other-origin.com/api", {
+                method: "POST",
+                body: "should not be hashed",
+            });
+            expect(capturedInit.headers).toBeUndefined();
+        });
+    });
+    describe("XMLHttpRequest", () => {
+        test("hashes URLSearchParams via toString(), not JSON.stringify", async () => {
+            const params = new URLSearchParams({ a: "1", b: "2" });
+            const setRequestHeader = jest.fn();
+            const xhr = new global.window.XMLHttpRequest();
+            xhr.setRequestHeader = setRequestHeader;
+            xhr.open("POST", "https://example.com/api");
+            await xhr.send(params);
+            expect(setRequestHeader).toHaveBeenCalledWith("x-amz-content-sha256", sha256(params.toString()));
+            expect(setRequestHeader).not.toHaveBeenCalledWith("x-amz-content-sha256", sha256("{}"));
+        });
+        test("hashes a plain string body", async () => {
+            const setRequestHeader = jest.fn();
+            const xhr = new global.window.XMLHttpRequest();
+            xhr.setRequestHeader = setRequestHeader;
+            xhr.open("PUT", "https://example.com/api");
+            await xhr.send("raw text body");
+            expect(setRequestHeader).toHaveBeenCalledWith("x-amz-content-sha256", sha256("raw text body"));
+        });
+        test("does not hash for non-PUT/POST methods", async () => {
+            const setRequestHeader = jest.fn();
+            const xhr = new global.window.XMLHttpRequest();
+            xhr.setRequestHeader = setRequestHeader;
+            xhr.open("GET", "https://example.com/api");
+            await xhr.send("should not be hashed");
+            expect(setRequestHeader).not.toHaveBeenCalled();
+        });
+        test("does not hash for cross-origin requests", async () => {
+            const setRequestHeader = jest.fn();
+            const xhr = new global.window.XMLHttpRequest();
+            xhr.setRequestHeader = setRequestHeader;
+            xhr.open("POST", "https://other-origin.com/api");
+            await xhr.send("should not be hashed");
+            expect(setRequestHeader).not.toHaveBeenCalled();
+        });
+        test("does not hash when there is no body", async () => {
+            const setRequestHeader = jest.fn();
+            const xhr = new global.window.XMLHttpRequest();
+            xhr.setRequestHeader = setRequestHeader;
+            xhr.open("POST", "https://example.com/api");
+            await xhr.send();
+            expect(setRequestHeader).not.toHaveBeenCalled();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"patch-fetch.test.js","sourceRoot":"","sources":["../../src/nextjs-build/patch-fetch.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport { createHash } from \"node:crypto\";\n\nfunction sha256(input: string | ArrayBuffer | Uint8Array) {\n  const buffer =\n    typeof input === \"string\"\n      ? Buffer.from(input)\n      : Buffer.from(new Uint8Array(input));\n  return createHash(\"sha256\").update(buffer).digest(\"hex\");\n}\n\ndescribe(\"patch-fetch\", () => {\n  let originalFetch: jest.Mock;\n  let capturedInit: RequestInit | undefined;\n\n  beforeEach(() => {\n    jest.resetModules();\n    capturedInit = undefined;\n\n    originalFetch = jest.fn((_input: unknown, init?: RequestInit) => {\n      capturedInit = init;\n      return Promise.resolve(new Response(\"ok\"));\n    });\n\n    (global as any).window = {\n      location: { href: \"https://example.com/\", hostname: \"example.com\" },\n      fetch: originalFetch,\n      XMLHttpRequest: class {\n        open(_method: string, _url: string) {}\n        send(_body?: unknown) {}\n        setRequestHeader(_name: string, _value: string) {}\n      },\n    };\n\n    // eslint-disable-next-line @typescript-eslint/no-require-imports -- must re-execute against the fresh `window` stub each test\n    require(\"./patch-fetch.js\");\n  });\n\n  afterEach(() => {\n    delete (global as any).window;\n  });\n\n  describe(\"fetch\", () => {\n    test(\"hashes URLSearchParams via toString(), not JSON.stringify\", async () => {\n      const params = new URLSearchParams({ a: \"1\", b: \"2\" });\n\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"POST\",\n        body: params,\n      });\n\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(\n        sha256(params.toString()),\n      );\n      expect(headers.get(\"x-amz-content-sha256\")).not.toBe(sha256(\"{}\"));\n    });\n\n    test(\"hashes a plain string body\", async () => {\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"POST\",\n        body: \"raw text body\",\n      });\n\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(sha256(\"raw text body\"));\n    });\n\n    test(\"hashes a FormData body over its exact encoded bytes and sets content-type\", async () => {\n      const formData = new FormData();\n      formData.append(\"field\", \"value\");\n      formData.append(\n        \"file\",\n        new Blob([\"file contents\"], { type: \"text/plain\" }),\n        \"file.txt\",\n      );\n\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"POST\",\n        body: formData,\n      });\n\n      // the body sent to the real fetch must be the re-encoded bytes, not the original FormData\n      const sentBytes = capturedInit!.body as Uint8Array;\n      expect(sentBytes).toBeInstanceOf(Uint8Array);\n\n      const headers = capturedInit!.headers as Headers;\n      const contentType = headers.get(\"content-type\")!;\n      expect(contentType).toMatch(/^multipart\\/form-data; boundary=/);\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(sha256(sentBytes));\n\n      // the hashed/sent bytes must round-trip back to the original fields\n      const roundTripped = await new Response(sentBytes, {\n        headers: { \"content-type\": contentType },\n      }).formData();\n      expect(roundTripped.get(\"field\")).toBe(\"value\");\n      const file = roundTripped.get(\"file\") as File;\n      expect(file.name).toBe(\"file.txt\");\n      expect(await file.text()).toBe(\"file contents\");\n    });\n\n    test(\"hashes a Blob body over its raw bytes\", async () => {\n      const blob = new Blob([\"blob contents\"], { type: \"text/plain\" });\n\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"POST\",\n        body: blob,\n      });\n\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(\n        sha256(await blob.arrayBuffer()),\n      );\n    });\n\n    test(\"hashes an ArrayBuffer body over its raw bytes\", async () => {\n      const buffer = new TextEncoder().encode(\"array buffer contents\").buffer;\n\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"PUT\",\n        body: buffer,\n      });\n\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(sha256(buffer));\n    });\n\n    test(\"hashes an empty byte array when no body is present\", async () => {\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"POST\",\n      });\n\n      const headers = capturedInit!.headers as Headers;\n      expect(headers.get(\"x-amz-content-sha256\")).toBe(\n        sha256(new Uint8Array(0)),\n      );\n    });\n\n    test(\"passes through untouched when init is omitted\", async () => {\n      await (global as any).window.fetch(\"https://example.com/api\");\n\n      expect(originalFetch).toHaveBeenCalledWith(\n        \"https://example.com/api\",\n        undefined,\n      );\n    });\n\n    test(\"passes through without hashing for non-PUT/POST methods\", async () => {\n      await (global as any).window.fetch(\"https://example.com/api\", {\n        method: \"GET\",\n        body: \"should not be hashed\",\n      });\n\n      expect(capturedInit!.headers).toBeUndefined();\n    });\n\n    test(\"passes through without hashing for cross-origin requests\", async () => {\n      await (global as any).window.fetch(\"https://other-origin.com/api\", {\n        method: \"POST\",\n        body: \"should not be hashed\",\n      });\n\n      expect(capturedInit!.headers).toBeUndefined();\n    });\n  });\n\n  describe(\"XMLHttpRequest\", () => {\n    test(\"hashes URLSearchParams via toString(), not JSON.stringify\", async () => {\n      const params = new URLSearchParams({ a: \"1\", b: \"2\" });\n      const setRequestHeader = jest.fn();\n\n      const xhr = new (global as any).window.XMLHttpRequest();\n      xhr.setRequestHeader = setRequestHeader;\n      xhr.open(\"POST\", \"https://example.com/api\");\n      await xhr.send(params);\n\n      expect(setRequestHeader).toHaveBeenCalledWith(\n        \"x-amz-content-sha256\",\n        sha256(params.toString()),\n      );\n      expect(setRequestHeader).not.toHaveBeenCalledWith(\n        \"x-amz-content-sha256\",\n        sha256(\"{}\"),\n      );\n    });\n\n    test(\"hashes a plain string body\", async () => {\n      const setRequestHeader = jest.fn();\n\n      const xhr = new (global as any).window.XMLHttpRequest();\n      xhr.setRequestHeader = setRequestHeader;\n      xhr.open(\"PUT\", \"https://example.com/api\");\n      await xhr.send(\"raw text body\");\n\n      expect(setRequestHeader).toHaveBeenCalledWith(\n        \"x-amz-content-sha256\",\n        sha256(\"raw text body\"),\n      );\n    });\n\n    test(\"does not hash for non-PUT/POST methods\", async () => {\n      const setRequestHeader = jest.fn();\n\n      const xhr = new (global as any).window.XMLHttpRequest();\n      xhr.setRequestHeader = setRequestHeader;\n      xhr.open(\"GET\", \"https://example.com/api\");\n      await xhr.send(\"should not be hashed\");\n\n      expect(setRequestHeader).not.toHaveBeenCalled();\n    });\n\n    test(\"does not hash for cross-origin requests\", async () => {\n      const setRequestHeader = jest.fn();\n\n      const xhr = new (global as any).window.XMLHttpRequest();\n      xhr.setRequestHeader = setRequestHeader;\n      xhr.open(\"POST\", \"https://other-origin.com/api\");\n      await xhr.send(\"should not be hashed\");\n\n      expect(setRequestHeader).not.toHaveBeenCalled();\n    });\n\n    test(\"does not hash when there is no body\", async () => {\n      const setRequestHeader = jest.fn();\n\n      const xhr = new (global as any).window.XMLHttpRequest();\n      xhr.setRequestHeader = setRequestHeader;\n      xhr.open(\"POST\", \"https://example.com/api\");\n      await xhr.send();\n\n      expect(setRequestHeader).not.toHaveBeenCalled();\n    });\n  });\n});\n"]}

package/lib/nextjs-cache.js

@@ -1,5 +1,4 @@
 "use strict";
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NextjsCache = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
@@ -14,6 +13,12 @@ const constants_1 = require("./constants");
  * Next.js Cache construct providing unified S3 and DynamoDB cache management.
  */
 class NextjsCache extends constructs_1.Construct {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsCache", version: "0.5.4" };
+    cacheBucket;
+    revalidationTable;
+    buildId;
+    bucketDeployment;
+    props;
     constructor(scope, id, props) {
         super(scope, id);
         this.props = props;
@@ -79,6 +84,4 @@ class NextjsCache extends constructs_1.Construct {
     }
 }
 exports.NextjsCache = NextjsCache;
-_a = JSII_RTTI_SYMBOL_1;
-NextjsCache[_a] = { fqn: "cdk-nextjs.NextjsCache", version: "0.5.2" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-cache.js","sourceRoot":"","sources":["../src/nextjs-cache.ts"],"names":[],"mappings":";;;;;AAAA,2BAAgC;AAChC,6CAA4C;AAC5C,2DAMkC;AAClC,+CAM4B;AAC5B,qEAIuC;AACvC,2CAAuC;AACvC,2CAAyC;AA+BzC;;GAEG;AACH,MAAa,WAAY,SAAQ,sBAAS;IAOxC,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAuB;QAC/D,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;QAC7B,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,WAAW,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACjE,IAAI,CAAC,iBAAiB;YACpB,KAAK,CAAC,iBAAiB,IAAI,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAC5D,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAClD,CAAC;IAED;;OAEG;IACK,iBAAiB;QACvB,MAAM,MAAM,GAAG,IAAI,eAAM,CAAC,IAAI,EAAE,QAAQ,EAAE;YACxC,UAAU,EAAE,yBAAgB,CAAC,UAAU;YACvC,iBAAiB,EAAE,0BAAiB,CAAC,SAAS;YAC9C,aAAa,EAAE,2BAAa,CAAC,OAAO;YACpC,iBAAiB,EAAE,IAAI;YACvB,UAAU,EAAE,IAAI;YAChB,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,gBAAgB;SAC1C,CAAC,CAAC;QAEH,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;OAGG;IACK,uBAAuB;QAC7B,MAAM,KAAK,GAAG,IAAI,sBAAO,CAAC,IAAI,EAAE,mBAAmB,EAAE;YACnD,YAAY,EAAE;gBACZ,IAAI,EAAE,IAAI;gBACV,IAAI,EAAE,4BAAa,CAAC,MAAM;aAC3B;YACD,OAAO,EAAE;gBACP,IAAI,EAAE,IAAI;gBACV,IAAI,EAAE,4BAAa,CAAC,MAAM;aAC3B;YACD,OAAO,EAAE,sBAAO,CAAC,QAAQ,EAAE;YAC3B,aAAa,EAAE,2BAAa,CAAC,OAAO;YACpC,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,sBAAsB;SAChD,CAAC,CAAC;QAEH,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACK,gBAAgB;QACtB,kCAAkC;QAClC,IAAI,CAAC,IAAA,eAAU,EAAC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,CAAC;YACzC,OAAO,CAAC,GAAG,CACT,GAAG,sBAAU,gCAAgC,IAAI,CAAC,KAAK,CAAC,YAAY,kCAAkC,CACvG,CAAC;YACF,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,CAAC,GAAG,CACT,GAAG,sBAAU,8BAA8B,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CACrE,CAAC;QAEF,uDAAuD;QACvD,MAAM,gBAAgB,GAAG,IAAI,oCAAgB,CAAC,IAAI,EAAE,qBAAqB,EAAE;YACzE,OAAO,EAAE,CAAC,0BAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;YAChD,iBAAiB,EAAE,IAAI,CAAC,WAAW;YACnC,oBAAoB,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,2CAA2C;YACrF,KAAK,EAAE,KAAK,EAAE,0GAA0G;YACxH,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,qBAAqB;SAC/C,CAAC,CAAC;QACH,OAAO,gBAAgB,CAAC;IAC1B,CAAC;;AAhFH,kCAiFC","sourcesContent":["import { existsSync } from \"fs\";\nimport { RemovalPolicy } from \"aws-cdk-lib\";\nimport {\n  AttributeType,\n  Billing,\n  TableV2,\n  TablePropsV2,\n  ITableV2,\n} from \"aws-cdk-lib/aws-dynamodb\";\nimport {\n  Bucket,\n  BucketEncryption,\n  BucketProps,\n  BlockPublicAccess,\n  IBucket,\n} from \"aws-cdk-lib/aws-s3\";\nimport {\n  BucketDeployment,\n  BucketDeploymentProps,\n  Source,\n} from \"aws-cdk-lib/aws-s3-deployment\";\nimport { Construct } from \"constructs\";\nimport { LOG_PREFIX } from \"./constants\";\n\nexport interface NextjsCacheOverrides {\n  readonly cacheBucketProps?: BucketProps;\n  readonly revalidationTableProps?: TablePropsV2;\n  readonly bucketDeploymentProps?: BucketDeploymentProps;\n}\n\nexport interface NextjsCacheProps {\n  readonly buildId: string;\n  /**\n   * Bring your own S3 bucket for cache storage. When provided, cdk-nextjs\n   * will skip creating a new bucket. Cache objects are prefixed with `buildId`\n   * so multiple deployments can safely share one bucket.\n   */\n  readonly cacheBucket?: IBucket;\n  /**\n   * Absolute path to the init cache directory\n   * @example \"/Users/john/myapp/.next/cdk-nextjs-init-cache\"\n   */\n  readonly initCacheDir: string;\n  readonly overrides?: NextjsCacheOverrides;\n  /**\n   * Bring your own DynamoDB table for revalidation metadata. When provided,\n   * cdk-nextjs will skip creating a new table. The table must have `pk` (String)\n   * as partition key and `sk` (String) as sort key. Entries are partitioned by\n   * `buildId` so multiple deployments can safely share one table.\n   */\n  readonly revalidationTable?: ITableV2;\n}\n\n/**\n * Next.js Cache construct providing unified S3 and DynamoDB cache management.\n */\nexport class NextjsCache extends Construct {\n  readonly cacheBucket: IBucket;\n  readonly revalidationTable: ITableV2;\n  readonly buildId: string;\n  readonly bucketDeployment?: BucketDeployment;\n  private props: NextjsCacheProps;\n\n  constructor(scope: Construct, id: string, props: NextjsCacheProps) {\n    super(scope, id);\n    this.props = props;\n    this.buildId = props.buildId;\n    this.cacheBucket = props.cacheBucket ?? this.createCacheBucket();\n    this.revalidationTable =\n      props.revalidationTable ?? this.createRevalidationTable();\n    this.bucketDeployment = this.createDeployment();\n  }\n\n  /**\n   * Creates S3 bucket for cache storage with BUILD_ID prefixing.\n   */\n  private createCacheBucket(): IBucket {\n    const bucket = new Bucket(this, \"Bucket\", {\n      encryption: BucketEncryption.S3_MANAGED,\n      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,\n      removalPolicy: RemovalPolicy.DESTROY,\n      autoDeleteObjects: true,\n      enforceSSL: true,\n      ...this.props.overrides?.cacheBucketProps,\n    });\n\n    return bucket;\n  }\n\n  /**\n   * Creates DynamoDB table for revalidation metadata\n   * Schema: pk (buildId or \"METADATA\"), sk (tag#cacheKey or \"CURRENT_BUILD\"), createdAt, revalidatedAt\n   */\n  private createRevalidationTable(): TableV2 {\n    const table = new TableV2(this, \"RevalidationTable\", {\n      partitionKey: {\n        name: \"pk\",\n        type: AttributeType.STRING,\n      },\n      sortKey: {\n        name: \"sk\",\n        type: AttributeType.STRING,\n      },\n      billing: Billing.onDemand(),\n      removalPolicy: RemovalPolicy.DESTROY,\n      ...this.props.overrides?.revalidationTableProps,\n    });\n\n    return table;\n  }\n\n  /**\n   * Deploy pre-built cache files from .next/cdk-nextjs-init-cache to S3\n   */\n  private createDeployment(): BucketDeployment | undefined {\n    // Check if cache directory exists\n    if (!existsSync(this.props.initCacheDir)) {\n      console.log(\n        `${LOG_PREFIX} No pre-built cache found at ${this.props.initCacheDir}, skipping init cache deployment`,\n      );\n      return undefined;\n    }\n\n    console.log(\n      `${LOG_PREFIX} Deploying init cache from ${this.props.initCacheDir}`,\n    );\n\n    // Use standard BucketDeployment for regular S3 buckets\n    const bucketDeployment = new BucketDeployment(this, \"InitCacheDeployment\", {\n      sources: [Source.asset(this.props.initCacheDir)],\n      destinationBucket: this.cacheBucket,\n      destinationKeyPrefix: this.props.buildId, // Add buildId prefix to all uploaded files\n      prune: false, // Don't delete existing objects to prevent 404s during deployment, pruning will be handled by post-deploy\n      ...this.props.overrides?.bucketDeploymentProps,\n    });\n    return bucketDeployment;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-cache.js","sourceRoot":"","sources":["../src/nextjs-cache.ts"],"names":[],"mappings":"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","sourcesContent":["import { existsSync } from \"fs\";\nimport { RemovalPolicy } from \"aws-cdk-lib\";\nimport {\n  AttributeType,\n  Billing,\n  TableV2,\n  TablePropsV2,\n  ITableV2,\n} from \"aws-cdk-lib/aws-dynamodb\";\nimport {\n  Bucket,\n  BucketEncryption,\n  BucketProps,\n  BlockPublicAccess,\n  IBucket,\n} from \"aws-cdk-lib/aws-s3\";\nimport {\n  BucketDeployment,\n  BucketDeploymentProps,\n  Source,\n} from \"aws-cdk-lib/aws-s3-deployment\";\nimport { Construct } from \"constructs\";\nimport { LOG_PREFIX } from \"./constants\";\n\nexport interface NextjsCacheOverrides {\n  readonly cacheBucketProps?: BucketProps;\n  readonly revalidationTableProps?: TablePropsV2;\n  readonly bucketDeploymentProps?: BucketDeploymentProps;\n}\n\nexport interface NextjsCacheProps {\n  readonly buildId: string;\n  /**\n   * Bring your own S3 bucket for cache storage. When provided, cdk-nextjs\n   * will skip creating a new bucket. Cache objects are prefixed with `buildId`\n   * so multiple deployments can safely share one bucket.\n   */\n  readonly cacheBucket?: IBucket;\n  /**\n   * Absolute path to the init cache directory\n   * @example \"/Users/john/myapp/.next/cdk-nextjs-init-cache\"\n   */\n  readonly initCacheDir: string;\n  readonly overrides?: NextjsCacheOverrides;\n  /**\n   * Bring your own DynamoDB table for revalidation metadata. When provided,\n   * cdk-nextjs will skip creating a new table. The table must have `pk` (String)\n   * as partition key and `sk` (String) as sort key. Entries are partitioned by\n   * `buildId` so multiple deployments can safely share one table.\n   */\n  readonly revalidationTable?: ITableV2;\n}\n\n/**\n * Next.js Cache construct providing unified S3 and DynamoDB cache management.\n */\nexport class NextjsCache extends Construct {\n  readonly cacheBucket: IBucket;\n  readonly revalidationTable: ITableV2;\n  readonly buildId: string;\n  readonly bucketDeployment?: BucketDeployment;\n  private props: NextjsCacheProps;\n\n  constructor(scope: Construct, id: string, props: NextjsCacheProps) {\n    super(scope, id);\n    this.props = props;\n    this.buildId = props.buildId;\n    this.cacheBucket = props.cacheBucket ?? this.createCacheBucket();\n    this.revalidationTable =\n      props.revalidationTable ?? this.createRevalidationTable();\n    this.bucketDeployment = this.createDeployment();\n  }\n\n  /**\n   * Creates S3 bucket for cache storage with BUILD_ID prefixing.\n   */\n  private createCacheBucket(): IBucket {\n    const bucket = new Bucket(this, \"Bucket\", {\n      encryption: BucketEncryption.S3_MANAGED,\n      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,\n      removalPolicy: RemovalPolicy.DESTROY,\n      autoDeleteObjects: true,\n      enforceSSL: true,\n      ...this.props.overrides?.cacheBucketProps,\n    });\n\n    return bucket;\n  }\n\n  /**\n   * Creates DynamoDB table for revalidation metadata\n   * Schema: pk (buildId or \"METADATA\"), sk (tag#cacheKey or \"CURRENT_BUILD\"), createdAt, revalidatedAt\n   */\n  private createRevalidationTable(): TableV2 {\n    const table = new TableV2(this, \"RevalidationTable\", {\n      partitionKey: {\n        name: \"pk\",\n        type: AttributeType.STRING,\n      },\n      sortKey: {\n        name: \"sk\",\n        type: AttributeType.STRING,\n      },\n      billing: Billing.onDemand(),\n      removalPolicy: RemovalPolicy.DESTROY,\n      ...this.props.overrides?.revalidationTableProps,\n    });\n\n    return table;\n  }\n\n  /**\n   * Deploy pre-built cache files from .next/cdk-nextjs-init-cache to S3\n   */\n  private createDeployment(): BucketDeployment | undefined {\n    // Check if cache directory exists\n    if (!existsSync(this.props.initCacheDir)) {\n      console.log(\n        `${LOG_PREFIX} No pre-built cache found at ${this.props.initCacheDir}, skipping init cache deployment`,\n      );\n      return undefined;\n    }\n\n    console.log(\n      `${LOG_PREFIX} Deploying init cache from ${this.props.initCacheDir}`,\n    );\n\n    // Use standard BucketDeployment for regular S3 buckets\n    const bucketDeployment = new BucketDeployment(this, \"InitCacheDeployment\", {\n      sources: [Source.asset(this.props.initCacheDir)],\n      destinationBucket: this.cacheBucket,\n      destinationKeyPrefix: this.props.buildId, // Add buildId prefix to all uploaded files\n      prune: false, // Don't delete existing objects to prevent 404s during deployment, pruning will be handled by post-deploy\n      ...this.props.overrides?.bucketDeploymentProps,\n    });\n    return bucketDeployment;\n  }\n}\n"]}

package/lib/nextjs-compute/nextjs-containers.js

@@ -1,5 +1,4 @@
 "use strict";
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NextjsContainers = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
@@ -19,6 +18,12 @@ const constants_1 = require("../constants");
  * Fargate.
  */
 class NextjsContainers extends constructs_1.Construct {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsContainers", version: "0.5.4" };
+    albFargateService;
+    ecsCluster;
+    url;
+    dockerImageAsset;
+    props;
     constructor(scope, id, props) {
         super(scope, id);
         this.props = props;
@@ -266,6 +271,4 @@ class NextjsContainers extends constructs_1.Construct {
     }
 }
 exports.NextjsContainers = NextjsContainers;
-_a = JSII_RTTI_SYMBOL_1;
-NextjsContainers[_a] = { fqn: "cdk-nextjs.NextjsContainers", version: "0.5.2" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-containers.js","sourceRoot":"","sources":["../../src/nextjs-compute/nextjs-containers.ts"],"names":[],"mappings":"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","sourcesContent":["import { copyFileSync, existsSync } from \"node:fs\";\nimport { join as joinPath } from \"node:path\";\nimport { CfnOutput, CfnResource, Duration, Stack } from \"aws-cdk-lib\";\nimport { GatewayVpcEndpointAwsService } from \"aws-cdk-lib/aws-ec2\";\nimport { DockerImageAsset } from \"aws-cdk-lib/aws-ecr-assets\";\nimport {\n  AwsLogDriverMode,\n  Cluster,\n  ContainerImage,\n  ContainerInsights,\n  CpuArchitecture,\n  HealthCheck,\n  ICluster,\n  LogDrivers,\n} from \"aws-cdk-lib/aws-ecs\";\nimport {\n  ApplicationLoadBalancedFargateService,\n  ApplicationLoadBalancedFargateServiceProps,\n} from \"aws-cdk-lib/aws-ecs-patterns\";\nimport {\n  ApplicationProtocolVersion,\n  IApplicationLoadBalancer,\n} from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport { CfnElement } from \"aws-cdk-lib/core\";\nimport { Construct } from \"constructs\";\nimport { NextjsComputeBaseProps } from \"./nextjs-compute-base-props\";\nimport { LOG_PREFIX, NextjsType } from \"../constants\";\nimport { OptionalApplicationLoadBalancedTaskImageOptions } from \"../generated-structs/OptionalApplicationLoadBalancedTaskImageOptions\";\nimport { OptionalClusterProps } from \"../generated-structs/OptionalClusterProps\";\nimport { OptionalDockerImageAssetProps } from \"../generated-structs/OptionalDockerImageAssetProps\";\n\nexport interface NextjsContainersOverrides {\n  readonly ecsClusterProps?: OptionalClusterProps;\n  readonly albFargateServiceProps?: ApplicationLoadBalancedFargateServiceProps;\n  readonly taskImageOptions?: OptionalApplicationLoadBalancedTaskImageOptions;\n  readonly dockerImageAssetProps?: OptionalDockerImageAssetProps;\n}\n\nexport interface NextjsContainersProps extends NextjsComputeBaseProps {\n  /**\n   * Bring your own Application Load Balancer. When provided, it is passed\n   * directly to `ApplicationLoadBalancedFargateService`. If the ALB already\n   * has a listener on port 80, call `removeAutoCreatedListener()` after\n   * construction to avoid deployment failures.\n   */\n  readonly alb?: IApplicationLoadBalancer;\n  /**\n   * Bring your own ECS cluster. When provided, cdk-nextjs will skip creating\n   * a new cluster and VPC gateway endpoints. The cluster is passed directly\n   * to `ApplicationLoadBalancedFargateService`.\n   */\n  readonly ecsCluster?: ICluster;\n  readonly overrides?: NextjsContainersOverrides;\n  readonly relativeEntrypointPath: string;\n}\n\n/**\n * Next.js load balanced via Application Load Balancer with containers via AWS\n * Fargate.\n */\nexport class NextjsContainers extends Construct {\n  albFargateService: ApplicationLoadBalancedFargateService;\n  ecsCluster: ICluster;\n  url: string;\n  dockerImageAsset: DockerImageAsset;\n\n  private props: NextjsContainersProps;\n\n  constructor(scope: Construct, id: string, props: NextjsContainersProps) {\n    super(scope, id);\n    this.props = props;\n\n    // Always create Docker image asset from local build output\n    this.dockerImageAsset = this.createDockerImageAsset();\n    if (props.ecsCluster) {\n      this.ecsCluster = props.ecsCluster;\n    } else {\n      this.ecsCluster = this.createEcsCluster();\n      if (!props.overrides?.ecsClusterProps?.vpc) {\n        this.addVpcGatewayEndpoints();\n      }\n    }\n    this.albFargateService = this.createAlbFargateSevice();\n    this.configureHealthCheck();\n    this.url = this.getUrl();\n  }\n\n  private createEcsCluster(): Cluster {\n    return new Cluster(this, \"EcsCluster\", {\n      enableFargateCapacityProviders: true,\n      containerInsightsV2: ContainerInsights.ENABLED,\n      ...this.props.overrides?.ecsClusterProps,\n    });\n  }\n\n  /**\n   * Add Gateway VPC endpoints for S3 and DynamoDB if user didn't provide a VPC.\n   * Gateway endpoints are free and improve performance by keeping traffic within AWS network.\n   */\n  private addVpcGatewayEndpoints(): void {\n    this.ecsCluster.vpc.addGatewayEndpoint(\"S3GatewayEndpoint\", {\n      service: GatewayVpcEndpointAwsService.S3,\n    });\n    this.ecsCluster.vpc.addGatewayEndpoint(\"DynamoDbGatewayEndpoint\", {\n      service: GatewayVpcEndpointAwsService.DYNAMODB,\n    });\n  }\n\n  private createDockerImageAsset(): DockerImageAsset {\n    // Build context is the buildDirectory (where the Next.js app is located)\n    const buildContext = this.props.buildDirectory;\n    const dockerfileName = this.getDockerfileName();\n\n    this.copyDockerfileToContext(buildContext, dockerfileName);\n\n    return new DockerImageAsset(this, \"DockerImageAsset\", {\n      directory: buildContext,\n      file: dockerfileName,\n      buildArgs: {\n        RELATIVE_PATH_TO_PACKAGE: this.props.relativePathToPackage || \".\",\n        ...this.props.overrides?.dockerImageAssetProps?.buildArgs,\n      },\n      exclude: [\"cdk.out\"], // for common case where cdk deploy is run in same directory as nextjs app\n      ...this.props.overrides?.dockerImageAssetProps,\n    });\n  }\n\n  private getDockerfileName(): string {\n    // Use the appropriate Dockerfile based on deployment type\n    return this.props.nextjsType === NextjsType.GLOBAL_CONTAINERS\n      ? \"global-containers.Dockerfile\"\n      : \"regional-containers.Dockerfile\";\n  }\n\n  private copyDockerfileToContext(\n    buildContext: string,\n    dockerfileName: string,\n  ): void {\n    const targetDockerfile = joinPath(buildContext, dockerfileName);\n\n    // Check if Dockerfile already exists - if so, use the existing one (developer control)\n    if (existsSync(targetDockerfile)) {\n      console.log(`${LOG_PREFIX} Using existing Dockerfile: ${dockerfileName}`);\n    } else {\n      const sourceDockerfile = joinPath(\n        __dirname,\n        \"..\",\n        \"nextjs-build\",\n        dockerfileName,\n      );\n\n      if (!existsSync(sourceDockerfile)) {\n        throw new Error(\n          `Source Dockerfile not found: ${sourceDockerfile}. Ensure the cdk-nextjs package is properly built.`,\n        );\n      }\n\n      copyFileSync(sourceDockerfile, targetDockerfile);\n      console.log(`${LOG_PREFIX} Created ${targetDockerfile}.`);\n    }\n  }\n\n  private createAlbFargateSevice(): ApplicationLoadBalancedFargateService {\n    let cpuArchitecture: CpuArchitecture | undefined = undefined;\n    if (process.arch === \"x64\") {\n      cpuArchitecture = CpuArchitecture.X86_64;\n    } else if (process.arch === \"arm64\") {\n      cpuArchitecture = CpuArchitecture.ARM64;\n    }\n    const albFargateService = new ApplicationLoadBalancedFargateService(\n      this,\n      \"AlbFargateService\",\n      {\n        circuitBreaker: { rollback: true, enable: true },\n        cluster: this.ecsCluster,\n        cpu: 1024,\n        healthCheckGracePeriod: Duration.seconds(10),\n        maxHealthyPercent: 200,\n        memoryLimitMiB: 2048,\n        minHealthyPercent: 100, // maintain service availability during deployment\n        /*\n          This protocol version is for the target group (Fargate), not the ALB\n          Listener. From docs, \"Application Load Balancers provide native support\n          for HTTP/2 with HTTPS listeners\". See https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html\n          Next.js default server does not support HTTP/2 as it's recommended\n          to proxy your Next.js server which we're doing with ALB.\n          Also note, CloudFront only supports HTTP/1.1 origins.\n          https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/RequestAndResponseBehaviorCustomOrigin.html#RequestCustomHTTPVersion\n        */\n        protocolVersion: ApplicationProtocolVersion.HTTP1,\n        // if NextjsType.GLOBAL_CONTAINERS then we use VPC Origin Access which allows putting ALB in private subnet\n        publicLoadBalancer:\n          this.props.nextjsType === NextjsType.REGIONAL_CONTAINERS,\n        runtimePlatform: {\n          cpuArchitecture,\n        },\n        taskImageOptions: {\n          command: [\"node\", this.props.relativeEntrypointPath],\n          containerName: \"nextjs\",\n          containerPort: 3000,\n          image: ContainerImage.fromDockerImageAsset(this.dockerImageAsset),\n          logDriver: LogDrivers.awsLogs({\n            streamPrefix: \"nextjs\",\n            mode: AwsLogDriverMode.NON_BLOCKING,\n          }),\n          ...this.props.overrides?.taskImageOptions,\n          environment: {\n            // Cache configuration environment variables\n            CDK_NEXTJS_CACHE_BUCKET_NAME: this.props.cacheBucket.bucketName,\n            CDK_NEXTJS_REVALIDATION_TABLE_NAME:\n              this.props.revalidationTable.tableName,\n            CDK_NEXTJS_BUILD_ID: this.props.buildId,\n            // Merge with user-provided environment variables (user values take precedence)\n            ...this.props.overrides?.taskImageOptions?.environment,\n          },\n        },\n        ...this.props.overrides?.albFargateServiceProps,\n        ...(this.props.alb ? { loadBalancer: this.props.alb } : {}),\n      },\n    );\n    // required or health checks fail\n    albFargateService.taskDefinition.defaultContainer?.addEnvironment(\n      \"HOSTNAME\",\n      \"0.0.0.0\",\n    );\n\n    // Grant cache access permissions\n    this.props.cacheBucket.grantReadWrite(\n      albFargateService.taskDefinition.taskRole,\n    );\n    this.props.revalidationTable.grantReadWriteData(\n      albFargateService.taskDefinition.taskRole,\n    );\n\n    // speed up deployments by shortening deregistration delay\n    // https://docs.aws.amazon.com/AmazonECS/latest/bestpracticesguide/load-balancer-connection-draining.html\n    // TODO: document that this should be increased if long lived connections are expected\n    albFargateService.targetGroup.setAttribute(\n      \"deregistration_delay.timeout_seconds\",\n      \"30\",\n    );\n    // Only configure ALB attributes when we own the ALB.\n    // If user provided their own, they're responsible for its configuration.\n    if (\n      !this.props.alb &&\n      !this.props.overrides?.albFargateServiceProps?.loadBalancer\n    ) {\n      // best practice to enable cross zone load balancing\n      // @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/disable-cross-zone.html\n      albFargateService.loadBalancer.setAttribute(\n        \"load_balancing.cross_zone.enabled\",\n        \"true\",\n      );\n    }\n    return albFargateService;\n  }\n  /**\n   * Configure health checks for containers at ALB and ECS level. This ensures\n   * unhealthy containers are removed. Both of these health checks can be\n   * overwritten by user by accessing `albFargateService` property, so no need\n   * for `overrides`.\n   */\n  private configureHealthCheck() {\n    // speed up deployments by shortening health checks\n    // see https://docs.aws.amazon.com/AmazonECS/latest/bestpracticesguide/load-balancer-healthcheck.html\n    this.albFargateService.targetGroup.configureHealthCheck({\n      path: this.props.healthCheckPath,\n      healthyThresholdCount: 2,\n      interval: Duration.seconds(10), // too frequent? but enables faster rollback...\n      timeout: Duration.seconds(5), // must be less than interval\n    });\n    const healthCheck: HealthCheck = {\n      command: [\n        \"CMD-SHELL\",\n        // curl isn't available in alpine linux\n        `wget --quiet --tries=1 --spider http://localhost:3000${this.props.healthCheckPath} || exit 1`,\n      ],\n    };\n    const defaultContainer =\n      this.albFargateService.taskDefinition.defaultContainer;\n    if (defaultContainer) {\n      // @ts-expect-error must use internal \"props\" attribute b/c no other way to add health check\n      defaultContainer.props.healthCheck = healthCheck;\n    }\n  }\n  private getUrl(): string {\n    const protocol = this.albFargateService.certificate ? \"https\" : \"http\";\n    // we check top-level alb and overrides first b/c if using imported\n    // loadBalancer then you cannot access `albFargateService.loadBalancer`,\n    // you must access via passed in `loadBalancer` which\n    // `ApplicationLoadBalancedFargateService` accepts as props\n    const dnsName =\n      this.props.alb?.loadBalancerDnsName ??\n      this.props.overrides?.albFargateServiceProps?.loadBalancer\n        ?.loadBalancerDnsName ??\n      this.albFargateService.loadBalancer.loadBalancerDnsName;\n    return `${protocol}://${dnsName}`;\n  }\n\n  /**\n   * Remove the HTTP listener that `ApplicationLoadBalancedFargateService`\n   * always creates. Call this when you bring your own ALB that already has a\n   * listener on the same port (typically port 80) to avoid a\n   * \"listener already exists on this port\" deployment failure.\n   *\n   * This method:\n   * 1. Removes the L1 `CfnListener` resource (keeps the L2 node so the\n   *    target group child is preserved).\n   * 2. Removes the associated security-group ingress rule for port 80.\n   * 3. Rebuilds the ECS service `DependsOn` without the deleted listener.\n   * 4. Removes `CfnOutput` resources auto-created by the ecs-patterns construct.\n   */\n  removeAutoCreatedListener(): void {\n    const listener = this.albFargateService.listener;\n    const cfnListener = listener.node.defaultChild;\n    if (!(cfnListener instanceof CfnResource)) return;\n\n    // 1. Remove only the CfnListener L1 resource, not the L2 construct.\n    //    The target group (a sibling child of the listener node) stays.\n    listener.node.tryRemoveChild(cfnListener.node.id);\n\n    // 2. Remove the SG ingress rule the listener auto-creates for port 80.\n    const albSgNode = this.node\n      .findAll()\n      .find(\n        (c) =>\n          c instanceof CfnResource &&\n          c.cfnResourceType === \"AWS::EC2::SecurityGroupIngress\" &&\n          c.node.path.includes(\"from 0.0.0.0/0:80\"),\n      );\n    if (albSgNode) {\n      albSgNode.node.scope?.node.tryRemoveChild(albSgNode.node.id);\n    }\n\n    // 3. Rebuild the ECS service DependsOn without the deleted listener.\n    //    CDK generates DependsOn during _toCloudFormation(). addOverride\n    //    runs after that and replaces the generated value.\n    const cfnService = this.albFargateService.service.node.defaultChild;\n    const cfnTargetGroup = this.albFargateService.targetGroup.node.defaultChild;\n    const taskDef = this.albFargateService.taskDefinition;\n    const taskRole = taskDef.taskRole.node.defaultChild;\n    const taskRolePolicy =\n      taskDef.taskRole.node.tryFindChild(\"DefaultPolicy\")?.node.defaultChild;\n\n    if (cfnService instanceof CfnResource) {\n      const stack = Stack.of(this);\n      const keepDeps = [cfnTargetGroup, taskRole, taskRolePolicy]\n        .filter((d): d is CfnElement => d instanceof CfnElement)\n        .map((d) => stack.getLogicalId(d));\n\n      // Also keep any listener rules (e.g. path-based routing rules)\n      for (const child of stack.node.findAll()) {\n        if (\n          child instanceof CfnResource &&\n          child.cfnResourceType === \"AWS::ElasticLoadBalancingV2::ListenerRule\"\n        ) {\n          keepDeps.push(stack.getLogicalId(child));\n        }\n      }\n      cfnService.addOverride(\"DependsOn\", keepDeps);\n    }\n\n    // 4. Remove CfnOutput resources auto-created by ApplicationLoadBalancedFargateService\n    for (const child of this.node.findAll()) {\n      if (child instanceof CfnOutput) {\n        child.node.scope?.node.tryRemoveChild(child.node.id);\n      }\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-containers.js","sourceRoot":"","sources":["../../src/nextjs-compute/nextjs-containers.ts"],"names":[],"mappings":"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","sourcesContent":["import { copyFileSync, existsSync } from \"node:fs\";\nimport { join as joinPath } from \"node:path\";\nimport { CfnOutput, CfnResource, Duration, Stack } from \"aws-cdk-lib\";\nimport { GatewayVpcEndpointAwsService } from \"aws-cdk-lib/aws-ec2\";\nimport { DockerImageAsset } from \"aws-cdk-lib/aws-ecr-assets\";\nimport {\n  AwsLogDriverMode,\n  Cluster,\n  ContainerImage,\n  ContainerInsights,\n  CpuArchitecture,\n  HealthCheck,\n  ICluster,\n  LogDrivers,\n} from \"aws-cdk-lib/aws-ecs\";\nimport {\n  ApplicationLoadBalancedFargateService,\n  ApplicationLoadBalancedFargateServiceProps,\n} from \"aws-cdk-lib/aws-ecs-patterns\";\nimport {\n  ApplicationProtocolVersion,\n  IApplicationLoadBalancer,\n} from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport { CfnElement } from \"aws-cdk-lib/core\";\nimport { Construct } from \"constructs\";\nimport { NextjsComputeBaseProps } from \"./nextjs-compute-base-props\";\nimport { LOG_PREFIX, NextjsType } from \"../constants\";\nimport { OptionalApplicationLoadBalancedTaskImageOptions } from \"../generated-structs/OptionalApplicationLoadBalancedTaskImageOptions\";\nimport { OptionalClusterProps } from \"../generated-structs/OptionalClusterProps\";\nimport { OptionalDockerImageAssetProps } from \"../generated-structs/OptionalDockerImageAssetProps\";\n\nexport interface NextjsContainersOverrides {\n  readonly ecsClusterProps?: OptionalClusterProps;\n  readonly albFargateServiceProps?: ApplicationLoadBalancedFargateServiceProps;\n  readonly taskImageOptions?: OptionalApplicationLoadBalancedTaskImageOptions;\n  readonly dockerImageAssetProps?: OptionalDockerImageAssetProps;\n}\n\nexport interface NextjsContainersProps extends NextjsComputeBaseProps {\n  /**\n   * Bring your own Application Load Balancer. When provided, it is passed\n   * directly to `ApplicationLoadBalancedFargateService`. If the ALB already\n   * has a listener on port 80, call `removeAutoCreatedListener()` after\n   * construction to avoid deployment failures.\n   */\n  readonly alb?: IApplicationLoadBalancer;\n  /**\n   * Bring your own ECS cluster. When provided, cdk-nextjs will skip creating\n   * a new cluster and VPC gateway endpoints. The cluster is passed directly\n   * to `ApplicationLoadBalancedFargateService`.\n   */\n  readonly ecsCluster?: ICluster;\n  readonly overrides?: NextjsContainersOverrides;\n  readonly relativeEntrypointPath: string;\n}\n\n/**\n * Next.js load balanced via Application Load Balancer with containers via AWS\n * Fargate.\n */\nexport class NextjsContainers extends Construct {\n  albFargateService: ApplicationLoadBalancedFargateService;\n  ecsCluster: ICluster;\n  url: string;\n  dockerImageAsset: DockerImageAsset;\n\n  private props: NextjsContainersProps;\n\n  constructor(scope: Construct, id: string, props: NextjsContainersProps) {\n    super(scope, id);\n    this.props = props;\n\n    // Always create Docker image asset from local build output\n    this.dockerImageAsset = this.createDockerImageAsset();\n    if (props.ecsCluster) {\n      this.ecsCluster = props.ecsCluster;\n    } else {\n      this.ecsCluster = this.createEcsCluster();\n      if (!props.overrides?.ecsClusterProps?.vpc) {\n        this.addVpcGatewayEndpoints();\n      }\n    }\n    this.albFargateService = this.createAlbFargateSevice();\n    this.configureHealthCheck();\n    this.url = this.getUrl();\n  }\n\n  private createEcsCluster(): Cluster {\n    return new Cluster(this, \"EcsCluster\", {\n      enableFargateCapacityProviders: true,\n      containerInsightsV2: ContainerInsights.ENABLED,\n      ...this.props.overrides?.ecsClusterProps,\n    });\n  }\n\n  /**\n   * Add Gateway VPC endpoints for S3 and DynamoDB if user didn't provide a VPC.\n   * Gateway endpoints are free and improve performance by keeping traffic within AWS network.\n   */\n  private addVpcGatewayEndpoints(): void {\n    this.ecsCluster.vpc.addGatewayEndpoint(\"S3GatewayEndpoint\", {\n      service: GatewayVpcEndpointAwsService.S3,\n    });\n    this.ecsCluster.vpc.addGatewayEndpoint(\"DynamoDbGatewayEndpoint\", {\n      service: GatewayVpcEndpointAwsService.DYNAMODB,\n    });\n  }\n\n  private createDockerImageAsset(): DockerImageAsset {\n    // Build context is the buildDirectory (where the Next.js app is located)\n    const buildContext = this.props.buildDirectory;\n    const dockerfileName = this.getDockerfileName();\n\n    this.copyDockerfileToContext(buildContext, dockerfileName);\n\n    return new DockerImageAsset(this, \"DockerImageAsset\", {\n      directory: buildContext,\n      file: dockerfileName,\n      buildArgs: {\n        RELATIVE_PATH_TO_PACKAGE: this.props.relativePathToPackage || \".\",\n        ...this.props.overrides?.dockerImageAssetProps?.buildArgs,\n      },\n      exclude: [\"cdk.out\"], // for common case where cdk deploy is run in same directory as nextjs app\n      ...this.props.overrides?.dockerImageAssetProps,\n    });\n  }\n\n  private getDockerfileName(): string {\n    // Use the appropriate Dockerfile based on deployment type\n    return this.props.nextjsType === NextjsType.GLOBAL_CONTAINERS\n      ? \"global-containers.Dockerfile\"\n      : \"regional-containers.Dockerfile\";\n  }\n\n  private copyDockerfileToContext(\n    buildContext: string,\n    dockerfileName: string,\n  ): void {\n    const targetDockerfile = joinPath(buildContext, dockerfileName);\n\n    // Check if Dockerfile already exists - if so, use the existing one (developer control)\n    if (existsSync(targetDockerfile)) {\n      console.log(`${LOG_PREFIX} Using existing Dockerfile: ${dockerfileName}`);\n    } else {\n      const sourceDockerfile = joinPath(\n        __dirname,\n        \"..\",\n        \"nextjs-build\",\n        dockerfileName,\n      );\n\n      if (!existsSync(sourceDockerfile)) {\n        throw new Error(\n          `Source Dockerfile not found: ${sourceDockerfile}. Ensure the cdk-nextjs package is properly built.`,\n        );\n      }\n\n      copyFileSync(sourceDockerfile, targetDockerfile);\n      console.log(`${LOG_PREFIX} Created ${targetDockerfile}.`);\n    }\n  }\n\n  private createAlbFargateSevice(): ApplicationLoadBalancedFargateService {\n    let cpuArchitecture: CpuArchitecture | undefined = undefined;\n    if (process.arch === \"x64\") {\n      cpuArchitecture = CpuArchitecture.X86_64;\n    } else if (process.arch === \"arm64\") {\n      cpuArchitecture = CpuArchitecture.ARM64;\n    }\n    const albFargateService = new ApplicationLoadBalancedFargateService(\n      this,\n      \"AlbFargateService\",\n      {\n        circuitBreaker: { rollback: true, enable: true },\n        cluster: this.ecsCluster,\n        cpu: 1024,\n        healthCheckGracePeriod: Duration.seconds(10),\n        maxHealthyPercent: 200,\n        memoryLimitMiB: 2048,\n        minHealthyPercent: 100, // maintain service availability during deployment\n        /*\n          This protocol version is for the target group (Fargate), not the ALB\n          Listener. From docs, \"Application Load Balancers provide native support\n          for HTTP/2 with HTTPS listeners\". See https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html\n          Next.js default server does not support HTTP/2 as it's recommended\n          to proxy your Next.js server which we're doing with ALB.\n          Also note, CloudFront only supports HTTP/1.1 origins.\n          https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/RequestAndResponseBehaviorCustomOrigin.html#RequestCustomHTTPVersion\n        */\n        protocolVersion: ApplicationProtocolVersion.HTTP1,\n        // if NextjsType.GLOBAL_CONTAINERS then we use VPC Origin Access which allows putting ALB in private subnet\n        publicLoadBalancer:\n          this.props.nextjsType === NextjsType.REGIONAL_CONTAINERS,\n        runtimePlatform: {\n          cpuArchitecture,\n        },\n        taskImageOptions: {\n          command: [\"node\", this.props.relativeEntrypointPath],\n          containerName: \"nextjs\",\n          containerPort: 3000,\n          image: ContainerImage.fromDockerImageAsset(this.dockerImageAsset),\n          logDriver: LogDrivers.awsLogs({\n            streamPrefix: \"nextjs\",\n            mode: AwsLogDriverMode.NON_BLOCKING,\n          }),\n          ...this.props.overrides?.taskImageOptions,\n          environment: {\n            // Cache configuration environment variables\n            CDK_NEXTJS_CACHE_BUCKET_NAME: this.props.cacheBucket.bucketName,\n            CDK_NEXTJS_REVALIDATION_TABLE_NAME:\n              this.props.revalidationTable.tableName,\n            CDK_NEXTJS_BUILD_ID: this.props.buildId,\n            // Merge with user-provided environment variables (user values take precedence)\n            ...this.props.overrides?.taskImageOptions?.environment,\n          },\n        },\n        ...this.props.overrides?.albFargateServiceProps,\n        ...(this.props.alb ? { loadBalancer: this.props.alb } : {}),\n      },\n    );\n    // required or health checks fail\n    albFargateService.taskDefinition.defaultContainer?.addEnvironment(\n      \"HOSTNAME\",\n      \"0.0.0.0\",\n    );\n\n    // Grant cache access permissions\n    this.props.cacheBucket.grantReadWrite(\n      albFargateService.taskDefinition.taskRole,\n    );\n    this.props.revalidationTable.grantReadWriteData(\n      albFargateService.taskDefinition.taskRole,\n    );\n\n    // speed up deployments by shortening deregistration delay\n    // https://docs.aws.amazon.com/AmazonECS/latest/bestpracticesguide/load-balancer-connection-draining.html\n    // TODO: document that this should be increased if long lived connections are expected\n    albFargateService.targetGroup.setAttribute(\n      \"deregistration_delay.timeout_seconds\",\n      \"30\",\n    );\n    // Only configure ALB attributes when we own the ALB.\n    // If user provided their own, they're responsible for its configuration.\n    if (\n      !this.props.alb &&\n      !this.props.overrides?.albFargateServiceProps?.loadBalancer\n    ) {\n      // best practice to enable cross zone load balancing\n      // @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/disable-cross-zone.html\n      albFargateService.loadBalancer.setAttribute(\n        \"load_balancing.cross_zone.enabled\",\n        \"true\",\n      );\n    }\n    return albFargateService;\n  }\n  /**\n   * Configure health checks for containers at ALB and ECS level. This ensures\n   * unhealthy containers are removed. Both of these health checks can be\n   * overwritten by user by accessing `albFargateService` property, so no need\n   * for `overrides`.\n   */\n  private configureHealthCheck() {\n    // speed up deployments by shortening health checks\n    // see https://docs.aws.amazon.com/AmazonECS/latest/bestpracticesguide/load-balancer-healthcheck.html\n    this.albFargateService.targetGroup.configureHealthCheck({\n      path: this.props.healthCheckPath,\n      healthyThresholdCount: 2,\n      interval: Duration.seconds(10), // too frequent? but enables faster rollback...\n      timeout: Duration.seconds(5), // must be less than interval\n    });\n    const healthCheck: HealthCheck = {\n      command: [\n        \"CMD-SHELL\",\n        // curl isn't available in alpine linux\n        `wget --quiet --tries=1 --spider http://localhost:3000${this.props.healthCheckPath} || exit 1`,\n      ],\n    };\n    const defaultContainer =\n      this.albFargateService.taskDefinition.defaultContainer;\n    if (defaultContainer) {\n      // @ts-expect-error must use internal \"props\" attribute b/c no other way to add health check\n      defaultContainer.props.healthCheck = healthCheck;\n    }\n  }\n  private getUrl(): string {\n    const protocol = this.albFargateService.certificate ? \"https\" : \"http\";\n    // we check top-level alb and overrides first b/c if using imported\n    // loadBalancer then you cannot access `albFargateService.loadBalancer`,\n    // you must access via passed in `loadBalancer` which\n    // `ApplicationLoadBalancedFargateService` accepts as props\n    const dnsName =\n      this.props.alb?.loadBalancerDnsName ??\n      this.props.overrides?.albFargateServiceProps?.loadBalancer\n        ?.loadBalancerDnsName ??\n      this.albFargateService.loadBalancer.loadBalancerDnsName;\n    return `${protocol}://${dnsName}`;\n  }\n\n  /**\n   * Remove the HTTP listener that `ApplicationLoadBalancedFargateService`\n   * always creates. Call this when you bring your own ALB that already has a\n   * listener on the same port (typically port 80) to avoid a\n   * \"listener already exists on this port\" deployment failure.\n   *\n   * This method:\n   * 1. Removes the L1 `CfnListener` resource (keeps the L2 node so the\n   *    target group child is preserved).\n   * 2. Removes the associated security-group ingress rule for port 80.\n   * 3. Rebuilds the ECS service `DependsOn` without the deleted listener.\n   * 4. Removes `CfnOutput` resources auto-created by the ecs-patterns construct.\n   */\n  removeAutoCreatedListener(): void {\n    const listener = this.albFargateService.listener;\n    const cfnListener = listener.node.defaultChild;\n    if (!(cfnListener instanceof CfnResource)) return;\n\n    // 1. Remove only the CfnListener L1 resource, not the L2 construct.\n    //    The target group (a sibling child of the listener node) stays.\n    listener.node.tryRemoveChild(cfnListener.node.id);\n\n    // 2. Remove the SG ingress rule the listener auto-creates for port 80.\n    const albSgNode = this.node\n      .findAll()\n      .find(\n        (c) =>\n          c instanceof CfnResource &&\n          c.cfnResourceType === \"AWS::EC2::SecurityGroupIngress\" &&\n          c.node.path.includes(\"from 0.0.0.0/0:80\"),\n      );\n    if (albSgNode) {\n      albSgNode.node.scope?.node.tryRemoveChild(albSgNode.node.id);\n    }\n\n    // 3. Rebuild the ECS service DependsOn without the deleted listener.\n    //    CDK generates DependsOn during _toCloudFormation(). addOverride\n    //    runs after that and replaces the generated value.\n    const cfnService = this.albFargateService.service.node.defaultChild;\n    const cfnTargetGroup = this.albFargateService.targetGroup.node.defaultChild;\n    const taskDef = this.albFargateService.taskDefinition;\n    const taskRole = taskDef.taskRole.node.defaultChild;\n    const taskRolePolicy =\n      taskDef.taskRole.node.tryFindChild(\"DefaultPolicy\")?.node.defaultChild;\n\n    if (cfnService instanceof CfnResource) {\n      const stack = Stack.of(this);\n      const keepDeps = [cfnTargetGroup, taskRole, taskRolePolicy]\n        .filter((d): d is CfnElement => d instanceof CfnElement)\n        .map((d) => stack.getLogicalId(d));\n\n      // Also keep any listener rules (e.g. path-based routing rules)\n      for (const child of stack.node.findAll()) {\n        if (\n          child instanceof CfnResource &&\n          child.cfnResourceType === \"AWS::ElasticLoadBalancingV2::ListenerRule\"\n        ) {\n          keepDeps.push(stack.getLogicalId(child));\n        }\n      }\n      cfnService.addOverride(\"DependsOn\", keepDeps);\n    }\n\n    // 4. Remove CfnOutput resources auto-created by ApplicationLoadBalancedFargateService\n    for (const child of this.node.findAll()) {\n      if (child instanceof CfnOutput) {\n        child.node.scope?.node.tryRemoveChild(child.node.id);\n      }\n    }\n  }\n}\n"]}

package/lib/nextjs-compute/nextjs-functions.js

@@ -1,5 +1,4 @@
 "use strict";
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NextjsFunctions = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
@@ -16,6 +15,10 @@ const get_architecture_1 = require("../utils/get-architecture");
  * Run Next.js in functions on AWS with AWS Lambda.
  */
 class NextjsFunctions extends constructs_1.Construct {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsFunctions", version: "0.5.4" };
+    function;
+    functionUrl;
+    props;
     constructor(scope, id, props) {
         super(scope, id);
         this.props = props;
@@ -95,6 +98,4 @@ class NextjsFunctions extends constructs_1.Construct {
     }
 }
 exports.NextjsFunctions = NextjsFunctions;
-_a = JSII_RTTI_SYMBOL_1;
-NextjsFunctions[_a] = { fqn: "cdk-nextjs.NextjsFunctions", version: "0.5.2" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-functions.js","sourceRoot":"","sources":["../../src/nextjs-compute/nextjs-functions.ts"],"names":[],"mappings":"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","sourcesContent":["import { copyFileSync, existsSync } from \"node:fs\";\nimport { join as joinPath } from \"node:path\";\nimport { join as joinPosix } from \"node:path/posix\";\nimport { Duration } from \"aws-cdk-lib\";\nimport { ServicePrincipal } from \"aws-cdk-lib/aws-iam\";\nimport {\n  AssetImageCodeProps,\n  DockerImageCode,\n  DockerImageFunction,\n  DockerImageFunctionProps,\n  FunctionUrl,\n  FunctionUrlAuthType,\n  InvokeMode,\n} from \"aws-cdk-lib/aws-lambda\";\nimport { Construct } from \"constructs\";\nimport { NextjsComputeBaseProps } from \"./nextjs-compute-base-props\";\nimport { LOG_PREFIX, NextjsType } from \"../constants\";\nimport { OptionalDockerImageFunctionProps } from \"../generated-structs/OptionalDockerImageFunctionProps\";\nimport { OptionalFunctionUrlProps } from \"../generated-structs/OptionalFunctionUrlProps\";\nimport { getLambdaArchitecture } from \"../utils/get-architecture\";\n\nexport interface NextjsFunctionsOverrides {\n  readonly dockerImageFunctionProps?: OptionalDockerImageFunctionProps;\n  readonly functionUrlProps?: OptionalFunctionUrlProps;\n  readonly assetImageCodeProps?: AssetImageCodeProps;\n}\n\nexport interface NextjsFunctionsProps extends NextjsComputeBaseProps {\n  readonly overrides?: NextjsFunctionsOverrides;\n}\n\n/**\n * Run Next.js in functions on AWS with AWS Lambda.\n */\nexport class NextjsFunctions extends Construct {\n  function: DockerImageFunction;\n  functionUrl?: FunctionUrl;\n\n  private props: NextjsFunctionsProps;\n\n  constructor(scope: Construct, id: string, props: NextjsFunctionsProps) {\n    super(scope, id);\n    this.props = props;\n    this.function = this.createFunction();\n    if (props.nextjsType === NextjsType.GLOBAL_FUNCTIONS) {\n      this.function.grantInvoke(\n        new ServicePrincipal(\"cloudfront.amazonaws.com\"),\n      );\n      this.functionUrl = this.function.addFunctionUrl({\n        authType: FunctionUrlAuthType.AWS_IAM,\n        invokeMode: InvokeMode.RESPONSE_STREAM,\n        ...this.props.overrides?.functionUrlProps,\n      });\n    }\n  }\n\n  private createFunction() {\n    // Create DockerImageCode from local build output or use provided dockerImageCode\n    const dockerImageCode = this.createDockerImageCode();\n\n    const functionProps: DockerImageFunctionProps = {\n      architecture: getLambdaArchitecture(),\n      code: dockerImageCode,\n      memorySize: 2048,\n      timeout: Duration.seconds(30),\n      ...this.props.overrides?.dockerImageFunctionProps,\n      environment: {\n        AWS_LWA_ENABLE_COMPRESSION: \"true\",\n        AWS_LWA_INVOKE_MODE: \"response_stream\",\n        AWS_LWA_READINESS_CHECK_PATH: this.props.healthCheckPath,\n        AWS_LWA_READINESS_CHECK_PORT: \"3000\",\n        READINESS_CHECK_PATH: `http://127.0.0.1:3000${this.props.healthCheckPath}`,\n        // Cache configuration environment variables\n        CDK_NEXTJS_CACHE_BUCKET_NAME: this.props.cacheBucket.bucketName,\n        CDK_NEXTJS_REVALIDATION_TABLE_NAME:\n          this.props.revalidationTable.tableName,\n        CDK_NEXTJS_BUILD_ID: this.props.buildId,\n        ...this.props.overrides?.dockerImageFunctionProps?.environment,\n      },\n    };\n\n    const fn = new DockerImageFunction(this, \"Functions\", functionProps);\n\n    // Grant cache access permissions\n    this.props.cacheBucket.grantReadWrite(fn);\n    this.props.revalidationTable.grantReadWriteData(fn);\n\n    return fn;\n  }\n\n  private createDockerImageCode(): DockerImageCode {\n    // Build context is the buildDirectory (where the Next.js app is located)\n    const buildContext = this.props.buildDirectory;\n    const dockerfileName = \"functions.Dockerfile\";\n\n    // Copy Dockerfile to build context to avoid path resolution issues\n    this.copyDockerfileToContext(buildContext, dockerfileName);\n\n    const relativeEntrypointPath = this.props.relativePathToPackage\n      ? // joinPosix b/c this will be referenced in Docker container (Linux)\n        joinPosix(this.props.relativePathToPackage, \"server.js\")\n      : \"server.js\";\n\n    return DockerImageCode.fromImageAsset(buildContext, {\n      file: dockerfileName, // Now it's just the filename in the build context\n      cmd: [\"node\", relativeEntrypointPath],\n      exclude: [\"cdk.out\"], // for common case where cdk deploy is run in same directory as nextjs app\n      buildArgs: {\n        RELATIVE_PATH_TO_PACKAGE: this.props.relativePathToPackage || \".\",\n        ...this.props.overrides?.assetImageCodeProps?.buildArgs,\n      },\n      ...this.props.overrides?.assetImageCodeProps,\n    });\n  }\n\n  private copyDockerfileToContext(\n    buildContext: string,\n    dockerfileName: string,\n  ): void {\n    const targetDockerfile = joinPath(buildContext, dockerfileName);\n\n    // Check if Dockerfile already exists - if so, use the existing one (developer control)\n    if (existsSync(targetDockerfile)) {\n      console.log(`${LOG_PREFIX} Using existing Dockerfile: ${dockerfileName}`);\n    } else {\n      const sourceDockerfile = joinPath(\n        __dirname,\n        \"..\",\n        \"nextjs-build\",\n        dockerfileName,\n      );\n\n      if (!existsSync(sourceDockerfile)) {\n        throw new Error(\n          `Source Dockerfile not found: ${sourceDockerfile}. Ensure the cdk-nextjs package is properly built.`,\n        );\n      }\n\n      copyFileSync(sourceDockerfile, targetDockerfile);\n      console.log(\n        `${LOG_PREFIX} Created ${dockerfileName} in your project directory.`,\n      );\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-functions.js","sourceRoot":"","sources":["../../src/nextjs-compute/nextjs-functions.ts"],"names":[],"mappings":"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","sourcesContent":["import { copyFileSync, existsSync } from \"node:fs\";\nimport { join as joinPath } from \"node:path\";\nimport { join as joinPosix } from \"node:path/posix\";\nimport { Duration } from \"aws-cdk-lib\";\nimport { ServicePrincipal } from \"aws-cdk-lib/aws-iam\";\nimport {\n  AssetImageCodeProps,\n  DockerImageCode,\n  DockerImageFunction,\n  DockerImageFunctionProps,\n  FunctionUrl,\n  FunctionUrlAuthType,\n  InvokeMode,\n} from \"aws-cdk-lib/aws-lambda\";\nimport { Construct } from \"constructs\";\nimport { NextjsComputeBaseProps } from \"./nextjs-compute-base-props\";\nimport { LOG_PREFIX, NextjsType } from \"../constants\";\nimport { OptionalDockerImageFunctionProps } from \"../generated-structs/OptionalDockerImageFunctionProps\";\nimport { OptionalFunctionUrlProps } from \"../generated-structs/OptionalFunctionUrlProps\";\nimport { getLambdaArchitecture } from \"../utils/get-architecture\";\n\nexport interface NextjsFunctionsOverrides {\n  readonly dockerImageFunctionProps?: OptionalDockerImageFunctionProps;\n  readonly functionUrlProps?: OptionalFunctionUrlProps;\n  readonly assetImageCodeProps?: AssetImageCodeProps;\n}\n\nexport interface NextjsFunctionsProps extends NextjsComputeBaseProps {\n  readonly overrides?: NextjsFunctionsOverrides;\n}\n\n/**\n * Run Next.js in functions on AWS with AWS Lambda.\n */\nexport class NextjsFunctions extends Construct {\n  function: DockerImageFunction;\n  functionUrl?: FunctionUrl;\n\n  private props: NextjsFunctionsProps;\n\n  constructor(scope: Construct, id: string, props: NextjsFunctionsProps) {\n    super(scope, id);\n    this.props = props;\n    this.function = this.createFunction();\n    if (props.nextjsType === NextjsType.GLOBAL_FUNCTIONS) {\n      this.function.grantInvoke(\n        new ServicePrincipal(\"cloudfront.amazonaws.com\"),\n      );\n      this.functionUrl = this.function.addFunctionUrl({\n        authType: FunctionUrlAuthType.AWS_IAM,\n        invokeMode: InvokeMode.RESPONSE_STREAM,\n        ...this.props.overrides?.functionUrlProps,\n      });\n    }\n  }\n\n  private createFunction() {\n    // Create DockerImageCode from local build output or use provided dockerImageCode\n    const dockerImageCode = this.createDockerImageCode();\n\n    const functionProps: DockerImageFunctionProps = {\n      architecture: getLambdaArchitecture(),\n      code: dockerImageCode,\n      memorySize: 2048,\n      timeout: Duration.seconds(30),\n      ...this.props.overrides?.dockerImageFunctionProps,\n      environment: {\n        AWS_LWA_ENABLE_COMPRESSION: \"true\",\n        AWS_LWA_INVOKE_MODE: \"response_stream\",\n        AWS_LWA_READINESS_CHECK_PATH: this.props.healthCheckPath,\n        AWS_LWA_READINESS_CHECK_PORT: \"3000\",\n        READINESS_CHECK_PATH: `http://127.0.0.1:3000${this.props.healthCheckPath}`,\n        // Cache configuration environment variables\n        CDK_NEXTJS_CACHE_BUCKET_NAME: this.props.cacheBucket.bucketName,\n        CDK_NEXTJS_REVALIDATION_TABLE_NAME:\n          this.props.revalidationTable.tableName,\n        CDK_NEXTJS_BUILD_ID: this.props.buildId,\n        ...this.props.overrides?.dockerImageFunctionProps?.environment,\n      },\n    };\n\n    const fn = new DockerImageFunction(this, \"Functions\", functionProps);\n\n    // Grant cache access permissions\n    this.props.cacheBucket.grantReadWrite(fn);\n    this.props.revalidationTable.grantReadWriteData(fn);\n\n    return fn;\n  }\n\n  private createDockerImageCode(): DockerImageCode {\n    // Build context is the buildDirectory (where the Next.js app is located)\n    const buildContext = this.props.buildDirectory;\n    const dockerfileName = \"functions.Dockerfile\";\n\n    // Copy Dockerfile to build context to avoid path resolution issues\n    this.copyDockerfileToContext(buildContext, dockerfileName);\n\n    const relativeEntrypointPath = this.props.relativePathToPackage\n      ? // joinPosix b/c this will be referenced in Docker container (Linux)\n        joinPosix(this.props.relativePathToPackage, \"server.js\")\n      : \"server.js\";\n\n    return DockerImageCode.fromImageAsset(buildContext, {\n      file: dockerfileName, // Now it's just the filename in the build context\n      cmd: [\"node\", relativeEntrypointPath],\n      exclude: [\"cdk.out\"], // for common case where cdk deploy is run in same directory as nextjs app\n      buildArgs: {\n        RELATIVE_PATH_TO_PACKAGE: this.props.relativePathToPackage || \".\",\n        ...this.props.overrides?.assetImageCodeProps?.buildArgs,\n      },\n      ...this.props.overrides?.assetImageCodeProps,\n    });\n  }\n\n  private copyDockerfileToContext(\n    buildContext: string,\n    dockerfileName: string,\n  ): void {\n    const targetDockerfile = joinPath(buildContext, dockerfileName);\n\n    // Check if Dockerfile already exists - if so, use the existing one (developer control)\n    if (existsSync(targetDockerfile)) {\n      console.log(`${LOG_PREFIX} Using existing Dockerfile: ${dockerfileName}`);\n    } else {\n      const sourceDockerfile = joinPath(\n        __dirname,\n        \"..\",\n        \"nextjs-build\",\n        dockerfileName,\n      );\n\n      if (!existsSync(sourceDockerfile)) {\n        throw new Error(\n          `Source Dockerfile not found: ${sourceDockerfile}. Ensure the cdk-nextjs package is properly built.`,\n        );\n      }\n\n      copyFileSync(sourceDockerfile, targetDockerfile);\n      console.log(\n        `${LOG_PREFIX} Created ${dockerfileName} in your project directory.`,\n      );\n    }\n  }\n}\n"]}