cdk-nextjs 0.6.1 → 0.7.0

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

@@ -3,12 +3,10 @@ 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 { OptionalNextjsPostDeployProps } from "../generated-structs/OptionalNextjsPostDeployProps";
 import { NextjsContainers, NextjsContainersOverrides } from "../nextjs-compute/nextjs-containers";
-import { NextjsPostDeploy, NextjsPostDeployOverrides } from "../nextjs-post-deploy";
+import { NextjsPostDeploy } from "../nextjs-post-deploy";
 export interface NextjsRegionalContainersConstructOverrides extends NextjsBaseConstructOverrides {
     readonly nextjsContainerProps?: OptionalNextjsContainersProps;
-    readonly nextjsPostDeployProps?: OptionalNextjsPostDeployProps;
 }
 /**
  * Overrides for `NextjsRegionalContainers`. Overrides are lower level than
@@ -18,7 +16,6 @@ export interface NextjsRegionalContainersConstructOverrides extends NextjsBaseCo
 export interface NextjsRegionalContainersOverrides extends NextjsBaseOverrides {
     readonly nextjsRegionalContainers?: NextjsRegionalContainersConstructOverrides;
     readonly nextjsContainers?: NextjsContainersOverrides;
-    readonly nextjsPostDeploy?: NextjsPostDeployOverrides;
 }
 export interface NextjsRegionalContainersProps extends NextjsBaseProps {
     /**
@@ -33,6 +30,23 @@ export interface NextjsRegionalContainersProps extends NextjsBaseProps {
      * a new cluster and VPC gateway endpoints.
      */
     readonly ecsCluster?: ICluster;
+    /**
+     * Path to API Route Handler that returns HTTP 200 to ensure compute health.
+     * Used by the ALB target group and the ECS container health check, both of
+     * which have to be able to tell a running task from a wedged one.
+     *
+     * Give the path as your app routes it, without your app's `basePath` —
+     * cdk-nextjs adds that prefix, since both checks hit the app directly.
+     * @example "/api/health"
+     * @example
+     * // api/health/route.ts
+     * import { NextResponse } from "next/server";
+     *
+     * export function GET() {
+     *   return NextResponse.json("");
+     * }
+     */
+    readonly healthCheckPath: string;
     /**
      * Override props of any construct.
      */
@@ -47,9 +61,15 @@ export interface NextjsRegionalContainersProps extends NextjsBaseProps {
 export declare class NextjsRegionalContainers extends NextjsBaseConstruct {
     nextjsContainers: NextjsContainers;
     nextjsPostDeploy: NextjsPostDeploy;
+    /**
+     * The ALB forwards every path to the container unchanged, so the app only
+     * answers under its own `basePath`. `resolvedBasePath` is deliberately not
+     * used here: for this `NextjsType` it only namespaces the S3 bucket and has no
+     * routing meaning, whereas the app's own `basePath` is what the container
+     * serves from.
+     */
     get url(): string;
     private props;
     constructor(scope: Construct, id: string, props: NextjsRegionalContainersProps);
     private createNextjsLoadBalancedContainers;
-    private createNextjsPostDeploy;
 }

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

@@ -5,7 +5,7 @@ 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
  * Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/introduction.html)
@@ -13,11 +13,18 @@ const nextjs_post_deploy_1 = require("../nextjs-post-deploy");
  * for containers.
  */
 class NextjsRegionalContainers extends nextjs_base_construct_1.NextjsBaseConstruct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsRegionalContainers", version: "0.6.1" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsRegionalContainers", version: "0.7.0" };
     nextjsContainers;
     nextjsPostDeploy;
+    /**
+     * The ALB forwards every path to the container unchanged, so the app only
+     * answers under its own `basePath`. `resolvedBasePath` is deliberately not
+     * used here: for this `NextjsType` it only namespaces the S3 bucket and has no
+     * routing meaning, whereas the app's own `basePath` is what the container
+     * serves from.
+     */
     get url() {
-        return this.nextjsContainers.url;
+        return (0, base_path_1.joinPath)(this.nextjsContainers.url, this.nextjsBuild.nextConfigBasePath);
     }
     props;
     constructor(scope, id, props) {
@@ -31,28 +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,
-            overrides: this.props.overrides?.nextjsPostDeploy,
-            ...this.props.overrides?.nextjsRegionalContainers?.nextjsPostDeployProps,
-        });
-    }
 }
 exports.NextjsRegionalContainers = NextjsRegionalContainers;
-//# sourceMappingURL=data:application/json;base64,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
+//# 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.1" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsRegionalFunctions", version: "0.7.0" };
     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,23 +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,
-            overrides: this.props.overrides?.nextjsPostDeploy,
-            ...this.props.overrides?.nextjsRegionalFunctions?.nextjsPostDeployProps,
-        });
-    }
 }
 exports.NextjsRegionalFunctions = NextjsRegionalFunctions;
-//# sourceMappingURL=data:application/json;base64,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
+//# 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;