cdk-nextjs 0.6.1 → 0.7.0

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

@@ -1,3 +1,4 @@
+import { IDistribution } from "aws-cdk-lib/aws-cloudfront";
 import { ITableV2 } from "aws-cdk-lib/aws-dynamodb";
 import { IVpc } from "aws-cdk-lib/aws-ec2";
 import { IBucket } from "aws-cdk-lib/aws-s3";
@@ -5,11 +6,12 @@ import { Construct } from "constructs";
 import { NextjsType } from "../constants";
 import { OptionalNextjsBuildProps } from "../generated-structs/OptionalNextjsBuildProps";
 import { OptionalNextjsCacheProps } from "../generated-structs/OptionalNextjsCacheProps";
+import { OptionalNextjsPostDeployProps } from "../generated-structs/OptionalNextjsPostDeployProps";
 import { NextjsBuild } from "../nextjs-build/nextjs-build";
 import { NextjsCache, NextjsCacheOverrides } from "../nextjs-cache";
 import { NextjsComputeBaseProps } from "../nextjs-compute/nextjs-compute-base-props";
-import { NextjsFunctions, NextjsFunctionsOverrides, NextjsFunctionsProps } from "../nextjs-compute/nextjs-functions";
-import { NextjsImageFunction, NextjsImageFunctionOverrides, NextjsImageFunctionProps } from "../nextjs-compute/nextjs-image-function";
+import { NextjsFunctionGroup, NextjsFunctions } from "../nextjs-compute/nextjs-functions";
+import { NextjsPostDeploy, NextjsPostDeployOverrides } from "../nextjs-post-deploy";
 import { NextjsStaticAssets, NextjsStaticAssetsOverrides, NextjsStaticAssetsProps } from "../nextjs-static-assets";
 /**
  * Base overrides for the props passed to constructs within root/top-level Next.js constructs
@@ -17,22 +19,15 @@ import { NextjsStaticAssets, NextjsStaticAssetsOverrides, NextjsStaticAssetsProp
 export interface NextjsBaseConstructOverrides {
     readonly nextjsBuildProps?: OptionalNextjsBuildProps;
     readonly nextjsCacheProps?: OptionalNextjsCacheProps;
+    readonly nextjsPostDeployProps?: OptionalNextjsPostDeployProps;
     readonly nextjsStaticAssetsProps?: NextjsStaticAssetsProps;
 }
-/**
- * Adds the overrides that only apply to the two Functions `NextjsType`s. The
- * Containers types serve `_next/image` from the standalone server itself and
- * have no Lambda functions to configure, so they would silently ignore these.
- */
-export interface NextjsFunctionsConstructOverrides extends NextjsBaseConstructOverrides {
-    readonly nextjsFunctionsProps?: NextjsFunctionsProps;
-    readonly nextjsImageFunctionProps?: NextjsImageFunctionProps;
-}
 /**
  * Base overrides for constructs shared between all root/top-level Next.js constructs.
  */
 export interface NextjsBaseOverrides {
     readonly nextjsCache?: NextjsCacheOverrides;
+    readonly nextjsPostDeploy?: NextjsPostDeployOverrides;
     readonly nextjsStaticAssets?: NextjsStaticAssetsOverrides;
 }
 export interface NextjsBaseProps {
@@ -50,12 +45,18 @@ export interface NextjsBaseProps {
      *   static assets from S3 using the request path as the object key, so the two
      *   have to be identical and a mismatch 404s all of them. Setting a different
      *   value throws.
-     * - `NextjsRegionalFunctions`: if you set this, the app's `basePath` must end
-     *   with it — either equal to it, or prefixed by the stage or base path
-     *   mapping API Gateway strips before matching resources (`basePath:
-     *   "/prod/base"` with this set to `"/base"`). Leaving it unset while the app
-     *   sets one is correct and common — an app served at the default `prod` stage
-     *   sets `basePath: "/prod"` and leaves this alone.
+     * - `NextjsRegionalFunctions`: leave this unset and it follows your app's
+     *   `basePath` minus the prefix API Gateway strips before matching resources —
+     *   the stage (`deployOptions.stageName`, default `prod`), or the base path
+     *   mapping of a custom domain set in `restApiProps.domainName`. So
+     *   `basePath: "/prod"` mounts at the root, `"/prod/base"` under `base`, and
+     *   `"/docs"` behind a custom domain mapped at the root under `docs`. On the
+     *   execute-api endpoint an app `basePath` that doesn't start with the stage
+     *   warns, since its links will miss the stage. If you set this, the app's
+     *   `basePath` must end with it. A domain attached later with
+     *   `addDomainName()` is not seen at synth; set this explicitly then — to
+     *   `"/"` when that domain's base path mapping strips your app's whole
+     *   `basePath`, which mounts every resource at the root.
      * - `NextjsRegionalContainers`: only namespaces the S3 bucket. The ALB sends
      *   every path to the container, which serves its own static assets, so this
      *   is unconstrained.
@@ -76,28 +77,26 @@ export interface NextjsBaseProps {
     readonly buildDirectory: string;
     /**
      * Bring your own S3 bucket for cache storage. When provided, cdk-nextjs
-     * will use this bucket instead of creating a new one. Cache objects are
-     * prefixed with `buildId` so multiple deployments can safely share one bucket.
-     */
-    readonly cacheBucket?: IBucket;
-    /**
-     * 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";
+     * will use this bucket instead of creating a new one.
      *
-     * export function GET() {
-     *   return NextResponse.json("");
-     * }
+     * The bucket must be dedicated to this one deployment. Don't share it with
+     * another deployment (another branch, stage, or app): every deploy's
+     * post-deploy step deletes every object under a top-level prefix other than
+     * the current `buildId/`, which includes every other deployment's cache.
      */
-    readonly healthCheckPath: string;
+    readonly cacheBucket?: IBucket;
     /**
      * Bring your own DynamoDB table for revalidation metadata. When provided,
      * cdk-nextjs will use this table instead of creating a new one. The table
      * must have `pk` (String) as partition key and `sk` (String) as sort key.
-     * Entries are partitioned by `buildId` so multiple deployments can safely
-     * share one table.
+     * Enable TTL on its `ttl` attribute too: each tag revalidation writes a
+     * revalidation log row that expires through it, and without TTL those rows
+     * accumulate.
+     *
+     * The table must be dedicated to this one deployment. Don't share it with
+     * another deployment (another branch, stage, or app): every deploy's
+     * post-deploy step deletes the entries of the build it last recorded in the
+     * table, which with a shared table is another deployment's live build.
      */
     readonly revalidationTable?: ITableV2;
     /**
@@ -109,7 +108,13 @@ export interface NextjsBaseProps {
     /**
      * Bring your own S3 bucket for static assets. When provided, cdk-nextjs
      * will deploy static assets to this bucket instead of creating a new one.
-     * Use with `basePath` to isolate assets per branch when sharing a bucket.
+     *
+     * Unlike `cacheBucket`, this one can be shared, but only between deployments
+     * with different `basePath`s (so different S3 key prefixes). Pruning only
+     * touches `<basePath>/_next/`, so it leaves the others' assets alone. Two
+     * deployments under the same prefix overwrite each other's `public/` files
+     * and prune each other's `_next/` assets once they are past the prune
+     * TTL (30 days by default).
      */
     readonly staticAssetsBucket?: IBucket;
     /**
@@ -138,7 +143,7 @@ export declare abstract class NextjsBaseConstruct extends Construct {
     abstract get url(): string;
     protected readonly nextjsType: NextjsType;
     protected readonly baseProps: NextjsBaseConstructProps;
-    protected readonly constructOverrides?: NextjsFunctionsConstructOverrides;
+    protected readonly constructOverrides?: NextjsBaseConstructOverrides;
     /**
      * The `basePath` everything downstream is built from: the `basePath` prop when
      * set, otherwise the app's own `basePath` for the `NextjsType`s where the two
@@ -147,36 +152,91 @@ export declare abstract class NextjsBaseConstruct extends Construct {
      */
     protected readonly resolvedBasePath?: string;
     constructor(scope: Construct, id: string, props: NextjsBaseConstructProps, nextjsType: NextjsType);
+    /**
+     * Warns when a path-style `assetPrefix` would 404 every bundle on this
+     * `NextjsType` — see {@link isAssetPrefixUnserved} for which combinations those
+     * are and why a prefix equal to the app's `basePath` is not one of them.
+     *
+     * Warn rather than throw: it is the app's config, the deployment otherwise
+     * works, and an absolute `assetPrefix` (already reduced to `""` by
+     * `relativeAssetPrefix`) is the supported way to serve assets from
+     * elsewhere.
+     */
+    private warnUnservedAssetPrefix;
     /**
      * For the Global `NextjsType`s the key prefix isn't a free choice: it has to be
      * `basePath` (see `resolveBasePath`). A `destinationKeyPrefix` override that
      * moves the objects elsewhere has no way to tell the distribution about it —
-     * unlike the image Lambda and `NextjsApi`, which read
+     * unlike the functions' image optimizer and `NextjsApi`, which read
      * `NextjsStaticAssets.keyPrefix` — so fail at synth rather than 404 every
      * static request.
      */
     private validateStaticAssetsKeyPrefix;
+    /**
+     * The prefix API Gateway will strip, read from the same `restApiProps`
+     * override `NextjsApi` builds its `RestApi` from. Only meaningful for
+     * `REGIONAL_FUNCTIONS`, and read before `NextjsApi` exists because the
+     * resolved `basePath` also decides the static assets' S3 key prefix.
+     *
+     * A domain attached later with `api.addDomainName()` is invisible here, the
+     * same limitation `NextjsApi.url` documents.
+     */
+    private apiGatewayPrefix;
     /**
      * Finds construct overrides (if present) on props for any `NextjsType`
      */
     private getConstructOverrides;
+    /**
+     * `overrides.nextjsFunctions`, which only the two Functions root constructs
+     * declare. Cast for the same reason as {@link functionGroups}.
+     */
+    private get functionsOverrides();
+    /**
+     * `functionGroups`, which only the two Functions root constructs accept —
+     * Containers deploy one task definition and have no 250 MB package limit to
+     * split around.
+     *
+     * Read off `baseProps` with a cast for the same reason as
+     * {@link getConstructOverrides}: `createNextjsBuild` and
+     * `createNextjsFunctions` are shared here, but the prop is declared on the
+     * subclasses, so nothing weaker than a cast can see it. Adding it to
+     * `NextjsBaseProps` would offer it to Containers, where it does nothing.
+     */
+    protected get functionGroups(): NextjsFunctionGroup[] | undefined;
+    /**
+     * The health check path as the running app actually serves it.
+     *
+     * Both consumers of this hit the app directly — the ALB target group forwards
+     * the path to the container unchanged, and the container's `wget` probe targets
+     * the local server — so the prefix that matters is the app's own `basePath`,
+     * not `resolvedBasePath` (which for `REGIONAL_CONTAINERS` is only an S3
+     * namespace). Left unprefixed, an app with a `basePath` 404s every health
+     * check, so the target never turns healthy and the deployment rolls back.
+     * `healthCheckPath` is therefore the path as the app routes it, without
+     * `basePath`; one that carries the prefix already gets it twice, which is the
+     * 0.6.2 breaking change for anyone who prefixed by hand to work around this.
+     *
+     * Takes the path as an argument rather than reading it off `baseProps`: only
+     * the two Containers root constructs declare `healthCheckPath`, since they're
+     * the only ones with something to health-check.
+     */
+    protected resolvedHealthCheckPath(healthCheckPath: string): string;
     /**
      * Get compute base props for both Lambda functions and containers
      */
     protected computeBaseProps(): NextjsComputeBaseProps;
+    /**
+     * Runs after the init cache upload: invalidating the CDN before the new
+     * cache is in place would only re-cache the responses the invalidation was
+     * meant to drop, and CloudFormation infers no ordering between the two
+     * custom resources on its own.
+     */
+    protected createNextjsPostDeploy(distribution?: IDistribution): NextjsPostDeploy;
     private createNextjsBuild;
     private createNextjsCache;
     private createNextjsStaticAssets;
     /**
      * Shared by `NextjsGlobalFunctions` and `NextjsRegionalFunctions`.
      */
-    protected createNextjsFunctions(overrides?: NextjsFunctionsOverrides): NextjsFunctions;
-    /**
-     * Shared by `NextjsGlobalFunctions` and `NextjsRegionalFunctions`, the only
-     * two `NextjsType`s for which `NextjsBuild` produces an image optimization
-     * asset. Only called when the dedicated image optimization Lambda is
-     * enabled, which is what makes the missing-asset check below an invariant
-     * violation rather than a supported configuration.
-     */
-    protected createNextjsImageFunction(overrides?: NextjsImageFunctionOverrides): NextjsImageFunction;
+    protected createNextjsFunctions(): NextjsFunctions;
 }

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

@@ -2,19 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NextjsBaseConstruct = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
 const constructs_1 = require("constructs");
 const constants_1 = require("../constants");
 const nextjs_build_1 = require("../nextjs-build/nextjs-build");
 const nextjs_cache_1 = require("../nextjs-cache");
 const nextjs_functions_1 = require("../nextjs-compute/nextjs-functions");
-const nextjs_image_function_1 = require("../nextjs-compute/nextjs-image-function");
+const nextjs_post_deploy_1 = require("../nextjs-post-deploy");
 const nextjs_static_assets_1 = require("../nextjs-static-assets");
 const base_path_1 = require("../utils/base-path");
 /**
  * Base class for all Next.js root constructs
  */
 class NextjsBaseConstruct extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsBaseConstruct", version: "0.6.1" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsBaseConstruct", version: "0.7.0" };
     nextjsBuild;
     nextjsStaticAssets;
     nextjsCache;
@@ -40,16 +41,37 @@ class NextjsBaseConstruct extends constructs_1.Construct {
         // A basePath that doesn't line up with the app's own deploys cleanly and
         // then 404s static assets, so reconcile the two up front and fail at synth
         // on a combination that can't work.
-        this.resolvedBasePath = (0, base_path_1.resolveBasePath)(nextjsType, props.basePath, this.nextjsBuild.nextConfigBasePath);
+        this.resolvedBasePath = (0, base_path_1.resolveBasePath)(nextjsType, props.basePath, this.nextjsBuild.nextConfigBasePath, this.apiGatewayPrefix());
         this.nextjsCache = this.createNextjsCache();
         this.nextjsStaticAssets = this.createNextjsStaticAssets();
         this.validateStaticAssetsKeyPrefix();
+        this.warnUnservedAssetPrefix();
+    }
+    /**
+     * Warns when a path-style `assetPrefix` would 404 every bundle on this
+     * `NextjsType` — see {@link isAssetPrefixUnserved} for which combinations those
+     * are and why a prefix equal to the app's `basePath` is not one of them.
+     *
+     * Warn rather than throw: it is the app's config, the deployment otherwise
+     * works, and an absolute `assetPrefix` (already reduced to `""` by
+     * `relativeAssetPrefix`) is the supported way to serve assets from
+     * elsewhere.
+     */
+    warnUnservedAssetPrefix() {
+        if (!(0, base_path_1.isAssetPrefixUnserved)(this.nextjsType, this.nextjsBuild.nextConfigAssetPrefix, this.nextjsBuild.nextConfigBasePath)) {
+            return;
+        }
+        console.warn(`${constants_1.LOG_PREFIX} your Next.js app sets \`assetPrefix: "${this.nextjsBuild.nextConfigAssetPrefix}"\`, ` +
+            `which NextjsType.${this.nextjsType} cannot serve: your bundles will be requested at ` +
+            `"${this.nextjsBuild.nextConfigAssetPrefix}/_next/static/..." and nothing answers there, so they will 404. ` +
+            "Drop `assetPrefix`, use an absolute one pointing at a CDN you front the assets bucket with, " +
+            "or deploy with NextjsGlobalFunctions/NextjsGlobalContainers.");
     }
     /**
      * For the Global `NextjsType`s the key prefix isn't a free choice: it has to be
      * `basePath` (see `resolveBasePath`). A `destinationKeyPrefix` override that
      * moves the objects elsewhere has no way to tell the distribution about it —
-     * unlike the image Lambda and `NextjsApi`, which read
+     * unlike the functions' image optimizer and `NextjsApi`, which read
      * `NextjsStaticAssets.keyPrefix` — so fail at synth rather than 404 every
      * static request.
      */
@@ -69,6 +91,32 @@ class NextjsBaseConstruct extends constructs_1.Construct {
                 "To namespace a shared bucket, use `basePath` — it prefixes the keys and the URLs together.");
         }
     }
