cdk-nextjs 0.0.0

package/lib/lambdas/sign-fn-url/sign-request.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signRequest = signRequest;
+exports.getRegionFromLambdaUrl = getRegionFromLambdaUrl;
+exports.cfHeadersToHeaderBag = cfHeadersToHeaderBag;
+exports.headerBagToCfHeaders = headerBagToCfHeaders;
+exports.queryStringToQueryParamBag = queryStringToQueryParamBag;
+// we bundle lambdas during build, so below dependencies actually don't need to be included in "dependencies"
+// eslint-disable-next-line import/no-extraneous-dependencies
+const sha256_js_1 = require("@aws-crypto/sha256-js");
+// eslint-disable-next-line import/no-extraneous-dependencies
+const signature_v4_1 = require("@smithy/signature-v4");
+let sigv4;
+/**
+ * Enables use of IAM_AUTH on Lambda Function URL
+ * @link https://medium.com/@dario_26152/restrict-access-to-lambda-functionurl-to-cloudfront-using-aws-iam-988583834705
+ */
+async function signRequest(request) {
+    if (!sigv4) {
+        const region = getRegionFromLambdaUrl(request.origin?.custom?.domainName || "");
+        sigv4 = getSigV4(region);
+    }
+    // remove x-forwarded-for b/c it changes from hop to hop
+    delete request.headers["x-forwarded-for"];
+    const headerBag = cfHeadersToHeaderBag(request.headers);
+    const hostname = headerBag.host;
+    if (!hostname)
+        throw new Error("host header missing");
+    let body;
+    if (request.body?.data) {
+        body = Buffer.from(request.body.data, "base64").toString();
+    }
+    const params = queryStringToQueryParamBag(request.querystring);
+    const signed = await sigv4.sign({
+        method: request.method,
+        headers: headerBag,
+        hostname,
+        path: request.uri,
+        body,
+        query: params,
+        protocol: "https",
+    });
+    request.headers = headerBagToCfHeaders(signed.headers);
+}
+function getSigV4(region) {
+    const accessKeyId = process.env.AWS_ACCESS_KEY_ID;
+    const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
+    const sessionToken = process.env.AWS_SESSION_TOKEN;
+    if (!region)
+        throw new Error("AWS_REGION missing");
+    if (!accessKeyId)
+        throw new Error("AWS_ACCESS_KEY_ID missing");
+    if (!secretAccessKey)
+        throw new Error("AWS_SECRET_ACCESS_KEY missing");
+    if (!sessionToken)
+        throw new Error("AWS_SESSION_TOKEN missing");
+    return new signature_v4_1.SignatureV4({
+        service: "lambda",
+        region,
+        credentials: {
+            accessKeyId,
+            secretAccessKey,
+            sessionToken,
+        },
+        sha256: sha256_js_1.Sha256,
+    });
+}
+function getRegionFromLambdaUrl(url) {
+    const region = url.split(".").at(2);
+    if (!region)
+        throw new Error("Region couldn't be extracted from Lambda Function URL");
+    return region;
+}
+/**
+ * Converts CloudFront headers (can have array of header values) to simple
+ * header bag (object) required by `sigv4.sign`
+ *
+ * NOTE: only includes headers allowed by origin policy to prevent signature
+ * mismatch
+ */
+function cfHeadersToHeaderBag(headers) {
+    const headerBag = {};
+    // assume first header value is the best match
+    // headerKey is case insensitive whereas key (adjacent property value that is
+    // not destructured) is case sensitive. we arbitrarily use case insensitive key
+    for (const [headerKey, [headerObj]] of Object.entries(headers)) {
+        const value = headerObj?.value;
+        if (value) {
+            headerBag[headerKey] = value;
+        }
+    }
+    return headerBag;
+}
+/**
+ * Converts simple header bag (object) to CloudFront headers
+ */
+function headerBagToCfHeaders(headerBag) {
+    const cfHeaders = {};
+    for (const [headerKey, value] of Object.entries(headerBag)) {
+        /*
+          When your Lambda function adds or modifies request headers and you don't include the header key field, Lambda@Edge automatically inserts a header key using the header name that you provide. Regardless of how you've formatted the header name, the header key that's inserted automatically is formatted with initial capitalization for each part, separated by hyphens (-).
+          See: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-event-structure.html
+        */
+        cfHeaders[headerKey] = [{ value }];
+    }
+    return cfHeaders;
+}
+/**
+ * Converts CloudFront querystring to QueryParamaterBag for IAM Sig V4
+ */
+function queryStringToQueryParamBag(querystring) {
+    const oldParams = new URLSearchParams(querystring);
+    const newParams = {};
+    for (const [k, v] of oldParams) {
+        newParams[k] = v;
+    }
+    return newParams;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sign-request.js","sourceRoot":"","sources":["../../../src/lambdas/sign-fn-url/sign-request.ts"],"names":[],"mappings":"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","sourcesContent":["// we bundle lambdas during build, so below dependencies actually don't need to be included in \"dependencies\"\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport { Sha256 } from \"@aws-crypto/sha256-js\";\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport { SignatureV4 } from \"@smithy/signature-v4\";\nimport type { CloudFrontHeaders, CloudFrontRequest } from \"aws-lambda\";\n\nlet sigv4: SignatureV4;\n\n/**\n * Enables use of IAM_AUTH on Lambda Function URL\n * @link https://medium.com/@dario_26152/restrict-access-to-lambda-functionurl-to-cloudfront-using-aws-iam-988583834705\n */\nexport async function signRequest(request: CloudFrontRequest) {\n  if (!sigv4) {\n    const region = getRegionFromLambdaUrl(\n      request.origin?.custom?.domainName || \"\",\n    );\n    sigv4 = getSigV4(region);\n  }\n  // remove x-forwarded-for b/c it changes from hop to hop\n  delete request.headers[\"x-forwarded-for\"];\n  const headerBag = cfHeadersToHeaderBag(request.headers);\n  const hostname = headerBag.host;\n  if (!hostname) throw new Error(\"host header missing\");\n  let body: string | undefined;\n  if (request.body?.data) {\n    body = Buffer.from(request.body.data, \"base64\").toString();\n  }\n  const params = queryStringToQueryParamBag(request.querystring);\n  const signed = await sigv4.sign({\n    method: request.method,\n    headers: headerBag,\n    hostname,\n    path: request.uri,\n    body,\n    query: params,\n    protocol: \"https\",\n  });\n  request.headers = headerBagToCfHeaders(signed.headers);\n}\n\nfunction getSigV4(region: string): SignatureV4 {\n  const accessKeyId = process.env.AWS_ACCESS_KEY_ID;\n  const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;\n  const sessionToken = process.env.AWS_SESSION_TOKEN;\n  if (!region) throw new Error(\"AWS_REGION missing\");\n  if (!accessKeyId) throw new Error(\"AWS_ACCESS_KEY_ID missing\");\n  if (!secretAccessKey) throw new Error(\"AWS_SECRET_ACCESS_KEY missing\");\n  if (!sessionToken) throw new Error(\"AWS_SESSION_TOKEN missing\");\n  return new SignatureV4({\n    service: \"lambda\",\n    region,\n    credentials: {\n      accessKeyId,\n      secretAccessKey,\n      sessionToken,\n    },\n    sha256: Sha256,\n  });\n}\n\nexport function getRegionFromLambdaUrl(url: string): string {\n  const region = url.split(\".\").at(2);\n  if (!region)\n    throw new Error(\"Region couldn't be extracted from Lambda Function URL\");\n  return region;\n}\n\n/**\n * Bag or Map used for HeaderBag or QueryStringParameterBag for `sigv4.sign()`\n */\ntype Bag = Record<string, string>;\n/**\n * Converts CloudFront headers (can have array of header values) to simple\n * header bag (object) required by `sigv4.sign`\n *\n * NOTE: only includes headers allowed by origin policy to prevent signature\n * mismatch\n */\nexport function cfHeadersToHeaderBag(headers: CloudFrontHeaders): Bag {\n  const headerBag: Bag = {};\n  // assume first header value is the best match\n  // headerKey is case insensitive whereas key (adjacent property value that is\n  // not destructured) is case sensitive. we arbitrarily use case insensitive key\n  for (const [headerKey, [headerObj]] of Object.entries(headers)) {\n    const value = headerObj?.value;\n    if (value) {\n      headerBag[headerKey] = value;\n    }\n  }\n  return headerBag;\n}\n\n/**\n * Converts simple header bag (object) to CloudFront headers\n */\nexport function headerBagToCfHeaders(headerBag: Bag): CloudFrontHeaders {\n  const cfHeaders: CloudFrontHeaders = {};\n  for (const [headerKey, value] of Object.entries(headerBag)) {\n    /*\n      When your Lambda function adds or modifies request headers and you don't include the header key field, Lambda@Edge automatically inserts a header key using the header name that you provide. Regardless of how you've formatted the header name, the header key that's inserted automatically is formatted with initial capitalization for each part, separated by hyphens (-).\n      See: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-event-structure.html\n    */\n    cfHeaders[headerKey] = [{ value }];\n  }\n  return cfHeaders;\n}\n\n/**\n * Converts CloudFront querystring to QueryParamaterBag for IAM Sig V4\n */\nexport function queryStringToQueryParamBag(querystring: string): Bag {\n  const oldParams = new URLSearchParams(querystring);\n  const newParams: Bag = {};\n  for (const [k, v] of oldParams) {\n    newParams[k] = v;\n  }\n  return newParams;\n}\n"]}

package/lib/lambdas/sign-fn-url/sign-request.test.d.ts

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

package/lib/lambdas/sign-fn-url/sign-request.test.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sign_request_1 = require("./sign-request");
+describe("LambdaOriginRequestIamAuth", () => {
+    test("signRequest should add x-amz headers", async () => {
+        // dummy AWS credentials
+        process.env = { ...process.env, ...getFakeAwsCreds() };
+        const event = getFakePageRequest();
+        const request = event.Records[0]?.cf.request;
+        if (!request)
+            throw new Error("Missing request");
+        await (0, sign_request_1.signRequest)(request);
+        const securityHeaders = [
+            "x-amz-date",
+            "x-amz-security-token",
+            "x-amz-content-sha256",
+            "authorization",
+        ];
+        const hasSignedHeaders = securityHeaders.every((h) => h in request.headers);
+        expect(hasSignedHeaders).toBe(true);
+    });
+    test("getRegionFromLambdaUrl should correctly get region", () => {
+        const event = getFakePageRequest();
+        const request = event.Records[0]?.cf.request;
+        if (!request)
+            throw new Error("Missing request");
+        const actual = (0, sign_request_1.getRegionFromLambdaUrl)(request.origin?.custom?.domainName || "");
+        expect(actual).toBe("us-east-1");
+    });
+});
+function getFakePageRequest() {
+    return {
+        Records: [
+            {
+                cf: {
+                    config: {
+                        distributionDomainName: "d6b8brjqfujeb.cloudfront.net",
+                        distributionId: "EHX2SDUU61T7U",
+                        eventType: "origin-request",
+                        requestId: "",
+                    },
+                    request: {
+                        clientIp: "1.1.1.1",
+                        headers: {
+                            host: [
+                                {
+                                    key: "Host",
+                                    value: "d6b8brjqfujeb.cloudfront.net",
+                                },
+                            ],
+                            "accept-language": [
+                                {
+                                    key: "Accept-Language",
+                                    value: "en-US,en;q=0.9",
+                                },
+                            ],
+                            referer: [
+                                {
+                                    key: "Referer",
+                                    value: "https://d6b8brjqfujeb.cloudfront.net/some/path",
+                                },
+                            ],
+                            "x-forwarded-for": [
+                                {
+                                    key: "X-Forwarded-For",
+                                    value: "1.1.1.1",
+                                },
+                            ],
+                            "user-agent": [
+                                {
+                                    key: "User-Agent",
+                                    value: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36",
+                                },
+                            ],
+                            via: [
+                                {
+                                    key: "Via",
+                                    value: "2.0 8bf94e29f889f8d0076c4502ae008b58.cloudfront.net (CloudFront)",
+                                },
+                            ],
+                            "accept-encoding": [
+                                {
+                                    key: "Accept-Encoding",
+                                    value: "br,gzip",
+                                },
+                            ],
+                            "sec-ch-ua": [
+                                {
+                                    key: "sec-ch-ua",
+                                    value: '"Google Chrome";v="113", "Chromium";v="113", "Not-A.Brand";v="24"',
+                                },
+                            ],
+                        },
+                        method: "GET",
+                        querystring: "",
+                        uri: "/some/path",
+                        origin: {
+                            custom: {
+                                customHeaders: {},
+                                domainName: "kjtbbx7u533q7p7n5font6gpci0phrng.lambda-url.us-east-1.on.aws",
+                                keepaliveTimeout: 5,
+                                path: "",
+                                port: 443,
+                                protocol: "https",
+                                readTimeout: 30,
+                                sslProtocols: ["TLSv1.2"],
+                            },
+                        },
+                        body: {
+                            action: "read-only",
+                            data: "",
+                            encoding: "base64",
+                            inputTruncated: false,
+                        },
+                    },
+                },
+            },
+        ],
+    };
+}
+function getFakeAwsCreds() {
+    return {
+        AWS_REGION: "us-east-1",
+        AWS_ACCESS_KEY_ID: "AKIAIOSFODNN7EXAMPLE",
+        AWS_SECRET_ACCESS_KEY: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+        AWS_SESSION_TOKEN: "ZQoJb3JpZ2luX2VjEFgaCXVzLWVhc3QtMSJGMEQCIHijzdTXh59aSe2hRfCWpFd2/jacPUC+8rCq3qBIiuG2AiAGX8jqld+p04nPYfuShi1lLN/Z1hEXG9QSNEmEFLTxGSqmAgiR//////////8BEAIaDDI2ODkxNDQ2NTIzMSIMrAMO5/GTvMgoG+chKvoB4f4V1TfkZiHOlmeMK6Ep58mav65A0WU3K9WPzdrJojnGqqTuS85zTlKhm3lfmMxCOtwS/OlOuiBQ1MZNlksK2je1FazgbXN46fNSi+iHiY9VfyRAd0wSLmXB8FFrCGsU92QOy/+deji0qIVadsjEyvBRxzQj5oIUI5sb74Yt7uNvka9fVZcT4s4IndYda0N7oZwIrApCuzzBMuoMAhabmgVrZTbiLmvOiFHS2XZWBySABdygqaIzfV7G4hjckvcXhtxpkw+HJUZTNzVUlspghzte1UG6VvIRV8ax3kWA3zqm8nA/1gHkl40DubJIXz1AJbg5Cps5moE1pjD7vNijBjqeAZh0Q/e0awIHnV4dXMfXUu5mWJ7Db9K1eUlSSL9FyiKeKd94HEdrbIrnPuIWVT/I/5RjNm7NgPYiqmpyx3fSpVcq9CKws0oEfBw6J9Hxk0IhV8yWFZYNMWIarUUZdmL9vVeJmFZmwyL4JjY1s/SZIU/oa8DtvkmP4RG4tTJfpyyhoKL0wJOevkYyoigNllBlLN59SZAT8CCADpN/B+sK",
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sign-request.test.js","sourceRoot":"","sources":["../../../src/lambdas/sign-fn-url/sign-request.test.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CloudFrontRequestEvent } from \"aws-lambda\";\nimport { getRegionFromLambdaUrl, signRequest } from \"./sign-request\";\n\ndescribe(\"LambdaOriginRequestIamAuth\", () => {\n  test(\"signRequest should add x-amz headers\", async () => {\n    // dummy AWS credentials\n    process.env = { ...process.env, ...getFakeAwsCreds() };\n    const event = getFakePageRequest();\n    const request = event.Records[0]?.cf.request;\n    if (!request) throw new Error(\"Missing request\");\n    await signRequest(request);\n    const securityHeaders = [\n      \"x-amz-date\",\n      \"x-amz-security-token\",\n      \"x-amz-content-sha256\",\n      \"authorization\",\n    ];\n    const hasSignedHeaders = securityHeaders.every((h) => h in request.headers);\n    expect(hasSignedHeaders).toBe(true);\n  });\n\n  test(\"getRegionFromLambdaUrl should correctly get region\", () => {\n    const event = getFakePageRequest();\n    const request = event.Records[0]?.cf.request;\n    if (!request) throw new Error(\"Missing request\");\n    const actual = getRegionFromLambdaUrl(\n      request.origin?.custom?.domainName || \"\",\n    );\n    expect(actual).toBe(\"us-east-1\");\n  });\n});\n\nfunction getFakePageRequest(): CloudFrontRequestEvent {\n  return {\n    Records: [\n      {\n        cf: {\n          config: {\n            distributionDomainName: \"d6b8brjqfujeb.cloudfront.net\",\n            distributionId: \"EHX2SDUU61T7U\",\n            eventType: \"origin-request\",\n            requestId: \"\",\n          },\n          request: {\n            clientIp: \"1.1.1.1\",\n            headers: {\n              host: [\n                {\n                  key: \"Host\",\n                  value: \"d6b8brjqfujeb.cloudfront.net\",\n                },\n              ],\n              \"accept-language\": [\n                {\n                  key: \"Accept-Language\",\n                  value: \"en-US,en;q=0.9\",\n                },\n              ],\n              referer: [\n                {\n                  key: \"Referer\",\n                  value: \"https://d6b8brjqfujeb.cloudfront.net/some/path\",\n                },\n              ],\n              \"x-forwarded-for\": [\n                {\n                  key: \"X-Forwarded-For\",\n                  value: \"1.1.1.1\",\n                },\n              ],\n              \"user-agent\": [\n                {\n                  key: \"User-Agent\",\n                  value:\n                    \"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36\",\n                },\n              ],\n              via: [\n                {\n                  key: \"Via\",\n                  value:\n                    \"2.0 8bf94e29f889f8d0076c4502ae008b58.cloudfront.net (CloudFront)\",\n                },\n              ],\n              \"accept-encoding\": [\n                {\n                  key: \"Accept-Encoding\",\n                  value: \"br,gzip\",\n                },\n              ],\n              \"sec-ch-ua\": [\n                {\n                  key: \"sec-ch-ua\",\n                  value:\n                    '\"Google Chrome\";v=\"113\", \"Chromium\";v=\"113\", \"Not-A.Brand\";v=\"24\"',\n                },\n              ],\n            },\n            method: \"GET\",\n            querystring: \"\",\n            uri: \"/some/path\",\n            origin: {\n              custom: {\n                customHeaders: {},\n                domainName:\n                  \"kjtbbx7u533q7p7n5font6gpci0phrng.lambda-url.us-east-1.on.aws\",\n                keepaliveTimeout: 5,\n                path: \"\",\n                port: 443,\n                protocol: \"https\",\n                readTimeout: 30,\n                sslProtocols: [\"TLSv1.2\"],\n              },\n            },\n            body: {\n              action: \"read-only\",\n              data: \"\",\n              encoding: \"base64\",\n              inputTruncated: false,\n            },\n          },\n        },\n      },\n    ],\n  };\n}\n\nfunction getFakeAwsCreds() {\n  return {\n    AWS_REGION: \"us-east-1\",\n    AWS_ACCESS_KEY_ID: \"AKIAIOSFODNN7EXAMPLE\",\n    AWS_SECRET_ACCESS_KEY: \"wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY\",\n    AWS_SESSION_TOKEN:\n      \"ZQoJb3JpZ2luX2VjEFgaCXVzLWVhc3QtMSJGMEQCIHijzdTXh59aSe2hRfCWpFd2/jacPUC+8rCq3qBIiuG2AiAGX8jqld+p04nPYfuShi1lLN/Z1hEXG9QSNEmEFLTxGSqmAgiR//////////8BEAIaDDI2ODkxNDQ2NTIzMSIMrAMO5/GTvMgoG+chKvoB4f4V1TfkZiHOlmeMK6Ep58mav65A0WU3K9WPzdrJojnGqqTuS85zTlKhm3lfmMxCOtwS/OlOuiBQ1MZNlksK2je1FazgbXN46fNSi+iHiY9VfyRAd0wSLmXB8FFrCGsU92QOy/+deji0qIVadsjEyvBRxzQj5oIUI5sb74Yt7uNvka9fVZcT4s4IndYda0N7oZwIrApCuzzBMuoMAhabmgVrZTbiLmvOiFHS2XZWBySABdygqaIzfV7G4hjckvcXhtxpkw+HJUZTNzVUlspghzte1UG6VvIRV8ax3kWA3zqm8nA/1gHkl40DubJIXz1AJbg5Cps5moE1pjD7vNijBjqeAZh0Q/e0awIHnV4dXMfXUu5mWJ7Db9K1eUlSSL9FyiKeKd94HEdrbIrnPuIWVT/I/5RjNm7NgPYiqmpyx3fSpVcq9CKws0oEfBw6J9Hxk0IhV8yWFZYNMWIarUUZdmL9vVeJmFZmwyL4JjY1s/SZIU/oa8DtvkmP4RG4tTJfpyyhoKL0wJOevkYyoigNllBlLN59SZAT8CCADpN/B+sK\",\n  };\n}\n"]}

