cdk-nextjs 0.4.2 → 0.4.4

package/lib/nextjs-api.js

@@ -0,0 +1,173 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NextjsApi = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_apigateway_1 = require("aws-cdk-lib/aws-apigateway");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const constructs_1 = require("constructs");
+/**
+ * Creates an API Gateway REST API for Next.js applications
+ */
+class NextjsApi extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        this.validateProps(props);
+        this.api = this.createRestApi();
+        this.baseResource = this.createBaseResource(props.basePath);
+        this.staticIntegrationRole = this.createStaticIntegrationRole();
+        this.createStaticIntegrations();
+        if (props.serverFunction) {
+            this.createDynamicIntegration(props.serverFunction);
+        }
+        else if (props.vpc) {
+            // [Future] create integration with ECS via VPC Link and ECS Service Discovery
+        }
+    }
+    validateProps(props) {
+        if (!props.serverFunction && !props.vpc) {
+            throw new Error("serverFunction or vpc must be set in NextjsApiProps");
+        }
+    }
+    createRestApi() {
+        return new aws_apigateway_1.RestApi(this, "RestApi", {
+            binaryMediaTypes: ["*/*"],
+            description: `cdk-nextjs REST API for ${aws_cdk_lib_1.Stack.of(this).stackName}`,
+            endpointTypes: [aws_apigateway_1.EndpointType.REGIONAL],
+            minCompressionSize: aws_cdk_lib_1.Size.bytes(0), // compress all responses for better perf
+            ...this.props.overrides?.restApiProps,
+        });
+    }
+    /**
+     * Create base resource path if needed. Important if `basePath` is set.
+     */
+    createBaseResource(basePath) {
+        // Create base resource path if needed
+        let baseResource = this.api.root;
+        if (basePath) {
+            const _basePath = basePath.startsWith("/")
+                ? basePath.substring(1)
+                : basePath;
+            baseResource = this.api.root.addResource(_basePath);
+        }
+        return baseResource;
+    }
+    createStaticIntegrationRole() {
+        // Create S3 integration role
+        const staticIntegrationRole = new aws_iam_1.Role(this, "StaticIntegrationRole", {
+            assumedBy: new aws_iam_1.ServicePrincipal("apigateway.amazonaws.com"),
+        });
+        staticIntegrationRole.addToPolicy(new aws_iam_1.PolicyStatement({
+            actions: ["s3:GetObject", "s3:ListBucket"],
+            resources: [
+                this.props.staticAssetsBucket.bucketArn,
+                `${this.props.staticAssetsBucket.bucketArn}/*`,
+            ],
+        }));
+        return staticIntegrationRole;
+    }
+    createStaticIntegrations() {
+        // Add static assets route (_next/static/*)
+        this.baseResource
+            .addResource("_next")
+            .addResource("static")
+            .addResource("{proxy+}")
+            .addMethod("GET", this.createS3Integration({ key: "_next/static/{key}" }), this.getStaticMethodOptions({ proxy: true }));
+        // add public directory files/directories that exist at top level but need to go to S3.
+        for (const publicDirEntry of this.props.publicDirEntries) {
+            if (publicDirEntry.isDirectory) {
+                this.baseResource
+                    .addResource(publicDirEntry.name)
+                    .addResource("{proxy+}")
+                    .addMethod("GET", this.createS3Integration({ key: `${publicDirEntry.name}/{key}` }), this.getStaticMethodOptions({ proxy: true }));
+            }
+            else {
+                this.baseResource
+                    .addResource(publicDirEntry.name)
+                    .addMethod("GET", this.createS3Integration({ key: publicDirEntry.name }), this.getStaticMethodOptions());
+            }
+        }
+    }
+    /**
+     * Maps API request to S3 request.
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-parameter-mapping-sources.html
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/integrating-api-with-aws-services-s3.html#api-items-in-folder-as-s3-objects-in-bucket
+     */
+    createS3Integration({ key }) {
+        const s3Integration = new aws_apigateway_1.AwsIntegration({
+            service: "s3",
+            integrationHttpMethod: "GET",
+            path: `${this.props.staticAssetsBucket.bucketName}/${key}`,
+            options: {
+                credentialsRole: this.staticIntegrationRole,
+                passthroughBehavior: aws_apigateway_1.PassthroughBehavior.WHEN_NO_TEMPLATES, // recommended
+                requestParameters: key.includes("{key}")
+                    ? {
+                        "integration.request.path.key": "method.request.path.proxy",
+                    }
+                    : undefined,
+                integrationResponses: [
+                    {
+                        statusCode: "200",
+                        responseParameters: {
+                            "method.response.header.Content-Type": "integration.response.header.Content-Type",
+                            "method.response.header.Content-Length": "integration.response.header.Content-Length",
+                            "method.response.header.Cache-Control": "integration.response.header.Cache-Control",
+                            "method.response.header.ETag": "integration.response.header.ETag",
+                            "method.response.header.Last-Modified": "integration.response.header.Last-Modified",
+                        },
+                    },
+                    {
+                        statusCode: "404",
+                        selectionPattern: "404",
+                    },
+                ],
+            },
+            ...this.props.overrides?.staticIntegrationProps,
+        });
+        return s3Integration;
+    }
+    getStaticMethodOptions({ proxy } = { proxy: false }) {
+        return {
+            requestParameters: proxy
+                ? {
+                    "method.request.path.proxy": true,
+                }
+                : undefined,
+            methodResponses: [
+                {
+                    statusCode: "200",
+                    responseParameters: {
+                        "method.response.header.Content-Type": true,
+                        "method.response.header.Content-Length": true,
+                        "method.response.header.Cache-Control": true,
+                        "method.response.header.ETag": true,
+                        "method.response.header.Last-Modified": true,
+                    },
+                },
+                {
+                    statusCode: "404",
+                },
+            ],
+            ...this.props.overrides?.s3MethodOptions,
+        };
+    }
+    /**
+     * Create Lambda Proxy integration for all other routes
+     */
+    createDynamicIntegration(serverFunction) {
+        const lambdaIntegration = new aws_apigateway_1.LambdaIntegration(serverFunction, {
+            ...this.props.overrides?.dynamicIntegrationProps,
+        });
+        // Add catch-all route for server-side rendering
+        this.baseResource.addMethod("ANY", lambdaIntegration);
+        const proxyResource = this.baseResource.addResource("{proxy+}");
+        proxyResource.addMethod("ANY", lambdaIntegration);
+    }
+}
+exports.NextjsApi = NextjsApi;
+_a = JSII_RTTI_SYMBOL_1;
+NextjsApi[_a] = { fqn: "cdk-nextjs.NextjsApi", version: "0.4.4" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-api.js","sourceRoot":"","sources":["../src/nextjs-api.ts"],"names":[],"mappings":"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","sourcesContent":["import { Size, Stack } from \"aws-cdk-lib\";\nimport {\n  RestApi,\n  LambdaIntegration,\n  AwsIntegration,\n  MethodOptions,\n  IResource,\n  EndpointType,\n  RestApiProps,\n  AwsIntegrationProps,\n  LambdaIntegrationOptions,\n  PassthroughBehavior,\n} from \"aws-cdk-lib/aws-apigateway\";\nimport { IVpc } from \"aws-cdk-lib/aws-ec2\";\nimport {\n  Role,\n  ServicePrincipal,\n  PolicyStatement,\n  IRole,\n} from \"aws-cdk-lib/aws-iam\";\nimport { IFunction } from \"aws-cdk-lib/aws-lambda\";\nimport { IBucket } from \"aws-cdk-lib/aws-s3\";\nimport { Construct } from \"constructs\";\nimport { PublicDirEntry } from \"./nextjs-build/nextjs-build\";\n\nexport interface NextjsApiOverrides {\n  readonly restApiProps?: RestApiProps;\n  readonly staticIntegrationProps?: AwsIntegrationProps;\n  readonly s3MethodOptions?: MethodOptions;\n  readonly dynamicIntegrationProps?: LambdaIntegrationOptions;\n}\n\nexport interface NextjsApiProps {\n  /**\n   * Optional base path for the application\n   */\n  readonly basePath?: string;\n  /**\n   * Override props for every construct.\n   */\n  readonly overrides?: NextjsApiOverrides;\n  /**\n   * Path to directory of Next.js app's public directory. Used to add resources\n   * to API Gateway REST API for public directory to go directly to S3.\n   */\n  readonly publicDirEntries: PublicDirEntry[];\n  /**\n   * Required if `NextjsRegionalFunctions`. The Lambda function for server-side rendering\n   */\n  readonly serverFunction?: IFunction;\n  /**\n   * The S3 bucket containing static assets\n   */\n  readonly staticAssetsBucket: IBucket;\n  /**\n   * [Future] Required if `NextjsRegionalContainers`. VPC to create VPC Link and ECS Service Discovery\n   */\n  readonly vpc?: IVpc;\n}\n\n/**\n * Creates an API Gateway REST API for Next.js applications\n */\nexport class NextjsApi extends Construct {\n  /**\n   * The API Gateway REST API\n   */\n  public readonly api: RestApi;\n\n  private readonly baseResource: IResource;\n  private readonly props: NextjsApiProps;\n  private staticIntegrationRole: IRole;\n\n  constructor(scope: Construct, id: string, props: NextjsApiProps) {\n    super(scope, id);\n    this.props = props;\n\n    this.validateProps(props);\n    this.api = this.createRestApi();\n    this.baseResource = this.createBaseResource(props.basePath);\n    this.staticIntegrationRole = this.createStaticIntegrationRole();\n    this.createStaticIntegrations();\n    if (props.serverFunction) {\n      this.createDynamicIntegration(props.serverFunction);\n    } else if (props.vpc) {\n      // [Future] create integration with ECS via VPC Link and ECS Service Discovery\n    }\n  }\n\n  private validateProps(props: NextjsApiProps) {\n    if (!props.serverFunction && !props.vpc) {\n      throw new Error(\"serverFunction or vpc must be set in NextjsApiProps\");\n    }\n  }\n\n  private createRestApi(): RestApi {\n    return new RestApi(this, \"RestApi\", {\n      binaryMediaTypes: [\"*/*\"],\n      description: `cdk-nextjs REST API for ${Stack.of(this).stackName}`,\n      endpointTypes: [EndpointType.REGIONAL],\n      minCompressionSize: Size.bytes(0), // compress all responses for better perf\n      ...this.props.overrides?.restApiProps,\n    });\n  }\n\n  /**\n   * Create base resource path if needed. Important if `basePath` is set.\n   */\n  private createBaseResource(basePath?: string): IResource {\n    // Create base resource path if needed\n    let baseResource = this.api.root;\n    if (basePath) {\n      const _basePath = basePath.startsWith(\"/\")\n        ? basePath.substring(1)\n        : basePath;\n\n      baseResource = this.api.root.addResource(_basePath);\n    }\n    return baseResource;\n  }\n\n  private createStaticIntegrationRole() {\n    // Create S3 integration role\n    const staticIntegrationRole = new Role(this, \"StaticIntegrationRole\", {\n      assumedBy: new ServicePrincipal(\"apigateway.amazonaws.com\"),\n    });\n\n    staticIntegrationRole.addToPolicy(\n      new PolicyStatement({\n        actions: [\"s3:GetObject\", \"s3:ListBucket\"],\n        resources: [\n          this.props.staticAssetsBucket.bucketArn,\n          `${this.props.staticAssetsBucket.bucketArn}/*`,\n        ],\n      }),\n    );\n    return staticIntegrationRole;\n  }\n\n  private createStaticIntegrations() {\n    // Add static assets route (_next/static/*)\n    this.baseResource\n      .addResource(\"_next\")\n      .addResource(\"static\")\n      .addResource(\"{proxy+}\")\n      .addMethod(\n        \"GET\",\n        this.createS3Integration({ key: \"_next/static/{key}\" }),\n        this.getStaticMethodOptions({ proxy: true }),\n      );\n    // add public directory files/directories that exist at top level but need to go to S3.\n    for (const publicDirEntry of this.props.publicDirEntries) {\n      if (publicDirEntry.isDirectory) {\n        this.baseResource\n          .addResource(publicDirEntry.name)\n          .addResource(\"{proxy+}\")\n          .addMethod(\n            \"GET\",\n            this.createS3Integration({ key: `${publicDirEntry.name}/{key}` }),\n            this.getStaticMethodOptions({ proxy: true }),\n          );\n      } else {\n        this.baseResource\n          .addResource(publicDirEntry.name)\n          .addMethod(\n            \"GET\",\n            this.createS3Integration({ key: publicDirEntry.name }),\n            this.getStaticMethodOptions(),\n          );\n      }\n    }\n  }\n\n  /**\n   * Maps API request to S3 request.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-parameter-mapping-sources.html\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/integrating-api-with-aws-services-s3.html#api-items-in-folder-as-s3-objects-in-bucket\n   */\n  private createS3Integration({ key }: { key: string }) {\n    const s3Integration = new AwsIntegration({\n      service: \"s3\",\n      integrationHttpMethod: \"GET\",\n      path: `${this.props.staticAssetsBucket.bucketName}/${key}`,\n      options: {\n        credentialsRole: this.staticIntegrationRole,\n        passthroughBehavior: PassthroughBehavior.WHEN_NO_TEMPLATES, // recommended\n        requestParameters: key.includes(\"{key}\")\n          ? {\n              \"integration.request.path.key\": \"method.request.path.proxy\",\n            }\n          : undefined,\n        integrationResponses: [\n          {\n            statusCode: \"200\",\n            responseParameters: {\n              \"method.response.header.Content-Type\":\n                \"integration.response.header.Content-Type\",\n              \"method.response.header.Content-Length\":\n                \"integration.response.header.Content-Length\",\n              \"method.response.header.Cache-Control\":\n                \"integration.response.header.Cache-Control\",\n              \"method.response.header.ETag\": \"integration.response.header.ETag\",\n              \"method.response.header.Last-Modified\":\n                \"integration.response.header.Last-Modified\",\n            },\n          },\n          {\n            statusCode: \"404\",\n            selectionPattern: \"404\",\n          },\n        ],\n      },\n      ...this.props.overrides?.staticIntegrationProps,\n    });\n    return s3Integration;\n  }\n\n  private getStaticMethodOptions({ proxy } = { proxy: false }): MethodOptions {\n    return {\n      requestParameters: proxy\n        ? {\n            \"method.request.path.proxy\": true,\n          }\n        : undefined,\n      methodResponses: [\n        {\n          statusCode: \"200\",\n          responseParameters: {\n            \"method.response.header.Content-Type\": true,\n            \"method.response.header.Content-Length\": true,\n            \"method.response.header.Cache-Control\": true,\n            \"method.response.header.ETag\": true,\n            \"method.response.header.Last-Modified\": true,\n          },\n        },\n        {\n          statusCode: \"404\",\n        },\n      ],\n      ...this.props.overrides?.s3MethodOptions,\n    };\n  }\n\n  /**\n   * Create Lambda Proxy integration for all other routes\n   */\n  private createDynamicIntegration(serverFunction: IFunction) {\n    const lambdaIntegration = new LambdaIntegration(serverFunction, {\n      ...this.props.overrides?.dynamicIntegrationProps,\n    });\n    // Add catch-all route for server-side rendering\n    this.baseResource.addMethod(\"ANY\", lambdaIntegration);\n    const proxyResource = this.baseResource.addResource(\"{proxy+}\");\n    proxyResource.addMethod(\"ANY\", lambdaIntegration);\n  }\n}\n"]}

