cdk-nextjs 0.5.15 → 0.6.0

package/lib/nextjs-static-assets.test.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const nextjs_static_assets_1 = require("./nextjs-static-assets");
+describe("NextjsStaticAssets", () => {
+    let stack;
+    let buildDirectory;
+    beforeEach(() => {
+        stack = new aws_cdk_lib_1.Stack(new aws_cdk_lib_1.App(), "TestStack");
+        buildDirectory = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "nextjs-static-assets-"));
+        const staticDir = (0, node_path_1.join)(buildDirectory, ".next", "static");
+        (0, node_fs_1.mkdirSync)(staticDir, { recursive: true });
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(staticDir, "chunk.js"), "// chunk");
+    });
+    afterEach(() => {
+        (0, node_fs_1.rmSync)(buildDirectory, { recursive: true, force: true });
+    });
+    function createStaticAssets(props) {
+        return new nextjs_static_assets_1.NextjsStaticAssets(stack, "NextjsStaticAssets", {
+            buildDirectory,
+            buildId: "test-build-id",
+            basePath: props.basePath,
+            overrides: props.destinationKeyPrefix === undefined
+                ? undefined
+                : {
+                    bucketDeploymentProps: {
+                        destinationKeyPrefix: props.destinationKeyPrefix,
+                    },
+                },
+        });
+    }
+    describe("keyPrefix", () => {
+        it("is empty when no basePath is set", () => {
+            expect(createStaticAssets({}).keyPrefix).toBe("");
+        });
+        it("strips surrounding slashes from basePath", () => {
+            expect(createStaticAssets({ basePath: "/base/" }).keyPrefix).toBe("base");
+        });
+        // The override is spread last into BucketDeployment, so it decides where
+        // the objects actually land. Consumers reading assets back out of the
+        // bucket have to see that, not the basePath prop.
+        it("reflects a destinationKeyPrefix override rather than basePath", () => {
+            expect(createStaticAssets({
+                basePath: "/base",
+                destinationKeyPrefix: "branch-x",
+            }).keyPrefix).toBe("branch-x");
+        });
+        it("is empty when an override clears the prefix", () => {
+            expect(createStaticAssets({ basePath: "/base", destinationKeyPrefix: "" })
+                .keyPrefix).toBe("");
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -8,6 +8,8 @@ import { OptionalNextjsCacheProps } from "../generated-structs/OptionalNextjsCac
 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 { NextjsStaticAssets, NextjsStaticAssetsOverrides, NextjsStaticAssetsProps } from "../nextjs-static-assets";
 /**
  * Base overrides for the props passed to constructs within root/top-level Next.js constructs
@@ -17,6 +19,15 @@ export interface NextjsBaseConstructOverrides {
     readonly nextjsCacheProps?: OptionalNextjsCacheProps;
     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.
  */
@@ -26,7 +37,28 @@ export interface NextjsBaseOverrides {
 }
 export interface NextjsBaseProps {
     /**
-     * Prefix to the URI path the app will be served at.
+     * Prefix to the URI path the app will be served at. Also namespaces the
+     * static assets in S3, so it doubles as a way to host multiple apps or
+     * branches out of one bucket.
+     *
+     * How this relates to the `basePath` in your app's `next.config.js` depends
+     * on the construct, and synth fails on a combination that can't serve the
+     * app:
+     *
+     * - `NextjsGlobalFunctions`/`NextjsGlobalContainers`: leave this unset and it
+     *   follows your app's `basePath`, which is what you want — CloudFront serves
+     *   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.
+     * - `NextjsRegionalContainers`: only namespaces the S3 bucket. The ALB sends
+     *   every path to the container, which serves its own static assets, so this
+     *   is unconstrained.
      * @example "/my-base-path"
      */
     readonly basePath?: string;
@@ -106,8 +138,24 @@ export declare abstract class NextjsBaseConstruct extends Construct {
     abstract get url(): string;
     protected readonly nextjsType: NextjsType;
     protected readonly baseProps: NextjsBaseConstructProps;
-    protected readonly constructOverrides?: NextjsBaseConstructOverrides;
+    protected readonly constructOverrides?: NextjsFunctionsConstructOverrides;
+    /**
+     * 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
+     * are necessarily the same. Normalized to a bare path segment, `undefined` for
+     * no `basePath`. Use this instead of `baseProps.basePath`.
+     */
+    protected readonly resolvedBasePath?: string;
     constructor(scope: Construct, id: string, props: NextjsBaseConstructProps, nextjsType: NextjsType);
+    /**
+     * 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
+     * `NextjsStaticAssets.keyPrefix` — so fail at synth rather than 404 every
+     * static request.
+     */
+    private validateStaticAssetsKeyPrefix;
     /**
      * Finds construct overrides (if present) on props for any `NextjsType`
      */
@@ -119,4 +167,16 @@ export declare abstract class NextjsBaseConstruct extends Construct {
     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;
 }

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

@@ -6,27 +6,68 @@ 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_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.5.15" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsBaseConstruct", version: "0.6.0" };
     nextjsBuild;
     nextjsStaticAssets;
     nextjsCache;
     nextjsType;
     // use baseProps instead of props so that child classes can use props
     baseProps;
+    // Widest shape of the per-`NextjsType` overrides. The public interface each
+    // root construct accepts is what actually gates which keys are settable.
     constructOverrides;
+    /**
+     * 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
+     * are necessarily the same. Normalized to a bare path segment, `undefined` for
+     * no `basePath`. Use this instead of `baseProps.basePath`.
+     */
+    resolvedBasePath;
     constructor(scope, id, props, nextjsType) {
         super(scope, id);
         this.baseProps = props;
         this.nextjsType = nextjsType;
         this.constructOverrides = this.getConstructOverrides(nextjsType);
         this.nextjsBuild = this.createNextjsBuild();
+        // 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.nextjsCache = this.createNextjsCache();
         this.nextjsStaticAssets = this.createNextjsStaticAssets();
+        this.validateStaticAssetsKeyPrefix();
+    }
+    /**
+     * 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
+     * `NextjsStaticAssets.keyPrefix` — so fail at synth rather than 404 every
+     * static request.
+     */
+    validateStaticAssetsKeyPrefix() {
+        if (this.nextjsType !== constants_1.NextjsType.GLOBAL_FUNCTIONS &&
+            this.nextjsType !== constants_1.NextjsType.GLOBAL_CONTAINERS) {
+            return;
+        }
+        const expected = this.resolvedBasePath ?? "";
+        const actual = this.nextjsStaticAssets.keyPrefix;
+        if (actual !== expected) {
+            throw new Error(`${constants_1.LOG_PREFIX} static assets key prefix mismatch for NextjsType.${this.nextjsType}: ` +
+                `the assets are uploaded under ${actual ? `"${actual}"` : "the bucket root"} ` +
+                `but CloudFront will request them under ${expected ? `"${expected}"` : "the bucket root"}, ` +
+                "using the request path as the S3 object key, so every `_next/static` and `public/` request would 404. " +
+                "Drop the `destinationKeyPrefix` override, or set it to the same value as `basePath`. " +
+                "To namespace a shared bucket, use `basePath` — it prefixes the keys and the URLs together.");
+        }
     }
     /**
      * Finds construct overrides (if present) on props for any `NextjsType`
@@ -83,11 +124,48 @@ class NextjsBaseConstruct extends constructs_1.Construct {
             bucket: this.baseProps.staticAssetsBucket,
             buildDirectory: this.baseProps.buildDirectory,
             buildId: this.nextjsBuild.buildId,
-            basePath: this.baseProps.basePath,
+            basePath: this.resolvedBasePath,
             overrides: this.baseProps.overrides?.nextjsStaticAssets,
             ...this.constructOverrides?.nextjsStaticAssetsProps,
         });
     }
+    /**
+     * Shared by `NextjsGlobalFunctions` and `NextjsRegionalFunctions`.
+     */
+    createNextjsFunctions(overrides) {
+        return new nextjs_functions_1.NextjsFunctions(this, "NextjsFunctions", {
+            ...this.computeBaseProps(),
+            overrides: {
+                ...overrides,
+                dockerImageFunctionProps: {
+                    ...overrides?.dockerImageFunctionProps,
+                    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 { 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  NextjsStaticAssets,\n  NextjsStaticAssetsOverrides,\n  NextjsStaticAssetsProps,\n} from \"../nextjs-static-assets\";\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 * 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.\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  protected readonly constructOverrides?: NextjsBaseConstructOverrides;\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    this.nextjsCache = this.createNextjsCache();\n    this.nextjsStaticAssets = this.createNextjsStaticAssets();\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   * 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.baseProps.basePath,\n      overrides: this.baseProps.overrides?.nextjsStaticAssets,\n      ...this.constructOverrides?.nextjsStaticAssetsProps,\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 { 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"]}

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

@@ -2,13 +2,13 @@ import { Distribution } from "aws-cdk-lib/aws-cloudfront";
 import { ICluster } from "aws-cdk-lib/aws-ecs";
 import { IApplicationLoadBalancer } from "aws-cdk-lib/aws-elasticloadbalancingv2";
 import { Construct } from "constructs";
+import { NextjsBaseConstructOverrides, NextjsBaseOverrides, NextjsBaseConstruct, NextjsBaseProps } from "./nextjs-base-construct";
 import { OptionalNextjsContainersProps } from "../generated-structs/OptionalNextjsContainersProps";
 import { OptionalNextjsDistributionProps } from "../generated-structs/OptionalNextjsDistributionProps";
 import { OptionalNextjsPostDeployProps } from "../generated-structs/OptionalNextjsPostDeployProps";
 import { NextjsContainers, NextjsContainersOverrides } from "../nextjs-compute/nextjs-containers";
 import { NextjsDistribution, NextjsDistributionOverrides } from "../nextjs-distribution";
 import { NextjsPostDeploy, NextjsPostDeployOverrides } from "../nextjs-post-deploy";
-import { NextjsBaseConstructOverrides, NextjsBaseOverrides, NextjsBaseConstruct, NextjsBaseProps } from "./nextjs-base-construct";
 export interface NextjsGlobalContainersConstructOverrides extends NextjsBaseConstructOverrides {
     readonly nextjsContainersProps?: OptionalNextjsContainersProps;
     readonly nextjsDistributionProps?: OptionalNextjsDistributionProps;
@@ -58,6 +58,11 @@ export declare class NextjsGlobalContainers extends NextjsBaseConstruct {
     nextjsContainers: NextjsContainers;
     nextjsDistribution: NextjsDistribution;
     nextjsPostDeploy: NextjsPostDeploy;
+    /**
+     * Public URL of the app, including `basePath` — the app only answers under
+     * that prefix, and it's derived from the app's own `basePath` when the prop is
+     * left unset, so it's there whether or not you asked for it.
+     */
     get url(): string;
     private props;
     constructor(scope: Construct, id: string, props: NextjsGlobalContainersProps);

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

@@ -6,10 +6,11 @@ const aws_cdk_lib_1 = require("aws-cdk-lib");
 const aws_iam_1 = require("aws-cdk-lib/aws-iam");
 const aws_ssm_1 = require("aws-cdk-lib/aws-ssm");
 const constants_1 = require("../constants");
+const nextjs_base_construct_1 = require("./nextjs-base-construct");
 const nextjs_containers_1 = require("../nextjs-compute/nextjs-containers");
 const nextjs_distribution_1 = require("../nextjs-distribution");
 const nextjs_post_deploy_1 = require("../nextjs-post-deploy");
-const nextjs_base_construct_1 = require("./nextjs-base-construct");
+const base_path_1 = require("../utils/base-path");
 /**
  * Deploy Next.js globally distributed with containers. Uses [CloudFront
  * Distribution](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/distribution-working-with.html)
@@ -17,12 +18,17 @@ const nextjs_base_construct_1 = require("./nextjs-base-construct");
  * for containers.
  */
 class NextjsGlobalContainers extends nextjs_base_construct_1.NextjsBaseConstruct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsGlobalContainers", version: "0.5.15" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsGlobalContainers", version: "0.6.0" };
     nextjsContainers;
     nextjsDistribution;
     nextjsPostDeploy;
+    /**
+     * Public URL of the app, including `basePath` — the app only answers under
+     * that prefix, and it's derived from the app's own `basePath` when the prop is
+     * left unset, so it's there whether or not you asked for it.
+     */
     get url() {
-        return `https://${this.nextjsDistribution.distribution.domainName}`;
+        return (0, base_path_1.joinPath)(`https://${this.nextjsDistribution.distribution.domainName}`, this.resolvedBasePath);
     }
     props;
     constructor(scope, id, props) {
@@ -104,7 +110,7 @@ class NextjsGlobalContainers extends nextjs_base_construct_1.NextjsBaseConstruct
     createNextjsDistribution() {
         return new nextjs_distribution_1.NextjsDistribution(this, "NextjsDistribution", {
             assetsBucket: this.nextjsStaticAssets.bucket,
-            basePath: this.props.basePath,
+            basePath: this.resolvedBasePath,
             certificate: this.nextjsContainers.albFargateService.certificate,
             distribution: this.props.distribution,
             loadBalancer: this.nextjsContainers.albFargateService.loadBalancer,
@@ -127,4 +133,4 @@ class NextjsGlobalContainers extends nextjs_base_construct_1.NextjsBaseConstruct
     }
 }
 exports.NextjsGlobalContainers = NextjsGlobalContainers;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-global-containers.js","sourceRoot":"","sources":["../../src/root-constructs/nextjs-global-containers.ts"],"names":[],"mappings":"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","sourcesContent":["import { Stack } from \"aws-cdk-lib\";\nimport { Distribution } from \"aws-cdk-lib/aws-cloudfront\";\nimport { ICluster } from \"aws-cdk-lib/aws-ecs\";\nimport { IApplicationLoadBalancer } from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport { PolicyStatement } from \"aws-cdk-lib/aws-iam\";\nimport { StringParameter } from \"aws-cdk-lib/aws-ssm\";\nimport { Construct } from \"constructs\";\nimport { NextjsType } from \"../constants\";\nimport { OptionalNextjsContainersProps } from \"../generated-structs/OptionalNextjsContainersProps\";\nimport { OptionalNextjsDistributionProps } from \"../generated-structs/OptionalNextjsDistributionProps\";\nimport { OptionalNextjsPostDeployProps } from \"../generated-structs/OptionalNextjsPostDeployProps\";\nimport {\n  NextjsContainers,\n  NextjsContainersOverrides,\n} from \"../nextjs-compute/nextjs-containers\";\nimport {\n  NextjsDistribution,\n  NextjsDistributionOverrides,\n} from \"../nextjs-distribution\";\nimport {\n  NextjsPostDeploy,\n  NextjsPostDeployOverrides,\n} from \"../nextjs-post-deploy\";\nimport {\n  NextjsBaseConstructOverrides,\n  NextjsBaseOverrides,\n  NextjsBaseConstruct,\n  NextjsBaseProps,\n} from \"./nextjs-base-construct\";\n\nexport interface NextjsGlobalContainersConstructOverrides extends NextjsBaseConstructOverrides {\n  readonly nextjsContainersProps?: OptionalNextjsContainersProps;\n  readonly nextjsDistributionProps?: OptionalNextjsDistributionProps;\n  readonly nextjsPostDeployProps?: OptionalNextjsPostDeployProps;\n}\n\n/**\n * Overrides for `NextjsGlobalContainers`. Overrides are lower level than\n * props and are passed directly to CDK Constructs giving you more control. It's\n * recommended to use caution and review source code so you know how they're used.\n */\nexport interface NextjsGlobalContainersOverrides extends NextjsBaseOverrides {\n  readonly nextjsGlobalContainers?: NextjsGlobalContainersConstructOverrides;\n  readonly nextjsContainers?: NextjsContainersOverrides;\n  readonly nextjsDistribution?: NextjsDistributionOverrides;\n  readonly nextjsPostDeploy?: NextjsPostDeployOverrides;\n}\n\nexport interface NextjsGlobalContainersProps extends NextjsBaseProps {\n  /**\n   * Bring your own Application Load Balancer. When provided, it is passed\n   * directly to `ApplicationLoadBalancedFargateService`. If the ALB already\n   * has a listener on port 80, call `removeAutoCreatedListener()` after\n   * construction to avoid deployment failures.\n   */\n  readonly alb?: IApplicationLoadBalancer;\n  /**\n   * Bring your own distribution. Can be used with `basePath` to host multiple\n   * apps on the same CloudFront distribution.\n   */\n  readonly distribution?: Distribution;\n  /**\n   * Bring your own ECS cluster. When provided, cdk-nextjs will skip creating\n   * a new cluster and VPC gateway endpoints.\n   */\n  readonly ecsCluster?: ICluster;\n  /**\n   * Override props of any construct.\n   */\n  readonly overrides?: NextjsGlobalContainersOverrides;\n}\n\n/**\n * Deploy Next.js globally distributed with containers. Uses [CloudFront\n * Distribution](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/distribution-working-with.html)\n * as Content Delivery Network (CDN) for global distribution and [AWS Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/AWS_Fargate.html)\n * for containers.\n */\nexport class NextjsGlobalContainers extends NextjsBaseConstruct {\n  nextjsContainers: NextjsContainers;\n  nextjsDistribution: NextjsDistribution;\n  nextjsPostDeploy: NextjsPostDeploy;\n  get url(): string {\n    return `https://${this.nextjsDistribution.distribution.domainName}`;\n  }\n\n  private props: NextjsGlobalContainersProps;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: NextjsGlobalContainersProps,\n  ) {\n    super(scope, id, props, NextjsType.GLOBAL_CONTAINERS);\n    this.props = props;\n\n    this.nextjsContainers = this.createNextjsContainers();\n    this.nextjsDistribution = this.createNextjsDistribution();\n    this.wireCloudFrontInvalidation();\n    this.nextjsPostDeploy = this.createNextjsPostDeploy();\n  }\n\n  /**\n   * Grants the task role permission to invalidate the distribution and passes\n   * along a way to look up its ID, so on-demand revalidation\n   * (revalidateTag/revalidatePath) can evict stale responses from the CDN\n   * edge cache, not just the origin's S3/DynamoDB cache.\n   *\n   * The distribution ID is published to an SSM Parameter (whose *name* is\n   * static and safe to embed in the task's environment) rather than passed\n   * directly, and the IAM grant is scoped to all distributions in this\n   * account/region rather than this specific one. See the equivalent method\n   * in `NextjsGlobalFunctions` for why: the same pattern is used here for\n   * consistency, even though containers' distribution (ALB-origin-based)\n   * doesn't hit the circular CloudFormation dependency functions' does.\n   */\n  private wireCloudFrontInvalidation(): void {\n    const stack = Stack.of(this);\n    const { taskDefinition } = this.nextjsContainers.albFargateService;\n    const distributionIdParameterName = `cdk-nextjs-distribution-id-${this.node.addr}`;\n\n    new StringParameter(this, \"DistributionIdParameter\", {\n      parameterName: distributionIdParameterName,\n      stringValue: this.nextjsDistribution.distribution.distributionId,\n    });\n\n    taskDefinition.addToTaskRolePolicy(\n      new PolicyStatement({\n        actions: [\"ssm:GetParameter\"],\n        resources: [\n          stack.formatArn({\n            service: \"ssm\",\n            resource: \"parameter\",\n            resourceName: distributionIdParameterName,\n          }),\n        ],\n      }),\n    );\n    taskDefinition.addToTaskRolePolicy(\n      new PolicyStatement({\n        actions: [\"cloudfront:CreateInvalidation\"],\n        // Scoped to all distributions (not just this one) for consistency\n        // with NextjsGlobalFunctions, which can't scope this to its specific\n        // distribution due to a circular CloudFormation dependency (see the\n        // class doc comment above and the equivalent method there). Hence\n        // the SSM parameter indirection above for looking up the ID at\n        // runtime instead of synth time.\n        resources: [\n          stack.formatArn({\n            service: \"cloudfront\",\n            region: \"\",\n            resource: \"distribution\",\n            resourceName: \"*\",\n          }),\n        ],\n      }),\n    );\n    taskDefinition.defaultContainer?.addEnvironment(\n      \"CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME\",\n      distributionIdParameterName,\n    );\n  }\n\n  private createNextjsContainers(): NextjsContainers {\n    // Create containers with local build output\n    return new NextjsContainers(this, \"NextjsContainers\", {\n      ...this.computeBaseProps(),\n      alb: this.props.alb,\n      ecsCluster: this.props.ecsCluster,\n      relativeEntrypointPath: this.nextjsBuild.relativePathToEntrypoint,\n      overrides: {\n        ...this.props.overrides?.nextjsContainers,\n        ecsClusterProps: {\n          ...this.props.overrides?.nextjsContainers?.ecsClusterProps,\n          vpc: this.baseProps.vpc,\n        },\n      },\n      ...this.props.overrides?.nextjsGlobalContainers?.nextjsContainersProps,\n    });\n  }\n\n  private createNextjsDistribution() {\n    return new NextjsDistribution(this, \"NextjsDistribution\", {\n      assetsBucket: this.nextjsStaticAssets.bucket,\n      basePath: this.props.basePath,\n      certificate: this.nextjsContainers.albFargateService.certificate,\n      distribution: this.props.distribution,\n      loadBalancer: this.nextjsContainers.albFargateService.loadBalancer,\n      nextjsType: this.nextjsType,\n      overrides: this.props.overrides?.nextjsDistribution,\n      publicDirEntries: this.nextjsBuild.publicDirEntries,\n      ...this.props.overrides?.nextjsGlobalContainers?.nextjsDistributionProps,\n    });\n  }\n\n  private createNextjsPostDeploy(): NextjsPostDeploy {\n    return new NextjsPostDeploy(this, \"NextjsPostDeploy\", {\n      buildId: this.nextjsBuild.buildId,\n      distribution: this.nextjsDistribution.distribution,\n      cacheBucket: this.nextjsCache.cacheBucket,\n      revalidationTable: this.nextjsCache.revalidationTable,\n      staticAssetsBucket: this.nextjsStaticAssets.bucket,\n      overrides: this.props.overrides?.nextjsPostDeploy,\n      ...this.props.overrides?.nextjsGlobalContainers?.nextjsPostDeployProps,\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-global-containers.js","sourceRoot":"","sources":["../../src/root-constructs/nextjs-global-containers.ts"],"names":[],"mappings":"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","sourcesContent":["import { Stack } from \"aws-cdk-lib\";\nimport { Distribution } from \"aws-cdk-lib/aws-cloudfront\";\nimport { ICluster } from \"aws-cdk-lib/aws-ecs\";\nimport { IApplicationLoadBalancer } from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport { PolicyStatement } from \"aws-cdk-lib/aws-iam\";\nimport { StringParameter } from \"aws-cdk-lib/aws-ssm\";\nimport { Construct } from \"constructs\";\nimport { NextjsType } from \"../constants\";\nimport {\n  NextjsBaseConstructOverrides,\n  NextjsBaseOverrides,\n  NextjsBaseConstruct,\n  NextjsBaseProps,\n} from \"./nextjs-base-construct\";\nimport { OptionalNextjsContainersProps } from \"../generated-structs/OptionalNextjsContainersProps\";\nimport { OptionalNextjsDistributionProps } from \"../generated-structs/OptionalNextjsDistributionProps\";\nimport { OptionalNextjsPostDeployProps } from \"../generated-structs/OptionalNextjsPostDeployProps\";\nimport {\n  NextjsContainers,\n  NextjsContainersOverrides,\n} from \"../nextjs-compute/nextjs-containers\";\nimport {\n  NextjsDistribution,\n  NextjsDistributionOverrides,\n} from \"../nextjs-distribution\";\nimport {\n  NextjsPostDeploy,\n  NextjsPostDeployOverrides,\n} from \"../nextjs-post-deploy\";\nimport { joinPath } from \"../utils/base-path\";\n\nexport interface NextjsGlobalContainersConstructOverrides extends NextjsBaseConstructOverrides {\n  readonly nextjsContainersProps?: OptionalNextjsContainersProps;\n  readonly nextjsDistributionProps?: OptionalNextjsDistributionProps;\n  readonly nextjsPostDeployProps?: OptionalNextjsPostDeployProps;\n}\n\n/**\n * Overrides for `NextjsGlobalContainers`. Overrides are lower level than\n * props and are passed directly to CDK Constructs giving you more control. It's\n * recommended to use caution and review source code so you know how they're used.\n */\nexport interface NextjsGlobalContainersOverrides extends NextjsBaseOverrides {\n  readonly nextjsGlobalContainers?: NextjsGlobalContainersConstructOverrides;\n  readonly nextjsContainers?: NextjsContainersOverrides;\n  readonly nextjsDistribution?: NextjsDistributionOverrides;\n  readonly nextjsPostDeploy?: NextjsPostDeployOverrides;\n}\n\nexport interface NextjsGlobalContainersProps extends NextjsBaseProps {\n  /**\n   * Bring your own Application Load Balancer. When provided, it is passed\n   * directly to `ApplicationLoadBalancedFargateService`. If the ALB already\n   * has a listener on port 80, call `removeAutoCreatedListener()` after\n   * construction to avoid deployment failures.\n   */\n  readonly alb?: IApplicationLoadBalancer;\n  /**\n   * Bring your own distribution. Can be used with `basePath` to host multiple\n   * apps on the same CloudFront distribution.\n   */\n  readonly distribution?: Distribution;\n  /**\n   * Bring your own ECS cluster. When provided, cdk-nextjs will skip creating\n   * a new cluster and VPC gateway endpoints.\n   */\n  readonly ecsCluster?: ICluster;\n  /**\n   * Override props of any construct.\n   */\n  readonly overrides?: NextjsGlobalContainersOverrides;\n}\n\n/**\n * Deploy Next.js globally distributed with containers. Uses [CloudFront\n * Distribution](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/distribution-working-with.html)\n * as Content Delivery Network (CDN) for global distribution and [AWS Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/AWS_Fargate.html)\n * for containers.\n */\nexport class NextjsGlobalContainers extends NextjsBaseConstruct {\n  nextjsContainers: NextjsContainers;\n  nextjsDistribution: NextjsDistribution;\n  nextjsPostDeploy: NextjsPostDeploy;\n  /**\n   * Public URL of the app, including `basePath` — the app only answers under\n   * that prefix, and it's derived from the app's own `basePath` when the prop is\n   * left unset, so it's there whether or not you asked for it.\n   */\n  get url(): string {\n    return joinPath(\n      `https://${this.nextjsDistribution.distribution.domainName}`,\n      this.resolvedBasePath,\n    );\n  }\n\n  private props: NextjsGlobalContainersProps;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: NextjsGlobalContainersProps,\n  ) {\n    super(scope, id, props, NextjsType.GLOBAL_CONTAINERS);\n    this.props = props;\n\n    this.nextjsContainers = this.createNextjsContainers();\n    this.nextjsDistribution = this.createNextjsDistribution();\n    this.wireCloudFrontInvalidation();\n    this.nextjsPostDeploy = this.createNextjsPostDeploy();\n  }\n\n  /**\n   * Grants the task role permission to invalidate the distribution and passes\n   * along a way to look up its ID, so on-demand revalidation\n   * (revalidateTag/revalidatePath) can evict stale responses from the CDN\n   * edge cache, not just the origin's S3/DynamoDB cache.\n   *\n   * The distribution ID is published to an SSM Parameter (whose *name* is\n   * static and safe to embed in the task's environment) rather than passed\n   * directly, and the IAM grant is scoped to all distributions in this\n   * account/region rather than this specific one. See the equivalent method\n   * in `NextjsGlobalFunctions` for why: the same pattern is used here for\n   * consistency, even though containers' distribution (ALB-origin-based)\n   * doesn't hit the circular CloudFormation dependency functions' does.\n   */\n  private wireCloudFrontInvalidation(): void {\n    const stack = Stack.of(this);\n    const { taskDefinition } = this.nextjsContainers.albFargateService;\n    const distributionIdParameterName = `cdk-nextjs-distribution-id-${this.node.addr}`;\n\n    new StringParameter(this, \"DistributionIdParameter\", {\n      parameterName: distributionIdParameterName,\n      stringValue: this.nextjsDistribution.distribution.distributionId,\n    });\n\n    taskDefinition.addToTaskRolePolicy(\n      new PolicyStatement({\n        actions: [\"ssm:GetParameter\"],\n        resources: [\n          stack.formatArn({\n            service: \"ssm\",\n            resource: \"parameter\",\n            resourceName: distributionIdParameterName,\n          }),\n        ],\n      }),\n    );\n    taskDefinition.addToTaskRolePolicy(\n      new PolicyStatement({\n        actions: [\"cloudfront:CreateInvalidation\"],\n        // Scoped to all distributions (not just this one) for consistency\n        // with NextjsGlobalFunctions, which can't scope this to its specific\n        // distribution due to a circular CloudFormation dependency (see the\n        // class doc comment above and the equivalent method there). Hence\n        // the SSM parameter indirection above for looking up the ID at\n        // runtime instead of synth time.\n        resources: [\n          stack.formatArn({\n            service: \"cloudfront\",\n            region: \"\",\n            resource: \"distribution\",\n            resourceName: \"*\",\n          }),\n        ],\n      }),\n    );\n    taskDefinition.defaultContainer?.addEnvironment(\n      \"CDK_NEXTJS_DISTRIBUTION_ID_PARAM_NAME\",\n      distributionIdParameterName,\n    );\n  }\n\n  private createNextjsContainers(): NextjsContainers {\n    // Create containers with local build output\n    return new NextjsContainers(this, \"NextjsContainers\", {\n      ...this.computeBaseProps(),\n      alb: this.props.alb,\n      ecsCluster: this.props.ecsCluster,\n      relativeEntrypointPath: this.nextjsBuild.relativePathToEntrypoint,\n      overrides: {\n        ...this.props.overrides?.nextjsContainers,\n        ecsClusterProps: {\n          ...this.props.overrides?.nextjsContainers?.ecsClusterProps,\n          vpc: this.baseProps.vpc,\n        },\n      },\n      ...this.props.overrides?.nextjsGlobalContainers?.nextjsContainersProps,\n    });\n  }\n\n  private createNextjsDistribution() {\n    return new NextjsDistribution(this, \"NextjsDistribution\", {\n      assetsBucket: this.nextjsStaticAssets.bucket,\n      basePath: this.resolvedBasePath,\n      certificate: this.nextjsContainers.albFargateService.certificate,\n      distribution: this.props.distribution,\n      loadBalancer: this.nextjsContainers.albFargateService.loadBalancer,\n      nextjsType: this.nextjsType,\n      overrides: this.props.overrides?.nextjsDistribution,\n      publicDirEntries: this.nextjsBuild.publicDirEntries,\n      ...this.props.overrides?.nextjsGlobalContainers?.nextjsDistributionProps,\n    });\n  }\n\n  private createNextjsPostDeploy(): NextjsPostDeploy {\n    return new NextjsPostDeploy(this, \"NextjsPostDeploy\", {\n      buildId: this.nextjsBuild.buildId,\n      distribution: this.nextjsDistribution.distribution,\n      cacheBucket: this.nextjsCache.cacheBucket,\n      revalidationTable: this.nextjsCache.revalidationTable,\n      staticAssetsBucket: this.nextjsStaticAssets.bucket,\n      overrides: this.props.overrides?.nextjsPostDeploy,\n      ...this.props.overrides?.nextjsGlobalContainers?.nextjsPostDeployProps,\n    });\n  }\n}\n"]}

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

@@ -1,13 +1,13 @@
 import { Distribution } from "aws-cdk-lib/aws-cloudfront";
 import { Construct } from "constructs";
+import { NextjsFunctionsConstructOverrides, NextjsBaseOverrides, NextjsBaseConstruct, NextjsBaseProps } from "./nextjs-base-construct";
 import { OptionalNextjsDistributionProps } from "../generated-structs/OptionalNextjsDistributionProps";
 import { OptionalNextjsPostDeployProps } from "../generated-structs/OptionalNextjsPostDeployProps";
-import { NextjsFunctions, NextjsFunctionsOverrides, NextjsFunctionsProps } from "../nextjs-compute/nextjs-functions";
+import { NextjsFunctions, NextjsFunctionsOverrides } from "../nextjs-compute/nextjs-functions";
+import { NextjsImageFunction, NextjsImageFunctionOverrides } from "../nextjs-compute/nextjs-image-function";
 import { NextjsDistribution, NextjsDistributionOverrides } from "../nextjs-distribution";
 import { NextjsPostDeploy, NextjsPostDeployOverrides } from "../nextjs-post-deploy";
-import { NextjsBaseConstructOverrides, NextjsBaseOverrides, NextjsBaseConstruct, NextjsBaseProps } from "./nextjs-base-construct";
-export interface NextjsGlobalFunctionsConstructOverrides extends NextjsBaseConstructOverrides {
-    readonly nextjsFunctionsProps?: NextjsFunctionsProps;
+export interface NextjsGlobalFunctionsConstructOverrides extends NextjsFunctionsConstructOverrides {
     readonly nextjsDistributionProps?: OptionalNextjsDistributionProps;
     readonly nextjsPostDeployProps?: OptionalNextjsPostDeployProps;
 }
@@ -19,6 +19,7 @@ export interface NextjsGlobalFunctionsConstructOverrides extends NextjsBaseConst
 export interface NextjsGlobalFunctionsOverrides extends NextjsBaseOverrides {
     readonly nextjsGlobalFunctions?: NextjsGlobalFunctionsConstructOverrides;
     readonly nextjsFunctions?: NextjsFunctionsOverrides;
+    readonly nextjsImageFunction?: NextjsImageFunctionOverrides;
     readonly nextjsDistribution?: NextjsDistributionOverrides;
     readonly nextjsPostDeploy?: NextjsPostDeployOverrides;
 }
@@ -41,8 +42,19 @@ export interface NextjsGlobalFunctionsProps extends NextjsBaseProps {
  */
 export declare class NextjsGlobalFunctions extends NextjsBaseConstruct {
     nextjsFunctions: NextjsFunctions;
+    /**
+     * Only created when the (experimental, unsupported) dedicated image
+     * optimization Lambda is enabled. `_next/image` is otherwise served by
+     * {@link nextjsFunctions}.
+     */
+    nextjsImageFunction?: NextjsImageFunction;
     nextjsDistribution: NextjsDistribution;
     nextjsPostDeploy: NextjsPostDeploy;
+    /**
+     * Public URL of the app, including `basePath` — the app only answers under
+     * that prefix, and it's derived from the app's own `basePath` when the prop is
+     * left unset, so it's there whether or not you asked for it.
+     */
     get url(): string;
     private props;
     constructor(scope: Construct, id: string, props: NextjsGlobalFunctionsProps);
@@ -62,7 +74,6 @@ export declare class NextjsGlobalFunctions extends NextjsBaseConstruct {
      * specific (not-yet-known-at-synth-time) distribution.
      */
     private wireCloudFrontInvalidation;
-    private createNextjsFunctions;
     private createNextjsDistribution;
     private createNextjsPostDeploy;
 }