cdk-nextjs 0.0.0

package/lib/nextjs-distribution.js

@@ -0,0 +1,362 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NextjsDistribution = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_cloudfront_1 = require("aws-cdk-lib/aws-cloudfront");
+const aws_cloudfront_origins_1 = require("aws-cdk-lib/aws-cloudfront-origins");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const constructs_1 = require("constructs");
+const common_1 = require("./common");
+const sign_fn_url_function_1 = require("./lambdas/sign-fn-url/sign-fn-url-function");
+class NextjsDistribution extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        /**
+         * Common security headers applied by default to all origins
+         * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-response-headers-policies.html#managed-response-headers-policies-security
+         */
+        this.commonSecurityHeadersBehavior = {
+            contentTypeOptions: { override: false },
+            frameOptions: {
+                frameOption: aws_cloudfront_1.HeadersFrameOption.SAMEORIGIN,
+                override: false,
+            },
+            referrerPolicy: {
+                override: false,
+                referrerPolicy: aws_cloudfront_1.HeadersReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN,
+            },
+            strictTransportSecurity: {
+                accessControlMaxAge: aws_cdk_lib_1.Duration.days(365),
+                includeSubdomains: true,
+                override: false,
+                preload: true,
+            },
+            xssProtection: { override: false, protection: true, modeBlock: true },
+        };
+        /**
+         * Given stack id: "arn:aws:cloudformation:us-east-1:905418358903:stack/lh-stickb-idp/4bf74be0-e880-11ee-aea9-0affc6185b25",
+         * returns "4bf74be0"
+         */
+        this.uniqueStackIdPart = aws_cdk_lib_1.Fn.select(0, aws_cdk_lib_1.Fn.split("-", aws_cdk_lib_1.Fn.select(2, aws_cdk_lib_1.Fn.split("/", `${aws_cdk_lib_1.Aws.STACK_ID}`))));
+        this.props = props;
+        this.staticOrigin = this.createStaticOrigin();
+        this.isFunctionCompute = props.nextjsType === common_1.NextjsType.GLOBAL_FUNCTIONS;
+        this.dynamicOrigin = this.createDynamicOrigin();
+        this.dynamicOriginResponsePolicy = this.createDynamicOriginRequestPolicy();
+        this.dynamicCloudFrontFunctionAssociations =
+            this.createDynamicCloudFrontFunctionAssociations();
+        if (this.isFunctionCompute) {
+            this.edgeLambdas = this.createEdgeLambdas();
+        }
+        this.staticBehaviorOptions = this.createStaticBehaviorOptions();
+        this.dynamicBehaviorOptions = this.createDynamicBehaviorOptions();
+        this.imageBehaviorOptions = this.createImageBehaviorOptions();
+        this.distribution = this.getDistribution();
+        this.addStaticBehaviors();
+        this.addDynamicBehaviors();
+        this.addS3OacAndRemoveOai();
+        if (this.isFunctionCompute) {
+            // this.addLambdaOac(); // TODO: wait for POST body encryption feature for Lambda OAC
+        }
+        new aws_cdk_lib_1.CfnOutput(this, "DistributionDomainName", {
+            value: this.distribution.domainName,
+        });
+    }
+    createStaticOrigin() {
+        const s3Origin = new aws_cloudfront_origins_1.S3Origin(this.props.assetsBucket, this.props.overrides?.s3OriginProps);
+        return s3Origin;
+    }
+    createDynamicOrigin() {
+        let protocolPolicy;
+        if (this.isFunctionCompute) {
+            protocolPolicy = aws_cloudfront_1.OriginProtocolPolicy.HTTPS_ONLY;
+        }
+        else {
+            protocolPolicy = this.props.certificate
+                ? aws_cloudfront_1.OriginProtocolPolicy.HTTPS_ONLY
+                : aws_cloudfront_1.OriginProtocolPolicy.HTTP_ONLY;
+        }
+        return new aws_cloudfront_origins_1.HttpOrigin(aws_cdk_lib_1.Fn.parseDomainName(this.props.dynamicUrl), {
+            protocolPolicy,
+            ...this.props.overrides?.dynamicHttpOriginProps,
+        });
+    }
+    /**
+     * Lambda Function URLs "expect the `Host` header to contain the origin domain
+     * name, not the domain name of the CloudFront distribution."
+     * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html#managed-origin-request-policy-all-viewer-except-host-header
+     */
+    createDynamicOriginRequestPolicy() {
+        return this.isFunctionCompute
+            ? aws_cloudfront_1.OriginRequestPolicy.ALL_VIEWER_EXCEPT_HOST_HEADER
+            : aws_cloudfront_1.OriginRequestPolicy.ALL_VIEWER;
+    }
+    /**
+     * Ensures Next.js `request.url` will be correct domain instead of URL of
+     * compute option (App Runner, Fargate, or Lambda)
+     * @see https://open-next.js.org/advanced/workaround#workaround-set-x-forwarded-host-header-aws-specific
+     */
+    createDynamicCloudFrontFunctionAssociations() {
+        const associations = [];
+        if (this.isFunctionCompute) {
+            const cloudFrontFn = new aws_cloudfront_1.Function(this, "CloudFrontFn", {
+                code: aws_cloudfront_1.FunctionCode.fromInline(`
+          function handler(event) {
+            var request = event.request;
+            request.headers["x-forwarded-host"] = request.headers.host;
+            return request;
+          }
+          `),
+            });
+            associations.push({
+                eventType: aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST,
+                function: cloudFrontFn,
+            });
+        }
+        return associations;
+    }
+    /**
+     * Required to sign requests so that we can use IAM_AUTH for Lambda Function URL
+     * to prevent public access. Once CloudFront Lambda OAC is released, we can
+     * use infra configuration for this instead of custom code.
+     */
+    createEdgeLambdas() {
+        if (!this.props.functionArn)
+            throw new Error("functionArn is required");
+        const edgeFn = new sign_fn_url_function_1.SignFnUrlFunction(this, "SignFnUrl", {
+            currentVersionOptions: {
+                retryAttempts: 0, // fail fast when trying to delete b/c replicated functions take long time to delete
+            },
+            initialPolicy: [
+                new aws_iam_1.PolicyStatement({
+                    actions: ["lambda:InvokeFunctionUrl"],
+                    resources: [this.props.functionArn],
+                }),
+            ],
+            ...this.props.overrides?.edgeFunctionProps,
+        });
+        edgeFn.currentVersion.grantInvoke(new aws_iam_1.ServicePrincipal("edgelambda.amazonaws.com"));
+        edgeFn.currentVersion.grantInvoke(new aws_iam_1.ServicePrincipal("lambda.amazonaws.com"));
+        // retain on delete b/c they take too long to delete resulting in stack failure
+        edgeFn.applyRemovalPolicy(aws_cdk_lib_1.RemovalPolicy.RETAIN);
+        return [
+            {
+                eventType: aws_cloudfront_1.LambdaEdgeEventType.ORIGIN_REQUEST,
+                functionVersion: edgeFn.currentVersion,
+                includeBody: true,
+            },
+        ];
+    }
+    createStaticBehaviorOptions() {
+        const staticBehaviorOptions = this.props.overrides?.staticBehaviorOptions;
+        const responseHeadersPolicy = staticBehaviorOptions?.responseHeadersPolicy ??
+            new aws_cloudfront_1.ResponseHeadersPolicy(this, "StaticResponseHeadersPolicy", {
+                securityHeadersBehavior: this.commonSecurityHeadersBehavior,
+                comment: `Nextjs Static Response Headers Policy for ${aws_cdk_lib_1.Stack.of(this).stackName}`,
+                ...this.props.overrides?.staticResponseHeadersPolicyProps,
+            });
+        return {
+            allowedMethods: aws_cloudfront_1.AllowedMethods.ALLOW_GET_HEAD_OPTIONS,
+            cachedMethods: aws_cloudfront_1.CachedMethods.CACHE_GET_HEAD_OPTIONS,
+            cachePolicy: aws_cloudfront_1.CachePolicy.CACHING_OPTIMIZED,
+            origin: this.staticOrigin,
+            responseHeadersPolicy,
+            viewerProtocolPolicy: aws_cloudfront_1.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+            ...staticBehaviorOptions,
+        };
+    }
+    createDynamicBehaviorOptions() {
+        const dynamicBehaviorOptions = this.props.overrides?.dynamicBehaviorOptions;
+        // create default cache policy if not provided
+        const cachePolicy = dynamicBehaviorOptions?.cachePolicy ??
+            new aws_cloudfront_1.CachePolicy(this, "DynamicCachePolicy", {
+                queryStringBehavior: aws_cloudfront_1.CacheQueryStringBehavior.all(),
+                headerBehavior: aws_cloudfront_1.CacheHeaderBehavior.allowList("accept", "rsc", "next-router-prefetch", "next-router-state-tree", "next-url", "x-prerender-revalidate"),
+                cookieBehavior: aws_cloudfront_1.CacheCookieBehavior.all(),
+                enableAcceptEncodingBrotli: true,
+                enableAcceptEncodingGzip: true,
+                comment: `Nextjs Dynamic Cache Policy for ${aws_cdk_lib_1.Stack.of(this).stackName}`,
+                ...this.props.overrides?.dynamicCachePolicyProps,
+            });
+        const responseHeadersPolicy = dynamicBehaviorOptions?.responseHeadersPolicy ??
+            new aws_cloudfront_1.ResponseHeadersPolicy(this, "DynamicResponseHeadersPolicy", {
+                securityHeadersBehavior: this.commonSecurityHeadersBehavior,
+                comment: `Nextjs Dynamic Response Headers Policy for ${aws_cdk_lib_1.Stack.of(this).stackName}`,
+                ...this.props.overrides?.dynamicBehaviorOptions?.responseHeadersPolicy,
+            });
+        const behaviorOptions = {
+            allowedMethods: aws_cloudfront_1.AllowedMethods.ALLOW_ALL,
+            cachePolicy,
+            edgeLambdas: this.edgeLambdas,
+            functionAssociations: this.dynamicCloudFrontFunctionAssociations,
+            origin: this.dynamicOrigin,
+            originRequestPolicy: this.dynamicOriginResponsePolicy,
+            responseHeadersPolicy,
+            viewerProtocolPolicy: aws_cloudfront_1.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+            ...dynamicBehaviorOptions,
+        };
+        return behaviorOptions;
+    }
+    createImageBehaviorOptions() {
+        const imageBehaviorOptions = this.props.overrides?.imageBehaviorOptions;
+        // add default cache policy if not provided
+        const cachePolicy = imageBehaviorOptions?.cachePolicy ??
+            new aws_cloudfront_1.CachePolicy(this, "ImageCachePolicy", {
+                queryStringBehavior: aws_cloudfront_1.CacheQueryStringBehavior.all(),
+                headerBehavior: aws_cloudfront_1.CacheHeaderBehavior.allowList("accept"),
+                cookieBehavior: aws_cloudfront_1.CacheCookieBehavior.none(),
+                enableAcceptEncodingBrotli: true,
+                enableAcceptEncodingGzip: true,
+                comment: `Nextjs Image Cache Policy for ${aws_cdk_lib_1.Stack.of(this).stackName}`,
+                ...this.props.overrides?.imageCachePolicyProps,
+            });
+        // add default response headers policy if not provided
+        const responseHeadersPolicy = imageBehaviorOptions?.responseHeadersPolicy ??
+            new aws_cloudfront_1.ResponseHeadersPolicy(this, "ImageResponseHeadersPolicy", {
+                securityHeadersBehavior: this.commonSecurityHeadersBehavior,
+                comment: `Nextjs Image Response Headers Policy for ${aws_cdk_lib_1.Stack.of(this).stackName}`,
+                ...this.props.overrides?.imageResponseHeadersPolicyProps,
+            });
+        return {
+            allowedMethods: aws_cloudfront_1.AllowedMethods.ALLOW_GET_HEAD_OPTIONS,
+            cachedMethods: aws_cloudfront_1.CachedMethods.CACHE_GET_HEAD_OPTIONS,
+            edgeLambdas: this.edgeLambdas,
+            functionAssociations: this.dynamicCloudFrontFunctionAssociations,
+            origin: this.dynamicOrigin,
+            originRequestPolicy: this.dynamicOriginResponsePolicy,
+            cachePolicy,
+            responseHeadersPolicy,
+            viewerProtocolPolicy: aws_cloudfront_1.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+            ...imageBehaviorOptions,
+        };
+    }
+    /**
+     * Creates or uses user specified CloudFront Distribution
+     */
+    getDistribution() {
+        let distribution;
+        if (this.props.distribution) {
+            distribution = this.props.distribution;
+        }
+        else {
+            distribution = new aws_cloudfront_1.Distribution(this, "Distribution", {
+                minimumProtocolVersion: aws_cloudfront_1.SecurityPolicyProtocol.TLS_V1_2_2021,
+                defaultBehavior: this.dynamicBehaviorOptions,
+                httpVersion: aws_cloudfront_1.HttpVersion.HTTP2, // HTTP2_AND_3 causes timeout issues with Lambda Function URLs!
+                comment: `cdk-nextjs Distribution for ${aws_cdk_lib_1.Stack.of(this).stackName}`,
+                ...this.props.overrides?.distributionProps,
+            });
+        }
+        return distribution;
+    }
+    addDynamicBehaviors() {
+        // Image Behavior
+        this.distribution.addBehavior(this.getPathPattern("_next/image*"), this.imageBehaviorOptions.origin, this.imageBehaviorOptions);
+        // Root Path Behaviors
+        if (this.props.basePath) {
+            // because we already have a basePath we don't use / instead we use /base-path
+            this.distribution.addBehavior(this.props.basePath, this.dynamicBehaviorOptions.origin, this.dynamicBehaviorOptions);
+            // when basePath is set, we emulate the "default behavior" (*) for the site as `/base-path/*`
+            this.distribution.addBehavior(this.getPathPattern("*"), this.dynamicBehaviorOptions.origin, this.dynamicBehaviorOptions);
+        }
+        else {
+            // if no base path, then default behavior will handle all other paths
+        }
+    }
+    addStaticBehaviors() {
+        this.distribution.addBehavior("_next/static*", this.staticOrigin, this.staticBehaviorOptions);
+        // 22 = 25 (max) - 1 (_next/image) - 1 (_next/static) - 1 (*)
+        if (this.props.publicDirEntries.length >= 22) {
+            throw new Error(`Too many public/ files in Next.js build. CloudFront limits Distributions to 25 Cache Behaviors. See documented limit here: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions. Try including all public files into 1 top level directory (i.e. static/*).`);
+        }
+        for (const publicFile of this.props.publicDirEntries) {
+            const pathPattern = publicFile.isDirectory
+                ? `${publicFile.name}/*`
+                : publicFile.name;
+            if (!/^[a-zA-Z0-9_\-.*$/~"'@:+?&]+$/.test(pathPattern)) {
+                throw new Error(`Invalid CloudFront Distribution Cache Behavior Path Pattern: ${pathPattern}. Please see documentation here: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/distribution-web-values-specify.html#DownloadDistValuesPathPattern`);
+            }
+            const finalPathPattern = this.getPathPattern(pathPattern);
+            this.distribution.addBehavior(finalPathPattern, this.staticOrigin, this.staticBehaviorOptions);
+        }
+    }
+    /**
+     * Optionally prepends base path to given path pattern.
+     */
+    getPathPattern(pathPattern) {
+        if (this.props.basePath) {
+            return `${this.props.basePath}/${pathPattern}`;
+        }
+        else {
+            return pathPattern;
+        }
+    }
+    /**
+     * Add Origin Access Control (OAC) to CloudFront Distribution which is preferred
+     * way to secure access from Distribution to S3. Remove legacy OAI.
+     *
+     * When CDK releases L2 support for this, please remove this code.
+     * @see https://github.com/aws/aws-cdk/issues/21771#issuecomment-1567647338
+     */
+    addS3OacAndRemoveOai() {
+        const s3Oac = new aws_cloudfront_1.CfnOriginAccessControl(this, "OAC", {
+            originAccessControlConfig: {
+                name: `OAC-S3-${this.uniqueStackIdPart}`,
+                originAccessControlOriginType: "s3",
+                signingBehavior: "always",
+                signingProtocol: "sigv4",
+            },
+        });
+        // add OAC to CloudFront Distribution
+        const cfnDistribution = this.distribution.node
+            .defaultChild;
+        cfnDistribution.addOverride("Properties.DistributionConfig.Origins.1.S3OriginConfig.OriginAccessIdentity", "");
+        cfnDistribution.addPropertyOverride("DistributionConfig.Origins.1.OriginAccessControlId", s3Oac.getAtt("Id"));
+        // add IAM Policy Statement to allow OAC access to Bucket
+        const oacBucketStatement = new aws_iam_1.PolicyStatement({
+            sid: "AllowS3OacAccess",
+            principals: [new aws_iam_1.ServicePrincipal("cloudfront.amazonaws.com")],
+            actions: ["s3:GetObject"],
+            resources: [this.props.assetsBucket.bucketArn + "/*"],
+            conditions: {
+                StringEquals: {
+                    "aws:sourceArn": aws_cdk_lib_1.Stack.of(this).formatArn({
+                        service: "cloudfront",
+                        region: "",
+                        resource: "distribution",
+                        resourceName: this.distribution.distributionId,
+                        arnFormat: aws_cdk_lib_1.ArnFormat.SLASH_RESOURCE_NAME,
+                    }),
+                },
+            },
+        });
+        this.props.assetsBucket.addToResourcePolicy(oacBucketStatement);
+        // Remove OAI IAM Policy Statement from Bucket Policy
+        const bucketPolicyJson = this.props.assetsBucket.policy?.document.toJSON();
+        const updatedBucketPolicyJson = {
+            Version: "2012-10-17",
+            Statement: [],
+        };
+        for (const statement of bucketPolicyJson.Statement) {
+            if (!("CanonicalUser" in statement.Principal)) {
+                updatedBucketPolicyJson.Statement.push(statement);
+            }
+        }
+        const bucketPolicy = this.props.assetsBucket.node.findChild("Policy").node
+            .defaultChild;
+        bucketPolicy.addOverride("Properties.PolicyDocument", updatedBucketPolicyJson);
+        // Remove S3 Origin Resource
+        const distributionChildren = this.distribution.node.findAll();
+        for (const child of distributionChildren) {
+            if (child.node.id === "S3Origin") {
+                child.node.tryRemoveChild("Resource");
+            }
+        }
+    }
+}
+exports.NextjsDistribution = NextjsDistribution;
+_a = JSII_RTTI_SYMBOL_1;
+NextjsDistribution[_a] = { fqn: "cdk-nextjs.NextjsDistribution", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-distribution.js","sourceRoot":"","sources":["../src/nextjs-distribution.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ArnFormat,\n  Aws,\n  CfnOutput,\n  Duration,\n  Fn,\n  RemovalPolicy,\n  Stack,\n} from \"aws-cdk-lib\";\nimport { ICertificate } from \"aws-cdk-lib/aws-certificatemanager\";\nimport {\n  AddBehaviorOptions,\n  AllowedMethods,\n  BehaviorOptions,\n  CacheCookieBehavior,\n  CacheHeaderBehavior,\n  CachePolicy,\n  CachePolicyProps,\n  CacheQueryStringBehavior,\n  CachedMethods,\n  CfnDistribution,\n  CfnOriginAccessControl,\n  Function as CloudFrontFunction,\n  Distribution,\n  FunctionAssociation,\n  FunctionCode,\n  FunctionEventType,\n  HeadersFrameOption,\n  HeadersReferrerPolicy,\n  HttpVersion,\n  IOriginRequestPolicy,\n  LambdaEdgeEventType,\n  OriginProtocolPolicy,\n  OriginRequestPolicy,\n  ResponseHeadersPolicy,\n  ResponseHeadersPolicyProps,\n  ResponseSecurityHeadersBehavior,\n  SecurityPolicyProtocol,\n  ViewerProtocolPolicy,\n} from \"aws-cdk-lib/aws-cloudfront\";\nimport {\n  HttpOrigin,\n  HttpOriginProps,\n  S3Origin,\n} from \"aws-cdk-lib/aws-cloudfront-origins\";\nimport { PolicyStatement, ServicePrincipal } from \"aws-cdk-lib/aws-iam\";\nimport { CfnBucketPolicy, IBucket } from \"aws-cdk-lib/aws-s3\";\nimport { Construct } from \"constructs\";\nimport { NextjsType } from \"./common\";\nimport { OptionalDistributionProps } from \"./generated-structs/OptionalDistributionProps\";\nimport { OptionalFunctionProps } from \"./generated-structs/OptionalFunctionProps\";\nimport { OptionalS3OriginProps } from \"./generated-structs/OptionalS3OriginProps\";\nimport { SignFnUrlFunction } from \"./lambdas/sign-fn-url/sign-fn-url-function\";\nimport { PublicDirEntry } from \"./nextjs-build/nextjs-build\";\n\nexport interface NextjsDistributionOverrides {\n  readonly edgeFunctionProps?: OptionalFunctionProps;\n  readonly distributionProps?: OptionalDistributionProps;\n  readonly imageBehaviorOptions?: AddBehaviorOptions;\n  readonly imageCachePolicyProps?: CachePolicyProps;\n  readonly imageResponseHeadersPolicyProps?: ResponseHeadersPolicyProps;\n  readonly dynamicBehaviorOptions?: AddBehaviorOptions;\n  readonly dynamicCachePolicyProps?: CachePolicyProps;\n  readonly dynamicResponseHeadersPolicyProps?: ResponseHeadersPolicyProps;\n  readonly dynamicHttpOriginProps?: HttpOriginProps;\n  readonly staticBehaviorOptions?: AddBehaviorOptions;\n  readonly staticResponseHeadersPolicyProps?: ResponseHeadersPolicyProps;\n  readonly s3OriginProps?: OptionalS3OriginProps;\n}\n\nexport interface NextjsDistributionProps {\n  /**\n   * Bucket containing static assets.\n   * Must be provided if you want to serve static files.\n   */\n  readonly assetsBucket: IBucket;\n  readonly basePath?: string;\n  /**\n   * Optional but only applicable for `NextjsType.GLOBAL_CONTAINERS`\n   */\n  readonly certificate?: ICertificate;\n  readonly distribution?: Distribution;\n  /**\n   * Dynamic (Next.js server) URL to add behavior to distribution\n   */\n  readonly dynamicUrl: string;\n  /**\n   * Required if `NextjsType.GLOBAL_FUNCTIONS`\n   */\n  readonly functionArn?: string;\n  readonly nextjsType: NextjsType;\n  /**\n   * Override props for every construct.\n   */\n  readonly overrides?: NextjsDistributionOverrides;\n  /**\n   * Path to directory of Next.js app's public directory. Used to add static\n   * behaviors to distribution.\n   */\n  readonly publicDirEntries: PublicDirEntry[];\n}\n\nexport class NextjsDistribution extends Construct {\n  distribution: Distribution;\n\n  private props: NextjsDistributionProps;\n  /**\n   * Common security headers applied by default to all origins\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-response-headers-policies.html#managed-response-headers-policies-security\n   */\n  private commonSecurityHeadersBehavior: ResponseSecurityHeadersBehavior = {\n    contentTypeOptions: { override: false },\n    frameOptions: {\n      frameOption: HeadersFrameOption.SAMEORIGIN,\n      override: false,\n    },\n    referrerPolicy: {\n      override: false,\n      referrerPolicy: HeadersReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN,\n    },\n\n    strictTransportSecurity: {\n      accessControlMaxAge: Duration.days(365),\n      includeSubdomains: true,\n      override: false,\n      preload: true,\n    },\n    xssProtection: { override: false, protection: true, modeBlock: true },\n  };\n  private staticOrigin: S3Origin;\n  private dynamicOrigin: HttpOrigin;\n  private dynamicOriginResponsePolicy: IOriginRequestPolicy;\n  private dynamicCloudFrontFunctionAssociations: FunctionAssociation[];\n  private edgeLambdas?: AddBehaviorOptions[\"edgeLambdas\"];\n  private isFunctionCompute: boolean;\n  private staticBehaviorOptions: BehaviorOptions;\n  private dynamicBehaviorOptions: BehaviorOptions;\n  private imageBehaviorOptions: BehaviorOptions;\n  /**\n   * Given stack id: \"arn:aws:cloudformation:us-east-1:905418358903:stack/lh-stickb-idp/4bf74be0-e880-11ee-aea9-0affc6185b25\",\n   * returns \"4bf74be0\"\n   */\n  private uniqueStackIdPart = Fn.select(\n    0,\n    Fn.split(\"-\", Fn.select(2, Fn.split(\"/\", `${Aws.STACK_ID}`))),\n  );\n\n  constructor(scope: Construct, id: string, props: NextjsDistributionProps) {\n    super(scope, id);\n    this.props = props;\n    this.staticOrigin = this.createStaticOrigin();\n    this.isFunctionCompute = props.nextjsType === NextjsType.GLOBAL_FUNCTIONS;\n    this.dynamicOrigin = this.createDynamicOrigin();\n    this.dynamicOriginResponsePolicy = this.createDynamicOriginRequestPolicy();\n    this.dynamicCloudFrontFunctionAssociations =\n      this.createDynamicCloudFrontFunctionAssociations();\n    if (this.isFunctionCompute) {\n      this.edgeLambdas = this.createEdgeLambdas();\n    }\n    this.staticBehaviorOptions = this.createStaticBehaviorOptions();\n    this.dynamicBehaviorOptions = this.createDynamicBehaviorOptions();\n    this.imageBehaviorOptions = this.createImageBehaviorOptions();\n    this.distribution = this.getDistribution();\n    this.addStaticBehaviors();\n    this.addDynamicBehaviors();\n    this.addS3OacAndRemoveOai();\n    if (this.isFunctionCompute) {\n      // this.addLambdaOac(); // TODO: wait for POST body encryption feature for Lambda OAC\n    }\n    new CfnOutput(this, \"DistributionDomainName\", {\n      value: this.distribution.domainName,\n    });\n  }\n\n  private createStaticOrigin(): S3Origin {\n    const s3Origin = new S3Origin(\n      this.props.assetsBucket,\n      this.props.overrides?.s3OriginProps,\n    );\n    return s3Origin;\n  }\n  private createDynamicOrigin(): HttpOrigin {\n    let protocolPolicy: OriginProtocolPolicy;\n    if (this.isFunctionCompute) {\n      protocolPolicy = OriginProtocolPolicy.HTTPS_ONLY;\n    } else {\n      protocolPolicy = this.props.certificate\n        ? OriginProtocolPolicy.HTTPS_ONLY\n        : OriginProtocolPolicy.HTTP_ONLY;\n    }\n    return new HttpOrigin(Fn.parseDomainName(this.props.dynamicUrl), {\n      protocolPolicy,\n      ...this.props.overrides?.dynamicHttpOriginProps,\n    });\n  }\n  /**\n   * Lambda Function URLs \"expect the `Host` header to contain the origin domain\n   * name, not the domain name of the CloudFront distribution.\"\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html#managed-origin-request-policy-all-viewer-except-host-header\n   */\n  private createDynamicOriginRequestPolicy(): IOriginRequestPolicy {\n    return this.isFunctionCompute\n      ? OriginRequestPolicy.ALL_VIEWER_EXCEPT_HOST_HEADER\n      : OriginRequestPolicy.ALL_VIEWER;\n  }\n  /**\n   * Ensures Next.js `request.url` will be correct domain instead of URL of\n   * compute option (App Runner, Fargate, or Lambda)\n   * @see https://open-next.js.org/advanced/workaround#workaround-set-x-forwarded-host-header-aws-specific\n   */\n  private createDynamicCloudFrontFunctionAssociations(): FunctionAssociation[] {\n    const associations: FunctionAssociation[] = [];\n    if (this.isFunctionCompute) {\n      const cloudFrontFn = new CloudFrontFunction(this, \"CloudFrontFn\", {\n        code: FunctionCode.fromInline(`\n          function handler(event) {\n            var request = event.request;\n            request.headers[\"x-forwarded-host\"] = request.headers.host;\n            return request;\n          }\n          `),\n      });\n      associations.push({\n        eventType: FunctionEventType.VIEWER_REQUEST,\n        function: cloudFrontFn,\n      });\n    }\n    return associations;\n  }\n  /**\n   * Required to sign requests so that we can use IAM_AUTH for Lambda Function URL\n   * to prevent public access. Once CloudFront Lambda OAC is released, we can\n   * use infra configuration for this instead of custom code.\n   */\n  private createEdgeLambdas(): AddBehaviorOptions[\"edgeLambdas\"] {\n    if (!this.props.functionArn) throw new Error(\"functionArn is required\");\n    const edgeFn = new SignFnUrlFunction(this, \"SignFnUrl\", {\n      currentVersionOptions: {\n        retryAttempts: 0, // fail fast when trying to delete b/c replicated functions take long time to delete\n      },\n      initialPolicy: [\n        new PolicyStatement({\n          actions: [\"lambda:InvokeFunctionUrl\"],\n          resources: [this.props.functionArn],\n        }),\n      ],\n      ...this.props.overrides?.edgeFunctionProps,\n    });\n    edgeFn.currentVersion.grantInvoke(\n      new ServicePrincipal(\"edgelambda.amazonaws.com\"),\n    );\n    edgeFn.currentVersion.grantInvoke(\n      new ServicePrincipal(\"lambda.amazonaws.com\"),\n    );\n    // retain on delete b/c they take too long to delete resulting in stack failure\n    edgeFn.applyRemovalPolicy(RemovalPolicy.RETAIN);\n    return [\n      {\n        eventType: LambdaEdgeEventType.ORIGIN_REQUEST,\n        functionVersion: edgeFn.currentVersion,\n        includeBody: true,\n      },\n    ];\n  }\n  private createStaticBehaviorOptions(): BehaviorOptions {\n    const staticBehaviorOptions = this.props.overrides?.staticBehaviorOptions;\n    const responseHeadersPolicy =\n      staticBehaviorOptions?.responseHeadersPolicy ??\n      new ResponseHeadersPolicy(this, \"StaticResponseHeadersPolicy\", {\n        securityHeadersBehavior: this.commonSecurityHeadersBehavior,\n        comment: `Nextjs Static Response Headers Policy for ${Stack.of(this).stackName}`,\n        ...this.props.overrides?.staticResponseHeadersPolicyProps,\n      });\n    return {\n      allowedMethods: AllowedMethods.ALLOW_GET_HEAD_OPTIONS,\n      cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,\n      cachePolicy: CachePolicy.CACHING_OPTIMIZED,\n      origin: this.staticOrigin,\n      responseHeadersPolicy,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      ...staticBehaviorOptions,\n    };\n  }\n  private createDynamicBehaviorOptions(): BehaviorOptions {\n    const dynamicBehaviorOptions = this.props.overrides?.dynamicBehaviorOptions;\n    // create default cache policy if not provided\n    const cachePolicy =\n      dynamicBehaviorOptions?.cachePolicy ??\n      new CachePolicy(this, \"DynamicCachePolicy\", {\n        queryStringBehavior: CacheQueryStringBehavior.all(),\n        headerBehavior: CacheHeaderBehavior.allowList(\n          \"accept\",\n          \"rsc\",\n          \"next-router-prefetch\",\n          \"next-router-state-tree\",\n          \"next-url\",\n          \"x-prerender-revalidate\",\n        ),\n        cookieBehavior: CacheCookieBehavior.all(),\n        enableAcceptEncodingBrotli: true,\n        enableAcceptEncodingGzip: true,\n        comment: `Nextjs Dynamic Cache Policy for ${Stack.of(this).stackName}`,\n        ...this.props.overrides?.dynamicCachePolicyProps,\n      });\n    const responseHeadersPolicy =\n      dynamicBehaviorOptions?.responseHeadersPolicy ??\n      new ResponseHeadersPolicy(this, \"DynamicResponseHeadersPolicy\", {\n        securityHeadersBehavior: this.commonSecurityHeadersBehavior,\n        comment: `Nextjs Dynamic Response Headers Policy for ${Stack.of(this).stackName}`,\n        ...this.props.overrides?.dynamicBehaviorOptions?.responseHeadersPolicy,\n      });\n    const behaviorOptions: BehaviorOptions = {\n      allowedMethods: AllowedMethods.ALLOW_ALL,\n      cachePolicy,\n      edgeLambdas: this.edgeLambdas,\n      functionAssociations: this.dynamicCloudFrontFunctionAssociations,\n      origin: this.dynamicOrigin,\n      originRequestPolicy: this.dynamicOriginResponsePolicy,\n      responseHeadersPolicy,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      ...dynamicBehaviorOptions,\n    };\n    return behaviorOptions;\n  }\n  private createImageBehaviorOptions(): BehaviorOptions {\n    const imageBehaviorOptions = this.props.overrides?.imageBehaviorOptions;\n    // add default cache policy if not provided\n    const cachePolicy =\n      imageBehaviorOptions?.cachePolicy ??\n      new CachePolicy(this, \"ImageCachePolicy\", {\n        queryStringBehavior: CacheQueryStringBehavior.all(),\n        headerBehavior: CacheHeaderBehavior.allowList(\"accept\"),\n        cookieBehavior: CacheCookieBehavior.none(),\n        enableAcceptEncodingBrotli: true,\n        enableAcceptEncodingGzip: true,\n        comment: `Nextjs Image Cache Policy for ${Stack.of(this).stackName}`,\n        ...this.props.overrides?.imageCachePolicyProps,\n      });\n    // add default response headers policy if not provided\n    const responseHeadersPolicy =\n      imageBehaviorOptions?.responseHeadersPolicy ??\n      new ResponseHeadersPolicy(this, \"ImageResponseHeadersPolicy\", {\n        securityHeadersBehavior: this.commonSecurityHeadersBehavior,\n        comment: `Nextjs Image Response Headers Policy for ${Stack.of(this).stackName}`,\n        ...this.props.overrides?.imageResponseHeadersPolicyProps,\n      });\n    return {\n      allowedMethods: AllowedMethods.ALLOW_GET_HEAD_OPTIONS,\n      cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,\n      edgeLambdas: this.edgeLambdas,\n      functionAssociations: this.dynamicCloudFrontFunctionAssociations,\n      origin: this.dynamicOrigin,\n      originRequestPolicy: this.dynamicOriginResponsePolicy,\n      cachePolicy,\n      responseHeadersPolicy,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      ...imageBehaviorOptions,\n    };\n  }\n  /**\n   * Creates or uses user specified CloudFront Distribution\n   */\n  private getDistribution(): Distribution {\n    let distribution: Distribution;\n    if (this.props.distribution) {\n      distribution = this.props.distribution;\n    } else {\n      distribution = new Distribution(this, \"Distribution\", {\n        minimumProtocolVersion: SecurityPolicyProtocol.TLS_V1_2_2021,\n        defaultBehavior: this.dynamicBehaviorOptions,\n        httpVersion: HttpVersion.HTTP2, // HTTP2_AND_3 causes timeout issues with Lambda Function URLs!\n        comment: `cdk-nextjs Distribution for ${Stack.of(this).stackName}`,\n        ...this.props.overrides?.distributionProps,\n      });\n    }\n    return distribution;\n  }\n  private addDynamicBehaviors() {\n    // Image Behavior\n    this.distribution.addBehavior(\n      this.getPathPattern(\"_next/image*\"),\n      this.imageBehaviorOptions.origin,\n      this.imageBehaviorOptions,\n    );\n    // Root Path Behaviors\n    if (this.props.basePath) {\n      // because we already have a basePath we don't use / instead we use /base-path\n      this.distribution.addBehavior(\n        this.props.basePath,\n        this.dynamicBehaviorOptions.origin,\n        this.dynamicBehaviorOptions,\n      );\n      // when basePath is set, we emulate the \"default behavior\" (*) for the site as `/base-path/*`\n      this.distribution.addBehavior(\n        this.getPathPattern(\"*\"),\n        this.dynamicBehaviorOptions.origin,\n        this.dynamicBehaviorOptions,\n      );\n    } else {\n      // if no base path, then default behavior will handle all other paths\n    }\n  }\n  private addStaticBehaviors() {\n    this.distribution.addBehavior(\n      \"_next/static*\",\n      this.staticOrigin,\n      this.staticBehaviorOptions,\n    );\n    // 22 = 25 (max) - 1 (_next/image) - 1 (_next/static) - 1 (*)\n    if (this.props.publicDirEntries.length >= 22) {\n      throw new Error(\n        `Too many public/ files in Next.js build. CloudFront limits Distributions to 25 Cache Behaviors. See documented limit here: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions. Try including all public files into 1 top level directory (i.e. static/*).`,\n      );\n    }\n    for (const publicFile of this.props.publicDirEntries) {\n      const pathPattern = publicFile.isDirectory\n        ? `${publicFile.name}/*`\n        : publicFile.name;\n      if (!/^[a-zA-Z0-9_\\-.*$/~\"'@:+?&]+$/.test(pathPattern)) {\n        throw new Error(\n          `Invalid CloudFront Distribution Cache Behavior Path Pattern: ${pathPattern}. Please see documentation here: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/distribution-web-values-specify.html#DownloadDistValuesPathPattern`,\n        );\n      }\n      const finalPathPattern = this.getPathPattern(pathPattern);\n      this.distribution.addBehavior(\n        finalPathPattern,\n        this.staticOrigin,\n        this.staticBehaviorOptions,\n      );\n    }\n  }\n  /**\n   * Optionally prepends base path to given path pattern.\n   */\n  private getPathPattern(pathPattern: string) {\n    if (this.props.basePath) {\n      return `${this.props.basePath}/${pathPattern}`;\n    } else {\n      return pathPattern;\n    }\n  }\n  /**\n   * Add Origin Access Control (OAC) to CloudFront Distribution which is preferred\n   * way to secure access from Distribution to S3. Remove legacy OAI.\n   *\n   * When CDK releases L2 support for this, please remove this code.\n   * @see https://github.com/aws/aws-cdk/issues/21771#issuecomment-1567647338\n   */\n  private addS3OacAndRemoveOai() {\n    const s3Oac = new CfnOriginAccessControl(this, \"OAC\", {\n      originAccessControlConfig: {\n        name: `OAC-S3-${this.uniqueStackIdPart}`,\n        originAccessControlOriginType: \"s3\",\n        signingBehavior: \"always\",\n        signingProtocol: \"sigv4\",\n      },\n    });\n    // add OAC to CloudFront Distribution\n    const cfnDistribution = this.distribution.node\n      .defaultChild as CfnDistribution;\n    cfnDistribution.addOverride(\n      \"Properties.DistributionConfig.Origins.1.S3OriginConfig.OriginAccessIdentity\",\n      \"\",\n    );\n    cfnDistribution.addPropertyOverride(\n      \"DistributionConfig.Origins.1.OriginAccessControlId\",\n      s3Oac.getAtt(\"Id\"),\n    );\n\n    // add IAM Policy Statement to allow OAC access to Bucket\n    const oacBucketStatement = new PolicyStatement({\n      sid: \"AllowS3OacAccess\",\n      principals: [new ServicePrincipal(\"cloudfront.amazonaws.com\")],\n      actions: [\"s3:GetObject\"],\n      resources: [this.props.assetsBucket.bucketArn + \"/*\"],\n      conditions: {\n        StringEquals: {\n          \"aws:sourceArn\": Stack.of(this).formatArn({\n            service: \"cloudfront\",\n            region: \"\",\n            resource: \"distribution\",\n            resourceName: this.distribution.distributionId,\n            arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n          }),\n        },\n      },\n    });\n    this.props.assetsBucket.addToResourcePolicy(oacBucketStatement);\n    // Remove OAI IAM Policy Statement from Bucket Policy\n    const bucketPolicyJson = this.props.assetsBucket.policy?.document.toJSON();\n    const updatedBucketPolicyJson = {\n      Version: \"2012-10-17\",\n      Statement: [] as unknown[],\n    };\n    for (const statement of bucketPolicyJson.Statement) {\n      if (!(\"CanonicalUser\" in statement.Principal)) {\n        updatedBucketPolicyJson.Statement.push(statement);\n      }\n    }\n    const bucketPolicy = this.props.assetsBucket.node.findChild(\"Policy\").node\n      .defaultChild as CfnBucketPolicy;\n    bucketPolicy.addOverride(\n      \"Properties.PolicyDocument\",\n      updatedBucketPolicyJson,\n    );\n\n    // Remove S3 Origin Resource\n    const distributionChildren = this.distribution.node.findAll();\n    for (const child of distributionChildren) {\n      if (child.node.id === \"S3Origin\") {\n        child.node.tryRemoveChild(\"Resource\");\n      }\n    }\n  }\n\n  // TODO: use when POST body encryption feature is added for Lambda OAC\n  // private addLambdaOac() {\n  //   const lambdaOac = new CfnOriginAccessControl(this, \"OAC\", {\n  //     originAccessControlConfig: {\n  //       name: `OAC-Lambda-${this.uniqueStackIdPart}`,\n  //       originAccessControlOriginType: \"lambda\",\n  //       signingBehavior: \"always\",\n  //       signingProtocol: \"sigv4\",\n  //     },\n  //   });\n  //   const cfnDistribution = this.distribution.node\n  //     .defaultChild as CfnDistribution;\n  //   cfnDistribution.addPropertyOverride(\n  //     \"DistributionConfig.Origins.0.OriginAccessControlId\",\n  //     lambdaOac.getAtt(\"Id\"),\n  //   );\n  // }\n}\n"]}

