cdk-nextjs 0.1.0 → 0.1.1

package/lib/nextjs-distribution.js

@@ -0,0 +1,331 @@
+"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 aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+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 },
+        };
+        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();
+        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 = aws_cloudfront_origins_1.S3BucketOrigin.withOriginAccessControl(this.props.assetsBucket, this.props.overrides?.s3BucketOriginProps);
+        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;
+        }
+        // WAITING FOR CLOUDFRONT FEATURE: CloudFront Lambda Function URL OAC
+        // doesn't support POST with body since CloudFront doesn't include sha256
+        // hash of body. see: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-restricting-access-to-lambda.html
+        // We could monkey patch `fetch` to include sha256 in request for server
+        // actions, but better solution is for cloudfront to support it
+        //
+        // TODO: use L2 construct when released: https://github.com/aws/aws-cdk/issues/31629
+        /**
+         * Given stack id: "arn:aws:cloudformation:us-east-1:905418358903:stack/lh-stickb-idp/4bf74be0-e880-11ee-aea9-0affc6185b25",
+         * returns "4bf74be0"
+         */
+        // const uniqueStackIdPart = Fn.select(
+        //   0,
+        //   Fn.split("-", Fn.select(2, Fn.split("/", `${Aws.STACK_ID}`))),
+        // );
+        // const lambdaOac = new CfnOriginAccessControl(this, "OAC", {
+        //   originAccessControlConfig: {
+        //     name: `OAC-Lambda-${uniqueStackIdPart}`,
+        //     originAccessControlOriginType: "lambda",
+        //     signingBehavior: "always",
+        //     signingProtocol: "sigv4",
+        //   },
+        // });
+        // const cfnDistribution = this.distribution.node
+        //   .defaultChild as CfnDistribution;
+        // cfnDistribution.addPropertyOverride(
+        //   "DistributionConfig.Origins.0.OriginAccessControlId",
+        //   lambdaOac.getAtt("Id"),
+        // );
+        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],
+                }),
+            ],
+            code: aws_lambda_1.Code.fromInline("export function handler() {}"),
+            handler: "handler",
+            runtime: aws_lambda_1.Runtime.NODEJS_LATEST,
+            ...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"));
+        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", {
+                // SECURITY NOTE: by default we don't include cookies in cache for
+                // images b/c it significantly improves image perf for most sites BUT
+                // if you have private images locked behind auth implemented with cookies
+                // you need to override this.
+                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,
+                // best to use HTTP 2 and 3 for compatability (HTTP 2) and performance (HTTP3)
+                // CloudFront will choose best option for client
+                httpVersion: aws_cloudfront_1.HttpVersion.HTTP2_AND_3,
+                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;
+        }
+    }
+}
+exports.NextjsDistribution = NextjsDistribution;
+_a = JSII_RTTI_SYMBOL_1;
+NextjsDistribution[_a] = { fqn: "cdk-nextjs.NextjsDistribution", version: "0.1.1" };
+//# 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 { CfnOutput, Duration, Fn, Stack } 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  Function as CloudFrontFunction,\n  Distribution,\n  FunctionAssociation,\n  FunctionCode,\n  FunctionEventType,\n  HeadersFrameOption,\n  HeadersReferrerPolicy,\n  HttpVersion,\n  IOrigin,\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  S3BucketOrigin,\n} from \"aws-cdk-lib/aws-cloudfront-origins\";\nimport { PolicyStatement, ServicePrincipal } from \"aws-cdk-lib/aws-iam\";\nimport { Code, Runtime } from \"aws-cdk-lib/aws-lambda\";\nimport { 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 { OptionalS3OriginBucketWithOACProps } from \"./generated-structs/OptionalS3OriginBucketWithOACProps\";\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 s3BucketOriginProps?: OptionalS3OriginBucketWithOACProps;\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: IOrigin;\n  private dynamicOrigin: IOrigin;\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  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    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(): IOrigin {\n    const s3Origin = S3BucketOrigin.withOriginAccessControl(\n      this.props.assetsBucket,\n      this.props.overrides?.s3BucketOriginProps,\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    // WAITING FOR CLOUDFRONT FEATURE: CloudFront Lambda Function URL OAC\n    // doesn't support POST with body since CloudFront doesn't include sha256\n    // hash of body. see: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-restricting-access-to-lambda.html\n    // We could monkey patch `fetch` to include sha256 in request for server\n    // actions, but better solution is for cloudfront to support it\n    //\n    // TODO: use L2 construct when released: https://github.com/aws/aws-cdk/issues/31629\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    // const uniqueStackIdPart = Fn.select(\n    //   0,\n    //   Fn.split(\"-\", Fn.select(2, Fn.split(\"/\", `${Aws.STACK_ID}`))),\n    // );\n    // const lambdaOac = new CfnOriginAccessControl(this, \"OAC\", {\n    //   originAccessControlConfig: {\n    //     name: `OAC-Lambda-${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    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      code: Code.fromInline(\"export function handler() {}\"),\n      handler: \"handler\",\n      runtime: Runtime.NODEJS_LATEST,\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    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        // SECURITY NOTE: by default we don't include cookies in cache for\n        // images b/c it significantly improves image perf for most sites BUT\n        // if you have private images locked behind auth implemented with cookies\n        // you need to override this.\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        // best to use HTTP 2 and 3 for compatability (HTTP 2) and performance (HTTP3)\n        // CloudFront will choose best option for client\n        httpVersion: HttpVersion.HTTP2_AND_3,\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"]}

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.1.1" };
+//# sourceMappingURL=data:application/json;base64,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

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);
+}

