cdk-nextjs 0.1.0 → 0.1.1

package/lib/nextjs-revalidation.js

@@ -0,0 +1,65 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NextjsRevalidation = 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 aws_lambda_event_sources_1 = require("aws-cdk-lib/aws-lambda-event-sources");
+const aws_sqs_1 = require("aws-cdk-lib/aws-sqs");
+const constructs_1 = require("constructs");
+const revalidate_function_1 = require("./lambdas/revalidate/revalidate-function");
+/**
+ * [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.
+ */
+class NextjsRevalidation extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        this.queue = this.createQueue();
+        this.fn = this.createFunction();
+    }
+    createQueue() {
+        const queue = new aws_sqs_1.Queue(this, "Queue", {
+            fifo: true,
+            contentBasedDeduplication: true,
+            ...this.props.overrides?.queueProps,
+        });
+        // https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-least-privilege-policy.html
+        queue.addToResourcePolicy(new aws_iam_1.PolicyStatement({
+            sid: "DenyUnsecureTransport",
+            actions: ["sqs:*"],
+            effect: aws_iam_1.Effect.DENY,
+            principals: [new aws_iam_1.AnyPrincipal()],
+            resources: [queue.queueArn],
+            conditions: {
+                Bool: { "aws:SecureTransport": "false" },
+            },
+        }));
+        // Allow server to send messages to the queue
+        queue.grantSendMessages(this.props.fn);
+        this.props.fn.addEnvironment("CDK_NEXTJS_QUEUE_URL", queue.queueUrl);
+        return queue;
+    }
+    createFunction() {
+        const fn = new revalidate_function_1.RevalidateFunction(this, "Fn", {
+            environment: {
+                PREVIEW_MODE_ID: this.props.previewModeId,
+            },
+            timeout: aws_cdk_lib_1.Duration.seconds(20),
+            ...this.props.overrides?.functionProps,
+        });
+        fn.addEventSource(new aws_lambda_event_sources_1.SqsEventSource(this.queue, {
+            ...this.props.overrides?.sqsEventSourceProps,
+        }));
+        return fn;
+    }
+}
+exports.NextjsRevalidation = NextjsRevalidation;
+_a = JSII_RTTI_SYMBOL_1;
+NextjsRevalidation[_a] = { fqn: "cdk-nextjs.NextjsRevalidation", version: "0.1.1" };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,21 @@
+import { Bucket, BucketProps } from "aws-cdk-lib/aws-s3";
+import { Construct } from "constructs";
+export interface NextjsStaticAssetsOverrides {
+    readonly bucketProps?: BucketProps;
+}
+export interface NextjsStaticAssetsProps {
+    readonly overrides?: NextjsStaticAssetsOverrides;
+    /**
+     * Required if `NextjsType.REGIONAL_CONTAINERS`
+     */
+    readonly vpcId?: string;
+}
+/**
+ * Creates S3 Bucket for public and _next/static assets.
+ */
+export declare class NextjsStaticAssets extends Construct {
+    bucket: Bucket;
+    private props;
+    constructor(scope: Construct, id: string, props: NextjsStaticAssetsProps);
+    private createBucket;
+}

package/lib/nextjs-static-assets.js

