cdk-nextjs 0.6.2 → 0.7.1

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

@@ -5,7 +5,6 @@ const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 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_post_deploy_1 = require("../nextjs-post-deploy");
 const base_path_1 = require("../utils/base-path");
 /**
  * Deploy Next.js load balanced with containers. Uses [Application Load
@@ -14,7 +13,7 @@ const base_path_1 = require("../utils/base-path");
  * for containers.
  */
 class NextjsRegionalContainers extends nextjs_base_construct_1.NextjsBaseConstruct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsRegionalContainers", version: "0.6.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsRegionalContainers", version: "0.7.1" };
     nextjsContainers;
     nextjsPostDeploy;
     /**
@@ -39,29 +38,23 @@ class NextjsRegionalContainers extends nextjs_base_construct_1.NextjsBaseConstru
         return new nextjs_containers_1.NextjsContainers(this, "NextjsContainers", {
             ...this.computeBaseProps(),
             alb: this.props.alb,
+            buildDirectory: this.props.buildDirectory,
             ecsCluster: this.props.ecsCluster,
+            healthCheckPath: this.resolvedHealthCheckPath(this.props.healthCheckPath),
             relativeEntrypointPath: this.nextjsBuild.relativePathToEntrypoint,
+            relativeProjectDir: this.nextjsBuild.relativeProjectDir,
             overrides: {
                 ...this.props.overrides?.nextjsContainers,
                 ecsClusterProps: {
                     ...this.props.overrides?.nextjsContainers?.ecsClusterProps,
-                    vpc: this.baseProps.vpc,
+                    // Conditional for the same reason as the Functions' `vpc`: assigned
+                    // unconditionally, an unset `vpc` prop would erase the override's.
+                    ...(this.baseProps.vpc ? { vpc: this.baseProps.vpc } : {}),
                 },
             },
             ...this.props.overrides?.nextjsRegionalContainers?.nextjsContainerProps,
         });
     }
-    createNextjsPostDeploy() {
-        return new nextjs_post_deploy_1.NextjsPostDeploy(this, "NextjsPostDeploy", {
-            buildId: this.nextjsBuild.buildId,
-            cacheBucket: this.nextjsCache.cacheBucket,
-            revalidationTable: this.nextjsCache.revalidationTable,
-            staticAssetsBucket: this.nextjsStaticAssets.bucket,
-            staticAssetsKeyPrefix: this.nextjsStaticAssets.keyPrefix,
-            overrides: this.props.overrides?.nextjsPostDeploy,
-            ...this.props.overrides?.nextjsRegionalContainers?.nextjsPostDeployProps,
-        });
-    }
 }
 exports.NextjsRegionalContainers = NextjsRegionalContainers;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-regional-containers.js","sourceRoot":"","sources":["../../src/root-constructs/nextjs-regional-containers.ts"],"names":[],"mappings":";;;;AAGA,4CAA0C;AAC1C,mEAKiC;AAGjC,2EAG6C;AAC7C,8DAG+B;AAC/B,kDAA8C;AAqC9C;;;;;GAKG;AACH,MAAa,wBAAyB,SAAQ,2CAAmB;;IAC/D,gBAAgB,CAAmB;IACnC,gBAAgB,CAAmB;IACnC;;;;;;OAMG;IACH,IAAI,GAAG;QACL,OAAO,IAAA,oBAAQ,EACb,IAAI,CAAC,gBAAgB,CAAC,GAAG,EACzB,IAAI,CAAC,WAAW,CAAC,kBAAkB,CACpC,CAAC;IACJ,CAAC;IAEO,KAAK,CAAgC;IAE7C,YACE,KAAgB,EAChB,EAAU,EACV,KAAoC;QAEpC,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,sBAAU,CAAC,mBAAmB,CAAC,CAAC;QACxD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QAEnB,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,kCAAkC,EAAE,CAAC;QAClE,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;IACxD,CAAC;IAEO,kCAAkC;QACxC,4CAA4C;QAC5C,OAAO,IAAI,oCAAgB,CAAC,IAAI,EAAE,kBAAkB,EAAE;YACpD,GAAG,IAAI,CAAC,gBAAgB,EAAE;YAC1B,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG;YACnB,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU;YACjC,sBAAsB,EAAE,IAAI,CAAC,WAAW,CAAC,wBAAwB;YACjE,SAAS,EAAE;gBACT,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,gBAAgB;gBACzC,eAAe,EAAE;oBACf,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,gBAAgB,EAAE,eAAe;oBAC1D,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG;iBACxB;aACF;YACD,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,wBAAwB,EAAE,oBAAoB;SACxE,CAAC,CAAC;IACL,CAAC;IAEO,sBAAsB;QAC5B,OAAO,IAAI,qCAAgB,CAAC,IAAI,EAAE,kBAAkB,EAAE;YACpD,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,OAAO;YACjC,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,WAAW;YACzC,iBAAiB,EAAE,IAAI,CAAC,WAAW,CAAC,iBAAiB;YACrD,kBAAkB,EAAE,IAAI,CAAC,kBAAkB,CAAC,MAAM;YAClD,qBAAqB,EAAE,IAAI,CAAC,kBAAkB,CAAC,SAAS;YACxD,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,gBAAgB;YACjD,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,wBAAwB,EAAE,qBAAqB;SACzE,CAAC,CAAC;IACL,CAAC;;AA3DH,4DA4DC","sourcesContent":["import { ICluster } from \"aws-cdk-lib/aws-ecs\";\nimport { IApplicationLoadBalancer } from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\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 { OptionalNextjsPostDeployProps } from \"../generated-structs/OptionalNextjsPostDeployProps\";\nimport {\n  NextjsContainers,\n  NextjsContainersOverrides,\n} from \"../nextjs-compute/nextjs-containers\";\nimport {\n  NextjsPostDeploy,\n  NextjsPostDeployOverrides,\n} from \"../nextjs-post-deploy\";\nimport { joinPath } from \"../utils/base-path\";\n\nexport interface NextjsRegionalContainersConstructOverrides extends NextjsBaseConstructOverrides {\n  readonly nextjsContainerProps?: OptionalNextjsContainersProps;\n  readonly nextjsPostDeployProps?: OptionalNextjsPostDeployProps;\n}\n\n/**\n * Overrides for `NextjsRegionalContainers`. 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 NextjsRegionalContainersOverrides extends NextjsBaseOverrides {\n  readonly nextjsRegionalContainers?: NextjsRegionalContainersConstructOverrides;\n  readonly nextjsContainers?: NextjsContainersOverrides;\n  readonly nextjsPostDeploy?: NextjsPostDeployOverrides;\n}\n\nexport interface NextjsRegionalContainersProps 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 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?: NextjsRegionalContainersOverrides;\n}\n\n/**\n * Deploy Next.js load balanced with containers. Uses [Application Load\n * Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/introduction.html)\n * for load balancing and [AWS Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/AWS_Fargate.html)\n * for containers.\n */\nexport class NextjsRegionalContainers extends NextjsBaseConstruct {\n  nextjsContainers: NextjsContainers;\n  nextjsPostDeploy: NextjsPostDeploy;\n  /**\n   * The ALB forwards every path to the container unchanged, so the app only\n   * answers under its own `basePath`. `resolvedBasePath` is deliberately not\n   * used here: for this `NextjsType` it only namespaces the S3 bucket and has no\n   * routing meaning, whereas the app's own `basePath` is what the container\n   * serves from.\n   */\n  get url(): string {\n    return joinPath(\n      this.nextjsContainers.url,\n      this.nextjsBuild.nextConfigBasePath,\n    );\n  }\n\n  private props: NextjsRegionalContainersProps;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: NextjsRegionalContainersProps,\n  ) {\n    super(scope, id, props, NextjsType.REGIONAL_CONTAINERS);\n    this.props = props;\n\n    this.nextjsContainers = this.createNextjsLoadBalancedContainers();\n    this.nextjsPostDeploy = this.createNextjsPostDeploy();\n  }\n\n  private createNextjsLoadBalancedContainers(): 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?.nextjsRegionalContainers?.nextjsContainerProps,\n    });\n  }\n\n  private createNextjsPostDeploy(): NextjsPostDeploy {\n    return new NextjsPostDeploy(this, \"NextjsPostDeploy\", {\n      buildId: this.nextjsBuild.buildId,\n      cacheBucket: this.nextjsCache.cacheBucket,\n      revalidationTable: this.nextjsCache.revalidationTable,\n      staticAssetsBucket: this.nextjsStaticAssets.bucket,\n      staticAssetsKeyPrefix: this.nextjsStaticAssets.keyPrefix,\n      overrides: this.props.overrides?.nextjsPostDeploy,\n      ...this.props.overrides?.nextjsRegionalContainers?.nextjsPostDeployProps,\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-regional-containers.js","sourceRoot":"","sources":["../../src/root-constructs/nextjs-regional-containers.ts"],"names":[],"mappings":";;;;AAGA,4CAA0C;AAC1C,mEAKiC;AAEjC,2EAG6C;AAE7C,kDAA8C;AAoD9C;;;;;GAKG;AACH,MAAa,wBAAyB,SAAQ,2CAAmB;;IAC/D,gBAAgB,CAAmB;IACnC,gBAAgB,CAAmB;IACnC;;;;;;OAMG;IACH,IAAI,GAAG;QACL,OAAO,IAAA,oBAAQ,EACb,IAAI,CAAC,gBAAgB,CAAC,GAAG,EACzB,IAAI,CAAC,WAAW,CAAC,kBAAkB,CACpC,CAAC;IACJ,CAAC;IAEO,KAAK,CAAgC;IAE7C,YACE,KAAgB,EAChB,EAAU,EACV,KAAoC;QAEpC,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,sBAAU,CAAC,mBAAmB,CAAC,CAAC;QACxD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QAEnB,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,kCAAkC,EAAE,CAAC;QAClE,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;IACxD,CAAC;IAEO,kCAAkC;QACxC,4CAA4C;QAC5C,OAAO,IAAI,oCAAgB,CAAC,IAAI,EAAE,kBAAkB,EAAE;YACpD,GAAG,IAAI,CAAC,gBAAgB,EAAE;YAC1B,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG;YACnB,cAAc,EAAE,IAAI,CAAC,KAAK,CAAC,cAAc;YACzC,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU;YACjC,eAAe,EAAE,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC;YACzE,sBAAsB,EAAE,IAAI,CAAC,WAAW,CAAC,wBAAwB;YACjE,kBAAkB,EAAE,IAAI,CAAC,WAAW,CAAC,kBAAkB;YACvD,SAAS,EAAE;gBACT,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,gBAAgB;gBACzC,eAAe,EAAE;oBACf,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,gBAAgB,EAAE,eAAe;oBAC1D,oEAAoE;oBACpE,mEAAmE;oBACnE,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;iBAC3D;aACF;YACD,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,wBAAwB,EAAE,oBAAoB;SACxE,CAAC,CAAC;IACL,CAAC;;AApDH,4DAqDC","sourcesContent":["import { ICluster } from \"aws-cdk-lib/aws-ecs\";\nimport { IApplicationLoadBalancer } from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\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 {\n  NextjsContainers,\n  NextjsContainersOverrides,\n} from \"../nextjs-compute/nextjs-containers\";\nimport { NextjsPostDeploy } from \"../nextjs-post-deploy\";\nimport { joinPath } from \"../utils/base-path\";\n\nexport interface NextjsRegionalContainersConstructOverrides extends NextjsBaseConstructOverrides {\n  readonly nextjsContainerProps?: OptionalNextjsContainersProps;\n}\n\n/**\n * Overrides for `NextjsRegionalContainers`. 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 NextjsRegionalContainersOverrides extends NextjsBaseOverrides {\n  readonly nextjsRegionalContainers?: NextjsRegionalContainersConstructOverrides;\n  readonly nextjsContainers?: NextjsContainersOverrides;\n}\n\nexport interface NextjsRegionalContainersProps 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 ECS cluster. When provided, cdk-nextjs will skip creating\n   * a new cluster and VPC gateway endpoints.\n   */\n  readonly ecsCluster?: ICluster;\n  /**\n   * Path to API Route Handler that returns HTTP 200 to ensure compute health.\n   * Used by the ALB target group and the ECS container health check, both of\n   * which have to be able to tell a running task from a wedged one.\n   *\n   * Give the path as your app routes it, without your app's `basePath` —\n   * cdk-nextjs adds that prefix, since both checks hit the app directly.\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   * Override props of any construct.\n   */\n  readonly overrides?: NextjsRegionalContainersOverrides;\n}\n\n/**\n * Deploy Next.js load balanced with containers. Uses [Application Load\n * Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/introduction.html)\n * for load balancing and [AWS Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/AWS_Fargate.html)\n * for containers.\n */\nexport class NextjsRegionalContainers extends NextjsBaseConstruct {\n  nextjsContainers: NextjsContainers;\n  nextjsPostDeploy: NextjsPostDeploy;\n  /**\n   * The ALB forwards every path to the container unchanged, so the app only\n   * answers under its own `basePath`. `resolvedBasePath` is deliberately not\n   * used here: for this `NextjsType` it only namespaces the S3 bucket and has no\n   * routing meaning, whereas the app's own `basePath` is what the container\n   * serves from.\n   */\n  get url(): string {\n    return joinPath(\n      this.nextjsContainers.url,\n      this.nextjsBuild.nextConfigBasePath,\n    );\n  }\n\n  private props: NextjsRegionalContainersProps;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: NextjsRegionalContainersProps,\n  ) {\n    super(scope, id, props, NextjsType.REGIONAL_CONTAINERS);\n    this.props = props;\n\n    this.nextjsContainers = this.createNextjsLoadBalancedContainers();\n    this.nextjsPostDeploy = this.createNextjsPostDeploy();\n  }\n\n  private createNextjsLoadBalancedContainers(): NextjsContainers {\n    // Create containers with local build output\n    return new NextjsContainers(this, \"NextjsContainers\", {\n      ...this.computeBaseProps(),\n      alb: this.props.alb,\n      buildDirectory: this.props.buildDirectory,\n      ecsCluster: this.props.ecsCluster,\n      healthCheckPath: this.resolvedHealthCheckPath(this.props.healthCheckPath),\n      relativeEntrypointPath: this.nextjsBuild.relativePathToEntrypoint,\n      relativeProjectDir: this.nextjsBuild.relativeProjectDir,\n      overrides: {\n        ...this.props.overrides?.nextjsContainers,\n        ecsClusterProps: {\n          ...this.props.overrides?.nextjsContainers?.ecsClusterProps,\n          // Conditional for the same reason as the Functions' `vpc`: assigned\n          // unconditionally, an unset `vpc` prop would erase the override's.\n          ...(this.baseProps.vpc ? { vpc: this.baseProps.vpc } : {}),\n        },\n      },\n      ...this.props.overrides?.nextjsRegionalContainers?.nextjsContainerProps,\n    });\n  }\n}\n"]}

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

@@ -1,13 +1,11 @@
 import { Construct } from "constructs";
-import { NextjsApi, NextjsApiOverrides, NextjsApiProps } from "../nextjs-api";
-import { NextjsBaseConstruct, NextjsBaseProps, NextjsFunctionsConstructOverrides, NextjsBaseOverrides } from "./nextjs-base-construct";
-import { OptionalNextjsPostDeployProps } from "../generated-structs/OptionalNextjsPostDeployProps";
-import { NextjsFunctions, NextjsFunctionsOverrides } from "../nextjs-compute/nextjs-functions";
-import { NextjsImageFunction, NextjsImageFunctionOverrides } from "../nextjs-compute/nextjs-image-function";
-import { NextjsPostDeploy, NextjsPostDeployOverrides } from "../nextjs-post-deploy";
-export interface NextjsRegionalFunctionsConstructOverrides extends NextjsFunctionsConstructOverrides {
-    readonly nextjsApiProps?: NextjsApiProps;
-    readonly nextjsPostDeployProps?: OptionalNextjsPostDeployProps;
+import { OptionalNextjsApiProps } from "../generated-structs/OptionalNextjsApiProps";
+import { NextjsApi, NextjsApiOverrides } from "../nextjs-api";
+import { NextjsBaseConstruct, NextjsBaseProps, NextjsBaseConstructOverrides, NextjsBaseOverrides } from "./nextjs-base-construct";
+import { NextjsFunctionGroup, NextjsFunctions, NextjsFunctionsOverrides } from "../nextjs-compute/nextjs-functions";
+import { NextjsPostDeploy } from "../nextjs-post-deploy";
+export interface NextjsRegionalFunctionsConstructOverrides extends NextjsBaseConstructOverrides {
+    readonly nextjsApiProps?: OptionalNextjsApiProps;
 }
 /**
  * Overrides for `NextjsRegionalFunctions`. Overrides are lower level than
@@ -17,11 +15,24 @@ export interface NextjsRegionalFunctionsConstructOverrides extends NextjsFunctio
 export interface NextjsRegionalFunctionsOverrides extends NextjsBaseOverrides {
     readonly nextjsRegionalFunctions?: NextjsRegionalFunctionsConstructOverrides;
     readonly nextjsFunctions?: NextjsFunctionsOverrides;
-    readonly nextjsImageFunction?: NextjsImageFunctionOverrides;
     readonly nextjsApi?: NextjsApiOverrides;
-    readonly nextjsPostDeploy?: NextjsPostDeployOverrides;
 }
 export interface NextjsRegionalFunctionsProps extends NextjsBaseProps {
+    /**
+     * Package sets of routes into separate Lambda functions, each fronted by its
+     * own API Gateway resources.
+     *
+     * Reach for this when a single function exceeds Lambda's 250 MB unzipped
+     * limit — cdk-nextjs throws at synth with the measured size when it does. It is
+     * not a performance or isolation feature: every group ships the same Next.js
+     * runtime, so splitting only moves route-local code.
+     *
+     * @see NextjsFunctionGroup for the pattern grammar and its limits. API Gateway
+     * could express more than CloudFront can, but the grammar is deliberately the
+     * same in both so switching deployment type never regroups routes.
+     * @default - one function serves every route
+     */
+    readonly functionGroups?: NextjsFunctionGroup[];
     /**
      * Override props of any construct.
      */
@@ -33,17 +44,10 @@ export interface NextjsRegionalFunctionsProps extends NextjsBaseProps {
  */
 export declare class NextjsRegionalFunctions 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;
     nextjsApi: NextjsApi;
     nextjsPostDeploy: NextjsPostDeploy;
     get url(): string;
     private props;
     constructor(scope: Construct, id: string, props: NextjsRegionalFunctionsProps);
     private createNextjsApi;
-    private createNextjsPostDeploy;
 }

package/lib/root-constructs/nextjs-regional-functions.js

@@ -2,24 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NextjsRegionalFunctions = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const function_groups_1 = require("../adapter/function-groups");
 const constants_1 = require("../constants");
 const nextjs_api_1 = require("../nextjs-api");
 const nextjs_base_construct_1 = require("./nextjs-base-construct");
-const nextjs_post_deploy_1 = require("../nextjs-post-deploy");
-const experimental_flags_1 = require("../utils/experimental-flags");
 /**
  * Deploy Next.js regionally with functions. Uses API Gateway REST API
  * for routing requests and AWS Lambda Functions for server-side rendering.
  */
 class NextjsRegionalFunctions extends nextjs_base_construct_1.NextjsBaseConstruct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsRegionalFunctions", version: "0.6.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsRegionalFunctions", version: "0.7.1" };
     nextjsFunctions;
-    /**
-     * Only created when the (experimental, unsupported) dedicated image
-     * optimization Lambda is enabled. `_next/image` is otherwise served by
-     * {@link nextjsFunctions}.
-     */
-    nextjsImageFunction;
     nextjsApi;
     nextjsPostDeploy;
     get url() {
@@ -29,10 +22,7 @@ class NextjsRegionalFunctions extends nextjs_base_construct_1.NextjsBaseConstruc
     constructor(scope, id, props) {
         super(scope, id, props, constants_1.NextjsType.REGIONAL_FUNCTIONS);
         this.props = props;
-        this.nextjsFunctions = this.createNextjsFunctions(this.props.overrides?.nextjsFunctions);
-        if ((0, experimental_flags_1.useDedicatedImageFunction)()) {
-            this.nextjsImageFunction = this.createNextjsImageFunction(this.props.overrides?.nextjsImageFunction);
-        }
+        this.nextjsFunctions = this.createNextjsFunctions();
         this.nextjsApi = this.createNextjsApi();
         this.nextjsPostDeploy = this.createNextjsPostDeploy();
     }
@@ -41,24 +31,16 @@ class NextjsRegionalFunctions extends nextjs_base_construct_1.NextjsBaseConstruc
             staticAssetsBucket: this.nextjsStaticAssets.bucket,
             staticAssetsKeyPrefix: this.nextjsStaticAssets.keyPrefix,
             serverFunction: this.nextjsFunctions.function,
-            imageFunction: this.nextjsImageFunction?.function,
             basePath: this.resolvedBasePath,
             overrides: this.props.overrides?.nextjsApi,
             publicDirEntries: this.nextjsBuild.publicDirEntries,
+            // `serverFunction` above is the default group's, which the `{proxy+}`
+            // catch-all reaches; the rest get resources of their own.
+            functionGroups: this.nextjsFunctions.functionGroups.filter((group) => group.name !== function_groups_1.DEFAULT_FUNCTION_GROUP),
+            functionGroupBehaviors: this.nextjsBuild.functionGroupBehaviors,
             ...this.props.overrides?.nextjsRegionalFunctions?.nextjsApiProps,
         });
     }