+    /**
+     * The prefix API Gateway will strip, read from the same `restApiProps`
+     * override `NextjsApi` builds its `RestApi` from. Only meaningful for
+     * `REGIONAL_FUNCTIONS`, and read before `NextjsApi` exists because the
+     * resolved `basePath` also decides the static assets' S3 key prefix.
+     *
+     * A domain attached later with `api.addDomainName()` is invisible here, the
+     * same limitation `NextjsApi.url` documents.
+     */
+    apiGatewayPrefix() {
+        // `overrides.nextjsApi` is the only typed way to reach the `RestApi`'s
+        // props: `nextjsRegionalFunctions.nextjsApiProps` is
+        // `OptionalNextjsApiProps`, which has no `overrides`.
+        const apiOverrides = this.baseProps.overrides?.nextjsApi;
+        const restApiProps = apiOverrides?.restApiProps;
+        const domainName = restApiProps?.domainName;
+        const strippedPrefix = domainName
+            ? (domainName.basePath ?? "")
+            : (restApiProps?.deployOptions?.stageName ?? "prod");
+        return {
+            strippedPrefix: aws_cdk_lib_1.Token.isUnresolved(strippedPrefix)
+                ? undefined
+                : strippedPrefix,
+            customDomain: domainName !== undefined,
+        };
+    }
     /**
      * Finds construct overrides (if present) on props for any `NextjsType`
      */