package/lib/nextjs-assets-deployment.js

@@ -104,5 +104,5 @@ class NextjsAssetsDeployment extends constructs_1.Construct {
 }
 exports.NextjsAssetsDeployment = NextjsAssetsDeployment;
 _a = JSII_RTTI_SYMBOL_1;
-NextjsAssetsDeployment[_a] = { fqn: "cdk-nextjs.NextjsAssetsDeployment", version: "0.4.2" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-assets-deployment.js","sourceRoot":"","sources":["../src/nextjs-assets-deployment.ts"],"names":[],"mappings":"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","sourcesContent":["import { join } from \"path/posix\";\nimport { CustomResource, Duration } from \"aws-cdk-lib\";\nimport { IVpc } from \"aws-cdk-lib/aws-ec2\";\nimport { AccessPoint } from \"aws-cdk-lib/aws-efs\";\nimport {\n  DockerImageCode,\n  DockerImageFunction,\n  FileSystem,\n} from \"aws-cdk-lib/aws-lambda\";\nimport { Bucket } from \"aws-cdk-lib/aws-s3\";\nimport { Construct } from \"constructs\";\nimport {\n  DATA_CACHE_PATH,\n  FULL_ROUTE_CACHE_PATH,\n  IMAGE_CACHE_PATH,\n  MOUNT_PATH,\n  NextjsType,\n  PUBLIC_PATH,\n  STATIC_PATH,\n} from \"./constants\";\nimport { OptionalCustomResourceProps } from \"./generated-structs/OptionalCustomResourceProps\";\nimport { OptionalDockerImageFunctionProps } from \"./generated-structs/OptionalDockerImageFunctionProps\";\nimport { NextjsBuild } from \"./nextjs-build/nextjs-build\";\nimport { NextjsBaseProps } from \"./root-constructs/nextjs-base-props\";\nimport { getLambdaArchitecture } from \"./utils/get-architecture\";\n\nexport interface NextjsAssetDeploymentOverrides {\n  /**\n   * Props that define the custom resource\n   */\n  readonly customResourceProps?: OptionalCustomResourceProps;\n  // NOTE: we don't offer overriding `customResourceProperties` since jsii doesn't support union types\n  // readonly customResourceProperties?: OptionalStaticAssetsCustomResourceProperties\n  readonly dockerImageFunctionProps?: OptionalDockerImageFunctionProps;\n}\n\nexport interface NextjsAssetsDeploymentProps {\n  readonly accessPoint: AccessPoint;\n  /**\n   * Prefix to the URI path the app will be served at.\n   * @example \"/my-base-path\"\n   */\n  readonly basePath?: string;\n  readonly buildId: string;\n  /**\n   * @see {@link NextjsBuild.buildImageDigest}\n   */\n  readonly buildImageDigest: string;\n  /**\n   * If true, logs details in custom resource lambda\n   * @default true\n   */\n  readonly debug?: boolean;\n  readonly dockerImageCode: DockerImageCode; // TODO: remove and build from common builder base?\n  readonly nextjsType: NextjsType;\n  readonly overrides?: NextjsAssetDeploymentOverrides;\n  /**\n   * @see {@link NextjsBaseProps.relativePathToPackage}\n   */\n  readonly relativePathToPackage?: string;\n  /**\n   * Required for `NextjsType.GlobalFunctions` and `NextjsType.GlobalContainers`\n   */\n  readonly staticAssetsBucket?: Bucket;\n  readonly vpc: IVpc;\n}\n\n/**\n * @internal\n */\nexport interface FsToS3Action {\n  type: \"fs-to-s3\";\n  destinationBucketName: string;\n  destinationKeyPrefix?: string;\n  sourcePath: string;\n}\n/**\n * @internal\n */\nexport interface FsToFsAction {\n  type: \"fs-to-fs\";\n  sourcePath: string;\n  destinationPath: string;\n  includeExtensions?: string[];\n}\n\n/**\n * @internal\n */\nexport interface StaticAssetsCustomResourceProperties {\n  actions: (FsToS3Action | FsToFsAction)[];\n  buildId: string;\n  /**\n   * @see {@link NextjsBuild.buildImageDigest}\n   */\n  buildImageDigest: string;\n  imageCachePath: string;\n  nextjsType: NextjsType;\n}\n\n/**\n * Deploys static assets to S3 and cache assets to EFS in Lambda Custom Resource.\n */\nexport class NextjsAssetsDeployment extends Construct {\n  customResource: CustomResource;\n  dockerImageFunction: DockerImageFunction;\n\n  private props: NextjsAssetsDeploymentProps;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: NextjsAssetsDeploymentProps,\n  ) {\n    super(scope, id);\n    this.props = props;\n    this.dockerImageFunction = this.createFunction();\n    this.customResource = this.createCustomResource();\n  }\n\n  private createFunction() {\n    const fn = new DockerImageFunction(this, \"Fn\", {\n      architecture: getLambdaArchitecture(),\n      code: this.props.dockerImageCode,\n      memorySize: 2048,\n      filesystem: FileSystem.fromEfsAccessPoint(\n        this.props.accessPoint,\n        MOUNT_PATH,\n      ),\n      vpc: this.props.vpc,\n      timeout: Duration.minutes(5),\n      ...this.props.overrides?.dockerImageFunctionProps,\n    });\n    if (this.props.debug !== false) {\n      fn.addEnvironment(\"DEBUG\", \"1\");\n    }\n    if (this.props.staticAssetsBucket) {\n      this.props.staticAssetsBucket.grantReadWrite(fn);\n    }\n    return fn;\n  }\n\n  private createCustomResource() {\n    const root = \"/app\";\n    const actions: StaticAssetsCustomResourceProperties[\"actions\"] = [];\n    if (this.props.staticAssetsBucket?.bucketName) {\n      // Prepare the destination key prefix with basePath when available\n      const staticKeyPrefix = this.props.basePath\n        ? `${this.props.basePath.replace(/^\\//, \"\")}/_next/static`\n        : \"_next/static\";\n\n      actions.push(\n        // static files\n        {\n          type: \"fs-to-s3\",\n          sourcePath: join(root, STATIC_PATH),\n          destinationBucketName: this.props.staticAssetsBucket.bucketName,\n          destinationKeyPrefix: staticKeyPrefix,\n        },\n        // public directory to s3 for CloudFront -> S3\n        {\n          type: \"fs-to-s3\",\n          sourcePath: join(root, PUBLIC_PATH),\n          destinationBucketName: this.props.staticAssetsBucket.bucketName,\n        },\n      );\n    }\n    actions.push(\n      // full route cache - https://nextjs.org/docs/app/building-your-application/caching#full-route-cache\n      {\n        type: \"fs-to-fs\",\n        sourcePath: join(\n          root,\n          \".next\",\n          \"standalone\",\n          this.props.relativePathToPackage || \"\",\n          FULL_ROUTE_CACHE_PATH,\n        ),\n        destinationPath: join(\n          MOUNT_PATH,\n          this.props.buildId,\n          FULL_ROUTE_CACHE_PATH,\n        ),\n        // only files with these extensions are needed in EFS FileSystem cache\n        // since these files are the only ones updated by Next.js during runtime.\n        // other files like .js and .nft.json files are static per deployment\n        includeExtensions: [\"body\", \"html\", \"rsc\", \"meta\"],\n      },\n      // after `next build` data cache https://nextjs.org/docs/app/building-your-application/caching#data-cache\n      // exists at top level .next/cache so we need to copy into relativePathToPackage\n      // normalized path\n      {\n        type: \"fs-to-fs\",\n        sourcePath: join(root, DATA_CACHE_PATH),\n        destinationPath: join(MOUNT_PATH, this.props.buildId, DATA_CACHE_PATH),\n      },\n      // public directory to EFS for needed optimizing images in public directory\n      // we don't load these into compute to save on image size\n      {\n        type: \"fs-to-fs\",\n        sourcePath: join(root, PUBLIC_PATH),\n        destinationPath: join(MOUNT_PATH, this.props.buildId, PUBLIC_PATH),\n      },\n      // images are optimized at runtime so nothing to deploy\n    );\n    const properties: StaticAssetsCustomResourceProperties = {\n      actions,\n      buildId: this.props.buildId,\n      // ensures this CR runs each time new builder image\n      buildImageDigest: this.props.buildImageDigest,\n      imageCachePath: join(MOUNT_PATH, this.props.buildId, IMAGE_CACHE_PATH),\n      nextjsType: this.props.nextjsType,\n    };\n    return new CustomResource(this, \"CustomResource\", {\n      properties,\n      resourceType: \"Custom::NextjsAssetsDeployment\",\n      serviceToken: this.dockerImageFunction.functionArn,\n      ...this.props.overrides?.customResourceProps,\n    });\n  }\n}\n"]}
+NextjsAssetsDeployment[_a] = { fqn: "cdk-nextjs.NextjsAssetsDeployment", version: "0.4.4" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-assets-deployment.js","sourceRoot":"","sources":["../src/nextjs-assets-deployment.ts"],"names":[],"mappings":"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","sourcesContent":["import { join } from \"path/posix\";\nimport { CustomResource, Duration } from \"aws-cdk-lib\";\nimport { IVpc } from \"aws-cdk-lib/aws-ec2\";\nimport { AccessPoint } from \"aws-cdk-lib/aws-efs\";\nimport {\n  DockerImageCode,\n  DockerImageFunction,\n  FileSystem,\n} from \"aws-cdk-lib/aws-lambda\";\nimport { Bucket } from \"aws-cdk-lib/aws-s3\";\nimport { Construct } from \"constructs\";\nimport {\n  DATA_CACHE_PATH,\n  FULL_ROUTE_CACHE_PATH,\n  IMAGE_CACHE_PATH,\n  MOUNT_PATH,\n  NextjsType,\n  PUBLIC_PATH,\n  STATIC_PATH,\n} from \"./constants\";\nimport { OptionalCustomResourceProps } from \"./generated-structs/OptionalCustomResourceProps\";\nimport { OptionalDockerImageFunctionProps } from \"./generated-structs/OptionalDockerImageFunctionProps\";\nimport { NextjsBuild } from \"./nextjs-build/nextjs-build\";\nimport { NextjsBaseProps } from \"./root-constructs/nextjs-base-construct\";\nimport { getLambdaArchitecture } from \"./utils/get-architecture\";\n\nexport interface NextjsAssetDeploymentOverrides {\n  /**\n   * Props that define the custom resource\n   */\n  readonly customResourceProps?: OptionalCustomResourceProps;\n  // NOTE: we don't offer overriding `customResourceProperties` since jsii doesn't support union types\n  // readonly customResourceProperties?: OptionalStaticAssetsCustomResourceProperties\n  readonly dockerImageFunctionProps?: OptionalDockerImageFunctionProps;\n}\n\nexport interface NextjsAssetsDeploymentProps {\n  readonly accessPoint: AccessPoint;\n  /**\n   * Prefix to the URI path the app will be served at.\n   * @example \"/my-base-path\"\n   */\n  readonly basePath?: string;\n  readonly buildId: string;\n  /**\n   * @see {@link NextjsBuild.buildImageDigest}\n   */\n  readonly buildImageDigest: string;\n  /**\n   * If true, logs details in custom resource lambda\n   * @default true\n   */\n  readonly debug?: boolean;\n  readonly dockerImageCode: DockerImageCode; // TODO: remove and build from common builder base?\n  readonly nextjsType: NextjsType;\n  readonly overrides?: NextjsAssetDeploymentOverrides;\n  /**\n   * @see {@link NextjsBaseProps.relativePathToPackage}\n   */\n  readonly relativePathToPackage?: string;\n  /**\n   * Required for `NextjsType.GlobalFunctions` and `NextjsType.GlobalContainers`\n   */\n  readonly staticAssetsBucket?: Bucket;\n  readonly vpc: IVpc;\n}\n\n/**\n * @internal\n */\nexport interface FsToS3Action {\n  type: \"fs-to-s3\";\n  destinationBucketName: string;\n  destinationKeyPrefix?: string;\n  sourcePath: string;\n}\n/**\n * @internal\n */\nexport interface FsToFsAction {\n  type: \"fs-to-fs\";\n  sourcePath: string;\n  destinationPath: string;\n  includeExtensions?: string[];\n}\n\n/**\n * @internal\n */\nexport interface StaticAssetsCustomResourceProperties {\n  actions: (FsToS3Action | FsToFsAction)[];\n  buildId: string;\n  /**\n   * @see {@link NextjsBuild.buildImageDigest}\n   */\n  buildImageDigest: string;\n  imageCachePath: string;\n  nextjsType: NextjsType;\n}\n\n/**\n * Deploys static assets to S3 and cache assets to EFS in Lambda Custom Resource.\n */\nexport class NextjsAssetsDeployment extends Construct {\n  customResource: CustomResource;\n  dockerImageFunction: DockerImageFunction;\n\n  private props: NextjsAssetsDeploymentProps;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: NextjsAssetsDeploymentProps,\n  ) {\n    super(scope, id);\n    this.props = props;\n    this.dockerImageFunction = this.createFunction();\n    this.customResource = this.createCustomResource();\n  }\n\n  private createFunction() {\n    const fn = new DockerImageFunction(this, \"Fn\", {\n      architecture: getLambdaArchitecture(),\n      code: this.props.dockerImageCode,\n      memorySize: 2048,\n      filesystem: FileSystem.fromEfsAccessPoint(\n        this.props.accessPoint,\n        MOUNT_PATH,\n      ),\n      vpc: this.props.vpc,\n      timeout: Duration.minutes(5),\n      ...this.props.overrides?.dockerImageFunctionProps,\n    });\n    if (this.props.debug !== false) {\n      fn.addEnvironment(\"DEBUG\", \"1\");\n    }\n    if (this.props.staticAssetsBucket) {\n      this.props.staticAssetsBucket.grantReadWrite(fn);\n    }\n    return fn;\n  }\n\n  private createCustomResource() {\n    const root = \"/app\";\n    const actions: StaticAssetsCustomResourceProperties[\"actions\"] = [];\n    if (this.props.staticAssetsBucket?.bucketName) {\n      // Prepare the destination key prefix with basePath when available\n      const staticKeyPrefix = this.props.basePath\n        ? `${this.props.basePath.replace(/^\\//, \"\")}/_next/static`\n        : \"_next/static\";\n\n      actions.push(\n        // static files\n        {\n          type: \"fs-to-s3\",\n          sourcePath: join(root, STATIC_PATH),\n          destinationBucketName: this.props.staticAssetsBucket.bucketName,\n          destinationKeyPrefix: staticKeyPrefix,\n        },\n        // public directory to s3 for CloudFront -> S3\n        {\n          type: \"fs-to-s3\",\n          sourcePath: join(root, PUBLIC_PATH),\n          destinationBucketName: this.props.staticAssetsBucket.bucketName,\n        },\n      );\n    }\n    actions.push(\n      // full route cache - https://nextjs.org/docs/app/building-your-application/caching#full-route-cache\n      {\n        type: \"fs-to-fs\",\n        sourcePath: join(\n          root,\n          \".next\",\n          \"standalone\",\n          this.props.relativePathToPackage || \"\",\n          FULL_ROUTE_CACHE_PATH,\n        ),\n        destinationPath: join(\n          MOUNT_PATH,\n          this.props.buildId,\n          FULL_ROUTE_CACHE_PATH,\n        ),\n        // only files with these extensions are needed in EFS FileSystem cache\n        // since these files are the only ones updated by Next.js during runtime.\n        // other files like .js and .nft.json files are static per deployment\n        includeExtensions: [\"body\", \"html\", \"rsc\", \"meta\"],\n      },\n      // after `next build` data cache https://nextjs.org/docs/app/building-your-application/caching#data-cache\n      // exists at top level .next/cache so we need to copy into relativePathToPackage\n      // normalized path\n      {\n        type: \"fs-to-fs\",\n        sourcePath: join(root, DATA_CACHE_PATH),\n        destinationPath: join(MOUNT_PATH, this.props.buildId, DATA_CACHE_PATH),\n      },\n      // public directory to EFS for needed optimizing images in public directory\n      // we don't load these into compute to save on image size\n      {\n        type: \"fs-to-fs\",\n        sourcePath: join(root, PUBLIC_PATH),\n        destinationPath: join(MOUNT_PATH, this.props.buildId, PUBLIC_PATH),\n      },\n      // images are optimized at runtime so nothing to deploy\n    );\n    const properties: StaticAssetsCustomResourceProperties = {\n      actions,\n      buildId: this.props.buildId,\n      // ensures this CR runs each time new builder image\n      buildImageDigest: this.props.buildImageDigest,\n      imageCachePath: join(MOUNT_PATH, this.props.buildId, IMAGE_CACHE_PATH),\n      nextjsType: this.props.nextjsType,\n    };\n    return new CustomResource(this, \"CustomResource\", {\n      properties,\n      resourceType: \"Custom::NextjsAssetsDeployment\",\n      serviceToken: this.dockerImageFunction.functionArn,\n      ...this.props.overrides?.customResourceProps,\n    });\n  }\n}\n"]}