package/lib/nextjs-invalidation.js

@@ -0,0 +1,52 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NextjsInvalidation = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const custom_resources_1 = require("aws-cdk-lib/custom-resources");
+const constructs_1 = require("constructs");
+class NextjsInvalidation extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const awsSdkCall = {
+            // make `physicalResourceId` change each time to invalidate CloudFront
+            // distribution on each change
+            physicalResourceId: custom_resources_1.PhysicalResourceId.of(`${props.distribution.distributionId}-${Date.now()}`),
+            action: "CreateInvalidationCommand",
+            service: "@aws-sdk/client-cloudfront",
+            parameters: {
+                DistributionId: props.distribution.distributionId,
+                InvalidationBatch: {
+                    CallerReference: new Date().toISOString(),
+                    Paths: {
+                        Quantity: 1,
+                        Items: ["/*"],
+                    },
+                },
+            },
+        };
+        new custom_resources_1.AwsCustomResource(this, "AwsCR", {
+            onCreate: awsSdkCall,
+            onUpdate: awsSdkCall,
+            policy: custom_resources_1.AwsCustomResourcePolicy.fromStatements([
+                new aws_iam_1.PolicyStatement({
+                    actions: ["cloudfront:CreateInvalidation"],
+                    resources: [
+                        aws_cdk_lib_1.Stack.of(this).formatArn({
+                            resource: `distribution/${props.distribution.distributionId}`,
+                            service: "cloudfront",
+                            region: "",
+                        }),
+                    ],
+                }),
+            ]),
+            ...props.overrides?.awsCustomResourceProps,
+        });
+    }
+}
+exports.NextjsInvalidation = NextjsInvalidation;
+_a = JSII_RTTI_SYMBOL_1;
+NextjsInvalidation[_a] = { fqn: "cdk-nextjs.NextjsInvalidation", version: "0.1.1" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/nextjs-revalidation.d.ts

@@ -0,0 +1,30 @@
+import { Function as LambdaFunction } from "aws-cdk-lib/aws-lambda";
+import { SqsEventSourceProps } from "aws-cdk-lib/aws-lambda-event-sources";
+import { Queue, QueueProps } from "aws-cdk-lib/aws-sqs";
+import { Construct } from "constructs";
+import { OptionalFunctionProps } from "./generated-structs/OptionalFunctionProps";
+export interface NextjsRevalidationOverrides {
+    readonly queueProps?: QueueProps;
+    readonly functionProps?: OptionalFunctionProps;
+    readonly sqsEventSourceProps?: SqsEventSourceProps;
+}
+export interface NextjsRevalidationProps {
+    readonly fn: LambdaFunction;
+    readonly overrides?: NextjsRevalidationOverrides;
+    readonly previewModeId: string;
+}
+/**
+ * [On-Demand Revalidation](https://nextjs.org/docs/app/building-your-application/caching#on-demand-revalidation)
+ * (i.e. `revalidateTag`, `revlidatePath`) doesn't work by default in Lambda
+ * environment because it tries to run every request completes when Lambda
+ * spins down. Therefore, we use a SQS Queue and Lambda function to run
+ * revalidation async.
+ */
+export declare class NextjsRevalidation extends Construct {
+    queue: Queue;
+    fn: LambdaFunction;
+    private props;
+    constructor(scope: Construct, id: string, props: NextjsRevalidationProps);
+    private createQueue;
+    private createFunction;
+}