-    createNextjsPostDeploy() {
-        return new nextjs_post_deploy_1.NextjsPostDeploy(this, "NextjsPostDeploy", {
-            buildId: this.nextjsBuild.buildId,
-            cacheBucket: this.nextjsCache.cacheBucket,
-            revalidationTable: this.nextjsCache.revalidationTable,
-            staticAssetsBucket: this.nextjsStaticAssets.bucket,
-            staticAssetsKeyPrefix: this.nextjsStaticAssets.keyPrefix,
-            overrides: this.props.overrides?.nextjsPostDeploy,
-            ...this.props.overrides?.nextjsRegionalFunctions?.nextjsPostDeployProps,
-        });
-    }
 }
 exports.NextjsRegionalFunctions = NextjsRegionalFunctions;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-regional-functions.js","sourceRoot":"","sources":["../../src/root-constructs/nextjs-regional-functions.ts"],"names":[],"mappings":";;;;AACA,4CAA0C;AAC1C,8CAA8E;AAC9E,mEAKiC;AAUjC,8DAG+B;AAC/B,oEAAwE;AA2BxE;;;GAGG;AACH,MAAa,uBAAwB,SAAQ,2CAAmB;;IAC9D,eAAe,CAAkB;IACjC;;;;OAIG;IACH,mBAAmB,CAAuB;IAC1C,SAAS,CAAY;IACrB,gBAAgB,CAAmB;IACnC,IAAI,GAAG;QACL,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC;IAC5B,CAAC;IAEO,KAAK,CAA+B;IAE5C,YACE,KAAgB,EAChB,EAAU,EACV,KAAmC;QAEnC,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,sBAAU,CAAC,kBAAkB,CAAC,CAAC;QACvD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QAEnB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,qBAAqB,CAC/C,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,eAAe,CACtC,CAAC;QACF,IAAI,IAAA,8CAAyB,GAAE,EAAE,CAAC;YAChC,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,yBAAyB,CACvD,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,mBAAmB,CAC1C,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QACxC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;IACxD,CAAC;IAEO,eAAe;QACrB,OAAO,IAAI,sBAAS,CAAC,IAAI,EAAE,WAAW,EAAE;YACtC,kBAAkB,EAAE,IAAI,CAAC,kBAAkB,CAAC,MAAM;YAClD,qBAAqB,EAAE,IAAI,CAAC,kBAAkB,CAAC,SAAS;YACxD,cAAc,EAAE,IAAI,CAAC,eAAe,CAAC,QAAQ;YAC7C,aAAa,EAAE,IAAI,CAAC,mBAAmB,EAAE,QAAQ;YACjD,QAAQ,EAAE,IAAI,CAAC,gBAAgB;YAC/B,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,SAAS;YAC1C,gBAAgB,EAAE,IAAI,CAAC,WAAW,CAAC,gBAAgB;YACnD,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,uBAAuB,EAAE,cAAc;SACjE,CAAC,CAAC;IACL,CAAC;IAEO,sBAAsB;QAC5B,OAAO,IAAI,qCAAgB,CAAC,IAAI,EAAE,kBAAkB,EAAE;YACpD,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,OAAO;YACjC,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,WAAW;YACzC,iBAAiB,EAAE,IAAI,CAAC,WAAW,CAAC,iBAAiB;YACrD,kBAAkB,EAAE,IAAI,CAAC,kBAAkB,CAAC,MAAM;YAClD,qBAAqB,EAAE,IAAI,CAAC,kBAAkB,CAAC,SAAS;YACxD,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,gBAAgB;YACjD,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,uBAAuB,EAAE,qBAAqB;SACxE,CAAC,CAAC;IACL,CAAC;;AA3DH,0DA4DC","sourcesContent":["import { Construct } from \"constructs\";\nimport { NextjsType } from \"../constants\";\nimport { NextjsApi, NextjsApiOverrides, NextjsApiProps } from \"../nextjs-api\";\nimport {\n  NextjsBaseConstruct,\n  NextjsBaseProps,\n  NextjsFunctionsConstructOverrides,\n  NextjsBaseOverrides,\n} from \"./nextjs-base-construct\";\nimport { OptionalNextjsPostDeployProps } from \"../generated-structs/OptionalNextjsPostDeployProps\";\nimport {\n  NextjsFunctions,\n  NextjsFunctionsOverrides,\n} from \"../nextjs-compute/nextjs-functions\";\nimport {\n  NextjsImageFunction,\n  NextjsImageFunctionOverrides,\n} from \"../nextjs-compute/nextjs-image-function\";\nimport {\n  NextjsPostDeploy,\n  NextjsPostDeployOverrides,\n} from \"../nextjs-post-deploy\";\nimport { useDedicatedImageFunction } from \"../utils/experimental-flags\";\n\nexport interface NextjsRegionalFunctionsConstructOverrides extends NextjsFunctionsConstructOverrides {\n  readonly nextjsApiProps?: NextjsApiProps;\n  readonly nextjsPostDeployProps?: OptionalNextjsPostDeployProps;\n}\n\n/**\n * Overrides for `NextjsRegionalFunctions`. 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 NextjsRegionalFunctionsOverrides extends NextjsBaseOverrides {\n  readonly nextjsRegionalFunctions?: NextjsRegionalFunctionsConstructOverrides;\n  readonly nextjsFunctions?: NextjsFunctionsOverrides;\n  readonly nextjsImageFunction?: NextjsImageFunctionOverrides;\n  readonly nextjsApi?: NextjsApiOverrides;\n  readonly nextjsPostDeploy?: NextjsPostDeployOverrides;\n}\n\nexport interface NextjsRegionalFunctionsProps extends NextjsBaseProps {\n  /**\n   * Override props of any construct.\n   */\n  readonly overrides?: NextjsRegionalFunctionsOverrides;\n}\n\n/**\n * Deploy Next.js regionally with functions. Uses API Gateway REST API\n * for routing requests and AWS Lambda Functions for server-side rendering.\n */\nexport class NextjsRegionalFunctions extends NextjsBaseConstruct {\n  nextjsFunctions: NextjsFunctions;\n  /**\n   * Only created when the (experimental, unsupported) dedicated image\n   * optimization Lambda is enabled. `_next/image` is otherwise served by\n   * {@link nextjsFunctions}.\n   */\n  nextjsImageFunction?: NextjsImageFunction;\n  nextjsApi: NextjsApi;\n  nextjsPostDeploy: NextjsPostDeploy;\n  get url(): string {\n    return this.nextjsApi.url;\n  }\n\n  private props: NextjsRegionalFunctionsProps;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: NextjsRegionalFunctionsProps,\n  ) {\n    super(scope, id, props, NextjsType.REGIONAL_FUNCTIONS);\n    this.props = props;\n\n    this.nextjsFunctions = this.createNextjsFunctions(\n      this.props.overrides?.nextjsFunctions,\n    );\n    if (useDedicatedImageFunction()) {\n      this.nextjsImageFunction = this.createNextjsImageFunction(\n        this.props.overrides?.nextjsImageFunction,\n      );\n    }\n    this.nextjsApi = this.createNextjsApi();\n    this.nextjsPostDeploy = this.createNextjsPostDeploy();\n  }\n\n  private createNextjsApi() {\n    return new NextjsApi(this, \"NextjsApi\", {\n      staticAssetsBucket: this.nextjsStaticAssets.bucket,\n      staticAssetsKeyPrefix: this.nextjsStaticAssets.keyPrefix,\n      serverFunction: this.nextjsFunctions.function,\n      imageFunction: this.nextjsImageFunction?.function,\n      basePath: this.resolvedBasePath,\n      overrides: this.props.overrides?.nextjsApi,\n      publicDirEntries: this.nextjsBuild.publicDirEntries,\n      ...this.props.overrides?.nextjsRegionalFunctions?.nextjsApiProps,\n    });\n  }\n\n  private createNextjsPostDeploy(): NextjsPostDeploy {\n    return new NextjsPostDeploy(this, \"NextjsPostDeploy\", {\n      buildId: this.nextjsBuild.buildId,\n      cacheBucket: this.nextjsCache.cacheBucket,\n      revalidationTable: this.nextjsCache.revalidationTable,\n      staticAssetsBucket: this.nextjsStaticAssets.bucket,\n      staticAssetsKeyPrefix: this.nextjsStaticAssets.keyPrefix,\n      overrides: this.props.overrides?.nextjsPostDeploy,\n      ...this.props.overrides?.nextjsRegionalFunctions?.nextjsPostDeployProps,\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/runtime/api-gateway-path.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The path to hand Next.js for an API Gateway REST event.