@@ -86,26 +134,99 @@ class NextjsBaseConstruct extends constructs_1.Construct {
         }
         return;
     }
+    /**
+     * `overrides.nextjsFunctions`, which only the two Functions root constructs
+     * declare. Cast for the same reason as {@link functionGroups}.
+     */
+    get functionsOverrides() {
+        const overrides = this.baseProps.overrides;
+        return overrides?.nextjsFunctions;
+    }
+    /**
+     * `functionGroups`, which only the two Functions root constructs accept —
+     * Containers deploy one task definition and have no 250 MB package limit to
+     * split around.
+     *
+     * Read off `baseProps` with a cast for the same reason as
+     * {@link getConstructOverrides}: `createNextjsBuild` and
+     * `createNextjsFunctions` are shared here, but the prop is declared on the
+     * subclasses, so nothing weaker than a cast can see it. Adding it to
+     * `NextjsBaseProps` would offer it to Containers, where it does nothing.
+     */
+    get functionGroups() {
+        const props = this.baseProps;
+        return props.functionGroups;
+    }
+    /**
+     * The health check path as the running app actually serves it.
+     *
+     * Both consumers of this hit the app directly — the ALB target group forwards
+     * the path to the container unchanged, and the container's `wget` probe targets
+     * the local server — so the prefix that matters is the app's own `basePath`,
+     * not `resolvedBasePath` (which for `REGIONAL_CONTAINERS` is only an S3
+     * namespace). Left unprefixed, an app with a `basePath` 404s every health
+     * check, so the target never turns healthy and the deployment rolls back.
+     * `healthCheckPath` is therefore the path as the app routes it, without
+     * `basePath`; one that carries the prefix already gets it twice, which is the
+     * 0.6.2 breaking change for anyone who prefixed by hand to work around this.
+     *
+     * Takes the path as an argument rather than reading it off `baseProps`: only
+     * the two Containers root constructs declare `healthCheckPath`, since they're
+     * the only ones with something to health-check.
+     */
+    resolvedHealthCheckPath(healthCheckPath) {
+        return (0, base_path_1.prefixWithBasePath)(this.nextjsBuild.nextConfigBasePath, healthCheckPath);
+    }
     /**
      * Get compute base props for both Lambda functions and containers
      */
     computeBaseProps() {
         return {
-            healthCheckPath: this.baseProps.healthCheckPath,
             cacheBucket: this.nextjsCache.cacheBucket,
             revalidationTable: this.nextjsCache.revalidationTable,
             buildId: this.nextjsBuild.buildId,
-            buildDirectory: this.baseProps.buildDirectory,
             nextjsType: this.nextjsType,
-            relativePathToPackage: this.nextjsBuild.relativePathToPackage,
+            staticAssetsBucket: this.nextjsStaticAssets.bucket,
+            staticAssetsKeyPrefix: this.nextjsStaticAssets.keyPrefix,
         };
     }
+    /**
+     * Runs after the init cache upload: invalidating the CDN before the new
+     * cache is in place would only re-cache the responses the invalidation was
+     * meant to drop, and CloudFormation infers no ordering between the two
+     * custom resources on its own.
+     */
+    createNextjsPostDeploy(distribution) {
+        const postDeploy = new nextjs_post_deploy_1.NextjsPostDeploy(this, "NextjsPostDeploy", {
+            basePath: this.resolvedBasePath,
+            buildId: this.nextjsBuild.buildId,
+            distribution,
+            cacheBucket: this.nextjsCache.cacheBucket,
+            revalidationTable: this.nextjsCache.revalidationTable,
+            staticAssetsBucket: this.nextjsStaticAssets.bucket,
+            staticAssetsKeyPrefix: this.nextjsStaticAssets.keyPrefix,
+            overrides: this.baseProps.overrides?.nextjsPostDeploy,
+            ...this.constructOverrides?.nextjsPostDeployProps,
+        });
+        if (this.nextjsCache.bucketDeployment) {
+            postDeploy.node.addDependency(this.nextjsCache.bucketDeployment);
+        }
+        return postDeploy;
+    }
     createNextjsBuild() {
         return new nextjs_build_1.NextjsBuild(this, "NextjsBuild", {
             buildCommand: this.baseProps.buildCommand,
             buildDirectory: this.baseProps.buildDirectory,
             nextjsType: this.nextjsType,
             skipBuild: this.baseProps.skipBuild,
+            // The build resolves the split, since only it knows the route templates;
+            // the constructs read the result back off the manifest.
+            functionGroups: this.functionGroups?.map(({ name, routes }) => ({
+                name,
+                routes,
+            })),
+            // What the Lambdas will run decides the `sharp` binaries staged for them.
+            architecture: this.functionsOverrides?.functionProps?.architecture,
             ...this.constructOverrides?.nextjsBuildProps,
         });
     }