package/lib/nextjs-build/nextjs-build.d.ts

@@ -3,7 +3,7 @@ import { AssetImageCodeProps, DockerImageCode } from "aws-cdk-lib/aws-lambda";
 import { Construct } from "constructs";
 import { NextjsType } from "../constants";
 import { OptionalDockerImageAssetProps } from "../generated-structs/OptionalDockerImageAssetProps";
-import { NextjsBaseProps } from "../root-constructs/nextjs-base-props";
+import { NextjsBaseProps } from "../root-constructs/nextjs-base-construct";
 export interface BuilderImageProps {
     /**
      * Build Args to be passed to `docker build` command.

package/lib/nextjs-build/nextjs-build.js

@@ -234,5 +234,5 @@ class NextjsBuild extends constructs_1.Construct {
 }
 exports.NextjsBuild = NextjsBuild;
 _a = JSII_RTTI_SYMBOL_1;
-NextjsBuild[_a] = { fqn: "cdk-nextjs.NextjsBuild", version: "0.4.2" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-build.js","sourceRoot":"","sources":["../../src/nextjs-build/nextjs-build.ts"],"names":[],"mappings":";;;;;AAAA,2DAA8C;AAC9C,qCAAsE;AACtE,yCAA2C;AAC3C,2CAAoD;AACpD,6CAAyC;AACzC,+DAAwE;AACxE,uDAA8E;AAC9E,2CAAuC;AACvC,4CAgBsB;AA4GtB;;;GAGG;AACH,MAAa,WAAY,SAAQ,sBAAS;IAoDxC,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAuB;QAC/D,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAVnB;;WAEG;QACK,qBAAgB,GAAG,oBAAoB,CAAC;QAExC,qBAAgB,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,QAAQ,CAAC;QAM5D,IAAI,CAAC,iBAAiB,GAAG,GAAG,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC;QAChF,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC,qBAAqB,IAAI,GAAG,CAAC;QAChE,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC,yBAAyB,EAAE,CAAC;QACjE,IAAI,CAAC,KAAK,CAAC,iBAAiB,EAAE,SAAS,EAAE,CAAC;YACxC,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC5B,CAAC;QACD,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;QACrD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QACjC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QACnD,IACE,KAAK,CAAC,UAAU,KAAK,sBAAU,CAAC,iBAAiB;YACjD,KAAK,CAAC,UAAU,KAAK,sBAAU,CAAC,mBAAmB,EACnD,CAAC;YACD,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC,8BAA8B,EAAE,CAAC;QACxE,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC,6BAA6B,EAAE,CAAC;QACtE,CAAC;QACD,IAAI,CAAC,8BAA8B;YACjC,IAAI,CAAC,oCAAoC,EAAE,CAAC;IAChD,CAAC;IAEO,yBAAyB;QAC/B,qDAAqD;QACrD,OAAO,IAAA,YAAS,EAAC,IAAI,CAAC,KAAK,CAAC,qBAAqB,IAAI,EAAE,EAAE,WAAW,CAAC,CAAC;IACxE,CAAC;IACD;;;;;OAKG;IACK,kBAAkB;QACxB,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,IAAI,eAAe,CAAC;QAChE,MAAM,EACJ,SAAS,GAAG;YACV,aAAa,EAAE,YAAY;YAC3B,wBAAwB,EAAE,IAAI,CAAC,qBAAqB;YACpD,GAAG,IAAI,CAAC,KAAK,CAAC,iBAAiB,EAAE,SAAS;SAC3C,EACD,WAAW,GAAG,EAAE,EAChB,OAAO,GAAG;YACR,iBAAiB;YACjB,MAAM;YACN,YAAY;YACZ,UAAU;YACV,YAAY;YACZ,MAAM;SACP,EACD,IAAI,GAAG,oBAAoB,EAC3B,QAAQ,GACT,GAAG,IAAI,CAAC,KAAK,CAAC,iBAAiB,IAAI,EAAE,CAAC;QAEvC,2EAA2E;QAC3E,MAAM,eAAe,GAAa;YAChC,IAAA,gBAAI,EAAC,SAAS,EAAE,8BAA8B,CAAC;SAChD,CAAC;QACF,8EAA8E;QAC9E,MAAM,iBAAiB,GAAa;YAClC,IAAA,gBAAI,EAAC,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,8BAA8B,CAAC;SAC9D,CAAC;QAEF,6GAA6G;QAC7G,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,iBAAiB,EAAE,IAAI,EAAE,CAAC;YACxC,eAAe,CAAC,IAAI,CAAC,IAAA,gBAAI,EAAC,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC;YAC5C,iBAAiB,CAAC,IAAI,CAAC,IAAA,gBAAI,EAAC,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC,CAAC;YAC5D,MAAM,cAAc,GAAG,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YAC3C,MAAM,oBAAoB,GAAG,IAAA,gBAAI,EAC/B,IAAI,CAAC,KAAK,CAAC,YAAY,EACvB,eAAe,CAChB,CAAC;YACF,IAAA,uBAAa,EAAC,oBAAoB,EAAE,cAAc,CAAC,CAAC;YACpD,iBAAiB,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QAC/C,CAAC;QAED,KAAK,MAAM,cAAc,IAAI,eAAe,EAAE,CAAC;YAC7C,IAAA,gBAAM,EACJ,cAAc,EACd,IAAA,gBAAI,EAAC,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,IAAA,oBAAQ,EAAC,cAAc,CAAC,CAAC,CACxD,CAAC;QACJ,CAAC;QAED,MAAM,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QACvD,IAAI,CAAC,8BAA8B,CACjC,IAAA,gBAAI,EAAC,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,IAAI,CAAC,EACnC,WAAW,CACZ,CAAC;QACF,MAAM,OAAO,GACX,IAAI,CAAC,KAAK,CAAC,iBAAiB,EAAE,OAAO;YACrC,GAAG,IAAI,CAAC,gBAAgB,UAAU,QAAQ,CAAC,CAAC,CAAC,cAAc,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,WAAW,IAAI,UAAU,IAAI,CAAC,iBAAiB,IAAI,YAAY,IAAI,CAAC;QACzJ,IAAI,KAAc,CAAC;QACnB,IAAI,CAAC;YACH,OAAO,CAAC,GAAG,CACT,gCAAgC,OAAO,kBAAkB,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CACnF,CAAC;YACF,IAAA,6BAAQ,EAAC,OAAO,EAAE;gBAChB,KAAK,EAAE,SAAS;gBAChB,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,YAAY;gBAC5B,GAAG,EAAE,OAAO,CAAC,GAAG;aACjB,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,KAAK,GAAG,GAAG,CAAC;QACd,CAAC;gBAAS,CAAC;YACT,KAAK,MAAM,gBAAgB,IAAI,iBAAiB,EAAE,CAAC;gBACjD,IAAA,gBAAM,EAAC,gBAAgB,CAAC,CAAC;YAC3B,CAAC;QACH,CAAC;QACD,IAAI,KAAK;YAAE,MAAM,KAAK,CAAC;IACzB,CAAC;IACO,8BAA8B,CACpC,qBAA6B,EAC7B,WAAqB;QAErB,MAAM,OAAO,GAA2B,EAAE,CAAC;QAC3C,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE,CAAC;YACrC,IAAI,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;gBAC5B,OAAO,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;YAChD,CAAC;QACH,CAAC;QACD,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC;aACpC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,IAAI,KAAK,EAAE,CAAC;aAC1C,IAAI,CAAC,GAAG,CAAC,CAAC;QACb,MAAM,OAAO,GAAG,IAAA,sBAAY,EAAC,qBAAqB,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC/D,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,4CAAgC,EAAE,OAAO,CAAC,CAAC;QAC3E,IAAA,uBAAa,EAAC,qBAAqB,EAAE,OAAO,CAAC,CAAC;IAChD,CAAC;IACO,iBAAiB,CACvB,SAAmD;QAEnD,OAAO,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;YAC5D,OAAO,GAAG,GAAG,gBAAgB,GAAG,KAAK,KAAK,GAAG,CAAC;QAChD,CAAC,EAAE,EAAE,CAAC,CAAC;IACT,CAAC;IACO,qBAAqB;QAC3B,MAAM,MAAM,GAAG,IAAA,6BAAQ,EACrB,GAAG,IAAI,CAAC,gBAAgB,8BAA8B,IAAI,CAAC,iBAAiB,EAAE,EAC9E,EAAE,QAAQ,EAAE,OAAO,EAAE,CACtB,CAAC;QACF,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,qBAAqB;IACnD,CAAC;IACO,mBAAmB;QACzB,MAAM,aAAa,GAAG,IAAA,YAAS,EAC7B,MAAM,EACN,IAAI,CAAC,KAAK,CAAC,qBAAqB,IAAI,EAAE,EACtC,QAAQ,CACT,CAAC;QACF,MAAM,sBAAsB,GAAG,IAAA,6BAAQ,EACrC,GAAG,IAAI,CAAC,gBAAgB,QAAQ,IAAI,CAAC,iBAAiB,wDAAwD,aAAa,4FAA4F,EACvN,EAAE,QAAQ,EAAE,OAAO,EAAE,CACtB,CAAC;QACF,OAAO,IAAI,CAAC,KAAK,CAAC,sBAAsB,CAAqB,CAAC;IAChE,CAAC;IACO,UAAU;QAChB,MAAM,WAAW,GAAG,IAAA,YAAS,EAC3B,MAAM,EACN,IAAI,CAAC,KAAK,CAAC,qBAAqB,IAAI,EAAE,EACtC,OAAO,EACP,UAAU,CACX,CAAC;QACF,MAAM,OAAO,GAAG,IAAA,6BAAQ,EACtB,GAAG,IAAI,CAAC,gBAAgB,QAAQ,IAAI,CAAC,iBAAiB,oBAAoB,WAAW,GAAG,EACxF,EAAE,QAAQ,EAAE,OAAO,EAAE,CACtB,CAAC;QACF,OAAO,OAAO,CAAC;IACjB,CAAC;IACO,8BAA8B;QACpC,MAAM,oBAAoB,GACxB,IAAI,CAAC,KAAK,CAAC,UAAU,KAAK,sBAAU,CAAC,iBAAiB;YACpD,CAAC,CAAC,QAAQ;YACV,CAAC,CAAC,UAAU,CAAC;QACjB,MAAM,cAAc,GAAG,GAAG,oBAAoB,wBAAwB,CAAC;QACvE,0EAA0E;QAC1E,yEAAyE;QACzE,uCAAuC;QACvC,MAAM,YAAY,GAChB,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,2BAA2B;YACjD,IAAA,gBAAI,EAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC;QACrD,MAAM,gBAAgB,GAAG,IAAI,iCAAgB,CAAC,IAAI,EAAE,OAAO,EAAE;YAC3D,SAAS,EAAE,YAAY;YACvB,SAAS,EAAE,IAAI,CAAC,gBAAgB,EAAE,oCAAoC;YACtE,IAAI,EAAE,cAAc;YACpB,UAAU,EAAE,wBAAU,CAAC,MAAM;YAC7B,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,qCAAqC;YAC9D,SAAS,EAAE;gBACT,CAAC,6BAAiB,CAAC,EAAE,IAAI,CAAC,OAAO;gBACjC,CAAC,wCAA4B,CAAC,EAAE,IAAI,CAAC,iBAAiB;gBACtD,CAAC,+BAAmB,CAAC,EAAE,sBAAU;gBACjC,CAAC,oCAAwB,CAAC,EAAE,2BAAe;gBAC3C,CAAC,gCAAoB,CAAC,EAAE,uBAAW;gBACnC,CAAC,qCAAyB,CAAC,EAAE,4BAAgB;gBAC7C,CAAC,+BAAmB,CAAC,EAAE,sBAAU;gBACjC,CAAC,6CAAiC,CAAC,EAAE,IAAI,CAAC,qBAAqB;gBAC/D,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,qCAAqC;oBAC5D,EAAE,SAAS;aACd;SACF,CAAC,CAAC;QACH,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAEO,6BAA6B;QACnC,MAAM,cAAc,GAAG,6BAA6B,CAAC;QACrD,0EAA0E;QAC1E,yEAAyE;QACzE,uCAAuC;QACvC,MAAM,YAAY,GAChB,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,0BAA0B;YAChD,IAAA,gBAAI,EAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC;QACrD,MAAM,eAAe,GAAG,4BAAe,CAAC,cAAc,CAAC,YAAY,EAAE;YACnE,GAAG,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,wBAAwB,CAAC;YAC5C,SAAS,EAAE,IAAI,CAAC,gBAAgB,EAAE,oCAAoC;YACtE,IAAI,EAAE,cAAc;YACpB,UAAU,EAAE,wBAAU,CAAC,MAAM;YAC7B,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,kCAAkC;YAC3D,SAAS,EAAE;gBACT,CAAC,6BAAiB,CAAC,EAAE,IAAI,CAAC,OAAO;gBACjC,CAAC,wCAA4B,CAAC,EAAE,IAAI,CAAC,iBAAiB;gBACtD,CAAC,+BAAmB,CAAC,EAAE,sBAAU;gBACjC,CAAC,oCAAwB,CAAC,EAAE,2BAAe;gBAC3C,CAAC,gCAAoB,CAAC,EAAE,uBAAW;gBACnC,CAAC,qCAAyB,CAAC,EAAE,4BAAgB;gBAC7C,CAAC,+BAAmB,CAAC,EAAE,sBAAU;gBACjC,CAAC,6CAAiC,CAAC,EAAE,IAAI,CAAC,qBAAqB;gBAC/D,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,kCAAkC,EAAE,SAAS;aACvE;SACF,CAAC,CAAC;QACH,kCAAkC;QAClC,wCAAwC;QACxC,OAAO,eAAe,CAAC;IACzB,CAAC;IAEO,oCAAoC;QAC1C,MAAM,cAAc,GAAG,8BAA8B,CAAC;QACtD;;WAEG;QACH,MAAM,YAAY,GAChB,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,iCAAiC;YACvD,IAAA,gBAAI,EACF,SAAS,EACT,IAAI,EACJ,IAAI,EACJ,QAAQ,EACR,SAAS,EACT,mBAAmB,EACnB,0BAA0B,CAC3B,CAAC;QACJ,sEAAsE;QACtE,mEAAmE;QACnE,yBAAyB;QACzB,MAAM,eAAe,GAAG,4BAAe,CAAC,cAAc,CAAC,YAAY,EAAE;YACnE,SAAS,EAAE,IAAI,CAAC,gBAAgB,EAAE,oCAAoC;YACtE,IAAI,EAAE,cAAc;YACpB,UAAU,EAAE,wBAAU,CAAC,MAAM;YAC7B,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,wCAAwC;YACjE,SAAS,EAAE;gBACT,CAAC,6BAAiB,CAAC,EAAE,IAAI,CAAC,OAAO;gBACjC,CAAC,wCAA4B,CAAC,EAAE,IAAI,CAAC,iBAAiB;gBACtD,CAAC,gCAAoB,CAAC,EAAE,uBAAW;gBACnC,CAAC,6CAAiC,CAAC,EAAE,IAAI,CAAC,qBAAqB;gBAC/D,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,wCAAwC;oBAC/D,EAAE,SAAS;aACd;SACF,CAAC,CAAC;QACH,OAAO,eAAe,CAAC;IACzB,CAAC;;AA9TH,kCA+TC","sourcesContent":["import { execSync } from \"node:child_process\";\nimport { cpSync, readFileSync, rmSync, writeFileSync } from \"node:fs\";\nimport { basename, join } from \"node:path\";\nimport { join as joinPosix } from \"node:path/posix\";\nimport { IgnoreMode } from \"aws-cdk-lib\";\nimport { DockerImageAsset, Platform } from \"aws-cdk-lib/aws-ecr-assets\";\nimport { AssetImageCodeProps, DockerImageCode } from \"aws-cdk-lib/aws-lambda\";\nimport { Construct } from \"constructs\";\nimport {\n  BUILDER_IMAGE_ALIAS_ARG_NAME,\n  MOUNT_PATH,\n  IMAGE_CACHE_PATH,\n  IMAGE_CACHE_PATH_ARG_NAME,\n  MOUNT_PATH_ARG_NAME,\n  NextjsType,\n  PUBLIC_PATH,\n  PUBLIC_PATH_ARG_NAME,\n  RELATIVE_PATH_TO_PACKAGE_ARG_NAME,\n  BUILD_ID_ARG_NAME,\n  DATA_CACHE_PATH_ARG_NAME,\n  DATA_CACHE_PATH,\n  CACHE_PATH,\n  CACHE_PATH_ARG_NAME,\n  INJECT_CDK_NEXTJS_BUILD_ENV_VARS,\n} from \"../constants\";\nimport { OptionalDockerImageAssetProps } from \"../generated-structs/OptionalDockerImageAssetProps\";\nimport { NextjsBaseProps } from \"../root-constructs/nextjs-base-props\";\n\nexport interface BuilderImageProps {\n  /**\n   * Build Args to be passed to `docker build` command.\n   */\n  readonly buildArgs?: Record<string, string>;\n  /**\n   * `docker build ...` command to run in {@link NextBaseProps.buildContext}.\n   * Default interpolates other props. If you override, other props will have\n   * no effect on command.\n   */\n  readonly command?: string;\n  /**\n   * Environment variables names to pass from host to container during build process.\n   *\n   * Note, a shell script, cdk-nextjs-load-env-vars.sh is created within the\n   * {@link NextBaseProps.buildContext} directory, which will contain all the\n   * environment variables defined in this prop. If you've created your own\n   * custom Dockerfile (passed in via {@link BuilderImageProps.customDockerfilePath})\n   * then you need to make sure you're copying it into the image.\n   *\n   * @example [\"MY_API_KEY\"]\n   */\n  readonly envVarNames?: string[];\n  /**\n   * Lines in .dockerignore file which will be created in your {@link NextBaseProps.buildContext}\n   * @default [\"node_modules\", \".git\", \".gitignore\", \".md\"]\n   */\n  readonly exclude?: string[];\n  /**\n   * Name of Dockerfile in builder build context. If specified, you are responsible\n   * for ensuring it exists in build context before construct is instantiated.\n   * @default \"builder.Dockerfile\"\n   */\n  readonly file?: string;\n  readonly platform?: Platform;\n  /**\n   * Skip building the builder image.\n   * @default false\n   */\n  readonly skipBuild?: boolean;\n}\n\nexport interface NextjsBuildOverrides {\n  readonly nextjsContainersDockerImageAssetProps?: OptionalDockerImageAssetProps;\n  readonly nextjsFunctionsAssetImageCodeProps?: AssetImageCodeProps;\n  readonly nextjsAssetDeploymentAssetImageCodeProps?: AssetImageCodeProps;\n  /**\n   * Default folder for build context is the \"lib/nextjs-build\" folder in the\n   * installed cdk-nextjs library which has the \"global-functions.Dockerfile\".\n   * Note, if you specify this then you're responsible for ensuring the dockerfile\n   * is present in the build context directory and any referenced files are\n   * present as well. You can specify dockerfile name with adjacent\n   * `nextjsFunctionsAssetImageCodeProps.file` property.\n   * @default \"cdk-nextjs/lib/nextjs-build\"\n   */\n  readonly functionsImageBuildContext?: string;\n  /**\n   * Default folder for build context is the \"lib/nextjs-build\" folder in the\n   * installed cdk-nextjs library which has the \"assets-deployment.Dockerfile\".\n   * Note, if you specify this then you're responsible for ensuring the dockerfile\n   * is present in the build context directory and any referenced files are\n   * present as well. You can specify dockerfile name with adjacent\n   * `nextjsAssetDeploymentAssetImageCodeProps.file` property.\n   * @default \"cdk-nextjs/lib/nextjs-build\"\n   */\n  readonly assetsDeploymentImageBuildContext?: string;\n  /**\n   * Default folder for build context is the \"assets/lambdas/assets-deployment/assets-deployment.lambda\" folder in the\n   * installed cdk-nextjs library which has the \"{...}-containers.Dockerfile\".\n   * Note, if you specify this then you're responsible for ensuring the dockerfile\n   * is present in the build context directory and any referenced files are\n   * present as well. You can specify dockerfile name with adjacent\n   * `nextjsContainersDockerImageAssetProps.file` property.\n   * @default \"cdk-nextjs/lib/nextjs-build\"\n   */\n  readonly containersImageBuildContext?: string;\n}\n\nexport interface NextjsBuildProps {\n  /**\n   * @see {@link NextjsBaseProps[\"buildCommand\"]}\n   */\n  readonly buildCommand: NextjsBaseProps[\"buildCommand\"];\n  /**\n   * @see {@link NextjsBaseProps[\"buildContext\"]}\n   */\n  readonly buildContext: NextjsBaseProps[\"buildContext\"];\n  /**\n   *\n   */\n  readonly builderImageProps?: BuilderImageProps;\n  /**\n   * @see {@link NextjsBaseProps.relativePathToPackage}\n   */\n  readonly relativePathToPackage?: NextjsBaseProps[\"relativePathToPackage\"];\n  readonly nextjsType: NextjsType;\n  readonly overrides?: NextjsBuildOverrides;\n}\n\nexport interface PublicDirEntry {\n  readonly name: string;\n  readonly isDirectory: boolean;\n}\n\n/**\n * Builds Next.js assets.\n * @link https://nextjs.org/docs/pages/api-reference/next-config-js/output\n */\nexport class NextjsBuild extends Construct {\n  /**\n   * Image alias of builder image Next.js app which is built for other images to be\n   * built `FROM`. This image isn't built with CDK Assets construct b/c it\n   * doesn't need to be uploaded to ECR. We still need to include slice of\n   * `node.addr` in tag in case multiple cdk-nextjs constructs are used.\n   */\n  builderImageAlias: string;\n  /**\n   * Unique id for Next.js build. Used to partition EFS FileSystem.\n   */\n  buildId: string;\n  /**\n   * Hash of builder image which will change whenever the image changes. Useful\n   * for passing to properties of custom resources that depend upon the builder\n   * image to re-run when build image changes.\n   */\n  buildImageDigest: string;\n  /**\n   * Docker image built if using Fargate.\n   */\n  imageForNextjsContainers?: DockerImageAsset;\n  /**\n   * Docker image built if using Lambda.\n   */\n  imageForNextjsFunctions?: DockerImageCode;\n  /**\n   * Docker image built for `NextjsAssetsDeployment`\n   */\n  imageForNextjsAssetsDeployment: DockerImageCode;\n  /**\n   * Absolute path to public. Use by CloudFront/ALB to create behaviors/rules\n   * @example \"/Users/john/myapp/public\"\n   */\n  publicDirEntries: PublicDirEntry[];\n  /**\n   * The entrypoint JavaScript file used as an argument for Node.js to run the\n   * Next.js standalone server relative to the standalone directory.\n   * @example \"./server.js\"\n   * @example \"./packages/ui/server.js\" (monorepo)\n   */\n  relativePathToEntrypoint: string;\n\n  /**\n   * Repository name for the builder image.\n   */\n  private builderImageRepo = \"cdk-nextjs/builder\";\n\n  private containerRuntime = process.env.CDK_DOCKER || \"docker\";\n  private props: NextjsBuildProps;\n  private relativePathToPackage: string;\n\n  constructor(scope: Construct, id: string, props: NextjsBuildProps) {\n    super(scope, id);\n    this.builderImageAlias = `${this.builderImageRepo}:${this.node.addr.slice(30)}`;\n    this.relativePathToPackage = props.relativePathToPackage || \".\";\n    this.props = props;\n    this.relativePathToEntrypoint = this.getRelativeEntrypointPath();\n    if (!props.builderImageProps?.skipBuild) {\n      this.createBuilderImage();\n    }\n    this.buildImageDigest = this.getBuilderImageDigest();\n    this.buildId = this.getBuildId();\n    this.publicDirEntries = this.getPublicDirEntries();\n    if (\n      props.nextjsType === NextjsType.GLOBAL_CONTAINERS ||\n      props.nextjsType === NextjsType.REGIONAL_CONTAINERS\n    ) {\n      this.imageForNextjsContainers = this.createImageForNextjsContainers();\n    } else {\n      this.imageForNextjsFunctions = this.createImageForNextjsFunctions();\n    }\n    this.imageForNextjsAssetsDeployment =\n      this.createImageForNextjsAssetsDeployment();\n  }\n\n  private getRelativeEntrypointPath() {\n    // joinPosix b/c this will be used in linux container\n    return joinPosix(this.props.relativePathToPackage || \"\", \"server.js\");\n  }\n  /**\n   * A builder or base image needs to be created so that the same image can be\n   * built `FROM` for `NextjsFunctions` or `NextjsContainers` and `NextjsAssetsDeployment`.\n   * This image doesn't need to be uploaded to ECR so we're \"manually\" creating\n   * it with `execSync` and other images will be built `FROM` it.\n   */\n  private createBuilderImage() {\n    const buildCommand = this.props.buildCommand || \"npm run build\";\n    const {\n      buildArgs = {\n        BUILD_COMMAND: buildCommand,\n        RELATIVE_PATH_TO_PACKAGE: this.relativePathToPackage,\n        ...this.props.builderImageProps?.buildArgs,\n      },\n      envVarNames = [],\n      exclude = [\n        \"**/node_modules\",\n        \".git\",\n        \"**/cdk.out\",\n        \"**/.next\",\n        \".gitignore\",\n        \"*.md\",\n      ],\n      file = \"builder.Dockerfile\",\n      platform,\n    } = this.props.builderImageProps || {};\n\n    // to be added to user provided build context before builder image is built\n    const filePathsToCopy: string[] = [\n      join(__dirname, \"cdk-nextjs-cache-handler.cjs\"),\n    ];\n    // to be removed from user provided build context after builder image is built\n    const filePathsToRemove: string[] = [\n      join(this.props.buildContext, \"cdk-nextjs-cache-handler.cjs\"),\n    ];\n\n    // if custom file (Dockerfile) is not specified then use library's default builder.Dockerfile + .dockerignore\n    if (!this.props.builderImageProps?.file) {\n      filePathsToCopy.push(join(__dirname, file));\n      filePathsToRemove.push(join(this.props.buildContext, file));\n      const excludeFileStr = exclude?.join(\"\\n\");\n      const dockerignoreFilePath = join(\n        this.props.buildContext,\n        \".dockerignore\",\n      );\n      writeFileSync(dockerignoreFilePath, excludeFileStr);\n      filePathsToRemove.push(dockerignoreFilePath);\n    }\n\n    for (const filePathToCopy of filePathsToCopy) {\n      cpSync(\n        filePathToCopy,\n        join(this.props.buildContext, basename(filePathToCopy)),\n      );\n    }\n\n    const buildArgsStr = this.createBuildArgStr(buildArgs);\n    this.injectBuilderDockerfileEnvVars(\n      join(this.props.buildContext, file),\n      envVarNames,\n    );\n    const command =\n      this.props.builderImageProps?.command ||\n      `${this.containerRuntime} build ${platform ? `--platform ${platform.platform}` : \"\"} --file ${file} --tag ${this.builderImageAlias} ${buildArgsStr} .`;\n    let error: unknown;\n    try {\n      console.log(\n        `Building image with command: ${command} in directory: ${this.props.buildContext}`,\n      );\n      execSync(command, {\n        stdio: \"inherit\",\n        cwd: this.props.buildContext,\n        env: process.env,\n      });\n    } catch (err) {\n      error = err;\n    } finally {\n      for (const filePathToRemove of filePathsToRemove) {\n        rmSync(filePathToRemove);\n      }\n    }\n    if (error) throw error;\n  }\n  private injectBuilderDockerfileEnvVars(\n    builderDockerfilePath: string,\n    envVarNames: string[],\n  ) {\n    const envVars: Record<string, string> = {};\n    for (const envVarName of envVarNames) {\n      if (process.env[envVarName]) {\n        envVars[envVarName] = process.env[envVarName];\n      }\n    }\n    const content = Object.entries(envVars)\n      .map(([name, value]) => `${name}=${value}`)\n      .join(\" \");\n    const oldFile = readFileSync(builderDockerfilePath).toString();\n    const newFile = oldFile.replace(INJECT_CDK_NEXTJS_BUILD_ENV_VARS, content);\n    writeFileSync(builderDockerfilePath, newFile);\n  }\n  private createBuildArgStr(\n    buildArgs: Required<BuilderImageProps>[\"buildArgs\"],\n  ) {\n    return Object.entries(buildArgs).reduce((acc, [key, value]) => {\n      return `${acc} --build-arg ${key}=\"${value}\"`;\n    }, \"\");\n  }\n  private getBuilderImageDigest() {\n    const digest = execSync(\n      `${this.containerRuntime} images --no-trunc --quiet ${this.builderImageAlias}`,\n      { encoding: \"utf-8\" },\n    );\n    return digest.slice(0, -1); // remove trailing \\n\n  }\n  private getPublicDirEntries(): PublicDirEntry[] {\n    const publicDirPath = joinPosix(\n      \"/app\",\n      this.props.relativePathToPackage || \"\",\n      \"public\",\n    );\n    const publicDirEntriesString = execSync(\n      `${this.containerRuntime} run ${this.builderImageAlias} node -e \"console.log(JSON.stringify(fs.readdirSync('${publicDirPath}', { withFileTypes: true }).map((e) => ({ name: e.name, isDirectory: e.isDirectory()}))))\"`,\n      { encoding: \"utf-8\" },\n    );\n    return JSON.parse(publicDirEntriesString) as PublicDirEntry[];\n  }\n  private getBuildId() {\n    const buildIdPath = joinPosix(\n      \"/app\",\n      this.props.relativePathToPackage || \"\",\n      \".next\",\n      \"BUILD_ID\",\n    );\n    const buildId = execSync(\n      `${this.containerRuntime} run ${this.builderImageAlias} /bin/sh -c \"cat ${buildIdPath}\"`,\n      { encoding: \"utf-8\" },\n    );\n    return buildId;\n  }\n  private createImageForNextjsContainers() {\n    const dockerfileNamePrefix =\n      this.props.nextjsType === NextjsType.GLOBAL_CONTAINERS\n        ? \"global\"\n        : \"regional\";\n    const dockerfileName = `${dockerfileNamePrefix}-containers.Dockerfile`;\n    // cdk-nextjs/builder-{hash} already contains built nextjs app which we'll\n    // `COPY --from=cdk-nextjs/builder-{hash}` so we just need the Dockerfile\n    // which is in lib/nextjs-build folder.\n    const buildContext =\n      this.props.overrides?.containersImageBuildContext ??\n      join(__dirname, \"..\", \"..\", \"lib\", \"nextjs-build\");\n    const dockerImageAsset = new DockerImageAsset(this, \"Image\", {\n      directory: buildContext,\n      extraHash: this.buildImageDigest, // rebuild when builder hash changes\n      file: dockerfileName,\n      ignoreMode: IgnoreMode.DOCKER,\n      ...this.props.overrides?.nextjsContainersDockerImageAssetProps,\n      buildArgs: {\n        [BUILD_ID_ARG_NAME]: this.buildId,\n        [BUILDER_IMAGE_ALIAS_ARG_NAME]: this.builderImageAlias,\n        [CACHE_PATH_ARG_NAME]: CACHE_PATH,\n        [DATA_CACHE_PATH_ARG_NAME]: DATA_CACHE_PATH,\n        [PUBLIC_PATH_ARG_NAME]: PUBLIC_PATH,\n        [IMAGE_CACHE_PATH_ARG_NAME]: IMAGE_CACHE_PATH,\n        [MOUNT_PATH_ARG_NAME]: MOUNT_PATH,\n        [RELATIVE_PATH_TO_PACKAGE_ARG_NAME]: this.relativePathToPackage,\n        ...this.props.overrides?.nextjsContainersDockerImageAssetProps\n          ?.buildArgs,\n      },\n    });\n    return dockerImageAsset;\n  }\n\n  private createImageForNextjsFunctions() {\n    const dockerfileName = \"global-functions.Dockerfile\";\n    // cdk-nextjs/builder-{hash} already contains built nextjs app which we'll\n    // `COPY --from=cdk-nextjs/builder-{hash}` so we just need the Dockerfile\n    // which is in lib/nextjs-build folder.\n    const buildContext =\n      this.props.overrides?.functionsImageBuildContext ??\n      join(__dirname, \"..\", \"..\", \"lib\", \"nextjs-build\");\n    const dockerImageCode = DockerImageCode.fromImageAsset(buildContext, {\n      cmd: [\"node\", this.relativePathToEntrypoint],\n      extraHash: this.buildImageDigest, // rebuild when builder hash changes\n      file: dockerfileName,\n      ignoreMode: IgnoreMode.DOCKER,\n      ...this.props.overrides?.nextjsFunctionsAssetImageCodeProps,\n      buildArgs: {\n        [BUILD_ID_ARG_NAME]: this.buildId,\n        [BUILDER_IMAGE_ALIAS_ARG_NAME]: this.builderImageAlias,\n        [CACHE_PATH_ARG_NAME]: CACHE_PATH,\n        [DATA_CACHE_PATH_ARG_NAME]: DATA_CACHE_PATH,\n        [PUBLIC_PATH_ARG_NAME]: PUBLIC_PATH,\n        [IMAGE_CACHE_PATH_ARG_NAME]: IMAGE_CACHE_PATH,\n        [MOUNT_PATH_ARG_NAME]: MOUNT_PATH,\n        [RELATIVE_PATH_TO_PACKAGE_ARG_NAME]: this.relativePathToPackage,\n        ...this.props.overrides?.nextjsFunctionsAssetImageCodeProps?.buildArgs,\n      },\n    });\n    // TODO: how to clean up temp dir?\n    // rmSync(tempDir, { recursive: true });\n    return dockerImageCode;\n  }\n\n  private createImageForNextjsAssetsDeployment() {\n    const dockerfileName = \"assets-deployment.Dockerfile\";\n    /**\n     * Path to bundled custom resource code\n     */\n    const buildContext =\n      this.props.overrides?.assetsDeploymentImageBuildContext ??\n      join(\n        __dirname,\n        \"..\",\n        \"..\",\n        \"assets\",\n        \"lambdas\",\n        \"assets-deployment\",\n        \"assets-deployment.lambda\",\n      );\n    // cdk-nextjs/builder-{hash} already contains Next.js built code which\n    // we'll copy into final image. But we also need lambda code to run\n    // asset deployment tasks\n    const dockerImageCode = DockerImageCode.fromImageAsset(buildContext, {\n      extraHash: this.buildImageDigest, // rebuild when builder hash changes\n      file: dockerfileName,\n      ignoreMode: IgnoreMode.DOCKER,\n      ...this.props.overrides?.nextjsAssetDeploymentAssetImageCodeProps,\n      buildArgs: {\n        [BUILD_ID_ARG_NAME]: this.buildId,\n        [BUILDER_IMAGE_ALIAS_ARG_NAME]: this.builderImageAlias,\n        [PUBLIC_PATH_ARG_NAME]: PUBLIC_PATH,\n        [RELATIVE_PATH_TO_PACKAGE_ARG_NAME]: this.relativePathToPackage,\n        ...this.props.overrides?.nextjsAssetDeploymentAssetImageCodeProps\n          ?.buildArgs,\n      },\n    });\n    return dockerImageCode;\n  }\n}\n"]}
+NextjsBuild[_a] = { fqn: "cdk-nextjs.NextjsBuild", version: "0.4.4" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-build.js","sourceRoot":"","sources":["../../src/nextjs-build/nextjs-build.ts"],"names":[],"mappings":"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","sourcesContent":["import { execSync } from \"node:child_process\";\nimport { cpSync, readFileSync, rmSync, writeFileSync } from \"node:fs\";\nimport { basename, join } from \"node:path\";\nimport { join as joinPosix } from \"node:path/posix\";\nimport { IgnoreMode } from \"aws-cdk-lib\";\nimport { DockerImageAsset, Platform } from \"aws-cdk-lib/aws-ecr-assets\";\nimport { AssetImageCodeProps, DockerImageCode } from \"aws-cdk-lib/aws-lambda\";\nimport { Construct } from \"constructs\";\nimport {\n  BUILDER_IMAGE_ALIAS_ARG_NAME,\n  MOUNT_PATH,\n  IMAGE_CACHE_PATH,\n  IMAGE_CACHE_PATH_ARG_NAME,\n  MOUNT_PATH_ARG_NAME,\n  NextjsType,\n  PUBLIC_PATH,\n  PUBLIC_PATH_ARG_NAME,\n  RELATIVE_PATH_TO_PACKAGE_ARG_NAME,\n  BUILD_ID_ARG_NAME,\n  DATA_CACHE_PATH_ARG_NAME,\n  DATA_CACHE_PATH,\n  CACHE_PATH,\n  CACHE_PATH_ARG_NAME,\n  INJECT_CDK_NEXTJS_BUILD_ENV_VARS,\n} from \"../constants\";\nimport { OptionalDockerImageAssetProps } from \"../generated-structs/OptionalDockerImageAssetProps\";\nimport { NextjsBaseProps } from \"../root-constructs/nextjs-base-construct\";\n\nexport interface BuilderImageProps {\n  /**\n   * Build Args to be passed to `docker build` command.\n   */\n  readonly buildArgs?: Record<string, string>;\n  /**\n   * `docker build ...` command to run in {@link NextBaseProps.buildContext}.\n   * Default interpolates other props. If you override, other props will have\n   * no effect on command.\n   */\n  readonly command?: string;\n  /**\n   * Environment variables names to pass from host to container during build process.\n   *\n   * Note, a shell script, cdk-nextjs-load-env-vars.sh is created within the\n   * {@link NextBaseProps.buildContext} directory, which will contain all the\n   * environment variables defined in this prop. If you've created your own\n   * custom Dockerfile (passed in via {@link BuilderImageProps.customDockerfilePath})\n   * then you need to make sure you're copying it into the image.\n   *\n   * @example [\"MY_API_KEY\"]\n   */\n  readonly envVarNames?: string[];\n  /**\n   * Lines in .dockerignore file which will be created in your {@link NextBaseProps.buildContext}\n   * @default [\"node_modules\", \".git\", \".gitignore\", \".md\"]\n   */\n  readonly exclude?: string[];\n  /**\n   * Name of Dockerfile in builder build context. If specified, you are responsible\n   * for ensuring it exists in build context before construct is instantiated.\n   * @default \"builder.Dockerfile\"\n   */\n  readonly file?: string;\n  readonly platform?: Platform;\n  /**\n   * Skip building the builder image.\n   * @default false\n   */\n  readonly skipBuild?: boolean;\n}\n\nexport interface NextjsBuildOverrides {\n  readonly nextjsContainersDockerImageAssetProps?: OptionalDockerImageAssetProps;\n  readonly nextjsFunctionsAssetImageCodeProps?: AssetImageCodeProps;\n  readonly nextjsAssetDeploymentAssetImageCodeProps?: AssetImageCodeProps;\n  /**\n   * Default folder for build context is the \"lib/nextjs-build\" folder in the\n   * installed cdk-nextjs library which has the \"global-functions.Dockerfile\".\n   * Note, if you specify this then you're responsible for ensuring the dockerfile\n   * is present in the build context directory and any referenced files are\n   * present as well. You can specify dockerfile name with adjacent\n   * `nextjsFunctionsAssetImageCodeProps.file` property.\n   * @default \"cdk-nextjs/lib/nextjs-build\"\n   */\n  readonly functionsImageBuildContext?: string;\n  /**\n   * Default folder for build context is the \"lib/nextjs-build\" folder in the\n   * installed cdk-nextjs library which has the \"assets-deployment.Dockerfile\".\n   * Note, if you specify this then you're responsible for ensuring the dockerfile\n   * is present in the build context directory and any referenced files are\n   * present as well. You can specify dockerfile name with adjacent\n   * `nextjsAssetDeploymentAssetImageCodeProps.file` property.\n   * @default \"cdk-nextjs/lib/nextjs-build\"\n   */\n  readonly assetsDeploymentImageBuildContext?: string;\n  /**\n   * Default folder for build context is the \"assets/lambdas/assets-deployment/assets-deployment.lambda\" folder in the\n   * installed cdk-nextjs library which has the \"{...}-containers.Dockerfile\".\n   * Note, if you specify this then you're responsible for ensuring the dockerfile\n   * is present in the build context directory and any referenced files are\n   * present as well. You can specify dockerfile name with adjacent\n   * `nextjsContainersDockerImageAssetProps.file` property.\n   * @default \"cdk-nextjs/lib/nextjs-build\"\n   */\n  readonly containersImageBuildContext?: string;\n}\n\nexport interface NextjsBuildProps {\n  /**\n   * @see {@link NextjsBaseProps[\"buildCommand\"]}\n   */\n  readonly buildCommand: NextjsBaseProps[\"buildCommand\"];\n  /**\n   * @see {@link NextjsBaseProps[\"buildContext\"]}\n   */\n  readonly buildContext: NextjsBaseProps[\"buildContext\"];\n  /**\n   *\n   */\n  readonly builderImageProps?: BuilderImageProps;\n  /**\n   * @see {@link NextjsBaseProps.relativePathToPackage}\n   */\n  readonly relativePathToPackage?: NextjsBaseProps[\"relativePathToPackage\"];\n  readonly nextjsType: NextjsType;\n  readonly overrides?: NextjsBuildOverrides;\n}\n\nexport interface PublicDirEntry {\n  readonly name: string;\n  readonly isDirectory: boolean;\n}\n\n/**\n * Builds Next.js assets.\n * @link https://nextjs.org/docs/pages/api-reference/next-config-js/output\n */\nexport class NextjsBuild extends Construct {\n  /**\n   * Image alias of builder image Next.js app which is built for other images to be\n   * built `FROM`. This image isn't built with CDK Assets construct b/c it\n   * doesn't need to be uploaded to ECR. We still need to include slice of\n   * `node.addr` in tag in case multiple cdk-nextjs constructs are used.\n   */\n  builderImageAlias: string;\n  /**\n   * Unique id for Next.js build. Used to partition EFS FileSystem.\n   */\n  buildId: string;\n  /**\n   * Hash of builder image which will change whenever the image changes. Useful\n   * for passing to properties of custom resources that depend upon the builder\n   * image to re-run when build image changes.\n   */\n  buildImageDigest: string;\n  /**\n   * Docker image built if using Fargate.\n   */\n  imageForNextjsContainers?: DockerImageAsset;\n  /**\n   * Docker image built if using Lambda.\n   */\n  imageForNextjsFunctions?: DockerImageCode;\n  /**\n   * Docker image built for `NextjsAssetsDeployment`\n   */\n  imageForNextjsAssetsDeployment: DockerImageCode;\n  /**\n   * Absolute path to public. Use by CloudFront/ALB to create behaviors/rules\n   * @example \"/Users/john/myapp/public\"\n   */\n  publicDirEntries: PublicDirEntry[];\n  /**\n   * The entrypoint JavaScript file used as an argument for Node.js to run the\n   * Next.js standalone server relative to the standalone directory.\n   * @example \"./server.js\"\n   * @example \"./packages/ui/server.js\" (monorepo)\n   */\n  relativePathToEntrypoint: string;\n\n  /**\n   * Repository name for the builder image.\n   */\n  private builderImageRepo = \"cdk-nextjs/builder\";\n\n  private containerRuntime = process.env.CDK_DOCKER || \"docker\";\n  private props: NextjsBuildProps;\n  private relativePathToPackage: string;\n\n  constructor(scope: Construct, id: string, props: NextjsBuildProps) {\n    super(scope, id);\n    this.builderImageAlias = `${this.builderImageRepo}:${this.node.addr.slice(30)}`;\n    this.relativePathToPackage = props.relativePathToPackage || \".\";\n    this.props = props;\n    this.relativePathToEntrypoint = this.getRelativeEntrypointPath();\n    if (!props.builderImageProps?.skipBuild) {\n      this.createBuilderImage();\n    }\n    this.buildImageDigest = this.getBuilderImageDigest();\n    this.buildId = this.getBuildId();\n    this.publicDirEntries = this.getPublicDirEntries();\n    if (\n      props.nextjsType === NextjsType.GLOBAL_CONTAINERS ||\n      props.nextjsType === NextjsType.REGIONAL_CONTAINERS\n    ) {\n      this.imageForNextjsContainers = this.createImageForNextjsContainers();\n    } else {\n      this.imageForNextjsFunctions = this.createImageForNextjsFunctions();\n    }\n    this.imageForNextjsAssetsDeployment =\n      this.createImageForNextjsAssetsDeployment();\n  }\n\n  private getRelativeEntrypointPath() {\n    // joinPosix b/c this will be used in linux container\n    return joinPosix(this.props.relativePathToPackage || \"\", \"server.js\");\n  }\n  /**\n   * A builder or base image needs to be created so that the same image can be\n   * built `FROM` for `NextjsFunctions` or `NextjsContainers` and `NextjsAssetsDeployment`.\n   * This image doesn't need to be uploaded to ECR so we're \"manually\" creating\n   * it with `execSync` and other images will be built `FROM` it.\n   */\n  private createBuilderImage() {\n    const buildCommand = this.props.buildCommand || \"npm run build\";\n    const {\n      buildArgs = {\n        BUILD_COMMAND: buildCommand,\n        RELATIVE_PATH_TO_PACKAGE: this.relativePathToPackage,\n        ...this.props.builderImageProps?.buildArgs,\n      },\n      envVarNames = [],\n      exclude = [\n        \"**/node_modules\",\n        \".git\",\n        \"**/cdk.out\",\n        \"**/.next\",\n        \".gitignore\",\n        \"*.md\",\n      ],\n      file = \"builder.Dockerfile\",\n      platform,\n    } = this.props.builderImageProps || {};\n\n    // to be added to user provided build context before builder image is built\n    const filePathsToCopy: string[] = [\n      join(__dirname, \"cdk-nextjs-cache-handler.cjs\"),\n    ];\n    // to be removed from user provided build context after builder image is built\n    const filePathsToRemove: string[] = [\n      join(this.props.buildContext, \"cdk-nextjs-cache-handler.cjs\"),\n    ];\n\n    // if custom file (Dockerfile) is not specified then use library's default builder.Dockerfile + .dockerignore\n    if (!this.props.builderImageProps?.file) {\n      filePathsToCopy.push(join(__dirname, file));\n      filePathsToRemove.push(join(this.props.buildContext, file));\n      const excludeFileStr = exclude?.join(\"\\n\");\n      const dockerignoreFilePath = join(\n        this.props.buildContext,\n        \".dockerignore\",\n      );\n      writeFileSync(dockerignoreFilePath, excludeFileStr);\n      filePathsToRemove.push(dockerignoreFilePath);\n    }\n\n    for (const filePathToCopy of filePathsToCopy) {\n      cpSync(\n        filePathToCopy,\n        join(this.props.buildContext, basename(filePathToCopy)),\n      );\n    }\n\n    const buildArgsStr = this.createBuildArgStr(buildArgs);\n    this.injectBuilderDockerfileEnvVars(\n      join(this.props.buildContext, file),\n      envVarNames,\n    );\n    const command =\n      this.props.builderImageProps?.command ||\n      `${this.containerRuntime} build ${platform ? `--platform ${platform.platform}` : \"\"} --file ${file} --tag ${this.builderImageAlias} ${buildArgsStr} .`;\n    let error: unknown;\n    try {\n      console.log(\n        `Building image with command: ${command} in directory: ${this.props.buildContext}`,\n      );\n      execSync(command, {\n        stdio: \"inherit\",\n        cwd: this.props.buildContext,\n        env: process.env,\n      });\n    } catch (err) {\n      error = err;\n    } finally {\n      for (const filePathToRemove of filePathsToRemove) {\n        rmSync(filePathToRemove);\n      }\n    }\n    if (error) throw error;\n  }\n  private injectBuilderDockerfileEnvVars(\n    builderDockerfilePath: string,\n    envVarNames: string[],\n  ) {\n    const envVars: Record<string, string> = {};\n    for (const envVarName of envVarNames) {\n      if (process.env[envVarName]) {\n        envVars[envVarName] = process.env[envVarName];\n      }\n    }\n    const content = Object.entries(envVars)\n      .map(([name, value]) => `${name}=${value}`)\n      .join(\" \");\n    const oldFile = readFileSync(builderDockerfilePath).toString();\n    const newFile = oldFile.replace(INJECT_CDK_NEXTJS_BUILD_ENV_VARS, content);\n    writeFileSync(builderDockerfilePath, newFile);\n  }\n  private createBuildArgStr(\n    buildArgs: Required<BuilderImageProps>[\"buildArgs\"],\n  ) {\n    return Object.entries(buildArgs).reduce((acc, [key, value]) => {\n      return `${acc} --build-arg ${key}=\"${value}\"`;\n    }, \"\");\n  }\n  private getBuilderImageDigest() {\n    const digest = execSync(\n      `${this.containerRuntime} images --no-trunc --quiet ${this.builderImageAlias}`,\n      { encoding: \"utf-8\" },\n    );\n    return digest.slice(0, -1); // remove trailing \\n\n  }\n  private getPublicDirEntries(): PublicDirEntry[] {\n    const publicDirPath = joinPosix(\n      \"/app\",\n      this.props.relativePathToPackage || \"\",\n      \"public\",\n    );\n    const publicDirEntriesString = execSync(\n      `${this.containerRuntime} run ${this.builderImageAlias} node -e \"console.log(JSON.stringify(fs.readdirSync('${publicDirPath}', { withFileTypes: true }).map((e) => ({ name: e.name, isDirectory: e.isDirectory()}))))\"`,\n      { encoding: \"utf-8\" },\n    );\n    return JSON.parse(publicDirEntriesString) as PublicDirEntry[];\n  }\n  private getBuildId() {\n    const buildIdPath = joinPosix(\n      \"/app\",\n      this.props.relativePathToPackage || \"\",\n      \".next\",\n      \"BUILD_ID\",\n    );\n    const buildId = execSync(\n      `${this.containerRuntime} run ${this.builderImageAlias} /bin/sh -c \"cat ${buildIdPath}\"`,\n      { encoding: \"utf-8\" },\n    );\n    return buildId;\n  }\n  private createImageForNextjsContainers() {\n    const dockerfileNamePrefix =\n      this.props.nextjsType === NextjsType.GLOBAL_CONTAINERS\n        ? \"global\"\n        : \"regional\";\n    const dockerfileName = `${dockerfileNamePrefix}-containers.Dockerfile`;\n    // cdk-nextjs/builder-{hash} already contains built nextjs app which we'll\n    // `COPY --from=cdk-nextjs/builder-{hash}` so we just need the Dockerfile\n    // which is in lib/nextjs-build folder.\n    const buildContext =\n      this.props.overrides?.containersImageBuildContext ??\n      join(__dirname, \"..\", \"..\", \"lib\", \"nextjs-build\");\n    const dockerImageAsset = new DockerImageAsset(this, \"Image\", {\n      directory: buildContext,\n      extraHash: this.buildImageDigest, // rebuild when builder hash changes\n      file: dockerfileName,\n      ignoreMode: IgnoreMode.DOCKER,\n      ...this.props.overrides?.nextjsContainersDockerImageAssetProps,\n      buildArgs: {\n        [BUILD_ID_ARG_NAME]: this.buildId,\n        [BUILDER_IMAGE_ALIAS_ARG_NAME]: this.builderImageAlias,\n        [CACHE_PATH_ARG_NAME]: CACHE_PATH,\n        [DATA_CACHE_PATH_ARG_NAME]: DATA_CACHE_PATH,\n        [PUBLIC_PATH_ARG_NAME]: PUBLIC_PATH,\n        [IMAGE_CACHE_PATH_ARG_NAME]: IMAGE_CACHE_PATH,\n        [MOUNT_PATH_ARG_NAME]: MOUNT_PATH,\n        [RELATIVE_PATH_TO_PACKAGE_ARG_NAME]: this.relativePathToPackage,\n        ...this.props.overrides?.nextjsContainersDockerImageAssetProps\n          ?.buildArgs,\n      },\n    });\n    return dockerImageAsset;\n  }\n\n  private createImageForNextjsFunctions() {\n    const dockerfileName = \"global-functions.Dockerfile\";\n    // cdk-nextjs/builder-{hash} already contains built nextjs app which we'll\n    // `COPY --from=cdk-nextjs/builder-{hash}` so we just need the Dockerfile\n    // which is in lib/nextjs-build folder.\n    const buildContext =\n      this.props.overrides?.functionsImageBuildContext ??\n      join(__dirname, \"..\", \"..\", \"lib\", \"nextjs-build\");\n    const dockerImageCode = DockerImageCode.fromImageAsset(buildContext, {\n      cmd: [\"node\", this.relativePathToEntrypoint],\n      extraHash: this.buildImageDigest, // rebuild when builder hash changes\n      file: dockerfileName,\n      ignoreMode: IgnoreMode.DOCKER,\n      ...this.props.overrides?.nextjsFunctionsAssetImageCodeProps,\n      buildArgs: {\n        [BUILD_ID_ARG_NAME]: this.buildId,\n        [BUILDER_IMAGE_ALIAS_ARG_NAME]: this.builderImageAlias,\n        [CACHE_PATH_ARG_NAME]: CACHE_PATH,\n        [DATA_CACHE_PATH_ARG_NAME]: DATA_CACHE_PATH,\n        [PUBLIC_PATH_ARG_NAME]: PUBLIC_PATH,\n        [IMAGE_CACHE_PATH_ARG_NAME]: IMAGE_CACHE_PATH,\n        [MOUNT_PATH_ARG_NAME]: MOUNT_PATH,\n        [RELATIVE_PATH_TO_PACKAGE_ARG_NAME]: this.relativePathToPackage,\n        ...this.props.overrides?.nextjsFunctionsAssetImageCodeProps?.buildArgs,\n      },\n    });\n    // TODO: how to clean up temp dir?\n    // rmSync(tempDir, { recursive: true });\n    return dockerImageCode;\n  }\n\n  private createImageForNextjsAssetsDeployment() {\n    const dockerfileName = \"assets-deployment.Dockerfile\";\n    /**\n     * Path to bundled custom resource code\n     */\n    const buildContext =\n      this.props.overrides?.assetsDeploymentImageBuildContext ??\n      join(\n        __dirname,\n        \"..\",\n        \"..\",\n        \"assets\",\n        \"lambdas\",\n        \"assets-deployment\",\n        \"assets-deployment.lambda\",\n      );\n    // cdk-nextjs/builder-{hash} already contains Next.js built code which\n    // we'll copy into final image. But we also need lambda code to run\n    // asset deployment tasks\n    const dockerImageCode = DockerImageCode.fromImageAsset(buildContext, {\n      extraHash: this.buildImageDigest, // rebuild when builder hash changes\n      file: dockerfileName,\n      ignoreMode: IgnoreMode.DOCKER,\n      ...this.props.overrides?.nextjsAssetDeploymentAssetImageCodeProps,\n      buildArgs: {\n        [BUILD_ID_ARG_NAME]: this.buildId,\n        [BUILDER_IMAGE_ALIAS_ARG_NAME]: this.builderImageAlias,\n        [PUBLIC_PATH_ARG_NAME]: PUBLIC_PATH,\n        [RELATIVE_PATH_TO_PACKAGE_ARG_NAME]: this.relativePathToPackage,\n        ...this.props.overrides?.nextjsAssetDeploymentAssetImageCodeProps\n          ?.buildArgs,\n      },\n    });\n    return dockerImageCode;\n  }\n}\n"]}

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