+ *
+ * API Gateway strips the prefix it routed on before invoking Lambda: the stage on
+ * the execute-api endpoint (`/prod/foo` arrives as `event.path = "/foo"`), or the
+ * base path mapping on a custom domain. `requestContext.path` keeps it. Which of
+ * the two is right depends on the app:
+ *
+ * - An app built with a `basePath` that *includes* the stripped prefix — the
+ *   usual execute-api setup, `basePath: "/prod"` so its links carry the stage —
+ *   only routes the unstripped path. Handing it `event.path` 404'd every request,
+ *   which is why `examples/app-playground` used to carry a `proxy.ts` that
+ *   prepended the stage from an environment variable.
+ * - Every other app — no `basePath`, or one API Gateway does not strip (a custom
+ *   domain mapped at the root) — routes `event.path`, and `requestContext.path`
+ *   would carry a stage it never heard of.
+ *
+ * So `requestContext.path` is used exactly when it starts with the app's
+ * `basePath` on a segment boundary, and nothing has to be configured: a stage
+ * named `test`, a renamed stage and a base path mapping are all read off the
+ * event. Measured against a deployed REST API: the two fields share an encoding
+ * (`/a%20b` in both), and only `event.path` is normalized — `/prod` arrives as
+ * `"/"` and `/prod//foo` as `"/foo"` — so reconstructing the prefix from their
+ * difference is not reliable, and taking `requestContext.path` whole is.
+ *
+ * @param basePath the app's own `basePath`, as the adapter manifest records it:
+ * `""` or a leading-slash path with no trailing slash.
+ */
+export declare function apiGatewayRequestPath(event: {
+    path: string;
+    requestContext: {
+        path?: string;
+    };
+}, basePath: string): string;