package/lib/nextjs-assets-deployment.d.ts

@@ -0,0 +1,116 @@
+import { CustomResource } from "aws-cdk-lib";
+import { IVpc } from "aws-cdk-lib/aws-ec2";
+import { AccessPoint } from "aws-cdk-lib/aws-efs";
+import { DockerImageCode, DockerImageFunction } from "aws-cdk-lib/aws-lambda";
+import { Bucket } from "aws-cdk-lib/aws-s3";
+import { Construct } from "constructs";
+import { OptionalDockerImageFunctionProps } from "./generated-structs/OptionalDockerImageFunctionProps";
+import { NextjsBuild } from "./nextjs-build/nextjs-build";
+export interface NextjsAssetDeploymentOverrides {
+    readonly dockerImageFunctionProps?: OptionalDockerImageFunctionProps;
+}
+export interface NextjsAssetsDeploymentProps {
+    readonly accessPoint: AccessPoint;
+    /**
+     * @see {@link NextjsBuild.buildImageDigest}
+     */
+    readonly buildImageDigest: string;
+    /**
+     * @default true
+     */
+    readonly debug?: boolean;
+    readonly dockerImageCode: DockerImageCode;
+    /**
+     * @see {@link NextjsBuild.containerMountPathForEfs}
+     */
+    readonly containerMountPathForEfs: NextjsBuild["containerMountPathForEfs"];
+    readonly overrides?: NextjsAssetDeploymentOverrides;
+    /**
+     * @see {@link NextjsBaseProps.relativePathToWorkspace}
+     */
+    readonly relativePathToWorkspace?: string;
+    /**
+     * Required for `NextjsType.GlobalFunctions` and `NextjsType.GlobalContainers`
+     */
+    readonly staticAssetsBucket?: Bucket;
+    readonly vpc: IVpc;
+}
+/**
+ * @internal
+ */
+export interface FsToS3Action {
+    type: "fs-to-s3";
+    destinationBucketName: string;
+    destinationKeyPrefix?: string;
+    sourcePath: string;
+}
+/**
+ * @internal
+ */
+export interface FsToFsAction {
+    type: "fs-to-fs";
+    sourcePath: string;
+    destinationPath: string;
+}
+/**
+ * @internal
+ */
+export interface PruneS3Action {
+    type: "prune-s3";
+    /**
+     * The minimum previous deployment count to prune
+     * @default 3
+     */
+    minPreviousDeployCountToPrune: number;
+    /**
+     * The minimum previous deployment date to prune
+     * @default new Date(new Date().setMonth(new Date().getMonth() - 1))
+     */
+    minPreviousDeployDateToPrune: string;
+    bucketName: string;
+    bucketPrefix?: string;
+}
+/**
+ * @internal
+ */
+export interface PruneFsAction {
+    type: "prune-fs";
+    /**
+     * The minimum previous deployment count to prune
+     * @default 3
+     */
+    minPreviousDeployCountToPrune: number;
+    /**
+     * The minimum previous deployment date to prune
+     * @default new Date(new Date().setMonth(new Date().getMonth() - 1))
+     */
+    minPreviousDeployDateToPrune: string;
+    directory: string;
+}
+/**
+ * @internal
+ */
+export interface CustomResourceProperties {
+    actions: (FsToS3Action | FsToFsAction | PruneS3Action | PruneFsAction)[];
+    /**
+     * {@link NextjsAssetDeploymentProps.builderImageDigest}
+     */
+    buildImageDigest: string;
+    imageCachePath: string;
+    prerenderManifestPath: string;
+}
+/**
+ * Deploys static assets to S3 and cache assets to EFS in Lambda Custom Resource.
+ */
+export declare class NextjsAssetsDeployment extends Construct {
+    customResource: CustomResource;
+    dockerImageFunction: DockerImageFunction;
+    /**
+     * Only used for `NextjsGlobalFunctions`
+     */
+    previewModeId: string;
+    private props;
+    constructor(scope: Construct, id: string, props: NextjsAssetsDeploymentProps);
+    private createFunction;
+    private createCustomResource;
+}