@@ -144,5 +144,5 @@ class NextjsContainers extends constructs_1.Construct {
 }
 exports.NextjsContainers = NextjsContainers;
 _a = JSII_RTTI_SYMBOL_1;
-NextjsContainers[_a] = { fqn: "cdk-nextjs.NextjsContainers", version: "0.4.2" };
+NextjsContainers[_a] = { fqn: "cdk-nextjs.NextjsContainers", version: "0.4.4" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-containers.js","sourceRoot":"","sources":["../../src/nextjs-compute/nextjs-containers.ts"],"names":[],"mappings":"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","sourcesContent":["import { join } from \"node:path/posix\";\nimport { Duration } from \"aws-cdk-lib\";\nimport { DockerImageAsset } from \"aws-cdk-lib/aws-ecr-assets\";\nimport {\n  AwsLogDriverMode,\n  Cluster,\n  ContainerImage,\n  ContainerInsights,\n  CpuArchitecture,\n  HealthCheck,\n  LogDrivers,\n} from \"aws-cdk-lib/aws-ecs\";\nimport {\n  ApplicationLoadBalancedFargateService,\n  ApplicationLoadBalancedFargateServiceProps,\n} from \"aws-cdk-lib/aws-ecs-patterns\";\nimport { FileSystem } from \"aws-cdk-lib/aws-efs\";\nimport { ApplicationProtocolVersion } from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport { Construct } from \"constructs\";\nimport { NextjsComputeBaseProps } from \"./nextjs-compute-base-props\";\nimport {\n  CDK_NEXTJS_SERVER_DIST_DIR_ENV_VAR_NAME,\n  MOUNT_PATH,\n  NextjsType,\n  SERVER_DIST_PATH,\n} from \"../constants\";\nimport { OptionalApplicationLoadBalancedTaskImageOptions } from \"../generated-structs/OptionalApplicationLoadBalancedTaskImageOptions\";\nimport { OptionalClusterProps } from \"../generated-structs/OptionalClusterProps\";\n\nexport interface NextjsContainersOverrides {\n  readonly ecsClusterProps?: OptionalClusterProps;\n  readonly albFargateServiceProps?: ApplicationLoadBalancedFargateServiceProps;\n  readonly taskImageOptions?: OptionalApplicationLoadBalancedTaskImageOptions;\n}\n\nexport interface NextjsContainersProps extends NextjsComputeBaseProps {\n  readonly dockerImageAsset: DockerImageAsset;\n  readonly fileSystem: FileSystem;\n  readonly nextjsType: NextjsType;\n  readonly overrides?: NextjsContainersOverrides;\n  readonly relativeEntrypointPath: string;\n  readonly buildId: string;\n}\n\n/**\n * Next.js load balanced via Application Load Balancer with containers via AWS\n * Fargate.\n */\nexport class NextjsContainers extends Construct {\n  albFargateService: ApplicationLoadBalancedFargateService;\n  ecsCluster: Cluster;\n  url: string;\n\n  private props: NextjsContainersProps;\n\n  constructor(scope: Construct, id: string, props: NextjsContainersProps) {\n    super(scope, id);\n    this.props = props;\n    this.ecsCluster = this.createEcsCluster();\n    this.albFargateService = this.createAlbFargateSevice();\n    this.configureHealthCheck();\n    this.attachFileSystem();\n    this.url = this.getUrl();\n  }\n\n  private createEcsCluster(): Cluster {\n    const cluster = new Cluster(this, \"EcsCluster\", {\n      enableFargateCapacityProviders: true,\n      containerInsightsV2: ContainerInsights.ENABLED,\n      vpc: this.props.vpc,\n      ...this.props.overrides?.ecsClusterProps,\n    });\n    return cluster;\n  }\n  private createAlbFargateSevice(): ApplicationLoadBalancedFargateService {\n    let cpuArchitecture: CpuArchitecture | undefined = undefined;\n    if (process.arch === \"x64\") {\n      cpuArchitecture = CpuArchitecture.X86_64;\n    } else if (process.arch === \"arm64\") {\n      cpuArchitecture = CpuArchitecture.ARM64;\n    }\n    const albFargateService = new ApplicationLoadBalancedFargateService(\n      this,\n      \"AlbFargateService\",\n      {\n        circuitBreaker: { rollback: true, enable: true },\n        cluster: this.ecsCluster,\n        cpu: 1024,\n        healthCheckGracePeriod: Duration.seconds(10),\n        maxHealthyPercent: 200,\n        memoryLimitMiB: 2048,\n        minHealthyPercent: 100, // maintain service availability during deployment\n        /*\n          This protocol version is for the target group (Fargate), not the ALB\n          Listener. From docs, \"Application Load Balancers provide native support\n          for HTTP/2 with HTTPS listeners\". See https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html\n          Next.js default server does not support HTTP/2 as it's recommended\n          to proxy your Next.js server which we're doing with ALB.\n          Also note, CloudFront only supports HTTP/1.1 origins.\n          https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/RequestAndResponseBehaviorCustomOrigin.html#RequestCustomHTTPVersion\n        */\n        protocolVersion: ApplicationProtocolVersion.HTTP1,\n        // if NextjsType.GLOBAL_CONTAINERS then we use VPC Origin Access which allows putting ALB in private subnet\n        publicLoadBalancer:\n          this.props.nextjsType === NextjsType.REGIONAL_CONTAINERS,\n        runtimePlatform: {\n          cpuArchitecture,\n        },\n        taskImageOptions: {\n          command: [\"node\", this.props.relativeEntrypointPath],\n          containerName: \"nextjs\",\n          containerPort: 3000,\n          image: ContainerImage.fromDockerImageAsset(\n            this.props.dockerImageAsset,\n          ),\n          logDriver: LogDrivers.awsLogs({\n            streamPrefix: \"nextjs\",\n            mode: AwsLogDriverMode.NON_BLOCKING,\n          }),\n          ...this.props.overrides?.taskImageOptions,\n        },\n        ...this.props.overrides?.albFargateServiceProps,\n      },\n    );\n    // required or health checks fail\n    albFargateService.taskDefinition.defaultContainer?.addEnvironment(\n      \"HOSTNAME\",\n      \"0.0.0.0\",\n    );\n    albFargateService.taskDefinition.defaultContainer?.addEnvironment(\n      CDK_NEXTJS_SERVER_DIST_DIR_ENV_VAR_NAME,\n      join(MOUNT_PATH, this.props.buildId, SERVER_DIST_PATH),\n    );\n    // speed up deployments by shortening deregistration delay\n    // https://docs.aws.amazon.com/AmazonECS/latest/bestpracticesguide/load-balancer-connection-draining.html\n    // TODO: document that this should be increased if long lived connections are expected\n    albFargateService.targetGroup.setAttribute(\n      \"deregistration_delay.timeout_seconds\",\n      \"30\",\n    );\n    // best practice to enable cross zone load balancing\n    // @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/disable-cross-zone.html\n    albFargateService.loadBalancer.setAttribute(\n      \"load_balancing.cross_zone.enabled\",\n      \"true\",\n    );\n    return albFargateService;\n  }\n  /**\n   * Configure health checks for containers at ALB and ECS level. This ensures\n   * unhealthy containers are removed. Both of these health checks can be\n   * overwritten by user by accessing `albFargateService` property, so no need\n   * for `overrides`.\n   */\n  private configureHealthCheck() {\n    // speed up deployments by shortening health checks\n    // see https://docs.aws.amazon.com/AmazonECS/latest/bestpracticesguide/load-balancer-healthcheck.html\n    this.albFargateService.targetGroup.configureHealthCheck({\n      path: this.props.healthCheckPath,\n      healthyThresholdCount: 2,\n      interval: Duration.seconds(10), // too frequent? but enables faster rollback...\n      timeout: Duration.seconds(5), // must be less than interval\n    });\n    const healthCheck: HealthCheck = {\n      command: [\n        \"CMD-SHELL\",\n        // curl isn't available in alpine linux\n        `wget --quiet --tries=1 --spider http://localhost:3000${this.props.healthCheckPath} || exit 1`,\n      ],\n    };\n    const defaultContainer =\n      this.albFargateService.taskDefinition.defaultContainer;\n    if (defaultContainer) {\n      // @ts-expect-error must use internal \"props\" attribute b/c no other way to add health check\n      defaultContainer.props.healthCheck = healthCheck;\n    }\n  }\n  private attachFileSystem() {\n    const container = this.albFargateService.taskDefinition.defaultContainer;\n    const volumeName = \"cdk-nextjs-volume\";\n    this.albFargateService.taskDefinition.addVolume({\n      name: volumeName,\n      efsVolumeConfiguration: {\n        fileSystemId: this.props.fileSystem.fileSystemId,\n        transitEncryption: \"ENABLED\",\n        authorizationConfig: {\n          accessPointId: this.props.accessPoint.accessPointId,\n          iam: \"ENABLED\",\n        },\n      },\n    });\n    container?.addMountPoints({\n      sourceVolume: volumeName,\n      containerPath: MOUNT_PATH,\n      readOnly: false,\n    });\n  }\n  private getUrl(): string {\n    const protocol = this.albFargateService.certificate ? \"https\" : \"http\";\n    return `${protocol}://${this.albFargateService.loadBalancer.loadBalancerDnsName}`;\n  }\n}\n"]}