package/lib/runtime/api-gateway-path.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiGatewayRequestPath = apiGatewayRequestPath;
+const base_path_1 = require("../utils/base-path");
+/**
+ * The path to hand Next.js for an API Gateway REST event.
+ *
+ * API Gateway strips the prefix it routed on before invoking Lambda: the stage on
+ * the execute-api endpoint (`/prod/foo` arrives as `event.path = "/foo"`), or the
+ * base path mapping on a custom domain. `requestContext.path` keeps it. Which of
+ * the two is right depends on the app:
+ *
+ * - An app built with a `basePath` that *includes* the stripped prefix — the
+ *   usual execute-api setup, `basePath: "/prod"` so its links carry the stage —
+ *   only routes the unstripped path. Handing it `event.path` 404'd every request,
+ *   which is why `examples/app-playground` used to carry a `proxy.ts` that
+ *   prepended the stage from an environment variable.
+ * - Every other app — no `basePath`, or one API Gateway does not strip (a custom
+ *   domain mapped at the root) — routes `event.path`, and `requestContext.path`
+ *   would carry a stage it never heard of.
+ *
+ * So `requestContext.path` is used exactly when it starts with the app's
+ * `basePath` on a segment boundary, and nothing has to be configured: a stage
+ * named `test`, a renamed stage and a base path mapping are all read off the
+ * event. Measured against a deployed REST API: the two fields share an encoding
+ * (`/a%20b` in both), and only `event.path` is normalized — `/prod` arrives as
+ * `"/"` and `/prod//foo` as `"/foo"` — so reconstructing the prefix from their
+ * difference is not reliable, and taking `requestContext.path` whole is.
+ *
+ * @param basePath the app's own `basePath`, as the adapter manifest records it:
+ * `""` or a leading-slash path with no trailing slash.
+ */
+function apiGatewayRequestPath(event, basePath) {
+    const unstripped = event.requestContext.path;
+    if (unstripped && (0, base_path_1.hasPathPrefix)(unstripped, basePath)) {
+        return unstripped;
+    }
+    return ((unstripped && withRepeatedSlashes(unstripped, event.path)) ?? event.path);
+}
+/**
+ * `event.path` with the repeated slashes API Gateway collapsed put back, or
+ * `undefined` when there are none to restore.
+ *
+ * `//` arrives as `event.path = "/"`, so Next.js never sees the repeated slash it
+ * redirects away (`normalizeRepeatedSlashes`), and the page is served at `//`
+ * itself - where the Pages Router's client throws `Invalid URL` building a URL
+ * from a protocol-relative path, and the page never hydrates. Found by next.js's
+ * `test/e2e/hydration` on Regional Functions.
+ *
+ * The prefix API Gateway stripped (the stage, or a base path mapping) is not
+ * recoverable by subtracting one field from the other, for the reason above.
+ * So whole leading segments are dropped from `requestContext.path` until what is
+ * left, collapsed, is `event.path`: the first such suffix is the unstripped path
+ * below the prefix. If none matches, `event.path` stands.
+ */
+function withRepeatedSlashes(unstripped, stripped) {
+    if (!unstripped.includes("//")) {
+        return undefined;
+    }
+    for (let rest = unstripped;;) {
+        if (rest.replace(/\/{2,}/g, "/") === stripped) {
+            return rest === stripped ? undefined : rest;
+        }
+        const next = rest.replace(/^\/[^/]+/, "");
+        if (next === rest) {
+            return undefined;
+        }
+        rest = next;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/runtime/api-gateway-path.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/runtime/api-gateway-path.test.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_gateway_path_1 = require("./api-gateway-path");
+/** The two fields as a deployed REST API reported them for the same request. */
+const event = (path, contextPath) => ({
+    path,
+    requestContext: { path: contextPath },
+});
+describe("apiGatewayRequestPath", () => {
+    it("keeps the stage for an app whose basePath is the stage", () => {
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)(event("/foo", "/prod/foo"), "/prod")).toBe("/prod/foo");
+    });
+    it("reads whatever the stage is called, not a fixed name", () => {
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)(event("/foo", "/test/foo"), "/test")).toBe("/test/foo");
+    });
+    it("serves the app's root at the bare stage URL", () => {
+        // `event.path` is normalized to "/" here, which is why the prefix cannot be
+        // recovered by subtracting one field from the other.
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)(event("/", "/prod"), "/prod")).toBe("/prod");
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)(event("/", "/prod/"), "/prod")).toBe("/prod/");
+    });
+    it("keeps a basePath nested below the stage", () => {
+        // `basePath: "/prod/base"` with the construct's `basePath` prop "base": the
+        // resources sit under /base, and only the stage is stripped.
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)(event("/base/foo", "/prod/base/foo"), "/prod/base")).toBe("/prod/base/foo");
+    });
+    it("passes the percent-encoding through untouched", () => {
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)(event("/a%20b/c", "/prod/a%20b/c"), "/prod")).toBe("/prod/a%20b/c");
+    });
+    it("leaves an app without a basePath on the stripped path", () => {
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)(event("/foo", "/prod/foo"), "")).toBe("/foo");
+    });
+    it("leaves an app whose basePath API Gateway does not strip alone", () => {
+        // A custom domain mapped at the root: nothing is stripped, so both fields
+        // agree and either would do.
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)(event("/docs/foo", "/docs/foo"), "/docs")).toBe("/docs/foo");
+        // And a basePath that is not the stage: the stage-carrying path would 404.
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)(event("/foo", "/prod/foo"), "/docs")).toBe("/foo");
+    });
+    it("matches the basePath on a segment boundary", () => {
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)(event("/foo", "/production/foo"), "/prod")).toBe("/foo");
+    });
+    it("keeps repeated slashes API Gateway collapsed out of event.path", () => {
+        // Below the stage, so Next.js can redirect `//` away itself.
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)(event("/", "/prod//"), "")).toBe("//");
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)(event("/foo", "/prod//foo"), "")).toBe("//foo");
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)(event("/a/b", "/prod/a//b"), "")).toBe("/a//b");
+        // A base path mapping of more than one segment strips as many.
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)(event("/foo", "/v1/api//foo"), "")).toBe("//foo");
+        // A custom domain mapped at the root strips nothing.
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)(event("/", "//"), "")).toBe("//");
+        // And with a basePath API Gateway does not strip.
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)(event("/docs/", "/docs//"), "/docs")).toBe("/docs//");
+    });
+    it("keeps event.path when the repeated slashes cannot be placed", () => {
+        // No suffix of the context path collapses to event.path.
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)(event("/bar", "/prod//foo"), "")).toBe("/bar");
+        // Repeated slashes only inside the stripped prefix.
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)(event("/foo", "//prod/foo"), "")).toBe("/foo");
+    });
+    it("falls back to event.path when the context has no path", () => {
+        expect((0, api_gateway_path_1.apiGatewayRequestPath)({ path: "/foo", requestContext: {} }, "/prod")).toBe("/foo");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-gateway-path.test.js","sourceRoot":"","sources":["../../src/runtime/api-gateway-path.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { apiGatewayRequestPath } from \"./api-gateway-path\";\n\n/** The two fields as a deployed REST API reported them for the same request. */\nconst event = (path: string, contextPath: string) => ({\n  path,\n  requestContext: { path: contextPath },\n});\n\ndescribe(\"apiGatewayRequestPath\", () => {\n  it(\"keeps the stage for an app whose basePath is the stage\", () => {\n    expect(apiGatewayRequestPath(event(\"/foo\", \"/prod/foo\"), \"/prod\")).toBe(\n      \"/prod/foo\",\n    );\n  });\n\n  it(\"reads whatever the stage is called, not a fixed name\", () => {\n    expect(apiGatewayRequestPath(event(\"/foo\", \"/test/foo\"), \"/test\")).toBe(\n      \"/test/foo\",\n    );\n  });\n\n  it(\"serves the app's root at the bare stage URL\", () => {\n    // `event.path` is normalized to \"/\" here, which is why the prefix cannot be\n    // recovered by subtracting one field from the other.\n    expect(apiGatewayRequestPath(event(\"/\", \"/prod\"), \"/prod\")).toBe(\"/prod\");\n    expect(apiGatewayRequestPath(event(\"/\", \"/prod/\"), \"/prod\")).toBe(\"/prod/\");\n  });\n\n  it(\"keeps a basePath nested below the stage\", () => {\n    // `basePath: \"/prod/base\"` with the construct's `basePath` prop \"base\": the\n    // resources sit under /base, and only the stage is stripped.\n    expect(\n      apiGatewayRequestPath(event(\"/base/foo\", \"/prod/base/foo\"), \"/prod/base\"),\n    ).toBe(\"/prod/base/foo\");\n  });\n\n  it(\"passes the percent-encoding through untouched\", () => {\n    expect(\n      apiGatewayRequestPath(event(\"/a%20b/c\", \"/prod/a%20b/c\"), \"/prod\"),\n    ).toBe(\"/prod/a%20b/c\");\n  });\n\n  it(\"leaves an app without a basePath on the stripped path\", () => {\n    expect(apiGatewayRequestPath(event(\"/foo\", \"/prod/foo\"), \"\")).toBe(\"/foo\");\n  });\n\n  it(\"leaves an app whose basePath API Gateway does not strip alone\", () => {\n    // A custom domain mapped at the root: nothing is stripped, so both fields\n    // agree and either would do.\n    expect(\n      apiGatewayRequestPath(event(\"/docs/foo\", \"/docs/foo\"), \"/docs\"),\n    ).toBe(\"/docs/foo\");\n    // And a basePath that is not the stage: the stage-carrying path would 404.\n    expect(apiGatewayRequestPath(event(\"/foo\", \"/prod/foo\"), \"/docs\")).toBe(\n      \"/foo\",\n    );\n  });\n\n  it(\"matches the basePath on a segment boundary\", () => {\n    expect(\n      apiGatewayRequestPath(event(\"/foo\", \"/production/foo\"), \"/prod\"),\n    ).toBe(\"/foo\");\n  });\n\n  it(\"keeps repeated slashes API Gateway collapsed out of event.path\", () => {\n    // Below the stage, so Next.js can redirect `//` away itself.\n    expect(apiGatewayRequestPath(event(\"/\", \"/prod//\"), \"\")).toBe(\"//\");\n    expect(apiGatewayRequestPath(event(\"/foo\", \"/prod//foo\"), \"\")).toBe(\n      \"//foo\",\n    );\n    expect(apiGatewayRequestPath(event(\"/a/b\", \"/prod/a//b\"), \"\")).toBe(\n      \"/a//b\",\n    );\n    // A base path mapping of more than one segment strips as many.\n    expect(apiGatewayRequestPath(event(\"/foo\", \"/v1/api//foo\"), \"\")).toBe(\n      \"//foo\",\n    );\n    // A custom domain mapped at the root strips nothing.\n    expect(apiGatewayRequestPath(event(\"/\", \"//\"), \"\")).toBe(\"//\");\n    // And with a basePath API Gateway does not strip.\n    expect(apiGatewayRequestPath(event(\"/docs/\", \"/docs//\"), \"/docs\")).toBe(\n      \"/docs//\",\n    );\n  });\n\n  it(\"keeps event.path when the repeated slashes cannot be placed\", () => {\n    // No suffix of the context path collapses to event.path.\n    expect(apiGatewayRequestPath(event(\"/bar\", \"/prod//foo\"), \"\")).toBe(\"/bar\");\n    // Repeated slashes only inside the stripped prefix.\n    expect(apiGatewayRequestPath(event(\"/foo\", \"//prod/foo\"), \"\")).toBe(\"/foo\");\n  });\n\n  it(\"falls back to event.path when the context has no path\", () => {\n    expect(\n      apiGatewayRequestPath({ path: \"/foo\", requestContext: {} }, \"/prod\"),\n    ).toBe(\"/foo\");\n  });\n});\n"]}