package/lib/nextjs-assets-deployment.js

@@ -0,0 +1,93 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NextjsAssetsDeployment = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const posix_1 = require("path/posix");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const constructs_1 = require("constructs");
+const common_1 = require("./common");
+/**
+ * Deploys static assets to S3 and cache assets to EFS in Lambda Custom Resource.
+ */
+class NextjsAssetsDeployment extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        this.dockerImageFunction = this.createFunction();
+        this.customResource = this.createCustomResource();
+        this.previewModeId = this.customResource.getAttString("previewModeId");
+    }
+    createFunction() {
+        let architecture = undefined;
+        if (process.arch === "x64") {
+            architecture = aws_lambda_1.Architecture.X86_64;
+        }
+        else if (process.arch === "arm64") {
+            architecture = aws_lambda_1.Architecture.ARM_64;
+        }
+        const fn = new aws_lambda_1.DockerImageFunction(this, "Fn", {
+            architecture,
+            code: this.props.dockerImageCode,
+            memorySize: 2048,
+            filesystem: aws_lambda_1.FileSystem.fromEfsAccessPoint(this.props.accessPoint, this.props.containerMountPathForEfs),
+            vpc: this.props.vpc,
+            timeout: aws_cdk_lib_1.Duration.minutes(5),
+            ...this.props.overrides?.dockerImageFunctionProps,
+        });
+        if (this.props.debug !== false) {
+            fn.addEnvironment("DEBUG", "1");
+        }
+        if (this.props.staticAssetsBucket) {
+            this.props.staticAssetsBucket.grantReadWrite(fn);
+        }
+        return fn;
+    }
+    createCustomResource() {
+        const root = "/app";
+        const actions = [];
+        if (this.props.staticAssetsBucket?.bucketName) {
+            actions.push({
+                type: "fs-to-s3",
+                sourcePath: (0, posix_1.join)(root, "public"),
+                destinationBucketName: this.props.staticAssetsBucket.bucketName,
+            }, 
+            // static files
+            {
+                type: "fs-to-s3",
+                sourcePath: (0, posix_1.join)(root, ".next", "static"),
+                destinationBucketName: this.props.staticAssetsBucket.bucketName,
+                destinationKeyPrefix: "_next/static",
+            });
+        }
+        actions.push(
+        // data cache - https://nextjs.org/docs/app/building-your-application/caching#data-cache
+        {
+            type: "fs-to-fs",
+            sourcePath: (0, posix_1.join)(root, ".next", "cache", "fetch-cache"),
+            destinationPath: (0, posix_1.join)(this.props.containerMountPathForEfs, common_1.DATA_CACHE_DIR),
+        }, 
+        // full route cache - https://nextjs.org/docs/app/building-your-application/caching#full-route-cache
+        {
+            type: "fs-to-fs",
+            sourcePath: (0, posix_1.join)(root, ".next", "standalone", this.props.relativePathToWorkspace || "", ".next", "server", "app"),
+            destinationPath: (0, posix_1.join)(this.props.containerMountPathForEfs, common_1.FULL_ROUTE_CACHE_DIR),
+        });
+        const properties = {
+            actions,
+            buildImageDigest: this.props.buildImageDigest,
+            imageCachePath: (0, posix_1.join)(this.props.containerMountPathForEfs, common_1.IMAGE_CACHE_DIR),
+            prerenderManifestPath: (0, posix_1.join)(root, ".next", "prerender-manifest.json"),
+        };
+        return new aws_cdk_lib_1.CustomResource(this, "CustomResource", {
+            properties,
+            resourceType: "Custom::NextjsAssetsDeployment",
+            serviceToken: this.dockerImageFunction.functionArn,
+        });
+    }
+}
+exports.NextjsAssetsDeployment = NextjsAssetsDeployment;
+_a = JSII_RTTI_SYMBOL_1;
+NextjsAssetsDeployment[_a] = { fqn: "cdk-nextjs.NextjsAssetsDeployment", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-assets-deployment.js","sourceRoot":"","sources":["../src/nextjs-assets-deployment.ts"],"names":[],"mappings":"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","sourcesContent":["import { join } from \"path/posix\";\nimport { CustomResource, Duration } from \"aws-cdk-lib\";\nimport { IVpc } from \"aws-cdk-lib/aws-ec2\";\nimport { AccessPoint } from \"aws-cdk-lib/aws-efs\";\nimport {\n  Architecture,\n  DockerImageCode,\n  DockerImageFunction,\n  FileSystem,\n} from \"aws-cdk-lib/aws-lambda\";\nimport { Bucket } from \"aws-cdk-lib/aws-s3\";\nimport { Construct } from \"constructs\";\nimport {\n  DATA_CACHE_DIR,\n  FULL_ROUTE_CACHE_DIR,\n  IMAGE_CACHE_DIR,\n} from \"./common\";\nimport { OptionalDockerImageFunctionProps } from \"./generated-structs/OptionalDockerImageFunctionProps\";\nimport { NextjsBuild } from \"./nextjs-build/nextjs-build\";\nimport { NextjsBaseProps } from \"./root-constructs/nextjs-base-props\";\n\nexport interface NextjsAssetDeploymentOverrides {\n  readonly dockerImageFunctionProps?: OptionalDockerImageFunctionProps;\n}\n\nexport interface NextjsAssetsDeploymentProps {\n  readonly accessPoint: AccessPoint;\n  /**\n   * @see {@link NextjsBuild.buildImageDigest}\n   */\n  readonly buildImageDigest: string;\n  /**\n   * @default true\n   */\n  readonly debug?: boolean;\n  readonly dockerImageCode: DockerImageCode; // TODO: remove and build from common builder base?\n  /**\n   * @see {@link NextjsBuild.containerMountPathForEfs}\n   */\n  readonly containerMountPathForEfs: NextjsBuild[\"containerMountPathForEfs\"];\n  readonly overrides?: NextjsAssetDeploymentOverrides;\n  /**\n   * @see {@link NextjsBaseProps.relativePathToWorkspace}\n   */\n  readonly relativePathToWorkspace?: string;\n  /**\n   * Required for `NextjsType.GlobalFunctions` and `NextjsType.GlobalContainers`\n   */\n  readonly staticAssetsBucket?: Bucket;\n  readonly vpc: IVpc;\n}\n\n/**\n * @internal\n */\nexport interface FsToS3Action {\n  type: \"fs-to-s3\";\n  destinationBucketName: string;\n  destinationKeyPrefix?: string;\n  sourcePath: string;\n}\n/**\n * @internal\n */\nexport interface FsToFsAction {\n  type: \"fs-to-fs\";\n  sourcePath: string;\n  destinationPath: string;\n}\n/**\n * @internal\n */\nexport interface PruneS3Action {\n  type: \"prune-s3\";\n  /**\n   * The minimum previous deployment count to prune\n   * @default 3\n   */\n  minPreviousDeployCountToPrune: number;\n  /**\n   * The minimum previous deployment date to prune\n   * @default new Date(new Date().setMonth(new Date().getMonth() - 1))\n   */\n  minPreviousDeployDateToPrune: string;\n  bucketName: string;\n  bucketPrefix?: string;\n}\n/**\n * @internal\n */\nexport interface PruneFsAction {\n  type: \"prune-fs\";\n  /**\n   * The minimum previous deployment count to prune\n   * @default 3\n   */\n  minPreviousDeployCountToPrune: number;\n  /**\n   * The minimum previous deployment date to prune\n   * @default new Date(new Date().setMonth(new Date().getMonth() - 1))\n   */\n  minPreviousDeployDateToPrune: string;\n  directory: string;\n}\n\n/**\n * @internal\n */\nexport interface CustomResourceProperties {\n  actions: (FsToS3Action | FsToFsAction | PruneS3Action | PruneFsAction)[];\n  /**\n   * {@link NextjsAssetDeploymentProps.builderImageDigest}\n   */\n  buildImageDigest: string;\n  imageCachePath: string;\n  prerenderManifestPath: string;\n}\n\n/**\n * Deploys static assets to S3 and cache assets to EFS in Lambda Custom Resource.\n */\nexport class NextjsAssetsDeployment extends Construct {\n  customResource: CustomResource;\n  dockerImageFunction: DockerImageFunction;\n  /**\n   * Only used for `NextjsGlobalFunctions`\n   */\n  previewModeId: string;\n\n  private props: NextjsAssetsDeploymentProps;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: NextjsAssetsDeploymentProps,\n  ) {\n    super(scope, id);\n    this.props = props;\n    this.dockerImageFunction = this.createFunction();\n    this.customResource = this.createCustomResource();\n    this.previewModeId = this.customResource.getAttString(\"previewModeId\");\n  }\n\n  private createFunction() {\n    let architecture: Architecture | undefined = undefined;\n    if (process.arch === \"x64\") {\n      architecture = Architecture.X86_64;\n    } else if (process.arch === \"arm64\") {\n      architecture = Architecture.ARM_64;\n    }\n    const fn = new DockerImageFunction(this, \"Fn\", {\n      architecture,\n      code: this.props.dockerImageCode,\n      memorySize: 2048,\n      filesystem: FileSystem.fromEfsAccessPoint(\n        this.props.accessPoint,\n        this.props.containerMountPathForEfs,\n      ),\n      vpc: this.props.vpc,\n      timeout: Duration.minutes(5),\n      ...this.props.overrides?.dockerImageFunctionProps,\n    });\n    if (this.props.debug !== false) {\n      fn.addEnvironment(\"DEBUG\", \"1\");\n    }\n    if (this.props.staticAssetsBucket) {\n      this.props.staticAssetsBucket.grantReadWrite(fn);\n    }\n    return fn;\n  }\n\n  private createCustomResource() {\n    const root = \"/app\";\n    const actions: CustomResourceProperties[\"actions\"] = [];\n    if (this.props.staticAssetsBucket?.bucketName) {\n      actions.push(\n        {\n          type: \"fs-to-s3\",\n          sourcePath: join(root, \"public\"),\n          destinationBucketName: this.props.staticAssetsBucket.bucketName,\n        },\n        // static files\n        {\n          type: \"fs-to-s3\",\n          sourcePath: join(root, \".next\", \"static\"),\n          destinationBucketName: this.props.staticAssetsBucket.bucketName,\n          destinationKeyPrefix: \"_next/static\",\n        },\n      );\n    }\n    actions.push(\n      // data cache - https://nextjs.org/docs/app/building-your-application/caching#data-cache\n      {\n        type: \"fs-to-fs\",\n        sourcePath: join(root, \".next\", \"cache\", \"fetch-cache\"),\n        destinationPath: join(\n          this.props.containerMountPathForEfs,\n          DATA_CACHE_DIR,\n        ),\n      },\n      // full route cache - https://nextjs.org/docs/app/building-your-application/caching#full-route-cache\n      {\n        type: \"fs-to-fs\",\n        sourcePath: join(\n          root,\n          \".next\",\n          \"standalone\",\n          this.props.relativePathToWorkspace || \"\",\n          \".next\",\n          \"server\",\n          \"app\",\n        ),\n        destinationPath: join(\n          this.props.containerMountPathForEfs,\n          FULL_ROUTE_CACHE_DIR,\n        ),\n      },\n      // images are optimized at runtime so nothing to deploy\n    );\n    const properties: CustomResourceProperties = {\n      actions,\n      buildImageDigest: this.props.buildImageDigest,\n      imageCachePath: join(\n        this.props.containerMountPathForEfs,\n        IMAGE_CACHE_DIR,\n      ),\n      prerenderManifestPath: join(root, \".next\", \"prerender-manifest.json\"),\n    };\n    return new CustomResource(this, \"CustomResource\", {\n      properties,\n      resourceType: \"Custom::NextjsAssetsDeployment\",\n      serviceToken: this.dockerImageFunction.functionArn,\n    });\n  }\n}\n"]}