package/lib/nextjs-file-system.d.ts

@@ -0,0 +1,42 @@
+import { Connections, IVpc } from "aws-cdk-lib/aws-ec2";
+import { AccessPoint, AccessPointProps, FileSystem, FileSystemProps } from "aws-cdk-lib/aws-efs";
+import { IRole } from "aws-cdk-lib/aws-iam";
+import { Construct } from "constructs";
+export interface NextjsFileSystemOverrides {
+    readonly fileSystemProps?: FileSystemProps;
+    readonly accessPointProps?: AccessPointProps;
+}
+export interface NextjsFileSystemProps {
+    readonly overrides?: NextjsFileSystemOverrides;
+    readonly vpc: IVpc;
+}
+export interface AllowComputeProps {
+    readonly connections: Connections;
+    readonly role: IRole;
+}
+/**
+ * Next.js Network File System enabling sharing of image optimization cache,
+ * data cach, and pages cache.
+ */
+export declare class NextjsFileSystem extends Construct {
+    fileSystem: FileSystem;
+    accessPoint: AccessPoint;
+    private props;
+    constructor(scope: Construct, id: string, props: NextjsFileSystemProps);
+    /**
+     * Creates EFS File System
+     *
+     * Note, the resource policy for the File System will include the boolean
+     * condition, `"elasticfilesystem:AccessedViaMountTarget": "true"` which from
+     * CDK [docs](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_efs-readme.html#permissions)
+     * says, "only allow access to clients using IAM authentication and deny access
+     * to anonymous clients".
+     * @see https://docs.aws.amazon.com/efs/latest/ug/access-control-block-public-access.html
+     *
+     * Ideally we could add IAM string condition `elasticfilesystem:AccessPointArn`
+     * to the resource policy but this causes circular dependency.
+     */
+    private createFileSystem;
+    private createAccessPoint;
+    allowCompute({ connections, role }: AllowComputeProps): void;
+}