package/lib/runtime/case-redirect.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The canonical spelling of a URL that reached the wrong function group only
+ * because of its case.
+ *
+ * CloudFront behaviors and API Gateway resources match paths case-sensitively,
+ * and Next.js's route matching does not, so `/API/reports/1` misses the
+ * `api/reports/*` behavior, reaches the default group, and matches
+ * `/api/reports/[id]` there, whose code another group carries. Redirecting it
+ * to `/api/reports/1` gets it to the group that has the route, where a 404
+ * would have told the client a URL `next start` serves does not exist.
+ */
+import { AdapterManifest } from "./manifest";
+/**
+ * `pathname` (as requested, percent-encoded) respelled with the static segments
+ * of `template` (the matched `manifest.entrypoints` key), keeping the request's
+ * own dynamic segment values and basePath, which the manifest key carries too.
+ * `undefined` when the two differ in anything but case — a rewrite, a
+ * mismatched shape — or not at all, since then a redirect would not change
+ * where the request goes. No locale handling: `functionGroups` cannot be
+ * combined with i18n (`assertNoI18nSplitting`).
+ */
+export declare function caseCanonicalPath(pathname: string, template: string, manifest: Pick<AdapterManifest, "config">): string | undefined;

package/lib/runtime/case-redirect.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.caseCanonicalPath = caseCanonicalPath;
+const util_1 = require("./util");
+const base_path_1 = require("../utils/base-path");
+/**
+ * `pathname` (as requested, percent-encoded) respelled with the static segments
+ * of `template` (the matched `manifest.entrypoints` key), keeping the request's
+ * own dynamic segment values and basePath, which the manifest key carries too.
+ * `undefined` when the two differ in anything but case — a rewrite, a
+ * mismatched shape — or not at all, since then a redirect would not change
+ * where the request goes. No locale handling: `functionGroups` cannot be
+ * combined with i18n (`assertNoI18nSplitting`).
+ */
+function caseCanonicalPath(pathname, template, manifest) {
+    const basePath = manifest.config.basePath ?? "";
+    let rest = pathname;
+    let prefix = "";
+    if (basePath) {
+        if (!(0, base_path_1.hasPathPrefix)(rest.toLowerCase(), basePath.toLowerCase())) {
+            return undefined;
+        }
+        prefix = basePath;
+        rest = rest.slice(basePath.length) || "/";
+    }
+    const trailingSlash = rest.length > 1 && rest.endsWith("/");
+    const requested = segments(rest);
+    const expected = segments((0, util_1.withoutPathPrefix)(template, basePath));
+    const canonical = [];
+    for (let i = 0; i < expected.length; i++) {
+        const part = expected[i];
+        if (/^\[\[?\.\.\./.test(part)) {
+            // A catch-all takes everything left, as requested.
+            canonical.push(...requested.slice(i));
+            return finish(prefix, canonical, trailingSlash, pathname);
+        }
+        const value = requested[i];
+        if (value === undefined) {
+            return undefined;
+        }
+        if (part.startsWith("[")) {
+            canonical.push(value);
+            continue;
+        }
+        if ((0, util_1.safeDecode)(value).toLowerCase() !== part.toLowerCase()) {
+            return undefined;
+        }
+        canonical.push(encodeURIComponent(part));
+    }
+    if (requested.length !== expected.length) {
+        return undefined;
+    }
+    return finish(prefix, canonical, trailingSlash, pathname);
+}
+function finish(prefix, canonical, trailingSlash, pathname) {
+    const path = `${prefix}/${canonical.join("/")}`.replace(/\/+$/, "") || "/";
+    const result = trailingSlash && path !== "/" ? `${path}/` : path;
+    return result === pathname ? undefined : result;
+}
+function segments(path) {
+    return path.split("/").filter(Boolean);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/runtime/case-redirect.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/runtime/case-redirect.test.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const case_redirect_1 = require("./case-redirect");
+const plain = { config: { basePath: "", i18n: null } };
+describe("caseCanonicalPath", () => {
+    it("respells static segments and keeps dynamic values", () => {
+        expect((0, case_redirect_1.caseCanonicalPath)("/API/reports/1", "/api/reports/[id]", plain)).toBe("/api/reports/1");
+        expect((0, case_redirect_1.caseCanonicalPath)("/API/Reports/AbC", "/api/reports/[id]", plain)).toBe("/api/reports/AbC");
+    });
+    it("is undefined when nothing would change", () => {
+        expect((0, case_redirect_1.caseCanonicalPath)("/api/reports/1", "/api/reports/[id]", plain)).toBeUndefined();
+    });
+    // A rewrite onto the route, or any other shape the template doesn't have.
+    it("is undefined when the path is not the template's shape", () => {
+        expect((0, case_redirect_1.caseCanonicalPath)("/feed/1", "/api/reports/[id]", plain)).toBeUndefined();
+        expect((0, case_redirect_1.caseCanonicalPath)("/API/reports/1/2", "/api/reports/[id]", plain)).toBeUndefined();
+    });
+    it("gives a catch-all everything left", () => {
+        expect((0, case_redirect_1.caseCanonicalPath)("/DOCS/A/b", "/docs/[...slug]", plain)).toBe("/docs/A/b");
+        expect((0, case_redirect_1.caseCanonicalPath)("/DOCS", "/docs/[[...slug]]", plain)).toBe("/docs");
+    });
+    // What dispatch actually hands over: `resolvedPathname` is a manifest key,
+    // which carries the basePath.
+    it("matches basePath-prefixed templates, keeping the canonical basePath", () => {
+        const manifest = {
+            config: { basePath: "/prod", i18n: null },
+        };
+        expect((0, case_redirect_1.caseCanonicalPath)("/prod/API/reports/1", "/prod/api/reports/[id]", manifest)).toBe("/prod/api/reports/1");
+        expect((0, case_redirect_1.caseCanonicalPath)("/PROD/API/reports/1/", "/prod/api/reports/[id]", manifest)).toBe("/prod/api/reports/1/");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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