package/lib/nextjs-build/add-cache-handler.d.ts

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

package/lib/nextjs-build/add-cache-handler.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+/**
+ * For `NextjsGlobalFunctions`, adds custom [Cache Handler](https://nextjs.org/docs/app/api-reference/next-config-js/incrementalCacheHandlerPath)
+ * so that time-based revalidation works. In serverless environment, functions
+ * spin down after request is complete but Next.js depends upon compute to still
+ * be running for time-based revalidation to work properly so we need to perform
+ * work async and use SQS Queue to do so.
+ */
+function addCacheHandler(requiredServerFilesPath) {
+    if (!(0, fs_1.existsSync)(requiredServerFilesPath)) {
+        throw new Error(`Could not find required server files path: ${requiredServerFilesPath}`);
+    }
+    const requiredServerFiles = JSON.parse((0, fs_1.readFileSync)(requiredServerFilesPath, {
+        encoding: "utf-8",
+    }));
+    requiredServerFiles.config.cacheHandler = "../cache-handler.cjs";
+    (0, fs_1.writeFileSync)(requiredServerFilesPath, JSON.stringify(requiredServerFiles));
+}
+const [requiredServerFilesPath] = process.argv.slice(2);
+addCacheHandler(requiredServerFilesPath);
+//# sourceMappingURL=data:application/json;base64,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