@@ -132,40 +253,29 @@ class NextjsBaseConstruct extends constructs_1.Construct {
     /**
      * Shared by `NextjsGlobalFunctions` and `NextjsRegionalFunctions`.
      */
-    createNextjsFunctions(overrides) {
+    createNextjsFunctions() {
+        // The getter, not a parameter, so the build and the functions read the
+        // same `architecture`.
+        const overrides = this.functionsOverrides;
         return new nextjs_functions_1.NextjsFunctions(this, "NextjsFunctions", {
             ...this.computeBaseProps(),
+            deploymentRoots: this.nextjsBuild.deploymentRoots,
+            architecture: this.nextjsBuild.architecture,
+            functionGroups: this.functionGroups,
             overrides: {
                 ...overrides,
-                dockerImageFunctionProps: {
-                    ...overrides?.dockerImageFunctionProps,
-                    vpc: this.baseProps.vpc,
+                functionProps: {
+                    ...overrides?.functionProps,
+                    // Spread conditionally rather than assigned: an unconditional
+                    // `vpc: this.baseProps.vpc` writes `undefined` over an
+                    // `overrides.nextjsFunctions.functionProps.vpc` the consumer supplied,
+                    // so the Lambdas deploy outside the VPC and cannot reach a private
+                    // RDS, ElastiCache, or VPC endpoint - with nothing said at synth.
+                    ...(this.baseProps.vpc ? { vpc: this.baseProps.vpc } : {}),
                 },
             },
-            ...this.constructOverrides?.nextjsFunctionsProps,
-        });
-    }
-    /**
-     * Shared by `NextjsGlobalFunctions` and `NextjsRegionalFunctions`, the only
-     * two `NextjsType`s for which `NextjsBuild` produces an image optimization
-     * asset. Only called when the dedicated image optimization Lambda is
-     * enabled, which is what makes the missing-asset check below an invariant
-     * violation rather than a supported configuration.
-     */
-    createNextjsImageFunction(overrides) {
-        if (!this.nextjsBuild.imageOptimizationAssetPath) {
-            throw new Error(`Missing NextjsBuild.imageOptimizationAssetPath for NextjsType.${this.nextjsType}`);
-        }
-        return new nextjs_image_function_1.NextjsImageFunction(this, "NextjsImageFunction", {
-            nextjsType: this.nextjsType,
-            imageOptimizationAssetPath: this.nextjsBuild.imageOptimizationAssetPath,
-            staticAssetsBucket: this.nextjsStaticAssets.bucket,
-            staticAssetsKeyPrefix: this.nextjsStaticAssets.keyPrefix,
-            vpc: this.baseProps.vpc,
-            overrides,
-            ...this.constructOverrides?.nextjsImageFunctionProps,
         });
     }
 }
 exports.NextjsBaseConstruct = NextjsBaseConstruct;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-base-construct.js","sourceRoot":"","sources":["../../src/root-constructs/nextjs-base-construct.ts"],"names":[],"mappings":"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","sourcesContent":["import { ITableV2 } from \"aws-cdk-lib/aws-dynamodb\";\nimport { IVpc } from \"aws-cdk-lib/aws-ec2\";\nimport { IBucket } from \"aws-cdk-lib/aws-s3\";\nimport { Construct } from \"constructs\";\nimport { LOG_PREFIX, NextjsType } from \"../constants\";\nimport { OptionalNextjsBuildProps } from \"../generated-structs/OptionalNextjsBuildProps\";\nimport { OptionalNextjsCacheProps } from \"../generated-structs/OptionalNextjsCacheProps\";\nimport { NextjsBuild } from \"../nextjs-build/nextjs-build\";\nimport { NextjsCache, NextjsCacheOverrides } from \"../nextjs-cache\";\nimport { NextjsComputeBaseProps } from \"../nextjs-compute/nextjs-compute-base-props\";\nimport {\n  NextjsFunctions,\n  NextjsFunctionsOverrides,\n  NextjsFunctionsProps,\n} from \"../nextjs-compute/nextjs-functions\";\nimport {\n  NextjsImageFunction,\n  NextjsImageFunctionOverrides,\n  NextjsImageFunctionProps,\n} from \"../nextjs-compute/nextjs-image-function\";\nimport {\n  NextjsStaticAssets,\n  NextjsStaticAssetsOverrides,\n  NextjsStaticAssetsProps,\n} from \"../nextjs-static-assets\";\nimport { resolveBasePath } from \"../utils/base-path\";\n\n/**\n * Base overrides for the props passed to constructs within root/top-level Next.js constructs\n */\nexport interface NextjsBaseConstructOverrides {\n  readonly nextjsBuildProps?: OptionalNextjsBuildProps;\n  readonly nextjsCacheProps?: OptionalNextjsCacheProps;\n  readonly nextjsStaticAssetsProps?: NextjsStaticAssetsProps;\n}\n\n/**\n * Adds the overrides that only apply to the two Functions `NextjsType`s. The\n * Containers types serve `_next/image` from the standalone server itself and\n * have no Lambda functions to configure, so they would silently ignore these.\n */\nexport interface NextjsFunctionsConstructOverrides extends NextjsBaseConstructOverrides {\n  readonly nextjsFunctionsProps?: NextjsFunctionsProps;\n  readonly nextjsImageFunctionProps?: NextjsImageFunctionProps;\n}\n\n/**\n * Base overrides for constructs shared between all root/top-level Next.js constructs.\n */\nexport interface NextjsBaseOverrides {\n  readonly nextjsCache?: NextjsCacheOverrides;\n  readonly nextjsStaticAssets?: NextjsStaticAssetsOverrides;\n}\n\nexport interface NextjsBaseProps {\n  /**\n   * Prefix to the URI path the app will be served at. Also namespaces the\n   * static assets in S3, so it doubles as a way to host multiple apps or\n   * branches out of one bucket.\n   *\n   * How this relates to the `basePath` in your app's `next.config.js` depends\n   * on the construct, and synth fails on a combination that can't serve the\n   * app:\n   *\n   * - `NextjsGlobalFunctions`/`NextjsGlobalContainers`: leave this unset and it\n   *   follows your app's `basePath`, which is what you want — CloudFront serves\n   *   static assets from S3 using the request path as the object key, so the two\n   *   have to be identical and a mismatch 404s all of them. Setting a different\n   *   value throws.\n   * - `NextjsRegionalFunctions`: if you set this, the app's `basePath` must end\n   *   with it — either equal to it, or prefixed by the stage or base path\n   *   mapping API Gateway strips before matching resources (`basePath:\n   *   \"/prod/base\"` with this set to `\"/base\"`). Leaving it unset while the app\n   *   sets one is correct and common — an app served at the default `prod` stage\n   *   sets `basePath: \"/prod\"` and leaves this alone.\n   * - `NextjsRegionalContainers`: only namespaces the S3 bucket. The ALB sends\n   *   every path to the container, which serves its own static assets, so this\n   *   is unconstrained.\n   * @example \"/my-base-path\"\n   */\n  readonly basePath?: string;\n  /**\n   * Command to generate optimized version of your Next.js app in container;\n   * @default \"npm run build\"\n   */\n  readonly buildCommand?: string;\n  /**\n   * Directory where the Next.js application is located for local builds.\n   * This should contain the package.json and Next.js application files.\n   * This is where {@link NextjsBaseProps.buildCommand} is run.\n   * @example join(import.meta.dirname, \"..\", \"web\") or \"/path/to/nextjs/app\"\n   */\n  readonly buildDirectory: string;\n  /**\n   * Bring your own S3 bucket for cache storage. When provided, cdk-nextjs\n   * will use this bucket instead of creating a new one. Cache objects are\n   * prefixed with `buildId` so multiple deployments can safely share one bucket.\n   */\n  readonly cacheBucket?: IBucket;\n  /**\n   * Path to API Route Handler that returns HTTP 200 to ensure compute health.\n   * @example \"/api/health\"\n   * @example\n   * // api/health/route.ts\n   * import { NextResponse } from \"next/server\";\n   *\n   * export function GET() {\n   *   return NextResponse.json(\"\");\n   * }\n   */\n  readonly healthCheckPath: string;\n  /**\n   * Bring your own DynamoDB table for revalidation metadata. When provided,\n   * cdk-nextjs will use this table instead of creating a new one. The table\n   * must have `pk` (String) as partition key and `sk` (String) as sort key.\n   * Entries are partitioned by `buildId` so multiple deployments can safely\n   * share one table.\n   */\n  readonly revalidationTable?: ITableV2;\n  /**\n   * Skips running `next build`. If `true`, you are responsible for running\n   * `next build` before this construct is synthesized.\n   * @default false\n   */\n  readonly skipBuild?: boolean;\n  /**\n   * Bring your own S3 bucket for static assets. When provided, cdk-nextjs\n   * will deploy static assets to this bucket instead of creating a new one.\n   * Use with `basePath` to isolate assets per branch when sharing a bucket.\n   */\n  readonly staticAssetsBucket?: IBucket;\n  /**\n   * Bring your own VPC.\n   * If provided, will be passed via overrides to the ECS Cluster (for container-based constructs)\n   * or to the Lambda function (for function-based constructs).\n   * If not provided, ECS Cluster will create a VPC automatically for containers,\n   * and Lambda functions will run outside a VPC.\n   */\n  readonly vpc?: IVpc;\n}\n\n/**\n * Required because if we add `overrides` onto `NextjsBaseProps` we get jsii\n * error: `Interface ... re-declares member \"overrides\"`\n */\nexport interface NextjsBaseConstructProps extends NextjsBaseProps {\n  readonly overrides?: NextjsBaseOverrides;\n}\n\n/**\n * Base class for all Next.js root constructs\n */\nexport abstract class NextjsBaseConstruct extends Construct {\n  nextjsBuild: NextjsBuild;\n  nextjsStaticAssets: NextjsStaticAssets;\n  nextjsCache: NextjsCache;\n\n  abstract get url(): string;\n\n  protected readonly nextjsType: NextjsType;\n  // use baseProps instead of props so that child classes can use props\n  protected readonly baseProps: NextjsBaseConstructProps;\n  // Widest shape of the per-`NextjsType` overrides. The public interface each\n  // root construct accepts is what actually gates which keys are settable.\n  protected readonly constructOverrides?: NextjsFunctionsConstructOverrides;\n  /**\n   * The `basePath` everything downstream is built from: the `basePath` prop when\n   * set, otherwise the app's own `basePath` for the `NextjsType`s where the two\n   * are necessarily the same. Normalized to a bare path segment, `undefined` for\n   * no `basePath`. Use this instead of `baseProps.basePath`.\n   */\n  protected readonly resolvedBasePath?: string;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: NextjsBaseConstructProps,\n    nextjsType: NextjsType,\n  ) {\n    super(scope, id);\n    this.baseProps = props;\n    this.nextjsType = nextjsType;\n    this.constructOverrides = this.getConstructOverrides(nextjsType);\n\n    this.nextjsBuild = this.createNextjsBuild();\n    // A basePath that doesn't line up with the app's own deploys cleanly and\n    // then 404s static assets, so reconcile the two up front and fail at synth\n    // on a combination that can't work.\n    this.resolvedBasePath = resolveBasePath(\n      nextjsType,\n      props.basePath,\n      this.nextjsBuild.nextConfigBasePath,\n    );\n    this.nextjsCache = this.createNextjsCache();\n    this.nextjsStaticAssets = this.createNextjsStaticAssets();\n    this.validateStaticAssetsKeyPrefix();\n  }\n\n  /**\n   * For the Global `NextjsType`s the key prefix isn't a free choice: it has to be\n   * `basePath` (see `resolveBasePath`). A `destinationKeyPrefix` override that\n   * moves the objects elsewhere has no way to tell the distribution about it —\n   * unlike the image Lambda and `NextjsApi`, which read\n   * `NextjsStaticAssets.keyPrefix` — so fail at synth rather than 404 every\n   * static request.\n   */\n  private validateStaticAssetsKeyPrefix(): void {\n    if (\n      this.nextjsType !== NextjsType.GLOBAL_FUNCTIONS &&\n      this.nextjsType !== NextjsType.GLOBAL_CONTAINERS\n    ) {\n      return;\n    }\n    const expected = this.resolvedBasePath ?? \"\";\n    const actual = this.nextjsStaticAssets.keyPrefix;\n    if (actual !== expected) {\n      throw new Error(\n        `${LOG_PREFIX} static assets key prefix mismatch for NextjsType.${this.nextjsType}: ` +\n          `the assets are uploaded under ${actual ? `\"${actual}\"` : \"the bucket root\"} ` +\n          `but CloudFront will request them under ${expected ? `\"${expected}\"` : \"the bucket root\"}, ` +\n          \"using the request path as the S3 object key, so every `_next/static` and `public/` request would 404. \" +\n          \"Drop the `destinationKeyPrefix` override, or set it to the same value as `basePath`. \" +\n          \"To namespace a shared bucket, use `basePath` — it prefixes the keys and the URLs together.\",\n      );\n    }\n  }\n\n  /**\n   * Finds construct overrides (if present) on props for any `NextjsType`\n   */\n  private getConstructOverrides(nextjsType: NextjsType) {\n    const nextjsTypeToKey: Record<NextjsType, string> = {\n      [NextjsType.GLOBAL_CONTAINERS]: \"nextjsGlobalContainers\",\n      [NextjsType.GLOBAL_FUNCTIONS]: \"nextjsGlobalFunctions\",\n      [NextjsType.REGIONAL_CONTAINERS]: \"nextjsRegionalContainers\",\n      [NextjsType.REGIONAL_FUNCTIONS]: \"nextjsRegionalFunctions\",\n    };\n    const key = nextjsTypeToKey[nextjsType];\n    const overrides = this.baseProps.overrides as\n      Record<string, unknown> | undefined;\n    if (overrides && key in overrides) {\n      return overrides[key] as NextjsFunctionsConstructOverrides;\n    }\n    return;\n  }\n\n  /**\n   * Get compute base props for both Lambda functions and containers\n   */\n  protected computeBaseProps(): NextjsComputeBaseProps {\n    return {\n      healthCheckPath: this.baseProps.healthCheckPath,\n      cacheBucket: this.nextjsCache.cacheBucket,\n      revalidationTable: this.nextjsCache.revalidationTable,\n      buildId: this.nextjsBuild.buildId,\n      buildDirectory: this.baseProps.buildDirectory,\n      nextjsType: this.nextjsType,\n      relativePathToPackage: this.nextjsBuild.relativePathToPackage,\n    };\n  }\n\n  private createNextjsBuild(): NextjsBuild {\n    return new NextjsBuild(this, \"NextjsBuild\", {\n      buildCommand: this.baseProps.buildCommand,\n      buildDirectory: this.baseProps.buildDirectory,\n      nextjsType: this.nextjsType,\n      skipBuild: this.baseProps.skipBuild,\n      ...this.constructOverrides?.nextjsBuildProps,\n    });\n  }\n\n  private createNextjsCache(): NextjsCache {\n    return new NextjsCache(this, \"NextjsCache\", {\n      buildId: this.nextjsBuild.buildId,\n      cacheBucket: this.baseProps.cacheBucket,\n      initCacheDir: this.nextjsBuild.initCacheDir,\n      overrides: this.baseProps.overrides?.nextjsCache,\n      revalidationTable: this.baseProps.revalidationTable,\n      ...this.constructOverrides?.nextjsCacheProps,\n    });\n  }\n\n  private createNextjsStaticAssets(): NextjsStaticAssets {\n    return new NextjsStaticAssets(this, \"NextjsStaticAssets\", {\n      bucket: this.baseProps.staticAssetsBucket,\n      buildDirectory: this.baseProps.buildDirectory,\n      buildId: this.nextjsBuild.buildId,\n      basePath: this.resolvedBasePath,\n      overrides: this.baseProps.overrides?.nextjsStaticAssets,\n      ...this.constructOverrides?.nextjsStaticAssetsProps,\n    });\n  }\n\n  /**\n   * Shared by `NextjsGlobalFunctions` and `NextjsRegionalFunctions`.\n   */\n  protected createNextjsFunctions(\n    overrides?: NextjsFunctionsOverrides,\n  ): NextjsFunctions {\n    return new NextjsFunctions(this, \"NextjsFunctions\", {\n      ...this.computeBaseProps(),\n      overrides: {\n        ...overrides,\n        dockerImageFunctionProps: {\n          ...overrides?.dockerImageFunctionProps,\n          vpc: this.baseProps.vpc,\n        },\n      },\n      ...this.constructOverrides?.nextjsFunctionsProps,\n    });\n  }\n\n  /**\n   * Shared by `NextjsGlobalFunctions` and `NextjsRegionalFunctions`, the only\n   * two `NextjsType`s for which `NextjsBuild` produces an image optimization\n   * asset. Only called when the dedicated image optimization Lambda is\n   * enabled, which is what makes the missing-asset check below an invariant\n   * violation rather than a supported configuration.\n   */\n  protected createNextjsImageFunction(\n    overrides?: NextjsImageFunctionOverrides,\n  ): NextjsImageFunction {\n    if (!this.nextjsBuild.imageOptimizationAssetPath) {\n      throw new Error(\n        `Missing NextjsBuild.imageOptimizationAssetPath for NextjsType.${this.nextjsType}`,\n      );\n    }\n    return new NextjsImageFunction(this, \"NextjsImageFunction\", {\n      nextjsType: this.nextjsType,\n      imageOptimizationAssetPath: this.nextjsBuild.imageOptimizationAssetPath,\n      staticAssetsBucket: this.nextjsStaticAssets.bucket,\n      staticAssetsKeyPrefix: this.nextjsStaticAssets.keyPrefix,\n      vpc: this.baseProps.vpc,\n      overrides,\n      ...this.constructOverrides?.nextjsImageFunctionProps,\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-base-construct.js","sourceRoot":"","sources":["../../src/root-constructs/nextjs-base-construct.ts"],"names":[],"mappings":"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","sourcesContent":["import { Token } from \"aws-cdk-lib\";\nimport { IDistribution } from \"aws-cdk-lib/aws-cloudfront\";\nimport { ITableV2 } from \"aws-cdk-lib/aws-dynamodb\";\nimport { IVpc } from \"aws-cdk-lib/aws-ec2\";\nimport { IBucket } from \"aws-cdk-lib/aws-s3\";\nimport { Construct } from \"constructs\";\nimport { LOG_PREFIX, NextjsType } from \"../constants\";\nimport { OptionalNextjsBuildProps } from \"../generated-structs/OptionalNextjsBuildProps\";\nimport { OptionalNextjsCacheProps } from \"../generated-structs/OptionalNextjsCacheProps\";\nimport { OptionalNextjsPostDeployProps } from \"../generated-structs/OptionalNextjsPostDeployProps\";\nimport { NextjsApiOverrides } from \"../nextjs-api\";\nimport { NextjsBuild } from \"../nextjs-build/nextjs-build\";\nimport { NextjsCache, NextjsCacheOverrides } from \"../nextjs-cache\";\nimport { NextjsComputeBaseProps } from \"../nextjs-compute/nextjs-compute-base-props\";\nimport {\n  NextjsFunctionGroup,\n  NextjsFunctions,\n  NextjsFunctionsOverrides,\n} from \"../nextjs-compute/nextjs-functions\";\nimport {\n  NextjsPostDeploy,\n  NextjsPostDeployOverrides,\n} from \"../nextjs-post-deploy\";\nimport {\n  NextjsStaticAssets,\n  NextjsStaticAssetsOverrides,\n  NextjsStaticAssetsProps,\n} from \"../nextjs-static-assets\";\nimport {\n  ApiGatewayPrefix,\n  isAssetPrefixUnserved,\n  prefixWithBasePath,\n  resolveBasePath,\n} from \"../utils/base-path\";\n\n/**\n * Base overrides for the props passed to constructs within root/top-level Next.js constructs\n */\nexport interface NextjsBaseConstructOverrides {\n  readonly nextjsBuildProps?: OptionalNextjsBuildProps;\n  readonly nextjsCacheProps?: OptionalNextjsCacheProps;\n  readonly nextjsPostDeployProps?: OptionalNextjsPostDeployProps;\n  readonly nextjsStaticAssetsProps?: NextjsStaticAssetsProps;\n}\n\n/**\n * Base overrides for constructs shared between all root/top-level Next.js constructs.\n */\nexport interface NextjsBaseOverrides {\n  readonly nextjsCache?: NextjsCacheOverrides;\n  readonly nextjsPostDeploy?: NextjsPostDeployOverrides;\n  readonly nextjsStaticAssets?: NextjsStaticAssetsOverrides;\n}\n\nexport interface NextjsBaseProps {\n  /**\n   * Prefix to the URI path the app will be served at. Also namespaces the\n   * static assets in S3, so it doubles as a way to host multiple apps or\n   * branches out of one bucket.\n   *\n   * How this relates to the `basePath` in your app's `next.config.js` depends\n   * on the construct, and synth fails on a combination that can't serve the\n   * app:\n   *\n   * - `NextjsGlobalFunctions`/`NextjsGlobalContainers`: leave this unset and it\n   *   follows your app's `basePath`, which is what you want — CloudFront serves\n   *   static assets from S3 using the request path as the object key, so the two\n   *   have to be identical and a mismatch 404s all of them. Setting a different\n   *   value throws.\n   * - `NextjsRegionalFunctions`: leave this unset and it follows your app's\n   *   `basePath` minus the prefix API Gateway strips before matching resources —\n   *   the stage (`deployOptions.stageName`, default `prod`), or the base path\n   *   mapping of a custom domain set in `restApiProps.domainName`. So\n   *   `basePath: \"/prod\"` mounts at the root, `\"/prod/base\"` under `base`, and\n   *   `\"/docs\"` behind a custom domain mapped at the root under `docs`. On the\n   *   execute-api endpoint an app `basePath` that doesn't start with the stage\n   *   warns, since its links will miss the stage. If you set this, the app's\n   *   `basePath` must end with it. A domain attached later with\n   *   `addDomainName()` is not seen at synth; set this explicitly then — to\n   *   `\"/\"` when that domain's base path mapping strips your app's whole\n   *   `basePath`, which mounts every resource at the root.\n   * - `NextjsRegionalContainers`: only namespaces the S3 bucket. The ALB sends\n   *   every path to the container, which serves its own static assets, so this\n   *   is unconstrained.\n   * @example \"/my-base-path\"\n   */\n  readonly basePath?: string;\n  /**\n   * Command to generate optimized version of your Next.js app in container;\n   * @default \"npm run build\"\n   */\n  readonly buildCommand?: string;\n  /**\n   * Directory where the Next.js application is located for local builds.\n   * This should contain the package.json and Next.js application files.\n   * This is where {@link NextjsBaseProps.buildCommand} is run.\n   * @example join(import.meta.dirname, \"..\", \"web\") or \"/path/to/nextjs/app\"\n   */\n  readonly buildDirectory: string;\n  /**\n   * Bring your own S3 bucket for cache storage. When provided, cdk-nextjs\n   * will use this bucket instead of creating a new one.\n   *\n   * The bucket must be dedicated to this one deployment. Don't share it with\n   * another deployment (another branch, stage, or app): every deploy's\n   * post-deploy step deletes every object under a top-level prefix other than\n   * the current `buildId/`, which includes every other deployment's cache.\n   */\n  readonly cacheBucket?: IBucket;\n  /**\n   * Bring your own DynamoDB table for revalidation metadata. When provided,\n   * cdk-nextjs will use this table instead of creating a new one. The table\n   * must have `pk` (String) as partition key and `sk` (String) as sort key.\n   * Enable TTL on its `ttl` attribute too: each tag revalidation writes a\n   * revalidation log row that expires through it, and without TTL those rows\n   * accumulate.\n   *\n   * The table must be dedicated to this one deployment. Don't share it with\n   * another deployment (another branch, stage, or app): every deploy's\n   * post-deploy step deletes the entries of the build it last recorded in the\n   * table, which with a shared table is another deployment's live build.\n   */\n  readonly revalidationTable?: ITableV2;\n  /**\n   * Skips running `next build`. If `true`, you are responsible for running\n   * `next build` before this construct is synthesized.\n   * @default false\n   */\n  readonly skipBuild?: boolean;\n  /**\n   * Bring your own S3 bucket for static assets. When provided, cdk-nextjs\n   * will deploy static assets to this bucket instead of creating a new one.\n   *\n   * Unlike `cacheBucket`, this one can be shared, but only between deployments\n   * with different `basePath`s (so different S3 key prefixes). Pruning only\n   * touches `<basePath>/_next/`, so it leaves the others' assets alone. Two\n   * deployments under the same prefix overwrite each other's `public/` files\n   * and prune each other's `_next/` assets once they are past the prune\n   * TTL (30 days by default).\n   */\n  readonly staticAssetsBucket?: IBucket;\n  /**\n   * Bring your own VPC.\n   * If provided, will be passed via overrides to the ECS Cluster (for container-based constructs)\n   * or to the Lambda function (for function-based constructs).\n   * If not provided, ECS Cluster will create a VPC automatically for containers,\n   * and Lambda functions will run outside a VPC.\n   */\n  readonly vpc?: IVpc;\n}\n\n/**\n * Required because if we add `overrides` onto `NextjsBaseProps` we get jsii\n * error: `Interface ... re-declares member \"overrides\"`\n */\nexport interface NextjsBaseConstructProps extends NextjsBaseProps {\n  readonly overrides?: NextjsBaseOverrides;\n}\n\n/**\n * Base class for all Next.js root constructs\n */\nexport abstract class NextjsBaseConstruct extends Construct {\n  nextjsBuild: NextjsBuild;\n  nextjsStaticAssets: NextjsStaticAssets;\n  nextjsCache: NextjsCache;\n\n  abstract get url(): string;\n\n  protected readonly nextjsType: NextjsType;\n  // use baseProps instead of props so that child classes can use props\n  protected readonly baseProps: NextjsBaseConstructProps;\n  // Widest shape of the per-`NextjsType` overrides. The public interface each\n  // root construct accepts is what actually gates which keys are settable.\n  protected readonly constructOverrides?: NextjsBaseConstructOverrides;\n  /**\n   * The `basePath` everything downstream is built from: the `basePath` prop when\n   * set, otherwise the app's own `basePath` for the `NextjsType`s where the two\n   * are necessarily the same. Normalized to a bare path segment, `undefined` for\n   * no `basePath`. Use this instead of `baseProps.basePath`.\n   */\n  protected readonly resolvedBasePath?: string;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: NextjsBaseConstructProps,\n    nextjsType: NextjsType,\n  ) {\n    super(scope, id);\n    this.baseProps = props;\n    this.nextjsType = nextjsType;\n    this.constructOverrides = this.getConstructOverrides(nextjsType);\n\n    this.nextjsBuild = this.createNextjsBuild();\n    // A basePath that doesn't line up with the app's own deploys cleanly and\n    // then 404s static assets, so reconcile the two up front and fail at synth\n    // on a combination that can't work.\n    this.resolvedBasePath = resolveBasePath(\n      nextjsType,\n      props.basePath,\n      this.nextjsBuild.nextConfigBasePath,\n      this.apiGatewayPrefix(),\n    );\n    this.nextjsCache = this.createNextjsCache();\n    this.nextjsStaticAssets = this.createNextjsStaticAssets();\n    this.validateStaticAssetsKeyPrefix();\n    this.warnUnservedAssetPrefix();\n  }\n\n  /**\n   * Warns when a path-style `assetPrefix` would 404 every bundle on this\n   * `NextjsType` — see {@link isAssetPrefixUnserved} for which combinations those\n   * are and why a prefix equal to the app's `basePath` is not one of them.\n   *\n   * Warn rather than throw: it is the app's config, the deployment otherwise\n   * works, and an absolute `assetPrefix` (already reduced to `\"\"` by\n   * `relativeAssetPrefix`) is the supported way to serve assets from\n   * elsewhere.\n   */\n  private warnUnservedAssetPrefix(): void {\n    if (\n      !isAssetPrefixUnserved(\n        this.nextjsType,\n        this.nextjsBuild.nextConfigAssetPrefix,\n        this.nextjsBuild.nextConfigBasePath,\n      )\n    ) {\n      return;\n    }\n    console.warn(\n      `${LOG_PREFIX} your Next.js app sets \\`assetPrefix: \"${this.nextjsBuild.nextConfigAssetPrefix}\"\\`, ` +\n        `which NextjsType.${this.nextjsType} cannot serve: your bundles will be requested at ` +\n        `\"${this.nextjsBuild.nextConfigAssetPrefix}/_next/static/...\" and nothing answers there, so they will 404. ` +\n        \"Drop `assetPrefix`, use an absolute one pointing at a CDN you front the assets bucket with, \" +\n        \"or deploy with NextjsGlobalFunctions/NextjsGlobalContainers.\",\n    );\n  }\n\n  /**\n   * For the Global `NextjsType`s the key prefix isn't a free choice: it has to be\n   * `basePath` (see `resolveBasePath`). A `destinationKeyPrefix` override that\n   * moves the objects elsewhere has no way to tell the distribution about it —\n   * unlike the functions' image optimizer and `NextjsApi`, which read\n   * `NextjsStaticAssets.keyPrefix` — so fail at synth rather than 404 every\n   * static request.\n   */\n  private validateStaticAssetsKeyPrefix(): void {\n    if (\n      this.nextjsType !== NextjsType.GLOBAL_FUNCTIONS &&\n      this.nextjsType !== NextjsType.GLOBAL_CONTAINERS\n    ) {\n      return;\n    }\n    const expected = this.resolvedBasePath ?? \"\";\n    const actual = this.nextjsStaticAssets.keyPrefix;\n    if (actual !== expected) {\n      throw new Error(\n        `${LOG_PREFIX} static assets key prefix mismatch for NextjsType.${this.nextjsType}: ` +\n          `the assets are uploaded under ${actual ? `\"${actual}\"` : \"the bucket root\"} ` +\n          `but CloudFront will request them under ${expected ? `\"${expected}\"` : \"the bucket root\"}, ` +\n          \"using the request path as the S3 object key, so every `_next/static` and `public/` request would 404. \" +\n          \"Drop the `destinationKeyPrefix` override, or set it to the same value as `basePath`. \" +\n          \"To namespace a shared bucket, use `basePath` — it prefixes the keys and the URLs together.\",\n      );\n    }\n  }\n\n  /**\n   * The prefix API Gateway will strip, read from the same `restApiProps`\n   * override `NextjsApi` builds its `RestApi` from. Only meaningful for\n   * `REGIONAL_FUNCTIONS`, and read before `NextjsApi` exists because the\n   * resolved `basePath` also decides the static assets' S3 key prefix.\n   *\n   * A domain attached later with `api.addDomainName()` is invisible here, the\n   * same limitation `NextjsApi.url` documents.\n   */\n  private apiGatewayPrefix(): ApiGatewayPrefix {\n    // `overrides.nextjsApi` is the only typed way to reach the `RestApi`'s\n    // props: `nextjsRegionalFunctions.nextjsApiProps` is\n    // `OptionalNextjsApiProps`, which has no `overrides`.\n    const apiOverrides = (\n      this.baseProps.overrides as { nextjsApi?: NextjsApiOverrides } | undefined\n    )?.nextjsApi;\n    const restApiProps = apiOverrides?.restApiProps;\n    const domainName = restApiProps?.domainName;\n    const strippedPrefix = domainName\n      ? (domainName.basePath ?? \"\")\n      : (restApiProps?.deployOptions?.stageName ?? \"prod\");\n    return {\n      strippedPrefix: Token.isUnresolved(strippedPrefix)\n        ? undefined\n        : strippedPrefix,\n      customDomain: domainName !== undefined,\n    };\n  }\n\n  /**\n   * Finds construct overrides (if present) on props for any `NextjsType`\n   */\n  private getConstructOverrides(nextjsType: NextjsType) {\n    const nextjsTypeToKey: Record<NextjsType, string> = {\n      [NextjsType.GLOBAL_CONTAINERS]: \"nextjsGlobalContainers\",\n      [NextjsType.GLOBAL_FUNCTIONS]: \"nextjsGlobalFunctions\",\n      [NextjsType.REGIONAL_CONTAINERS]: \"nextjsRegionalContainers\",\n      [NextjsType.REGIONAL_FUNCTIONS]: \"nextjsRegionalFunctions\",\n    };\n    const key = nextjsTypeToKey[nextjsType];\n    const overrides = this.baseProps.overrides as\n      Record<string, unknown> | undefined;\n    if (overrides && key in overrides) {\n      return overrides[key] as NextjsBaseConstructOverrides;\n    }\n    return;\n  }\n\n  /**\n   * `overrides.nextjsFunctions`, which only the two Functions root constructs\n   * declare. Cast for the same reason as {@link functionGroups}.\n   */\n  private get functionsOverrides(): NextjsFunctionsOverrides | undefined {\n    const overrides = this.baseProps.overrides as\n      { nextjsFunctions?: NextjsFunctionsOverrides } | undefined;\n    return overrides?.nextjsFunctions;\n  }\n\n  /**\n   * `functionGroups`, which only the two Functions root constructs accept —\n   * Containers deploy one task definition and have no 250 MB package limit to\n   * split around.\n   *\n   * Read off `baseProps` with a cast for the same reason as\n   * {@link getConstructOverrides}: `createNextjsBuild` and\n   * `createNextjsFunctions` are shared here, but the prop is declared on the\n   * subclasses, so nothing weaker than a cast can see it. Adding it to\n   * `NextjsBaseProps` would offer it to Containers, where it does nothing.\n   */\n  protected get functionGroups(): NextjsFunctionGroup[] | undefined {\n    const props = this.baseProps as { functionGroups?: NextjsFunctionGroup[] };\n    return props.functionGroups;\n  }\n\n  /**\n   * The health check path as the running app actually serves it.\n   *\n   * Both consumers of this hit the app directly — the ALB target group forwards\n   * the path to the container unchanged, and the container's `wget` probe targets\n   * the local server — so the prefix that matters is the app's own `basePath`,\n   * not `resolvedBasePath` (which for `REGIONAL_CONTAINERS` is only an S3\n   * namespace). Left unprefixed, an app with a `basePath` 404s every health\n   * check, so the target never turns healthy and the deployment rolls back.\n   * `healthCheckPath` is therefore the path as the app routes it, without\n   * `basePath`; one that carries the prefix already gets it twice, which is the\n   * 0.6.2 breaking change for anyone who prefixed by hand to work around this.\n   *\n   * Takes the path as an argument rather than reading it off `baseProps`: only\n   * the two Containers root constructs declare `healthCheckPath`, since they're\n   * the only ones with something to health-check.\n   */\n  protected resolvedHealthCheckPath(healthCheckPath: string): string {\n    return prefixWithBasePath(\n      this.nextjsBuild.nextConfigBasePath,\n      healthCheckPath,\n    );\n  }\n\n  /**\n   * Get compute base props for both Lambda functions and containers\n   */\n  protected computeBaseProps(): NextjsComputeBaseProps {\n    return {\n      cacheBucket: this.nextjsCache.cacheBucket,\n      revalidationTable: this.nextjsCache.revalidationTable,\n      buildId: this.nextjsBuild.buildId,\n      nextjsType: this.nextjsType,\n      staticAssetsBucket: this.nextjsStaticAssets.bucket,\n      staticAssetsKeyPrefix: this.nextjsStaticAssets.keyPrefix,\n    };\n  }\n\n  /**\n   * Runs after the init cache upload: invalidating the CDN before the new\n   * cache is in place would only re-cache the responses the invalidation was\n   * meant to drop, and CloudFormation infers no ordering between the two\n   * custom resources on its own.\n   */\n  protected createNextjsPostDeploy(\n    distribution?: IDistribution,\n  ): NextjsPostDeploy {\n    const postDeploy = new NextjsPostDeploy(this, \"NextjsPostDeploy\", {\n      basePath: this.resolvedBasePath,\n      buildId: this.nextjsBuild.buildId,\n      distribution,\n      cacheBucket: this.nextjsCache.cacheBucket,\n      revalidationTable: this.nextjsCache.revalidationTable,\n      staticAssetsBucket: this.nextjsStaticAssets.bucket,\n      staticAssetsKeyPrefix: this.nextjsStaticAssets.keyPrefix,\n      overrides: this.baseProps.overrides?.nextjsPostDeploy,\n      ...this.constructOverrides?.nextjsPostDeployProps,\n    });\n    if (this.nextjsCache.bucketDeployment) {\n      postDeploy.node.addDependency(this.nextjsCache.bucketDeployment);\n    }\n    return postDeploy;\n  }\n\n  private createNextjsBuild(): NextjsBuild {\n    return new NextjsBuild(this, \"NextjsBuild\", {\n      buildCommand: this.baseProps.buildCommand,\n      buildDirectory: this.baseProps.buildDirectory,\n      nextjsType: this.nextjsType,\n      skipBuild: this.baseProps.skipBuild,\n      // The build resolves the split, since only it knows the route templates;\n      // the constructs read the result back off the manifest.\n      functionGroups: this.functionGroups?.map(({ name, routes }) => ({\n        name,\n        routes,\n      })),\n      // What the Lambdas will run decides the `sharp` binaries staged for them.\n      architecture: this.functionsOverrides?.functionProps?.architecture,\n      ...this.constructOverrides?.nextjsBuildProps,\n    });\n  }\n\n  private createNextjsCache(): NextjsCache {\n    return new NextjsCache(this, \"NextjsCache\", {\n      buildId: this.nextjsBuild.buildId,\n      cacheBucket: this.baseProps.cacheBucket,\n      initCacheDir: this.nextjsBuild.initCacheDir,\n      overrides: this.baseProps.overrides?.nextjsCache,\n      revalidationTable: this.baseProps.revalidationTable,\n      ...this.constructOverrides?.nextjsCacheProps,\n    });\n  }\n\n  private createNextjsStaticAssets(): NextjsStaticAssets {\n    return new NextjsStaticAssets(this, \"NextjsStaticAssets\", {\n      bucket: this.baseProps.staticAssetsBucket,\n      buildDirectory: this.baseProps.buildDirectory,\n      buildId: this.nextjsBuild.buildId,\n      basePath: this.resolvedBasePath,\n      overrides: this.baseProps.overrides?.nextjsStaticAssets,\n      ...this.constructOverrides?.nextjsStaticAssetsProps,\n    });\n  }\n\n  /**\n   * Shared by `NextjsGlobalFunctions` and `NextjsRegionalFunctions`.\n   */\n  protected createNextjsFunctions(): NextjsFunctions {\n    // The getter, not a parameter, so the build and the functions read the\n    // same `architecture`.\n    const overrides = this.functionsOverrides;\n    return new NextjsFunctions(this, \"NextjsFunctions\", {\n      ...this.computeBaseProps(),\n      deploymentRoots: this.nextjsBuild.deploymentRoots,\n      architecture: this.nextjsBuild.architecture,\n      functionGroups: this.functionGroups,\n      overrides: {\n        ...overrides,\n        functionProps: {\n          ...overrides?.functionProps,\n          // Spread conditionally rather than assigned: an unconditional\n          // `vpc: this.baseProps.vpc` writes `undefined` over an\n          // `overrides.nextjsFunctions.functionProps.vpc` the consumer supplied,\n          // so the Lambdas deploy outside the VPC and cannot reach a private\n          // RDS, ElastiCache, or VPC endpoint - with nothing said at synth.\n          ...(this.baseProps.vpc ? { vpc: this.baseProps.vpc } : {}),\n        },\n      },\n    });\n  }\n}\n"]}