package/lib/nextjs-file-system.js

@@ -0,0 +1,74 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NextjsFileSystem = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_efs_1 = require("aws-cdk-lib/aws-efs");
+const constructs_1 = require("constructs");
+/**
+ * Next.js Network File System enabling sharing of image optimization cache,
+ * data cach, and pages cache.
+ */
+class NextjsFileSystem extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        this.fileSystem = this.createFileSystem();
+        this.accessPoint = this.createAccessPoint();
+    }
+    /**
+     * Creates EFS File System
+     *
+     * Note, the resource policy for the File System will include the boolean
+     * condition, `"elasticfilesystem:AccessedViaMountTarget": "true"` which from
+     * CDK [docs](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_efs-readme.html#permissions)
+     * says, "only allow access to clients using IAM authentication and deny access
+     * to anonymous clients".
+     * @see https://docs.aws.amazon.com/efs/latest/ug/access-control-block-public-access.html
+     *
+     * Ideally we could add IAM string condition `elasticfilesystem:AccessPointArn`
+     * to the resource policy but this causes circular dependency.
+     */
+    createFileSystem() {
+        const fileSystem = new aws_efs_1.FileSystem(this, "FileSystem", {
+            encrypted: true,
+            lifecyclePolicy: aws_efs_1.LifecyclePolicy.AFTER_30_DAYS,
+            removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+            vpc: this.props.vpc,
+            allowAnonymousAccess: false,
+            ...this.props.overrides?.fileSystemProps,
+        });
+        return fileSystem;
+    }
+    createAccessPoint() {
+        const uid = "1001";
+        const gid = "1001";
+        const accessPoint = new aws_efs_1.AccessPoint(this, "AccessPoint", {
+            // as /next/cache doesn't exist in a new efs filesystem, the efs will
+            // create the directory with the following options
+            createAcl: {
+                ownerGid: gid,
+                ownerUid: uid,
+                permissions: "755",
+            },
+            fileSystem: this.fileSystem,
+            path: "/next/cache",
+            // enforce POSIX identity so container wil access file system with this identity
+            posixUser: {
+                gid,
+                uid,
+            },
+            ...this.props.overrides?.accessPointProps,
+        });
+        return accessPoint;
+    }
+    allowCompute({ connections, role }) {
+        this.fileSystem.connections.allowDefaultPortFrom(connections);
+        this.fileSystem.grantReadWrite(role);
+    }
+}
+exports.NextjsFileSystem = NextjsFileSystem;
+_a = JSII_RTTI_SYMBOL_1;
+NextjsFileSystem[_a] = { fqn: "cdk-nextjs.NextjsFileSystem", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV4dGpzLWZpbGUtc3lzdGVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL25leHRqcy1maWxlLXN5c3RlbS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLDZDQUE0QztBQUU1QyxpREFNNkI7QUFFN0IsMkNBQXVDO0FBaUJ2Qzs7O0dBR0c7QUFDSCxNQUFhLGdCQUFpQixTQUFRLHNCQUFTO0lBSzdDLFlBQVksS0FBZ0IsRUFBRSxFQUFVLEVBQUUsS0FBNEI7UUFDcEUsS0FBSyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsQ0FBQztRQUNqQixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztRQUNuQixJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDO1FBQzFDLElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSxDQUFDLGlCQUFpQixFQUFFLENBQUM7SUFDOUMsQ0FBQztJQUNEOzs7Ozs7Ozs7Ozs7T0FZRztJQUNLLGdCQUFnQjtRQUN0QixNQUFNLFVBQVUsR0FBRyxJQUFJLG9CQUFVLENBQUMsSUFBSSxFQUFFLFlBQVksRUFBRTtZQUNwRCxTQUFTLEVBQUUsSUFBSTtZQUNmLGVBQWUsRUFBRSx5QkFBZSxDQUFDLGFBQWE7WUFDOUMsYUFBYSxFQUFFLDJCQUFhLENBQUMsT0FBTztZQUNwQyxHQUFHLEVBQUUsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHO1lBQ25CLG9CQUFvQixFQUFFLEtBQUs7WUFDM0IsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLFNBQVMsRUFBRSxlQUFlO1NBQ3pDLENBQUMsQ0FBQztRQUNILE9BQU8sVUFBVSxDQUFDO0lBQ3BCLENBQUM7SUFDTyxpQkFBaUI7UUFDdkIsTUFBTSxHQUFHLEdBQUcsTUFBTSxDQUFDO1FBQ25CLE1BQU0sR0FBRyxHQUFHLE1BQU0sQ0FBQztRQUNuQixNQUFNLFdBQVcsR0FBRyxJQUFJLHFCQUFXLENBQUMsSUFBSSxFQUFFLGFBQWEsRUFBRTtZQUN2RCxxRUFBcUU7WUFDckUsa0RBQWtEO1lBQ2xELFNBQVMsRUFBRTtnQkFDVCxRQUFRLEVBQUUsR0FBRztnQkFDYixRQUFRLEVBQUUsR0FBRztnQkFDYixXQUFXLEVBQUUsS0FBSzthQUNuQjtZQUNELFVBQVUsRUFBRSxJQUFJLENBQUMsVUFBVTtZQUMzQixJQUFJLEVBQUUsYUFBYTtZQUNuQixnRkFBZ0Y7WUFDaEYsU0FBUyxFQUFFO2dCQUNULEdBQUc7Z0JBQ0gsR0FBRzthQUNKO1lBQ0QsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLFNBQVMsRUFBRSxnQkFBZ0I7U0FDMUMsQ0FBQyxDQUFDO1FBQ0gsT0FBTyxXQUFXLENBQUM7SUFDckIsQ0FBQztJQUNELFlBQVksQ0FBQyxFQUFFLFdBQVcsRUFBRSxJQUFJLEVBQXFCO1FBQ25ELElBQUksQ0FBQyxVQUFVLENBQUMsV0FBVyxDQUFDLG9CQUFvQixDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQzlELElBQUksQ0FBQyxVQUFVLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3ZDLENBQUM7O0FBNURILDRDQTZEQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJlbW92YWxQb2xpY3kgfSBmcm9tIFwiYXdzLWNkay1saWJcIjtcbmltcG9ydCB7IENvbm5lY3Rpb25zLCBJVnBjIH0gZnJvbSBcImF3cy1jZGstbGliL2F3cy1lYzJcIjtcbmltcG9ydCB7XG4gIEFjY2Vzc1BvaW50LFxuICBBY2Nlc3NQb2ludFByb3BzLFxuICBGaWxlU3lzdGVtLFxuICBGaWxlU3lzdGVtUHJvcHMsXG4gIExpZmVjeWNsZVBvbGljeSxcbn0gZnJvbSBcImF3cy1jZGstbGliL2F3cy1lZnNcIjtcbmltcG9ydCB7IElSb2xlIH0gZnJvbSBcImF3cy1jZGstbGliL2F3cy1pYW1cIjtcbmltcG9ydCB7IENvbnN0cnVjdCB9IGZyb20gXCJjb25zdHJ1Y3RzXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTmV4dGpzRmlsZVN5c3RlbU92ZXJyaWRlcyB7XG4gIHJlYWRvbmx5IGZpbGVTeXN0ZW1Qcm9wcz86IEZpbGVTeXN0ZW1Qcm9wcztcbiAgcmVhZG9ubHkgYWNjZXNzUG9pbnRQcm9wcz86IEFjY2Vzc1BvaW50UHJvcHM7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgTmV4dGpzRmlsZVN5c3RlbVByb3BzIHtcbiAgcmVhZG9ubHkgb3ZlcnJpZGVzPzogTmV4dGpzRmlsZVN5c3RlbU92ZXJyaWRlcztcbiAgcmVhZG9ubHkgdnBjOiBJVnBjO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEFsbG93Q29tcHV0ZVByb3BzIHtcbiAgcmVhZG9ubHkgY29ubmVjdGlvbnM6IENvbm5lY3Rpb25zO1xuICByZWFkb25seSByb2xlOiBJUm9sZTtcbn1cblxuLyoqXG4gKiBOZXh0LmpzIE5ldHdvcmsgRmlsZSBTeXN0ZW0gZW5hYmxpbmcgc2hhcmluZyBvZiBpbWFnZSBvcHRpbWl6YXRpb24gY2FjaGUsXG4gKiBkYXRhIGNhY2gsIGFuZCBwYWdlcyBjYWNoZS5cbiAqL1xuZXhwb3J0IGNsYXNzIE5leHRqc0ZpbGVTeXN0ZW0gZXh0ZW5kcyBDb25zdHJ1Y3Qge1xuICBmaWxlU3lzdGVtOiBGaWxlU3lzdGVtO1xuICBhY2Nlc3NQb2ludDogQWNjZXNzUG9pbnQ7XG4gIHByaXZhdGUgcHJvcHM6IE5leHRqc0ZpbGVTeXN0ZW1Qcm9wcztcblxuICBjb25zdHJ1Y3RvcihzY29wZTogQ29uc3RydWN0LCBpZDogc3RyaW5nLCBwcm9wczogTmV4dGpzRmlsZVN5c3RlbVByb3BzKSB7XG4gICAgc3VwZXIoc2NvcGUsIGlkKTtcbiAgICB0aGlzLnByb3BzID0gcHJvcHM7XG4gICAgdGhpcy5maWxlU3lzdGVtID0gdGhpcy5jcmVhdGVGaWxlU3lzdGVtKCk7XG4gICAgdGhpcy5hY2Nlc3NQb2ludCA9IHRoaXMuY3JlYXRlQWNjZXNzUG9pbnQoKTtcbiAgfVxuICAvKipcbiAgICogQ3JlYXRlcyBFRlMgRmlsZSBTeXN0ZW1cbiAgICpcbiAgICogTm90ZSwgdGhlIHJlc291cmNlIHBvbGljeSBmb3IgdGhlIEZpbGUgU3lzdGVtIHdpbGwgaW5jbHVkZSB0aGUgYm9vbGVhblxuICAgKiBjb25kaXRpb24sIGBcImVsYXN0aWNmaWxlc3lzdGVtOkFjY2Vzc2VkVmlhTW91bnRUYXJnZXRcIjogXCJ0cnVlXCJgIHdoaWNoIGZyb21cbiAgICogQ0RLIFtkb2NzXShodHRwczovL2RvY3MuYXdzLmFtYXpvbi5jb20vY2RrL2FwaS92Mi9kb2NzL2F3cy1jZGstbGliLmF3c19lZnMtcmVhZG1lLmh0bWwjcGVybWlzc2lvbnMpXG4gICAqIHNheXMsIFwib25seSBhbGxvdyBhY2Nlc3MgdG8gY2xpZW50cyB1c2luZyBJQU0gYXV0aGVudGljYXRpb24gYW5kIGRlbnkgYWNjZXNzXG4gICAqIHRvIGFub255bW91cyBjbGllbnRzXCIuXG4gICAqIEBzZWUgaHR0cHM6Ly9kb2NzLmF3cy5hbWF6b24uY29tL2Vmcy9sYXRlc3QvdWcvYWNjZXNzLWNvbnRyb2wtYmxvY2stcHVibGljLWFjY2Vzcy5odG1sXG4gICAqXG4gICAqIElkZWFsbHkgd2UgY291bGQgYWRkIElBTSBzdHJpbmcgY29uZGl0aW9uIGBlbGFzdGljZmlsZXN5c3RlbTpBY2Nlc3NQb2ludEFybmBcbiAgICogdG8gdGhlIHJlc291cmNlIHBvbGljeSBidXQgdGhpcyBjYXVzZXMgY2lyY3VsYXIgZGVwZW5kZW5jeS5cbiAgICovXG4gIHByaXZhdGUgY3JlYXRlRmlsZVN5c3RlbSgpIHtcbiAgICBjb25zdCBmaWxlU3lzdGVtID0gbmV3IEZpbGVTeXN0ZW0odGhpcywgXCJGaWxlU3lzdGVtXCIsIHtcbiAgICAgIGVuY3J5cHRlZDogdHJ1ZSxcbiAgICAgIGxpZmVjeWNsZVBvbGljeTogTGlmZWN5Y2xlUG9saWN5LkFGVEVSXzMwX0RBWVMsXG4gICAgICByZW1vdmFsUG9saWN5OiBSZW1vdmFsUG9saWN5LkRFU1RST1ksXG4gICAgICB2cGM6IHRoaXMucHJvcHMudnBjLFxuICAgICAgYWxsb3dBbm9ueW1vdXNBY2Nlc3M6IGZhbHNlLFxuICAgICAgLi4udGhpcy5wcm9wcy5vdmVycmlkZXM/LmZpbGVTeXN0ZW1Qcm9wcyxcbiAgICB9KTtcbiAgICByZXR1cm4gZmlsZVN5c3RlbTtcbiAgfVxuICBwcml2YXRlIGNyZWF0ZUFjY2Vzc1BvaW50KCkge1xuICAgIGNvbnN0IHVpZCA9IFwiMTAwMVwiO1xuICAgIGNvbnN0IGdpZCA9IFwiMTAwMVwiO1xuICAgIGNvbnN0IGFjY2Vzc1BvaW50ID0gbmV3IEFjY2Vzc1BvaW50KHRoaXMsIFwiQWNjZXNzUG9pbnRcIiwge1xuICAgICAgLy8gYXMgL25leHQvY2FjaGUgZG9lc24ndCBleGlzdCBpbiBhIG5ldyBlZnMgZmlsZXN5c3RlbSwgdGhlIGVmcyB3aWxsXG4gICAgICAvLyBjcmVhdGUgdGhlIGRpcmVjdG9yeSB3aXRoIHRoZSBmb2xsb3dpbmcgb3B0aW9uc1xuICAgICAgY3JlYXRlQWNsOiB7XG4gICAgICAgIG93bmVyR2lkOiBnaWQsXG4gICAgICAgIG93bmVyVWlkOiB1aWQsXG4gICAgICAgIHBlcm1pc3Npb25zOiBcIjc1NVwiLFxuICAgICAgfSxcbiAgICAgIGZpbGVTeXN0ZW06IHRoaXMuZmlsZVN5c3RlbSxcbiAgICAgIHBhdGg6IFwiL25leHQvY2FjaGVcIixcbiAgICAgIC8vIGVuZm9yY2UgUE9TSVggaWRlbnRpdHkgc28gY29udGFpbmVyIHdpbCBhY2Nlc3MgZmlsZSBzeXN0ZW0gd2l0aCB0aGlzIGlkZW50aXR5XG4gICAgICBwb3NpeFVzZXI6IHtcbiAgICAgICAgZ2lkLFxuICAgICAgICB1aWQsXG4gICAgICB9LFxuICAgICAgLi4udGhpcy5wcm9wcy5vdmVycmlkZXM/LmFjY2Vzc1BvaW50UHJvcHMsXG4gICAgfSk7XG4gICAgcmV0dXJuIGFjY2Vzc1BvaW50O1xuICB9XG4gIGFsbG93Q29tcHV0ZSh7IGNvbm5lY3Rpb25zLCByb2xlIH06IEFsbG93Q29tcHV0ZVByb3BzKSB7XG4gICAgdGhpcy5maWxlU3lzdGVtLmNvbm5lY3Rpb25zLmFsbG93RGVmYXVsdFBvcnRGcm9tKGNvbm5lY3Rpb25zKTtcbiAgICB0aGlzLmZpbGVTeXN0ZW0uZ3JhbnRSZWFkV3JpdGUocm9sZSk7XG4gIH1cbn1cbiJdfQ==

package/lib/nextjs-invalidation.d.ts

@@ -0,0 +1,19 @@
+import { IDistribution } from "aws-cdk-lib/aws-cloudfront";
+import { AwsCustomResourceProps } from "aws-cdk-lib/custom-resources";
+import { Construct } from "constructs";
+export interface NextjsInvalidationOverrides {
+    readonly awsCustomResourceProps?: AwsCustomResourceProps;
+}
+export interface NextjsInvalidationProps {
+    /**
+     * CloudFront Distribution to invalidate
+     */
+    readonly distribution: IDistribution;
+    /**
+     * Override props for every construct.
+     */
+    readonly overrides?: NextjsInvalidationOverrides;
+}
+export declare class NextjsInvalidation extends Construct {
+    constructor(scope: Construct, id: string, props: NextjsInvalidationProps);
+}