package/lib/nextjs-build/add-cache-handler.mjs

@@ -0,0 +1,18 @@
+// src/nextjs-build/add-cache-handler.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+function addCacheHandler(requiredServerFilesPath2) {
+  if (!existsSync(requiredServerFilesPath2)) {
+    throw new Error(
+      `Could not find required server files path: ${requiredServerFilesPath2}`
+    );
+  }
+  const requiredServerFiles = JSON.parse(
+    readFileSync(requiredServerFilesPath2, {
+      encoding: "utf-8"
+    })
+  );
+  requiredServerFiles.config.cacheHandler = "../cache-handler.cjs";
+  writeFileSync(requiredServerFilesPath2, JSON.stringify(requiredServerFiles));
+}
+var [requiredServerFilesPath] = process.argv.slice(2);
+addCacheHandler(requiredServerFilesPath);

package/lib/nextjs-build/builder.Dockerfile

@@ -0,0 +1,29 @@
+#checkov:skip=CKV_DOCKER_2: healthcheck not needed for local only container
+#checkov:skip=CKV_DOCKER_3: user not required for local builder container
+FROM public.ecr.aws/docker/library/node:20-alpine
+# Check https://github.com/nodejs/docker-node/tree/b4117f9333da4138b03a546ec926ef50a31506c3#nodealpine to understand why libc6-compat might be needed.
+RUN apk add --no-cache libc6-compat
+WORKDIR /app
+# It's preferrable to only copy package.json's and lockfiles, install, and then
+# copy the rest of the code to efficiently utilize build cache. We don't do that
+#$ here because it's highly customized based on a projects setup. We recommend
+# developers use `overrides.nextjsXX.nextjsBuildProps.builderImageProps.srcDockerfilePath`
+# to optimize for their setup.
+COPY . .
+# Install dependencies based on the preferred package manager
+RUN \
+  if [ -f yarn.lock ]; then yarn --frozen-lockfile; \
+  elif [ -f package-lock.json ]; then npm ci; \
+  elif [ -f pnpm-lock.yaml ]; then corepack enable pnpm && pnpm i --frozen-lockfile; \
+  else echo "Lockfile not found." && exit 1; \
+  fi
+ARG BUILD_COMMAND
+ARG RELATIVE_PATH_TO_WORKSPACE
+RUN \
+  if [ -f ./cdk-nextjs-load-env-vars.sh ]; then \
+    chmod u+x ./cdk-nextjs-load-env-vars.sh && \
+    . ./cdk-nextjs-load-env-vars.sh; \
+  fi && \
+  cd $RELATIVE_PATH_TO_WORKSPACE && \
+  $BUILD_COMMAND
+# TODO: remove unnecessary node_modules: https://github.com/sst/open-next/pull/242