package/lib/nextjs-compute/nextjs-functions.d.ts

@@ -1,6 +1,7 @@
 import { DockerImageCode, DockerImageFunction, FunctionUrl } from "aws-cdk-lib/aws-lambda";
 import { Construct } from "constructs";
 import { NextjsComputeBaseProps } from "./nextjs-compute-base-props";
+import { NextjsType } from "../constants";
 import { OptionalDockerImageFunctionProps } from "../generated-structs/OptionalDockerImageFunctionProps";
 import { OptionalFunctionUrlProps } from "../generated-structs/OptionalFunctionUrlProps";
 export interface NextjsFunctionsOverrides {
@@ -11,13 +12,14 @@ export interface NextjsFunctionsProps extends NextjsComputeBaseProps {
     readonly dockerImageCode: DockerImageCode;
     readonly overrides?: NextjsFunctionsOverrides;
     readonly buildId: string;
+    readonly nextjsType: NextjsType;
 }
 /**
  * Run Next.js in functions on AWS with AWS Lambda.
  */
 export declare class NextjsFunctions extends Construct {
     function: DockerImageFunction;
-    functionUrl: FunctionUrl;
+    functionUrl?: FunctionUrl;
     private props;
     constructor(scope: Construct, id: string, props: NextjsFunctionsProps);
     private createFunction;

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

@@ -17,13 +17,12 @@ class NextjsFunctions extends constructs_1.Construct {
         super(scope, id);
         this.props = props;
         this.function = this.createFunction();
-        this.functionUrl = this.function.addFunctionUrl({
-            authType: aws_lambda_1.FunctionUrlAuthType.AWS_IAM,
-            invokeMode: aws_lambda_1.InvokeMode.RESPONSE_STREAM,
-            ...this.props.overrides?.functionUrlProps,
-        });
-        if (!this.function.role) {
-            throw new Error("Function role is undefined");
+        if (props.nextjsType === constants_1.NextjsType.GLOBAL_FUNCTIONS) {
+            this.functionUrl = this.function.addFunctionUrl({
+                authType: aws_lambda_1.FunctionUrlAuthType.AWS_IAM,
+                invokeMode: aws_lambda_1.InvokeMode.RESPONSE_STREAM,
+                ...this.props.overrides?.functionUrlProps,
+            });
         }
     }
     createFunction() {
@@ -37,7 +36,9 @@ class NextjsFunctions extends constructs_1.Construct {
             ...this.props.overrides?.dockerImageFunctionProps,
             environment: {
                 AWS_LWA_ENABLE_COMPRESSION: "true",
-                AWS_LWA_INVOKE_MODE: "response_stream",
+                AWS_LWA_INVOKE_MODE: this.props.nextjsType === constants_1.NextjsType.GLOBAL_FUNCTIONS
+                    ? "response_stream"
+                    : "buffered", // API GW doesn't support response streaming yet so must buffer
                 AWS_LWA_READINESS_CHECK_PATH: this.props.healthCheckPath,
                 AWS_LWA_READINESS_CHECK_PORT: "3000",
                 READINESS_CHECK_PATH: `http://127.0.0.1:3000${this.props.healthCheckPath}`,
@@ -50,5 +51,5 @@ class NextjsFunctions extends constructs_1.Construct {
 }
 exports.NextjsFunctions = NextjsFunctions;
 _a = JSII_RTTI_SYMBOL_1;
-NextjsFunctions[_a] = { fqn: "cdk-nextjs.NextjsFunctions", version: "0.4.2" };
-//# sourceMappingURL=data:application/json;base64,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
+NextjsFunctions[_a] = { fqn: "cdk-nextjs.NextjsFunctions", version: "0.4.4" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/nextjs-distribution.d.ts

@@ -49,8 +49,8 @@ export interface NextjsDistributionProps {
      */
     readonly overrides?: NextjsDistributionOverrides;
     /**
-     * Path to directory of Next.js app's public directory. Used to add static
-     * behaviors to distribution.
+     * Entries (files/directories) within Next.js app's public directory. Used to
+     * add static behaviors to distribution.
      */
     readonly publicDirEntries: PublicDirEntry[];
 }