@@ -0,0 +1,33 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NextjsStaticAssets = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const constructs_1 = require("constructs");
+/**
+ * Creates S3 Bucket for public and _next/static assets.
+ */
+class NextjsStaticAssets extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        this.bucket = this.createBucket();
+    }
+    createBucket() {
+        return new aws_s3_1.Bucket(this, "Bucket", {
+            removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+            autoDeleteObjects: true,
+            enforceSSL: true,
+            blockPublicAccess: aws_s3_1.BlockPublicAccess.BLOCK_ALL,
+            encryption: aws_s3_1.BucketEncryption.S3_MANAGED,
+            minimumTLSVersion: 1.2,
+            ...this.props.overrides?.bucketProps,
+        });
+    }
+}
+exports.NextjsStaticAssets = NextjsStaticAssets;
+_a = JSII_RTTI_SYMBOL_1;
+NextjsStaticAssets[_a] = { fqn: "cdk-nextjs.NextjsStaticAssets", version: "0.1.1" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/nextjs-vpc.d.ts

@@ -0,0 +1,42 @@
+import { IVpc } from "aws-cdk-lib/aws-ec2";
+import { Construct } from "constructs";
+import { NextjsType } from "./common";
+import { OptionalVpcProps } from "./generated-structs/OptionalVpcProps";
+export interface NextjsVpcOverrides {
+    readonly vpcProps?: OptionalVpcProps;
+}
+export interface NextjsVpcProps {
+    readonly nextjsType: NextjsType;
+    /**
+     * Override any construct.
+     */
+    readonly overrides?: NextjsVpcOverrides;
+    /**
+     * Bring your own VPC.
+     */
+    readonly vpc?: IVpc;
+}
+export declare class NextjsVpc extends Construct {
+    vpc: IVpc;
+    private props;
+    constructor(scope: Construct, id: string, props: NextjsVpcProps);
+    /**
+     * cdk-nextjs requires a VPC because of the use of EFS. The Next.js containers
+     * or functions can be placed in "private with egress" subnets or "private isolated"
+     * subnets. "Private with egress" subnets allow for outbound traffic to the internet
+     * but require a NAT Gateway which costs $65/month for 2 AZs. "Private isolated"
+     * subnets do not require a NAT Gateway therefore they are used by default.
+     * @see https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2-readme.html#subnet-types
+     */
+    private createVpc;
+    /**
+     * Best practice is to use VPC endpoints between VPC and serverless resources
+     * so that traffic does not go over public internet.
+     *
+     * While gateway endpoints are free, interface endpoints (use PrivateLink)
+     * cost ~$7/month/az.
+     *
+     * @see https://www.alexdebrie.com/posts/aws-lambda-vpc/#set-up-a-vpc-endpoint-for-your-aws-service
+     */
+    private createVpcEndpoints;
+}

package/lib/nextjs-vpc.js

@@ -0,0 +1,64 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NextjsVpc = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_ec2_1 = require("aws-cdk-lib/aws-ec2");
+const constructs_1 = require("constructs");
+const common_1 = require("./common");
+class NextjsVpc extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        if (props.vpc) {
+            this.vpc = props.vpc;
+        }
+        else {
+            this.vpc = props.vpc ?? this.createVpc();
+            this.createVpcEndpoints();
+        }
+    }
+    /**
+     * cdk-nextjs requires a VPC because of the use of EFS. The Next.js containers
+     * or functions can be placed in "private with egress" subnets or "private isolated"
+     * subnets. "Private with egress" subnets allow for outbound traffic to the internet
+     * but require a NAT Gateway which costs $65/month for 2 AZs. "Private isolated"
+     * subnets do not require a NAT Gateway therefore they are used by default.
+     * @see https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2-readme.html#subnet-types
+     */
+    createVpc() {
+        return new aws_ec2_1.Vpc(this, "Vpc", {
+            maxAzs: 2, // might want 3 in production
+            subnetConfiguration: [
+                { name: "Public", subnetType: aws_ec2_1.SubnetType.PUBLIC },
+                // PrivateWithEgress subnet uses NAT Gateway which costs $32/az/month
+                {
+                    name: "PrivateWithEgress",
+                    subnetType: aws_ec2_1.SubnetType.PRIVATE_WITH_EGRESS,
+                },
+                { name: "PrivateIsolated", subnetType: aws_ec2_1.SubnetType.PRIVATE_ISOLATED },
+            ],
+            ...this.props.overrides?.vpcProps,
+        });
+    }
+    /**
+     * Best practice is to use VPC endpoints between VPC and serverless resources
+     * so that traffic does not go over public internet.
+     *
+     * While gateway endpoints are free, interface endpoints (use PrivateLink)
+     * cost ~$7/month/az.
+     *
+     * @see https://www.alexdebrie.com/posts/aws-lambda-vpc/#set-up-a-vpc-endpoint-for-your-aws-service
+     */
+    createVpcEndpoints() {
+        if (this.props.nextjsType === common_1.NextjsType.GLOBAL_FUNCTIONS) {
+            this.vpc.addInterfaceEndpoint("SqsInterfaceEndpoint", {
+                service: aws_ec2_1.InterfaceVpcEndpointAwsService.SQS,
+            });
+        }
+    }
+}
+exports.NextjsVpc = NextjsVpc;
+_a = JSII_RTTI_SYMBOL_1;
+NextjsVpc[_a] = { fqn: "cdk-nextjs.NextjsVpc", version: "0.1.1" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/root-constructs/nextjs-base-overrides.d.ts

@@ -0,0 +1,26 @@
+import { OptionalNextjsAssetsDeploymentProps } from "../generated-structs/OptionalNextjsAssetsDeploymentProps";
+import { OptionalNextjsBuildProps } from "../generated-structs/OptionalNextjsBuildProps";
+import { OptionalNextjsFileSystemProps } from "../generated-structs/OptionalNextjsFileSystemProps";
+import { OptionalNextjsVpcProps } from "../generated-structs/OptionalNextjsVpcProps";
+import { NextjsAssetDeploymentOverrides } from "../nextjs-assets-deployment";
+import { NextjsBuildOverrides } from "../nextjs-build/nextjs-build";
+import { NextjsFileSystemOverrides } from "../nextjs-file-system";
+import { NextjsVpcOverrides } from "../nextjs-vpc";
+/**
+ * Base overrides for the props passed to constructs within root/top-level Next.js constructs
+ */
+export interface BaseNextjsConstructOverrides {
+    readonly nextjsBuildProps?: OptionalNextjsBuildProps;
+    readonly nextjsVpcProps?: OptionalNextjsVpcProps;
+    readonly nextjsFileSystemProps?: OptionalNextjsFileSystemProps;
+    readonly nextjsAssetsDeploymentProps?: OptionalNextjsAssetsDeploymentProps;
+}
+/**
+ * Base overrides for constructs shared between all root/top-level Next.js constructs.
+ */
+export interface BaseNextjsOverrides {
+    readonly nextjsBuild?: NextjsBuildOverrides;
+    readonly nextjsFileSystem?: NextjsFileSystemOverrides;
+    readonly nextjsVpc?: NextjsVpcOverrides;
+    readonly nextjsAssetsDeployment?: NextjsAssetDeploymentOverrides;
+}

package/lib/root-constructs/nextjs-base-overrides.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/lib/root-constructs/nextjs-base-props.d.ts

@@ -0,0 +1,56 @@
+export interface NextjsBaseProps {
+    /**
+     * Command to generate optimized version of your Next.js app in container;
+     * @default "npm run build"
+     */
+    readonly buildCommand?: string;
+    /**
+     * [Build context](https://docs.docker.com/build/building/context/) for
+     * `docker build`. This directory should contain your lockfile (i.e.
+     * pnpm-lock.yaml) for your Next.js app. If you're not in a monorepo, then
+     * this will be the same directory as your Next.js app. If you are in a
+     * monorepo, then this value should be the root of your monorepo. You then
+     * must pass the relative path to your Next.js app via {@link NextjsBaseProps.relativePathToWorkspace}
+     *  @example fileURLToPath(new URL("../ui", import.meta.url))
+     *  @example fileURLToPath(new URL("../..", import.meta.url)) (monorepo)
+     */
+    readonly buildContext: string;
+    /**
+     * Path to API Route Handler that returns HTTP 200 to ensure compute health.
+     * @example "/api/health"
+     * @example
+     * // api/health/route.ts
+     * import { NextResponse } from "next/server";
+     *
+     * export function GET() {
+     *   return NextResponse.json("");
+     * }
+     */
+    readonly healthCheckPath: string;
+    /**
+     * Use this if building in monorepo. This is the relative path from
+     * {@link NextjsBaseProps.buildContext} or root workspace to nested workspace
+     * containing Next.js app. See example below:
+     *
+     * Let's say you have a monorepo with the following folder structure:
+     * - my-monorepo/
+     *   - packages/
+     *     - ui/
+     *       - package.json (nested)
+     *   - package.json (root)
+     *
+     * And your Next.js app directory is the ui folder. Then you would set {@link NextjsBaseProps.buildContext}
+     * to `"/absolute/path/to/my-monorepo"` and {@link NextjsBaseProps.relativePathToWorkspace}
+     * to `"./packages/ui"`.
+     *
+     * Note, setting {@link NextjsBaseProps.buildContext} to the root of your
+     * monorepo will invalidate container runtime (i.e. docker) build cache when any file is
+     * changed in your monorepo. This is slows down deployments. Checkout how you
+     * can use [turbo](https://turbo.build/) in [Deploying with Docker Guide](https://turbo.build/repo/docs/handbook/deploying-with-docker)
+     * to achieve better build caching. It's as easy as running
+     * `turbo prune my-app --docker` - no config file required.
+     *
+     * @example "./packages/ui"
+     */
+    readonly relativePathToWorkspace?: string;
+}

package/lib/root-constructs/nextjs-base-props.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/lib/root-constructs/nextjs-global-containers.d.ts

@@ -0,0 +1,74 @@
+import { Distribution } from "aws-cdk-lib/aws-cloudfront";
+import { Construct } from "constructs";
+import { BaseNextjsConstructOverrides, BaseNextjsOverrides } from "./nextjs-base-overrides";
+import { NextjsBaseProps } from "./nextjs-base-props";
+import { OptionalNextjsContainersProps } from "../generated-structs/OptionalNextjsContainersProps";
+import { OptionalNextjsDistributionProps } from "../generated-structs/OptionalNextjsDistributionProps";
+import { OptionalNextjsInvalidationProps } from "../generated-structs/OptionalNextjsInvalidationProps";
+import { NextjsAssetsDeployment } from "../nextjs-assets-deployment";
+import { NextjsBuild } from "../nextjs-build/nextjs-build";
+import { NextjsContainers, NextjsContainersOverrides } from "../nextjs-compute/nextjs-containers";
+import { NextjsDistribution, NextjsDistributionOverrides } from "../nextjs-distribution";
+import { NextjsFileSystem } from "../nextjs-file-system";
+import { NextjsInvalidation, NextjsInvalidationOverrides } from "../nextjs-invalidation";
+import { NextjsRevalidationProps } from "../nextjs-revalidation";
+import { NextjsStaticAssets, NextjsStaticAssetsOverrides, NextjsStaticAssetsProps } from "../nextjs-static-assets";
+import { NextjsVpc } from "../nextjs-vpc";
+export interface NextjsGlobalContainersConstructOverrides extends BaseNextjsConstructOverrides {
+    readonly nextjsContainersProps?: OptionalNextjsContainersProps;
+    readonly nextjsDistributionProps?: OptionalNextjsDistributionProps;
+    readonly nextjsRevalidationProps?: NextjsRevalidationProps;
+    readonly nextjsStaticAssetsProps?: NextjsStaticAssetsProps;
+    readonly nextjsInvalidationProps?: OptionalNextjsInvalidationProps;
+}
+export interface NextjsGlobalContainersOverrides extends BaseNextjsOverrides {
+    readonly nextjsGlobalContainers?: NextjsGlobalContainersConstructOverrides;
+    readonly nextjsContainers?: NextjsContainersOverrides;
+    readonly nextjsDistribution?: NextjsDistributionOverrides;
+    readonly nextjsInvalidation?: NextjsInvalidationOverrides;
+    readonly nextjsStaticAssets?: NextjsStaticAssetsOverrides;
+}
+export interface NextjsGlobalContainersProps extends NextjsBaseProps {
+    /**
+     * Prefix to the URI path the app will be served at. Especially useful when
+     * passing in your own `distribution`.
+     * @example "/my-base-path"
+     */
+    readonly basePath?: string;
+    /**
+     * Bring your own distribution. Can be used with `basePath` to host multiple
+     * apps on the same CloudFront distribution.
+     */
+    readonly distribution?: Distribution;
+    /**
+     * Override props of any construct.
+     */
+    readonly overrides?: NextjsGlobalContainersOverrides;
+}
+/**
+ * Deploy Next.js globally distributed with containers. Uses [CloudFront
+ * Distribution](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/distribution-working-with.html)
+ * as Content Delivery Network (CDN) for global distribution and [AWS Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/AWS_Fargate.html)
+ * for containers.
+ */
+export declare class NextjsGlobalContainers extends Construct {
+    nextjsBuild: NextjsBuild;
+    nextjsStaticAssets: NextjsStaticAssets;
+    nextjsVpc: NextjsVpc;
+    nextjsFileSystem: NextjsFileSystem;
+    nextjsAssetsDeployment: NextjsAssetsDeployment;
+    nextjsContainers: NextjsContainers;
+    nextjsDistribution: NextjsDistribution;
+    nextjsInvalidation: NextjsInvalidation;
+    private nextjsType;
+    private props;
+    constructor(scope: Construct, id: string, props: NextjsGlobalContainersProps);
+    private createNextjsBuild;
+    private createNextjsStaticAssets;
+    private createVpc;
+    private createNextjsFileSystem;
+    private createNextjsAssetsDeployment;
+    private createNextjsContainers;
+    private createNextjsDistribution;
+    private createNextjsInvalidation;
+}

package/lib/root-constructs/nextjs-global-containers.js

@@ -0,0 +1,125 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NextjsGlobalContainers = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const constructs_1 = require("constructs");
+const common_1 = require("../common");
+const nextjs_assets_deployment_1 = require("../nextjs-assets-deployment");
+const nextjs_build_1 = require("../nextjs-build/nextjs-build");
+const nextjs_containers_1 = require("../nextjs-compute/nextjs-containers");
+const nextjs_distribution_1 = require("../nextjs-distribution");
+const nextjs_file_system_1 = require("../nextjs-file-system");
+const nextjs_invalidation_1 = require("../nextjs-invalidation");
+const nextjs_static_assets_1 = require("../nextjs-static-assets");
+const nextjs_vpc_1 = require("../nextjs-vpc");
+/**
+ * Deploy Next.js globally distributed with containers. Uses [CloudFront
+ * Distribution](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/distribution-working-with.html)
+ * as Content Delivery Network (CDN) for global distribution and [AWS Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/AWS_Fargate.html)
+ * for containers.
+ */
+class NextjsGlobalContainers extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.nextjsType = common_1.NextjsType.GLOBAL_CONTAINERS;
+        this.props = props;
+        this.nextjsBuild = this.createNextjsBuild();
+        this.nextjsStaticAssets = this.createNextjsStaticAssets();
+        this.nextjsVpc = this.createVpc();
+        this.nextjsFileSystem = this.createNextjsFileSystem();
+        this.nextjsAssetsDeployment = this.createNextjsAssetsDeployment();
+        this.nextjsContainers = this.createNextjsContainers();
+        this.nextjsFileSystem.allowCompute({
+            connections: this.nextjsContainers.albFargateService.service.connections,
+            role: this.nextjsContainers.albFargateService.taskDefinition.taskRole,
+        });
+        this.nextjsDistribution = this.createNextjsDistribution();
+        this.nextjsInvalidation = this.createNextjsInvalidation();
+    }
+    createNextjsBuild() {
+        return new nextjs_build_1.NextjsBuild(this, "NextjsBuild", {
+            buildCommand: this.props.buildCommand,
+            buildContext: this.props.buildContext,
+            nextjsType: this.nextjsType,
+            relativePathToWorkspace: this.props.relativePathToWorkspace,
+            overrides: this.props.overrides?.nextjsBuild,
+            ...this.props.overrides?.nextjsGlobalContainers?.nextjsBuildProps,
+        });
+    }
+    createNextjsStaticAssets() {
+        return new nextjs_static_assets_1.NextjsStaticAssets(this, "NextjsStaticAssets", {
+            overrides: this.props.overrides?.nextjsStaticAssets,
+            ...this.props.overrides?.nextjsGlobalContainers?.nextjsStaticAssetsProps,
+        });
+    }
+    createVpc() {
+        return new nextjs_vpc_1.NextjsVpc(this, "NextjsVpc", {
+            nextjsType: this.nextjsType,
+            overrides: this.props.overrides?.nextjsVpc,
+            ...this.props.overrides?.nextjsGlobalContainers?.nextjsVpcProps,
+        });
+    }
+    createNextjsFileSystem() {
+        return new nextjs_file_system_1.NextjsFileSystem(this, "NextjsFileSystem", {
+            vpc: this.nextjsVpc.vpc,
+            overrides: this.props.overrides?.nextjsFileSystem,
+            ...this.props.overrides?.nextjsGlobalContainers?.nextjsFileSystemProps,
+        });
+    }
+    createNextjsAssetsDeployment() {
+        return new nextjs_assets_deployment_1.NextjsAssetsDeployment(this, "NextjsAssetsDeployment", {
+            accessPoint: this.nextjsFileSystem.accessPoint,
+            buildImageDigest: this.nextjsBuild.buildImageDigest,
+            dockerImageCode: this.nextjsBuild.imageForNextjsAssetsDeployment,
+            containerMountPathForEfs: this.nextjsBuild.containerMountPathForEfs,
+            overrides: this.props.overrides?.nextjsAssetsDeployment,
+            relativePathToWorkspace: this.props.relativePathToWorkspace,
+            staticAssetsBucket: this.nextjsStaticAssets.bucket,
+            vpc: this.nextjsVpc.vpc,
+            ...this.props.overrides?.nextjsGlobalContainers
+                ?.nextjsAssetsDeploymentProps,
+        });
+    }
+    createNextjsContainers() {
+        if (!this.nextjsBuild.imageForNextjsContainers) {
+            throw new Error("nextjsBuild.dockerImageAsset is undefined");
+        }
+        return new nextjs_containers_1.NextjsContainers(this, "NextjsContainers", {
+            accessPoint: this.nextjsFileSystem.accessPoint,
+            containerMountPathForEfs: this.nextjsBuild.containerMountPathForEfs,
+            dockerImageAsset: this.nextjsBuild.imageForNextjsContainers,
+            fileSystem: this.nextjsFileSystem.fileSystem,
+            healthCheckPath: this.props.healthCheckPath,
+            nextjsType: this.nextjsType,
+            relativeEntrypointPath: this.nextjsBuild.relativePathToEntrypoint,
+            overrides: this.props.overrides?.nextjsContainers,
+            vpc: this.nextjsVpc.vpc,
+            ...this.props.overrides?.nextjsGlobalContainers?.nextjsContainersProps,
+        });
+    }
+    createNextjsDistribution() {
+        return new nextjs_distribution_1.NextjsDistribution(this, "NextjsDistribution", {
+            assetsBucket: this.nextjsStaticAssets.bucket,
+            basePath: this.props.basePath,
+            certificate: this.nextjsContainers.albFargateService.certificate,
+            distribution: this.props.distribution,
+            dynamicUrl: this.nextjsContainers.url,
+            nextjsType: this.nextjsType,
+            overrides: this.props.overrides?.nextjsDistribution,
+            publicDirEntries: this.nextjsBuild.publicDirEntries,
+            ...this.props.overrides?.nextjsGlobalContainers?.nextjsDistributionProps,
+        });
+    }
+    createNextjsInvalidation() {
+        return new nextjs_invalidation_1.NextjsInvalidation(this, "NextjsInvalidation", {
+            distribution: this.nextjsDistribution.distribution,
+            overrides: this.props.overrides?.nextjsInvalidation,
+            ...this.props.overrides?.nextjsGlobalContainers?.nextjsInvalidationProps,
+        });
+    }
+}
+exports.NextjsGlobalContainers = NextjsGlobalContainers;
+_a = JSII_RTTI_SYMBOL_1;
+NextjsGlobalContainers[_a] = { fqn: "cdk-nextjs.NextjsGlobalContainers", version: "0.1.1" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-global-containers.js","sourceRoot":"","sources":["../../src/root-constructs/nextjs-global-containers.ts"],"names":[],"mappings":"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","sourcesContent":["import { Distribution } from \"aws-cdk-lib/aws-cloudfront\";\nimport { Construct } from \"constructs\";\nimport {\n  BaseNextjsConstructOverrides,\n  BaseNextjsOverrides,\n} from \"./nextjs-base-overrides\";\nimport { NextjsBaseProps } from \"./nextjs-base-props\";\nimport { NextjsType } from \"../common\";\nimport { OptionalNextjsContainersProps } from \"../generated-structs/OptionalNextjsContainersProps\";\nimport { OptionalNextjsDistributionProps } from \"../generated-structs/OptionalNextjsDistributionProps\";\nimport { OptionalNextjsInvalidationProps } from \"../generated-structs/OptionalNextjsInvalidationProps\";\nimport { NextjsAssetsDeployment } from \"../nextjs-assets-deployment\";\nimport { NextjsBuild } from \"../nextjs-build/nextjs-build\";\nimport {\n  NextjsContainers,\n  NextjsContainersOverrides,\n} from \"../nextjs-compute/nextjs-containers\";\nimport {\n  NextjsDistribution,\n  NextjsDistributionOverrides,\n} from \"../nextjs-distribution\";\nimport { NextjsFileSystem } from \"../nextjs-file-system\";\nimport {\n  NextjsInvalidation,\n  NextjsInvalidationOverrides,\n} from \"../nextjs-invalidation\";\nimport { NextjsRevalidationProps } from \"../nextjs-revalidation\";\nimport {\n  NextjsStaticAssets,\n  NextjsStaticAssetsOverrides,\n  NextjsStaticAssetsProps,\n} from \"../nextjs-static-assets\";\nimport { NextjsVpc } from \"../nextjs-vpc\";\n\nexport interface NextjsGlobalContainersConstructOverrides\n  extends BaseNextjsConstructOverrides {\n  readonly nextjsContainersProps?: OptionalNextjsContainersProps;\n  readonly nextjsDistributionProps?: OptionalNextjsDistributionProps;\n  readonly nextjsRevalidationProps?: NextjsRevalidationProps;\n  readonly nextjsStaticAssetsProps?: NextjsStaticAssetsProps;\n  readonly nextjsInvalidationProps?: OptionalNextjsInvalidationProps;\n}\n\nexport interface NextjsGlobalContainersOverrides extends BaseNextjsOverrides {\n  readonly nextjsGlobalContainers?: NextjsGlobalContainersConstructOverrides;\n  readonly nextjsContainers?: NextjsContainersOverrides;\n  readonly nextjsDistribution?: NextjsDistributionOverrides;\n  readonly nextjsInvalidation?: NextjsInvalidationOverrides;\n  readonly nextjsStaticAssets?: NextjsStaticAssetsOverrides;\n}\n\nexport interface NextjsGlobalContainersProps extends NextjsBaseProps {\n  /**\n   * Prefix to the URI path the app will be served at. Especially useful when\n   * passing in your own `distribution`.\n   * @example \"/my-base-path\"\n   */\n  readonly basePath?: string;\n  /**\n   * Bring your own distribution. Can be used with `basePath` to host multiple\n   * apps on the same CloudFront distribution.\n   */\n  readonly distribution?: Distribution;\n  /**\n   * Override props of any construct.\n   */\n  readonly overrides?: NextjsGlobalContainersOverrides;\n}\n\n/**\n * Deploy Next.js globally distributed with containers. Uses [CloudFront\n * Distribution](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/distribution-working-with.html)\n * as Content Delivery Network (CDN) for global distribution and [AWS Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/AWS_Fargate.html)\n * for containers.\n */\nexport class NextjsGlobalContainers extends Construct {\n  nextjsBuild: NextjsBuild;\n  nextjsStaticAssets: NextjsStaticAssets;\n  nextjsVpc: NextjsVpc;\n  nextjsFileSystem: NextjsFileSystem;\n  nextjsAssetsDeployment: NextjsAssetsDeployment;\n  nextjsContainers: NextjsContainers;\n  nextjsDistribution: NextjsDistribution;\n  nextjsInvalidation: NextjsInvalidation;\n\n  private nextjsType = NextjsType.GLOBAL_CONTAINERS;\n  private props: NextjsGlobalContainersProps;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: NextjsGlobalContainersProps,\n  ) {\n    super(scope, id);\n    this.props = props;\n    this.nextjsBuild = this.createNextjsBuild();\n    this.nextjsStaticAssets = this.createNextjsStaticAssets();\n    this.nextjsVpc = this.createVpc();\n    this.nextjsFileSystem = this.createNextjsFileSystem();\n    this.nextjsAssetsDeployment = this.createNextjsAssetsDeployment();\n    this.nextjsContainers = this.createNextjsContainers();\n    this.nextjsFileSystem.allowCompute({\n      connections: this.nextjsContainers.albFargateService.service.connections,\n      role: this.nextjsContainers.albFargateService.taskDefinition.taskRole,\n    });\n    this.nextjsDistribution = this.createNextjsDistribution();\n    this.nextjsInvalidation = this.createNextjsInvalidation();\n  }\n\n  private createNextjsBuild() {\n    return new NextjsBuild(this, \"NextjsBuild\", {\n      buildCommand: this.props.buildCommand,\n      buildContext: this.props.buildContext,\n      nextjsType: this.nextjsType,\n      relativePathToWorkspace: this.props.relativePathToWorkspace,\n      overrides: this.props.overrides?.nextjsBuild,\n      ...this.props.overrides?.nextjsGlobalContainers?.nextjsBuildProps,\n    });\n  }\n  private createNextjsStaticAssets() {\n    return new NextjsStaticAssets(this, \"NextjsStaticAssets\", {\n      overrides: this.props.overrides?.nextjsStaticAssets,\n      ...this.props.overrides?.nextjsGlobalContainers?.nextjsStaticAssetsProps,\n    });\n  }\n  private createVpc() {\n    return new NextjsVpc(this, \"NextjsVpc\", {\n      nextjsType: this.nextjsType,\n      overrides: this.props.overrides?.nextjsVpc,\n      ...this.props.overrides?.nextjsGlobalContainers?.nextjsVpcProps,\n    });\n  }\n  private createNextjsFileSystem() {\n    return new NextjsFileSystem(this, \"NextjsFileSystem\", {\n      vpc: this.nextjsVpc.vpc,\n      overrides: this.props.overrides?.nextjsFileSystem,\n      ...this.props.overrides?.nextjsGlobalContainers?.nextjsFileSystemProps,\n    });\n  }\n  private createNextjsAssetsDeployment() {\n    return new NextjsAssetsDeployment(this, \"NextjsAssetsDeployment\", {\n      accessPoint: this.nextjsFileSystem.accessPoint,\n      buildImageDigest: this.nextjsBuild.buildImageDigest,\n      dockerImageCode: this.nextjsBuild.imageForNextjsAssetsDeployment,\n      containerMountPathForEfs: this.nextjsBuild.containerMountPathForEfs,\n      overrides: this.props.overrides?.nextjsAssetsDeployment,\n      relativePathToWorkspace: this.props.relativePathToWorkspace,\n      staticAssetsBucket: this.nextjsStaticAssets.bucket,\n      vpc: this.nextjsVpc.vpc,\n      ...this.props.overrides?.nextjsGlobalContainers\n        ?.nextjsAssetsDeploymentProps,\n    });\n  }\n  private createNextjsContainers() {\n    if (!this.nextjsBuild.imageForNextjsContainers) {\n      throw new Error(\"nextjsBuild.dockerImageAsset is undefined\");\n    }\n    return new NextjsContainers(this, \"NextjsContainers\", {\n      accessPoint: this.nextjsFileSystem.accessPoint,\n      containerMountPathForEfs: this.nextjsBuild.containerMountPathForEfs,\n      dockerImageAsset: this.nextjsBuild.imageForNextjsContainers,\n      fileSystem: this.nextjsFileSystem.fileSystem,\n      healthCheckPath: this.props.healthCheckPath,\n      nextjsType: this.nextjsType,\n      relativeEntrypointPath: this.nextjsBuild.relativePathToEntrypoint,\n      overrides: this.props.overrides?.nextjsContainers,\n      vpc: this.nextjsVpc.vpc,\n      ...this.props.overrides?.nextjsGlobalContainers?.nextjsContainersProps,\n    });\n  }\n  private createNextjsDistribution() {\n    return new NextjsDistribution(this, \"NextjsDistribution\", {\n      assetsBucket: this.nextjsStaticAssets.bucket,\n      basePath: this.props.basePath,\n      certificate: this.nextjsContainers.albFargateService.certificate,\n      distribution: this.props.distribution,\n      dynamicUrl: this.nextjsContainers.url,\n      nextjsType: this.nextjsType,\n      overrides: this.props.overrides?.nextjsDistribution,\n      publicDirEntries: this.nextjsBuild.publicDirEntries,\n      ...this.props.overrides?.nextjsGlobalContainers?.nextjsDistributionProps,\n    });\n  }\n  private createNextjsInvalidation() {\n    return new NextjsInvalidation(this, \"NextjsInvalidation\", {\n      distribution: this.nextjsDistribution.distribution,\n      overrides: this.props.overrides?.nextjsInvalidation,\n      ...this.props.overrides?.nextjsGlobalContainers?.nextjsInvalidationProps,\n    });\n  }\n}\n"]}