cdk-nextjs 0.6.2 → 0.7.1

package/lib/nextjs-api.js

@@ -2,16 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NextjsApi = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const node_path_1 = require("node:path");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const aws_apigateway_1 = require("aws-cdk-lib/aws-apigateway");
+const aws_events_1 = require("aws-cdk-lib/aws-events");
+const aws_events_targets_1 = require("aws-cdk-lib/aws-events-targets");
 const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
 const constructs_1 = require("constructs");
+const constants_1 = require("./constants");
+const nextjs_static_assets_1 = require("./nextjs-static-assets");
 const base_path_1 = require("./utils/base-path");
+/**
+ * What API Gateway accepts as a resource path part, per CDK's own check in
+ * `Resource`: `[a-zA-Z0-9:._-$]`, plus an optional trailing `+`.
+ */
+const API_PATH_PART = /^[a-zA-Z0-9:._\-$]+$/;
 /**
  * Creates an API Gateway REST API for Next.js applications
  */
 class NextjsApi extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsApi", version: "0.6.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsApi", version: "0.7.1" };
     /**
      * The API Gateway REST API
      */
@@ -40,8 +51,26 @@ class NextjsApi extends constructs_1.Construct {
             ];
         return (0, base_path_1.joinPath)(origin, prefix, this.props.basePath);
     }
+    /**
+     * Deploys the stage again after each stack update.
+     * @see NextjsApiProps.redeployAfterUpdate
+     */
+    redeployFunction;
+    /**
+     * Matches this stack's `UPDATE_COMPLETE` and `UPDATE_ROLLBACK_COMPLETE` and
+     * invokes {@link redeployFunction}.
+     */
+    redeployRule;
     baseResource;
     nextResource;
+    /**
+     * Resources created only as parents of a group route, and their paths. API
+     * Gateway answers a request for a resource with no method itself — 403
+     * "Missing Authentication Token" — rather than falling back to a `{proxy+}`
+     * higher up, so each needs one. Without it a `/api/reports/**` group turned
+     * `/api/reports` and `/api` into 403s.
+     */
+    groupParentResources = new Map();
     props;
     staticIntegrationRole;
     constructor(scope, id, props) {
@@ -54,16 +83,77 @@ class NextjsApi extends constructs_1.Construct {
         this.staticIntegrationRole = this.createStaticIntegrationRole();
         this.createStaticIntegrations();
         if (props.serverFunction) {
-            // Without a dedicated image function, `_next/image` falls through to the
-            // `{proxy+}` catch-all on the server function.
-            if (props.imageFunction) {
-                this.createImageIntegration(props.imageFunction);
-            }
+            // Group resources before the catch-all, so `addResource` sees a clean tree
+            // and a group can claim a path the catch-all would otherwise serve.
+            this.createFunctionGroupIntegrations();
+            // `_next/image` has no resource of its own: it falls through to the
+            // `{proxy+}` catch-all, and the server function optimizes in-process.
             this.createDynamicIntegration(props.serverFunction);
         }
         else if (props.vpc) {
             // [Future] create integration with ECS via VPC Link and ECS Service Discovery
         }
+        if (props.redeployAfterUpdate !== false &&
+            props.overrides?.restApiProps?.deploy !== false) {
+            [this.redeployFunction, this.redeployRule] = this.createRedeploy();
+        }
+    }
+    /** @see NextjsApiProps.redeployAfterUpdate */
+    createRedeploy() {
+        const stack = aws_cdk_lib_1.Stack.of(this);
+        const { restApiId } = this.api;
+        const { stageName } = this.api.deploymentStage;
+        const fn = new aws_lambda_1.Function(this, "RedeployFn", {
+            // Plain bundled JS with no native dependencies: always arm64.
+            architecture: aws_lambda_1.Architecture.ARM_64,
+            code: aws_lambda_1.Code.fromAsset((0, node_path_1.join)(__dirname, "../assets/lambdas/redeploy-stage/redeploy-stage.lambda")),
+            handler: "index.handler",
+            memorySize: 256,
+            runtime: new aws_lambda_1.Runtime("nodejs24.x", aws_lambda_1.RuntimeFamily.NODEJS),
+            timeout: aws_cdk_lib_1.Duration.minutes(1),
+            ...this.props.overrides?.redeployFunctionProps,
+            environment: {
+                ...this.props.overrides?.redeployFunctionProps?.environment,
+                REST_API_ID: restApiId,
+                STAGE_NAME: stageName,
+            },
+        });
+        // API Gateway authorizes its management API by HTTP verb on the resource
+        // path; these are the four calls `redeployStage` makes, on this API only.
+        const restApi = `arn:${stack.partition}:apigateway:${stack.region}::/restapis/${restApiId}`;
+        fn.addToRolePolicy(new aws_iam_1.PolicyStatement({
+            actions: ["apigateway:POST"],
+            resources: [`${restApi}/deployments`],
+        }));
+        fn.addToRolePolicy(new aws_iam_1.PolicyStatement({
+            actions: ["apigateway:GET"],
+            resources: [`${restApi}/deployments`, `${restApi}/stages`],
+        }));
+        fn.addToRolePolicy(new aws_iam_1.PolicyStatement({
+            actions: ["apigateway:DELETE"],
+            resources: [`${restApi}/deployments/*`],
+        }));
+        // CloudFormation sends every stack status change to the default event bus
+        // ("Monitoring CloudFormation ... events with EventBridge" in the
+        // CloudFormation User Guide). `UPDATE_COMPLETE` comes after
+        // `UPDATE_COMPLETE_CLEANUP_IN_PROGRESS`, so removed resources are gone by
+        // then. A rollback restores the stage to the pre-update deployment, which
+        // can carry the same staleness from an earlier update, so it redeploys too.
+        const rule = new aws_events_1.Rule(this, "RedeployRule", {
+            description: `Redeploys ${stack.stackName}'s REST API stage after a stack update`,
+            eventPattern: {
+                source: ["aws.cloudformation"],
+                detailType: ["CloudFormation Stack Status Change"],
+                detail: {
+                    "stack-id": [stack.stackId],
+                    "status-details": {
+                        status: ["UPDATE_COMPLETE", "UPDATE_ROLLBACK_COMPLETE"],
+                    },
+                },
+            },
+            targets: [new aws_events_targets_1.LambdaFunction(fn, { retryAttempts: 2 })],
+        });
+        return [fn, rule];
     }
     validateProps(props) {
         if (!props.serverFunction && !props.vpc) {
@@ -75,7 +165,12 @@ class NextjsApi extends constructs_1.Construct {
             binaryMediaTypes: ["*/*"],
             description: `cdk-nextjs REST API for ${aws_cdk_lib_1.Stack.of(this).stackName}`,
             endpointTypes: [aws_apigateway_1.EndpointType.REGIONAL],
-            minCompressionSize: aws_cdk_lib_1.Size.bytes(0), // compress all responses for better perf
+            // Inert for the dynamic routes: API Gateway does not compress a response it
+            // streams (`ResponseTransferMode.STREAM`), which every Lambda integration
+            // here uses, so the runtime gzips those itself. Kept because it still
+            // applies to the buffered S3 static integrations, and because a consumer
+            // who overrides an integration to BUFFERED gets compression back.
+            minCompressionSize: aws_cdk_lib_1.Size.bytes(0),
             ...this.props.overrides?.restApiProps,
         });
     }
@@ -102,13 +197,21 @@ class NextjsApi extends constructs_1.Construct {
         const staticIntegrationRole = new aws_iam_1.Role(this, "StaticIntegrationRole", {
             assumedBy: new aws_iam_1.ServicePrincipal("apigateway.amazonaws.com"),
         });
+        // Only this app's own objects: a shared bucket holds other apps' assets
+        // under their own prefixes. `s3:ListBucket` makes a missing key a 404 (the
+        // only error the integration maps) rather than a 403. It stays unconditioned:
+        // S3 checks it during a GetObject, where no `s3:prefix` is present, so a
+        // prefix condition would turn every missing key back into a 403.
         staticIntegrationRole.addToPolicy(new aws_iam_1.PolicyStatement({
-            actions: ["s3:GetObject", "s3:ListBucket"],
+            actions: ["s3:GetObject"],
             resources: [
-                this.props.staticAssetsBucket.bucketArn,
-                `${this.props.staticAssetsBucket.bucketArn}/*`,
+                `${this.props.staticAssetsBucket.bucketArn}/${(0, nextjs_static_assets_1.staticAssetsObjectsPattern)(this.props.staticAssetsKeyPrefix)}`,
             ],
         }));
+        staticIntegrationRole.addToPolicy(new aws_iam_1.PolicyStatement({
+            actions: ["s3:ListBucket"],
+            resources: [this.props.staticAssetsBucket.bucketArn],
+        }));
         return staticIntegrationRole;
     }
     createStaticIntegrations() {
@@ -117,7 +220,17 @@ class NextjsApi extends constructs_1.Construct {
             .addResource("{proxy+}")
             .addMethod("GET", this.createS3Integration({ key: this.s3Key("_next/static/{key}") }), this.getStaticMethodOptions({ proxy: true }));
         // add public directory files/directories that exist at top level but need to go to S3.
+        const unroutable = [];
         for (const publicDirEntry of this.props.publicDirEntries) {
+            // A space or a non-ASCII character is legal in `public/` and illegal in an
+            // API Gateway resource path part, and `addResource` throws — which took the
+            // whole synth down for an app that deploys fine on the Global types
+            // (`next-image-legacy/unicode`, whose `public/` holds "hello world.jpg").
+            // Warn and skip the one entry instead: that asset 404s, the app deploys.
+            if (!API_PATH_PART.test(publicDirEntry.name)) {
+                unroutable.push(`"${publicDirEntry.name}"`);
+                continue;
+            }
             if (publicDirEntry.isDirectory) {
                 this.baseResource
                     .addResource(publicDirEntry.name)
@@ -132,6 +245,15 @@ class NextjsApi extends constructs_1.Construct {
                     .addMethod("GET", this.createS3Integration({ key: this.s3Key(publicDirEntry.name) }), this.getStaticMethodOptions());
             }
         }
+        if (unroutable.length > 0) {
+            aws_cdk_lib_1.Annotations.of(this).addWarning(`${constants_1.LOG_PREFIX} An API Gateway resource path part only allows ` +
+                "[a-zA-Z0-9:._-$], so these top-level public/ entries get no resource of " +
+                "their own; their requests reach the server function, which reads them " +
+                `from S3 instead: ${unroutable.join(", ")}. To serve them directly, rename them, move them into a ` +
+                "public/ subdirectory whose own name is expressible, or use " +
+                "NextjsGlobalFunctions or NextjsGlobalContainers, whose CloudFront " +
+                "behaviors can match them.");
+        }
     }
     /**
      * Prefixes a request path with the key prefix the assets were uploaded under,
@@ -153,11 +275,18 @@ class NextjsApi extends constructs_1.Construct {
             options: {
                 credentialsRole: this.staticIntegrationRole,
                 passthroughBehavior: aws_apigateway_1.PassthroughBehavior.WHEN_NO_TEMPLATES, // recommended
-                requestParameters: key.includes("{key}")
-                    ? {
-                        "integration.request.path.key": "method.request.path.proxy",
-                    }
-                    : undefined,
+                requestParameters: {
+                    // Without this S3 never sees the conditional request, so every
+                    // revalidation of an immutable `_next/static` chunk re-downloads it
+                    // with a 200 instead of getting a 304.
+                    "integration.request.header.If-None-Match": "method.request.header.If-None-Match",
+                    "integration.request.header.If-Modified-Since": "method.request.header.If-Modified-Since",
+                    ...(key.includes("{key}")
+                        ? {
+                            "integration.request.path.key": "method.request.path.proxy",
+                        }
+                        : {}),
+                },
                 integrationResponses: [
                     {
                         statusCode: "200",
@@ -169,6 +298,17 @@ class NextjsApi extends constructs_1.Construct {
                             "method.response.header.Last-Modified": "integration.response.header.Last-Modified",
                         },
                     },
+                    {
+                        // A 304 carries no body, and `ETag` is the header a client needs
+                        // back to keep revalidating.
+                        statusCode: "304",
+                        selectionPattern: "304",
+                        responseParameters: {
+                            "method.response.header.Cache-Control": "integration.response.header.Cache-Control",
+                            "method.response.header.ETag": "integration.response.header.ETag",
+                            "method.response.header.Last-Modified": "integration.response.header.Last-Modified",
+                        },
+                    },
                     {
                         statusCode: "404",
                         selectionPattern: "404",
@@ -181,11 +321,13 @@ class NextjsApi extends constructs_1.Construct {
     }
     getStaticMethodOptions({ proxy } = { proxy: false }) {
         return {
-            requestParameters: proxy
-                ? {
-                    "method.request.path.proxy": true,
-                }
-                : undefined,
+            requestParameters: {
+                // Declared optional (`false`): a plain GET carries neither, and
+                // requiring them would 400 it.
+                "method.request.header.If-None-Match": false,
+                "method.request.header.If-Modified-Since": false,
+                ...(proxy ? { "method.request.path.proxy": true } : {}),
+            },
             methodResponses: [
                 {
                     statusCode: "200",
@@ -197,6 +339,14 @@ class NextjsApi extends constructs_1.Construct {
                         "method.response.header.Last-Modified": true,
                     },
                 },
+                {
+                    statusCode: "304",
+                    responseParameters: {
+                        "method.response.header.Cache-Control": true,
+                        "method.response.header.ETag": true,
+                        "method.response.header.Last-Modified": true,
+                    },
+                },
                 {
                     statusCode: "404",
                 },
@@ -205,38 +355,188 @@ class NextjsApi extends constructs_1.Construct {
         };
     }
     /**
-     * Create Lambda Proxy integration for the `_next/image` route.
+     * One resource subtree per function group pattern.
+     *
+     * Unlike CloudFront this needs no ordering: API Gateway matches on a resource
+     * *tree*, so `/api/reports/{proxy+}` beats `/api/{proxy+}` beats `/{proxy+}`
+     * structurally, and "longest pattern wins" comes for free. What does need care
+     * is not creating the same path twice — two groups under `/api` share the `api`
+     * resource — so every segment goes through {@link resourceFor}.
      */
-    createImageIntegration(imageFunction) {
-        // imageFunction is assumed to be the dedicated, streaming-capable image
-        // Lambda (see its doc comment); override responseTransferMode via
-        // imageIntegrationProps if that assumption doesn't hold for a custom
-        // imageFunction, otherwise API Gateway returns a 502. Deliberately
-        // doesn't inherit dynamicIntegrationProps: that's for serverFunction,
-        // a different Lambda with different (and possibly conflicting, e.g.
-        // BUFFERED for a non-streaming Lambda Web Adapter setup) streaming
-        // requirements than the always-streaming dedicated image Lambda.
-        const imageIntegration = new aws_apigateway_1.LambdaIntegration(imageFunction, {
-            responseTransferMode: aws_apigateway_1.ResponseTransferMode.STREAM,
-            ...this.props.overrides?.imageIntegrationProps,
-        });
-        const imageResource = this.nextResource.addResource("image");
-        imageResource.addMethod("ANY", imageIntegration);
+    createFunctionGroupIntegrations() {
+        const groups = this.props.functionGroups ?? [];
+        const behaviors = this.props.functionGroupBehaviors ?? [];
+        const unknown = behaviors.find((behavior) => !groups.some((group) => group.name === behavior.group));
+        if (unknown) {
+            throw new Error(`${constants_1.LOG_PREFIX} \`functionGroupBehaviors\` routes to function group ` +
+                `"${unknown.group}", which is not in \`functionGroups\`.`);
+        }
+        const routeResources = new Set();
+        /** Each subtree's base path and the integration its `{proxy+}` got. */
+        const subtrees = [];
+        for (const group of groups) {
+            const integration = new aws_apigateway_1.LambdaIntegration(group.function, {
+                responseTransferMode: aws_apigateway_1.ResponseTransferMode.STREAM,
+                // One API-wide permission per function; see `createDynamicIntegration`.
+                scopePermissionToMethod: false,
+                ...this.props.overrides?.dynamicIntegrationProps,
+            });
+            // The CloudFront patterns are for the edge; a resource path per route
+            // covers what they do here, a `trailingSlash` form included, since API
+            // Gateway matches `/pricing/` on the `pricing` resource.
+            const own = behaviors.filter((behavior) => behavior.group === group.name);
+            const hasDataRoutes = own.some(({ pattern }) => pattern.startsWith("_next/data/"));
+            for (const route of new Set(own.map((behavior) => behavior.route))) {
+                this.assertRoutable(route, group.name);
+                this.assertNoPublicCollision(route, group.name);
+                for (const path of this.resourcePathsFor(route, hasDataRoutes)) {
+                    const resource = this.resourceFor(path);
+                    resource.addMethod("ANY", integration);
+                    routeResources.add(resource);
+                    if (path[path.length - 1] === "{proxy+}") {
+                        subtrees.push([path.slice(0, -1), integration]);
+                    }
+                }
+            }
+        }
+        // A parent under another group's subtree belongs to that group, as it does
+        // at the edge and in `assignRoutesToGroups`: with `/api/**` and
+        // `/api/reports/**`, `/api/reports` is the `api` group's. The deepest
+        // covering subtree wins; the rest are left to the default function.
+        for (const [resource, path] of this.groupParentResources) {
+            if (routeResources.has(resource)) {
+                this.groupParentResources.delete(resource);
+                continue;
+            }
+            const owner = subtrees
+                .filter(([base]) => base.length < path.length &&
+                base.every((segment, i) => segment === path[i]))
+                .sort(([a], [b]) => b.length - a.length)[0];
+            if (owner) {
+                resource.addMethod("ANY", owner[1]);
+                this.groupParentResources.delete(resource);
+            }
+        }
+    }
+    /**
+     * The group pattern validation accepts every character a CloudFront path
+     * pattern can hold, and API Gateway's path parts hold fewer: `~`, `@`, `+`,
+     * `&` and quotes pass it and then fail `addResource` with an error that names
+     * neither the group nor the pattern. Say which, and what to do instead.
+     */
+    assertRoutable(route, groupName) {
+        const segments = (route.endsWith("/**") ? route.slice(0, -3) : route)
+            .split("/")
+            .filter(Boolean);
+        const invalid = segments.find((segment) => !API_PATH_PART.test(segment));
+        if (invalid === undefined) {
+            return;
+        }
+        throw new Error(`${constants_1.LOG_PREFIX} functionGroups pattern "${route}" (group "${groupName}") ` +
+            `has a segment, "${invalid}", that an API Gateway resource path part ` +
+            "cannot hold: only [a-zA-Z0-9:._-$] are allowed. Route that path from " +
+            "a pattern higher up the tree (e.g. its parent directory with `/**`), " +
+            "or use NextjsGlobalFunctions, whose CloudFront behaviors allow it.");
+    }
+    /**
+     * Refuse a group route that shares a resource with a `public/` entry.
+     *
+     * A public directory `docs` is `docs/{proxy+}` with a `GET` to S3. `/docs/**`
+     * adds `ANY` to that same resource, and API Gateway prefers the `GET`, so
+     * every page load under the group went to S3; `/docs/guide/**` is a more
+     * specific resource instead, and takes `/docs/guide/…` away from the public
+     * files. A public file `pricing` and an exact `/pricing` are the same
+     * resource the same way. `NextjsDistribution` rejects the CloudFront
+     * equivalents.
+     */
+    assertNoPublicCollision(route, groupName) {
+        const isSubtree = route.endsWith("/**");
+        const segments = (isSubtree ? route.slice(0, -3) : route)
+            .split("/")
+            .filter(Boolean);
+        const entry = this.props.publicDirEntries.find((it) => it.isDirectory
+            ? it.name === segments[0] && (isSubtree || segments.length > 1)
+            : !isSubtree && segments.length === 1 && it.name === segments[0]);
+        if (!entry) {
+            return;
+        }
+        throw new Error(`${constants_1.LOG_PREFIX} functionGroups pattern "${route}" (group "${groupName}") ` +
+            `overlaps the top-level public/ ${entry.isDirectory ? "directory" : "file"} ` +
+            `"${entry.name}", which API Gateway serves from S3 on the same ` +
+            `resource path, so one of the two would never be reached. Move those ` +
+            `public/ files under a directory no route uses, or group a different ` +
+            `path.`);
+    }
+    /**
+     * Resource paths, as segment arrays, for one group pattern.
+     *
+     * A subtree gets `{proxy+}` as its last segment and so owns everything *under*
+     * the path but not the path itself, matching both the CloudFront translation and
+     * `assignRoutesToGroups`. An exact path gets no proxy segment, which leaves its
+     * children falling through to the root `{proxy+}` — also the CloudFront result.
+     */
+    resourcePathsFor(route, hasDataRoutes) {
+        const isSubtree = route.endsWith("/**");
+        const base = (isSubtree ? route.slice(0, -3) : route)
+            .split("/")
+            .filter(Boolean);
+        const paths = [isSubtree ? [...base, "{proxy+}"] : base];
+        if (hasDataRoutes) {
+            // `<buildId>` changes every build, so it is a path parameter rather than a
+            // literal — the integration ignores it, the runtime reads it off the URL.
+            // Unlike CloudFront's `*`, which `NextjsDistribution` had to replace with
+            // the literal ID, a path parameter is exactly one segment, so
+            // `/_next/data/{buildId}/blog/{proxy+}` cannot capture another group's
+            // `/_next/data/<id>/docs/blog/…`. A request for an old build ID reaches
+            // the group, which 404s it just as the default function would.
+            const dataPrefix = ["_next", "data", "{buildId}"];
+            paths.push(isSubtree
+                ? [...dataPrefix, ...base, "{proxy+}"]
+                : [
+                    ...dataPrefix,
+                    ...base.slice(0, -1),
+                    `${base[base.length - 1]}.json`,
+                ]);
+        }
+        return paths;
+    }
+    /** Walk or create a resource path, reusing whatever already exists. */
+    resourceFor(segments) {
+        let resource = this.baseResource;
+        for (const [index, segment] of segments.entries()) {
+            const existing = resource.getResource(segment);
+            resource = existing ?? resource.addResource(segment);
+            if (!existing && index < segments.length - 1) {
+                this.groupParentResources.set(resource, segments.slice(0, index + 1));
+            }
+        }
+        return resource;
     }
     /**
      * Create Lambda Proxy integration for all other routes
      */
     createDynamicIntegration(serverFunction) {
-        // All other routes use streaming for better performance
+        // All other routes use streaming for better performance.
+        //
+        // `scopePermissionToMethod: false` grants the function one permission for
+        // this API's execute-api ARN (`<api>/*/*/*`) instead of two per method (the
+        // method and its console test-invoke). Every group adds resources that the
+        // default function still answers for its parents and data routes, and at
+        // ~350 bytes a statement the per-method policy outgrows Lambda's 20 KB
+        // resource-policy cap after a few dozen `ANY` methods, failing the deploy.
         const streamingIntegration = new aws_apigateway_1.LambdaIntegration(serverFunction, {
             responseTransferMode: aws_apigateway_1.ResponseTransferMode.STREAM,
+            scopePermissionToMethod: false,
             ...this.props.overrides?.dynamicIntegrationProps,
         });
         // Add catch-all routes with streaming integration for server-side rendering
         this.baseResource.addMethod("ANY", streamingIntegration);
+        for (const resource of this.groupParentResources.keys()) {
+            resource.addMethod("ANY", streamingIntegration);
+        }
         const proxyResource = this.baseResource.addResource("{proxy+}");
         proxyResource.addMethod("ANY", streamingIntegration);
     }
 }
 exports.NextjsApi = NextjsApi;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-api.js","sourceRoot":"","sources":["../src/nextjs-api.ts"],"names":[],"mappings":"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","sourcesContent":["import { Size, Stack } from \"aws-cdk-lib\";\nimport {\n  RestApi,\n  LambdaIntegration,\n  AwsIntegration,\n  MethodOptions,\n  IResource,\n  EndpointType,\n  RestApiProps,\n  AwsIntegrationProps,\n  LambdaIntegrationOptions,\n  PassthroughBehavior,\n  ResponseTransferMode,\n} from \"aws-cdk-lib/aws-apigateway\";\nimport { IVpc } from \"aws-cdk-lib/aws-ec2\";\nimport {\n  Role,\n  ServicePrincipal,\n  PolicyStatement,\n  IRole,\n} from \"aws-cdk-lib/aws-iam\";\nimport { IFunction } from \"aws-cdk-lib/aws-lambda\";\nimport { IBucket } from \"aws-cdk-lib/aws-s3\";\nimport { Construct } from \"constructs\";\nimport { PublicDirEntry } from \"./nextjs-build/nextjs-build\";\nimport { joinPath, normalizeBasePath } from \"./utils/base-path\";\n\nexport interface NextjsApiOverrides {\n  readonly restApiProps?: RestApiProps;\n  readonly staticIntegrationProps?: AwsIntegrationProps;\n  readonly s3MethodOptions?: MethodOptions;\n  readonly dynamicIntegrationProps?: LambdaIntegrationOptions;\n  readonly imageIntegrationProps?: LambdaIntegrationOptions;\n}\n\nexport interface NextjsApiProps {\n  /**\n   * Optional base path for the application\n   */\n  readonly basePath?: string;\n  /**\n   * Override props for every construct.\n   */\n  readonly overrides?: NextjsApiOverrides;\n  /**\n   * Path to directory of Next.js app's public directory. Used to add resources\n   * to API Gateway REST API for public directory to go directly to S3.\n   */\n  readonly publicDirEntries: PublicDirEntry[];\n  /**\n   * Required if `NextjsRegionalFunctions`. The Lambda function for server-side rendering\n   */\n  readonly serverFunction?: IFunction;\n  /**\n   * Dedicated image optimization Lambda for the `_next/image` route. When\n   * omitted, no `_next/image` resource is created and those requests fall\n   * through to `serverFunction` via the `{proxy+}` catch-all.\n   *\n   * When provided, it is assumed to support Lambda response streaming (as the\n   * dedicated image Lambda this package builds does) and is invoked with\n   * `ResponseTransferMode.STREAM` accordingly. If you supply a custom\n   * `imageFunction` that doesn't support streaming, override\n   * `responseTransferMode` to `BUFFERED` via `overrides.imageIntegrationProps`,\n   * otherwise API Gateway returns a 502.\n   */\n  readonly imageFunction?: IFunction;\n  /**\n   * The S3 bucket containing static assets\n   */\n  readonly staticAssetsBucket: IBucket;\n  /**\n   * S3 key prefix the static assets were uploaded under, i.e.\n   * `NextjsStaticAssets.keyPrefix`, which namespaces a shared bucket.\n   *\n   * Independent of `basePath` above: that one is the URL prefix the REST API\n   * serves the app at (commonly the API Gateway stage), while this one is where\n   * the objects live in the bucket. `_next/static` and public directory\n   * requests are mapped to S3 keys directly, so they 404 unless this prefix is\n   * applied.\n   */\n  readonly staticAssetsKeyPrefix?: string;\n  /**\n   * [Future] Required if `NextjsRegionalContainers`. VPC to create VPC Link and ECS Service Discovery\n   */\n  readonly vpc?: IVpc;\n}\n\n/**\n * Creates an API Gateway REST API for Next.js applications\n */\nexport class NextjsApi extends Construct {\n  /**\n   * The API Gateway REST API\n   */\n  public readonly api: RestApi;\n\n  /**\n   * Public URL of the app, including every path segment the API nests it under.\n   * Prefers a custom domain configured through `overrides.restApiProps.domainName`\n   * over the execute-api endpoint.\n   *\n   * A domain attached after this construct is created (`api.addDomainName()`) is\n   * still used for the host, but CDK keeps its base path mappings private, so a\n   * mapping added that way won't show up here.\n   */\n  get url(): string {\n    const customDomain = this.api.domainName;\n    // A custom domain reaches the stage through a base path mapping, so the\n    // stage name isn't in the path there; the mapping may be, when set.\n    const [origin, prefix] = customDomain\n      ? [\n          `https://${customDomain.domainName}`,\n          this.props.overrides?.restApiProps?.domainName?.basePath,\n        ]\n      : [\n          `https://${this.api.restApiId}.execute-api.${Stack.of(this).region}.amazonaws.com`,\n          this.api.deploymentStage.stageName,\n        ];\n    return joinPath(origin, prefix, this.props.basePath);\n  }\n\n  private readonly baseResource: IResource;\n  private readonly nextResource: IResource;\n  private readonly props: NextjsApiProps;\n  private staticIntegrationRole: IRole;\n\n  constructor(scope: Construct, id: string, props: NextjsApiProps) {\n    super(scope, id);\n    this.props = props;\n\n    this.validateProps(props);\n    this.api = this.createRestApi();\n    this.baseResource = this.createBaseResource(props.basePath);\n    this.nextResource = this.baseResource.addResource(\"_next\");\n    this.staticIntegrationRole = this.createStaticIntegrationRole();\n    this.createStaticIntegrations();\n    if (props.serverFunction) {\n      // Without a dedicated image function, `_next/image` falls through to the\n      // `{proxy+}` catch-all on the server function.\n      if (props.imageFunction) {\n        this.createImageIntegration(props.imageFunction);\n      }\n      this.createDynamicIntegration(props.serverFunction);\n    } else if (props.vpc) {\n      // [Future] create integration with ECS via VPC Link and ECS Service Discovery\n    }\n  }\n\n  private validateProps(props: NextjsApiProps) {\n    if (!props.serverFunction && !props.vpc) {\n      throw new Error(\"serverFunction or vpc must be set in NextjsApiProps\");\n    }\n  }\n\n  private createRestApi(): RestApi {\n    return new RestApi(this, \"RestApi\", {\n      binaryMediaTypes: [\"*/*\"],\n      description: `cdk-nextjs REST API for ${Stack.of(this).stackName}`,\n      endpointTypes: [EndpointType.REGIONAL],\n      minCompressionSize: Size.bytes(0), // compress all responses for better perf\n      ...this.props.overrides?.restApiProps,\n    });\n  }\n\n  /**\n   * Create base resource path if needed. Important if `basePath` is set.\n   *\n   * A nested `basePath` (\"/team/app\") has to become one resource per segment:\n   * API Gateway path parts can't contain \"/\", so passing the whole thing to a\n   * single `addResource` fails validation at synth. `resolveBasePath` accepts\n   * nested values, so this is reachable.\n   */\n  private createBaseResource(basePath?: string): IResource {\n    // Create base resource path if needed\n    const normalized = normalizeBasePath(basePath);\n    if (!normalized) {\n      return this.api.root;\n    }\n    return normalized\n      .split(\"/\")\n      .reduce<IResource>(\n        (parent, segment) => parent.addResource(segment),\n        this.api.root,\n      );\n  }\n\n  private createStaticIntegrationRole() {\n    // Create S3 integration role\n    const staticIntegrationRole = new Role(this, \"StaticIntegrationRole\", {\n      assumedBy: new ServicePrincipal(\"apigateway.amazonaws.com\"),\n    });\n\n    staticIntegrationRole.addToPolicy(\n      new PolicyStatement({\n        actions: [\"s3:GetObject\", \"s3:ListBucket\"],\n        resources: [\n          this.props.staticAssetsBucket.bucketArn,\n          `${this.props.staticAssetsBucket.bucketArn}/*`,\n        ],\n      }),\n    );\n    return staticIntegrationRole;\n  }\n\n  private createStaticIntegrations() {\n    this.nextResource\n      .addResource(\"static\")\n      .addResource(\"{proxy+}\")\n      .addMethod(\n        \"GET\",\n        this.createS3Integration({ key: this.s3Key(\"_next/static/{key}\") }),\n        this.getStaticMethodOptions({ proxy: true }),\n      );\n    // add public directory files/directories that exist at top level but need to go to S3.\n    for (const publicDirEntry of this.props.publicDirEntries) {\n      if (publicDirEntry.isDirectory) {\n        this.baseResource\n          .addResource(publicDirEntry.name)\n          .addResource(\"{proxy+}\")\n          .addMethod(\n            \"GET\",\n            this.createS3Integration({\n              key: this.s3Key(`${publicDirEntry.name}/{key}`),\n            }),\n            this.getStaticMethodOptions({ proxy: true }),\n          );\n      } else {\n        this.baseResource\n          .addResource(publicDirEntry.name)\n          .addMethod(\n            \"GET\",\n            this.createS3Integration({ key: this.s3Key(publicDirEntry.name) }),\n            this.getStaticMethodOptions(),\n          );\n      }\n    }\n  }\n\n  /**\n   * Prefixes a request path with the key prefix the assets were uploaded under,\n   * since the S3 integrations address objects by key rather than by URL.\n   */\n  private s3Key(key: string): string {\n    return joinPath(this.props.staticAssetsKeyPrefix, key);\n  }\n\n  /**\n   * Maps API request to S3 request.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-parameter-mapping-sources.html\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/integrating-api-with-aws-services-s3.html#api-items-in-folder-as-s3-objects-in-bucket\n   */\n  private createS3Integration({ key }: { key: string }) {\n    const s3Integration = new AwsIntegration({\n      service: \"s3\",\n      integrationHttpMethod: \"GET\",\n      path: `${this.props.staticAssetsBucket.bucketName}/${key}`,\n      options: {\n        credentialsRole: this.staticIntegrationRole,\n        passthroughBehavior: PassthroughBehavior.WHEN_NO_TEMPLATES, // recommended\n        requestParameters: key.includes(\"{key}\")\n          ? {\n              \"integration.request.path.key\": \"method.request.path.proxy\",\n            }\n          : undefined,\n        integrationResponses: [\n          {\n            statusCode: \"200\",\n            responseParameters: {\n              \"method.response.header.Content-Type\":\n                \"integration.response.header.Content-Type\",\n              \"method.response.header.Content-Length\":\n                \"integration.response.header.Content-Length\",\n              \"method.response.header.Cache-Control\":\n                \"integration.response.header.Cache-Control\",\n              \"method.response.header.ETag\": \"integration.response.header.ETag\",\n              \"method.response.header.Last-Modified\":\n                \"integration.response.header.Last-Modified\",\n            },\n          },\n          {\n            statusCode: \"404\",\n            selectionPattern: \"404\",\n          },\n        ],\n      },\n      ...this.props.overrides?.staticIntegrationProps,\n    });\n    return s3Integration;\n  }\n\n  private getStaticMethodOptions({ proxy } = { proxy: false }): MethodOptions {\n    return {\n      requestParameters: proxy\n        ? {\n            \"method.request.path.proxy\": true,\n          }\n        : undefined,\n      methodResponses: [\n        {\n          statusCode: \"200\",\n          responseParameters: {\n            \"method.response.header.Content-Type\": true,\n            \"method.response.header.Content-Length\": true,\n            \"method.response.header.Cache-Control\": true,\n            \"method.response.header.ETag\": true,\n            \"method.response.header.Last-Modified\": true,\n          },\n        },\n        {\n          statusCode: \"404\",\n        },\n      ],\n      ...this.props.overrides?.s3MethodOptions,\n    };\n  }\n\n  /**\n   * Create Lambda Proxy integration for the `_next/image` route.\n   */\n  private createImageIntegration(imageFunction: IFunction) {\n    // imageFunction is assumed to be the dedicated, streaming-capable image\n    // Lambda (see its doc comment); override responseTransferMode via\n    // imageIntegrationProps if that assumption doesn't hold for a custom\n    // imageFunction, otherwise API Gateway returns a 502. Deliberately\n    // doesn't inherit dynamicIntegrationProps: that's for serverFunction,\n    // a different Lambda with different (and possibly conflicting, e.g.\n    // BUFFERED for a non-streaming Lambda Web Adapter setup) streaming\n    // requirements than the always-streaming dedicated image Lambda.\n    const imageIntegration = new LambdaIntegration(imageFunction, {\n      responseTransferMode: ResponseTransferMode.STREAM,\n      ...this.props.overrides?.imageIntegrationProps,\n    });\n    const imageResource = this.nextResource.addResource(\"image\");\n    imageResource.addMethod(\"ANY\", imageIntegration);\n  }\n\n  /**\n   * Create Lambda Proxy integration for all other routes\n   */\n  private createDynamicIntegration(serverFunction: IFunction) {\n    // All other routes use streaming for better performance\n    const streamingIntegration = new LambdaIntegration(serverFunction, {\n      responseTransferMode: ResponseTransferMode.STREAM,\n      ...this.props.overrides?.dynamicIntegrationProps,\n    });\n\n    // Add catch-all routes with streaming integration for server-side rendering\n    this.baseResource.addMethod(\"ANY\", streamingIntegration);\n    const proxyResource = this.baseResource.addResource(\"{proxy+}\");\n    proxyResource.addMethod(\"ANY\", streamingIntegration);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-api.js","sourceRoot":"","sources":["../src/nextjs-api.ts"],"names":[],"mappings":"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","sourcesContent":["import { join } from \"node:path\";\nimport { Annotations, Duration, Size, Stack } from \"aws-cdk-lib\";\nimport {\n  RestApi,\n  LambdaIntegration,\n  AwsIntegration,\n  MethodOptions,\n  IResource,\n  EndpointType,\n  RestApiProps,\n  AwsIntegrationProps,\n  LambdaIntegrationOptions,\n  PassthroughBehavior,\n  ResponseTransferMode,\n} from \"aws-cdk-lib/aws-apigateway\";\nimport { IVpc } from \"aws-cdk-lib/aws-ec2\";\nimport { Rule } from \"aws-cdk-lib/aws-events\";\nimport { LambdaFunction as LambdaFunctionTarget } from \"aws-cdk-lib/aws-events-targets\";\nimport {\n  Role,\n  ServicePrincipal,\n  PolicyStatement,\n  IRole,\n} from \"aws-cdk-lib/aws-iam\";\nimport {\n  Architecture,\n  Code,\n  Function as LambdaFunction,\n  IFunction,\n  Runtime,\n  RuntimeFamily,\n} from \"aws-cdk-lib/aws-lambda\";\nimport { IBucket } from \"aws-cdk-lib/aws-s3\";\nimport { Construct } from \"constructs\";\nimport { LOG_PREFIX } from \"./constants\";\nimport { OptionalFunctionProps } from \"./generated-structs/OptionalFunctionProps\";\nimport {\n  NextjsFunctionGroupBehavior,\n  PublicDirEntry,\n} from \"./nextjs-build/nextjs-build\";\nimport { staticAssetsObjectsPattern } from \"./nextjs-static-assets\";\nimport { joinPath, normalizeBasePath } from \"./utils/base-path\";\n\n/**\n * What API Gateway accepts as a resource path part, per CDK's own check in\n * `Resource`: `[a-zA-Z0-9:._-$]`, plus an optional trailing `+`.\n */\nconst API_PATH_PART = /^[a-zA-Z0-9:._\\-$]+$/;\n\nexport interface NextjsApiOverrides {\n  readonly restApiProps?: RestApiProps;\n  readonly staticIntegrationProps?: AwsIntegrationProps;\n  readonly s3MethodOptions?: MethodOptions;\n  readonly dynamicIntegrationProps?: LambdaIntegrationOptions;\n  /**\n   * Props for the function that deploys the stage again after each stack\n   * update.\n   * @see NextjsApiProps.redeployAfterUpdate\n   */\n  readonly redeployFunctionProps?: OptionalFunctionProps;\n}\n\nexport interface NextjsApiProps {\n  /**\n   * Optional base path for the application\n   */\n  readonly basePath?: string;\n  /**\n   * Override props for every construct.\n   */\n  readonly overrides?: NextjsApiOverrides;\n  /**\n   * Path to directory of Next.js app's public directory. Used to add resources\n   * to API Gateway REST API for public directory to go directly to S3.\n   */\n  readonly publicDirEntries: PublicDirEntry[];\n  /**\n   * Required if `NextjsRegionalFunctions`. The Lambda function for server-side rendering\n   */\n  readonly serverFunction?: IFunction;\n  /**\n   * The S3 bucket containing static assets\n   */\n  readonly staticAssetsBucket: IBucket;\n  /**\n   * S3 key prefix the static assets were uploaded under, i.e.\n   * `NextjsStaticAssets.keyPrefix`, which namespaces a shared bucket.\n   *\n   * Independent of `basePath` above: that one is the URL prefix the REST API\n   * serves the app at (commonly the API Gateway stage), while this one is where\n   * the objects live in the bucket. `_next/static` and public directory\n   * requests are mapped to S3 keys directly, so they 404 unless this prefix is\n   * applied.\n   */\n  readonly staticAssetsKeyPrefix?: string;\n  /**\n   * [Future] Required if `NextjsRegionalContainers`. VPC to create VPC Link and ECS Service Discovery\n   */\n  readonly vpc?: IVpc;\n  /**\n   * The non-`default` function groups, the Lambdas\n   * {@link functionGroupBehaviors} route to.\n   * @default - no splitting; `{proxy+}` serves every dynamic route\n   */\n  readonly functionGroups?: NextjsApiFunctionGroup[];\n  /**\n   * `NextjsBuild.functionGroupBehaviors`: each distinct `route` becomes a\n   * resource subtree integrated with its group, so the routes each group was\n   * packaged with reach it rather than {@link serverFunction}.\n   * @default - none\n   */\n  readonly functionGroupBehaviors?: NextjsFunctionGroupBehavior[];\n  /**\n   * Deploy the stage again once each stack update has finished, so it serves\n   * the API as it is after the update.\n   *\n   * CloudFormation snapshots the API into a new deployment while resources\n   * removed from the template still exist — it deletes them only during\n   * cleanup — so the stage keeps serving them. After removing a function\n   * group, its routes then point at a deleted Lambda and answer 500 until the\n   * next deployment. An EventBridge rule on this stack's `UPDATE_COMPLETE`\n   * (and `UPDATE_ROLLBACK_COMPLETE`) invokes a small function that deploys the\n   * stage from the live API and deletes the deployments its earlier runs made.\n   *\n   * Ignored when `overrides.restApiProps.deploy` is `false`: there is no stage.\n   * @default true\n   */\n  readonly redeployAfterUpdate?: boolean;\n}\n\n/** A non-default function group and the Lambda its routes must reach. */\nexport interface NextjsApiFunctionGroup {\n  readonly name: string;\n  readonly function: IFunction;\n}\n\n/**\n * Creates an API Gateway REST API for Next.js applications\n */\nexport class NextjsApi extends Construct {\n  /**\n   * The API Gateway REST API\n   */\n  public readonly api: RestApi;\n\n  /**\n   * Public URL of the app, including every path segment the API nests it under.\n   * Prefers a custom domain configured through `overrides.restApiProps.domainName`\n   * over the execute-api endpoint.\n   *\n   * A domain attached after this construct is created (`api.addDomainName()`) is\n   * still used for the host, but CDK keeps its base path mappings private, so a\n   * mapping added that way won't show up here.\n   */\n  get url(): string {\n    const customDomain = this.api.domainName;\n    // A custom domain reaches the stage through a base path mapping, so the\n    // stage name isn't in the path there; the mapping may be, when set.\n    const [origin, prefix] = customDomain\n      ? [\n          `https://${customDomain.domainName}`,\n          this.props.overrides?.restApiProps?.domainName?.basePath,\n        ]\n      : [\n          `https://${this.api.restApiId}.execute-api.${Stack.of(this).region}.amazonaws.com`,\n          this.api.deploymentStage.stageName,\n        ];\n    return joinPath(origin, prefix, this.props.basePath);\n  }\n\n  /**\n   * Deploys the stage again after each stack update.\n   * @see NextjsApiProps.redeployAfterUpdate\n   */\n  public readonly redeployFunction?: LambdaFunction;\n  /**\n   * Matches this stack's `UPDATE_COMPLETE` and `UPDATE_ROLLBACK_COMPLETE` and\n   * invokes {@link redeployFunction}.\n   */\n  public readonly redeployRule?: Rule;\n\n  private readonly baseResource: IResource;\n  private readonly nextResource: IResource;\n  /**\n   * Resources created only as parents of a group route, and their paths. API\n   * Gateway answers a request for a resource with no method itself — 403\n   * \"Missing Authentication Token\" — rather than falling back to a `{proxy+}`\n   * higher up, so each needs one. Without it a `/api/reports/**` group turned\n   * `/api/reports` and `/api` into 403s.\n   */\n  private readonly groupParentResources = new Map<IResource, string[]>();\n  private readonly props: NextjsApiProps;\n  private staticIntegrationRole: IRole;\n\n  constructor(scope: Construct, id: string, props: NextjsApiProps) {\n    super(scope, id);\n    this.props = props;\n\n    this.validateProps(props);\n    this.api = this.createRestApi();\n    this.baseResource = this.createBaseResource(props.basePath);\n    this.nextResource = this.baseResource.addResource(\"_next\");\n    this.staticIntegrationRole = this.createStaticIntegrationRole();\n    this.createStaticIntegrations();\n    if (props.serverFunction) {\n      // Group resources before the catch-all, so `addResource` sees a clean tree\n      // and a group can claim a path the catch-all would otherwise serve.\n      this.createFunctionGroupIntegrations();\n      // `_next/image` has no resource of its own: it falls through to the\n      // `{proxy+}` catch-all, and the server function optimizes in-process.\n      this.createDynamicIntegration(props.serverFunction);\n    } else if (props.vpc) {\n      // [Future] create integration with ECS via VPC Link and ECS Service Discovery\n    }\n    if (\n      props.redeployAfterUpdate !== false &&\n      props.overrides?.restApiProps?.deploy !== false\n    ) {\n      [this.redeployFunction, this.redeployRule] = this.createRedeploy();\n    }\n  }\n\n  /** @see NextjsApiProps.redeployAfterUpdate */\n  private createRedeploy(): [LambdaFunction, Rule] {\n    const stack = Stack.of(this);\n    const { restApiId } = this.api;\n    const { stageName } = this.api.deploymentStage;\n    const fn = new LambdaFunction(this, \"RedeployFn\", {\n      // Plain bundled JS with no native dependencies: always arm64.\n      architecture: Architecture.ARM_64,\n      code: Code.fromAsset(\n        join(\n          __dirname,\n          \"../assets/lambdas/redeploy-stage/redeploy-stage.lambda\",\n        ),\n      ),\n      handler: \"index.handler\",\n      memorySize: 256,\n      runtime: new Runtime(\"nodejs24.x\", RuntimeFamily.NODEJS),\n      timeout: Duration.minutes(1),\n      ...this.props.overrides?.redeployFunctionProps,\n      environment: {\n        ...this.props.overrides?.redeployFunctionProps?.environment,\n        REST_API_ID: restApiId,\n        STAGE_NAME: stageName,\n      },\n    });\n    // API Gateway authorizes its management API by HTTP verb on the resource\n    // path; these are the four calls `redeployStage` makes, on this API only.\n    const restApi = `arn:${stack.partition}:apigateway:${stack.region}::/restapis/${restApiId}`;\n    fn.addToRolePolicy(\n      new PolicyStatement({\n        actions: [\"apigateway:POST\"],\n        resources: [`${restApi}/deployments`],\n      }),\n    );\n    fn.addToRolePolicy(\n      new PolicyStatement({\n        actions: [\"apigateway:GET\"],\n        resources: [`${restApi}/deployments`, `${restApi}/stages`],\n      }),\n    );\n    fn.addToRolePolicy(\n      new PolicyStatement({\n        actions: [\"apigateway:DELETE\"],\n        resources: [`${restApi}/deployments/*`],\n      }),\n    );\n    // CloudFormation sends every stack status change to the default event bus\n    // (\"Monitoring CloudFormation ... events with EventBridge\" in the\n    // CloudFormation User Guide). `UPDATE_COMPLETE` comes after\n    // `UPDATE_COMPLETE_CLEANUP_IN_PROGRESS`, so removed resources are gone by\n    // then. A rollback restores the stage to the pre-update deployment, which\n    // can carry the same staleness from an earlier update, so it redeploys too.\n    const rule = new Rule(this, \"RedeployRule\", {\n      description: `Redeploys ${stack.stackName}'s REST API stage after a stack update`,\n      eventPattern: {\n        source: [\"aws.cloudformation\"],\n        detailType: [\"CloudFormation Stack Status Change\"],\n        detail: {\n          \"stack-id\": [stack.stackId],\n          \"status-details\": {\n            status: [\"UPDATE_COMPLETE\", \"UPDATE_ROLLBACK_COMPLETE\"],\n          },\n        },\n      },\n      targets: [new LambdaFunctionTarget(fn, { retryAttempts: 2 })],\n    });\n    return [fn, rule];\n  }\n\n  private validateProps(props: NextjsApiProps) {\n    if (!props.serverFunction && !props.vpc) {\n      throw new Error(\"serverFunction or vpc must be set in NextjsApiProps\");\n    }\n  }\n\n  private createRestApi(): RestApi {\n    return new RestApi(this, \"RestApi\", {\n      binaryMediaTypes: [\"*/*\"],\n      description: `cdk-nextjs REST API for ${Stack.of(this).stackName}`,\n      endpointTypes: [EndpointType.REGIONAL],\n      // Inert for the dynamic routes: API Gateway does not compress a response it\n      // streams (`ResponseTransferMode.STREAM`), which every Lambda integration\n      // here uses, so the runtime gzips those itself. Kept because it still\n      // applies to the buffered S3 static integrations, and because a consumer\n      // who overrides an integration to BUFFERED gets compression back.\n      minCompressionSize: Size.bytes(0),\n      ...this.props.overrides?.restApiProps,\n    });\n  }\n\n  /**\n   * Create base resource path if needed. Important if `basePath` is set.\n   *\n   * A nested `basePath` (\"/team/app\") has to become one resource per segment:\n   * API Gateway path parts can't contain \"/\", so passing the whole thing to a\n   * single `addResource` fails validation at synth. `resolveBasePath` accepts\n   * nested values, so this is reachable.\n   */\n  private createBaseResource(basePath?: string): IResource {\n    // Create base resource path if needed\n    const normalized = normalizeBasePath(basePath);\n    if (!normalized) {\n      return this.api.root;\n    }\n    return normalized\n      .split(\"/\")\n      .reduce<IResource>(\n        (parent, segment) => parent.addResource(segment),\n        this.api.root,\n      );\n  }\n\n  private createStaticIntegrationRole() {\n    // Create S3 integration role\n    const staticIntegrationRole = new Role(this, \"StaticIntegrationRole\", {\n      assumedBy: new ServicePrincipal(\"apigateway.amazonaws.com\"),\n    });\n\n    // Only this app's own objects: a shared bucket holds other apps' assets\n    // under their own prefixes. `s3:ListBucket` makes a missing key a 404 (the\n    // only error the integration maps) rather than a 403. It stays unconditioned:\n    // S3 checks it during a GetObject, where no `s3:prefix` is present, so a\n    // prefix condition would turn every missing key back into a 403.\n    staticIntegrationRole.addToPolicy(\n      new PolicyStatement({\n        actions: [\"s3:GetObject\"],\n        resources: [\n          `${this.props.staticAssetsBucket.bucketArn}/${staticAssetsObjectsPattern(this.props.staticAssetsKeyPrefix)}`,\n        ],\n      }),\n    );\n    staticIntegrationRole.addToPolicy(\n      new PolicyStatement({\n        actions: [\"s3:ListBucket\"],\n        resources: [this.props.staticAssetsBucket.bucketArn],\n      }),\n    );\n    return staticIntegrationRole;\n  }\n\n  private createStaticIntegrations() {\n    this.nextResource\n      .addResource(\"static\")\n      .addResource(\"{proxy+}\")\n      .addMethod(\n        \"GET\",\n        this.createS3Integration({ key: this.s3Key(\"_next/static/{key}\") }),\n        this.getStaticMethodOptions({ proxy: true }),\n      );\n    // add public directory files/directories that exist at top level but need to go to S3.\n    const unroutable: string[] = [];\n    for (const publicDirEntry of this.props.publicDirEntries) {\n      // A space or a non-ASCII character is legal in `public/` and illegal in an\n      // API Gateway resource path part, and `addResource` throws — which took the\n      // whole synth down for an app that deploys fine on the Global types\n      // (`next-image-legacy/unicode`, whose `public/` holds \"hello world.jpg\").\n      // Warn and skip the one entry instead: that asset 404s, the app deploys.\n      if (!API_PATH_PART.test(publicDirEntry.name)) {\n        unroutable.push(`\"${publicDirEntry.name}\"`);\n        continue;\n      }\n      if (publicDirEntry.isDirectory) {\n        this.baseResource\n          .addResource(publicDirEntry.name)\n          .addResource(\"{proxy+}\")\n          .addMethod(\n            \"GET\",\n            this.createS3Integration({\n              key: this.s3Key(`${publicDirEntry.name}/{key}`),\n            }),\n            this.getStaticMethodOptions({ proxy: true }),\n          );\n      } else {\n        this.baseResource\n          .addResource(publicDirEntry.name)\n          .addMethod(\n            \"GET\",\n            this.createS3Integration({ key: this.s3Key(publicDirEntry.name) }),\n            this.getStaticMethodOptions(),\n          );\n      }\n    }\n    if (unroutable.length > 0) {\n      Annotations.of(this).addWarning(\n        `${LOG_PREFIX} An API Gateway resource path part only allows ` +\n          \"[a-zA-Z0-9:._-$], so these top-level public/ entries get no resource of \" +\n          \"their own; their requests reach the server function, which reads them \" +\n          `from S3 instead: ${unroutable.join(\", \")}. To serve them directly, rename them, move them into a ` +\n          \"public/ subdirectory whose own name is expressible, or use \" +\n          \"NextjsGlobalFunctions or NextjsGlobalContainers, whose CloudFront \" +\n          \"behaviors can match them.\",\n      );\n    }\n  }\n\n  /**\n   * Prefixes a request path with the key prefix the assets were uploaded under,\n   * since the S3 integrations address objects by key rather than by URL.\n   */\n  private s3Key(key: string): string {\n    return joinPath(this.props.staticAssetsKeyPrefix, key);\n  }\n\n  /**\n   * Maps API request to S3 request.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-parameter-mapping-sources.html\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/integrating-api-with-aws-services-s3.html#api-items-in-folder-as-s3-objects-in-bucket\n   */\n  private createS3Integration({ key }: { key: string }) {\n    const s3Integration = new AwsIntegration({\n      service: \"s3\",\n      integrationHttpMethod: \"GET\",\n      path: `${this.props.staticAssetsBucket.bucketName}/${key}`,\n      options: {\n        credentialsRole: this.staticIntegrationRole,\n        passthroughBehavior: PassthroughBehavior.WHEN_NO_TEMPLATES, // recommended\n        requestParameters: {\n          // Without this S3 never sees the conditional request, so every\n          // revalidation of an immutable `_next/static` chunk re-downloads it\n          // with a 200 instead of getting a 304.\n          \"integration.request.header.If-None-Match\":\n            \"method.request.header.If-None-Match\",\n          \"integration.request.header.If-Modified-Since\":\n            \"method.request.header.If-Modified-Since\",\n          ...(key.includes(\"{key}\")\n            ? {\n                \"integration.request.path.key\": \"method.request.path.proxy\",\n              }\n            : {}),\n        },\n        integrationResponses: [\n          {\n            statusCode: \"200\",\n            responseParameters: {\n              \"method.response.header.Content-Type\":\n                \"integration.response.header.Content-Type\",\n              \"method.response.header.Content-Length\":\n                \"integration.response.header.Content-Length\",\n              \"method.response.header.Cache-Control\":\n                \"integration.response.header.Cache-Control\",\n              \"method.response.header.ETag\": \"integration.response.header.ETag\",\n              \"method.response.header.Last-Modified\":\n                \"integration.response.header.Last-Modified\",\n            },\n          },\n          {\n            // A 304 carries no body, and `ETag` is the header a client needs\n            // back to keep revalidating.\n            statusCode: \"304\",\n            selectionPattern: \"304\",\n            responseParameters: {\n              \"method.response.header.Cache-Control\":\n                \"integration.response.header.Cache-Control\",\n              \"method.response.header.ETag\": \"integration.response.header.ETag\",\n              \"method.response.header.Last-Modified\":\n                \"integration.response.header.Last-Modified\",\n            },\n          },\n          {\n            statusCode: \"404\",\n            selectionPattern: \"404\",\n          },\n        ],\n      },\n      ...this.props.overrides?.staticIntegrationProps,\n    });\n    return s3Integration;\n  }\n\n  private getStaticMethodOptions({ proxy } = { proxy: false }): MethodOptions {\n    return {\n      requestParameters: {\n        // Declared optional (`false`): a plain GET carries neither, and\n        // requiring them would 400 it.\n        \"method.request.header.If-None-Match\": false,\n        \"method.request.header.If-Modified-Since\": false,\n        ...(proxy ? { \"method.request.path.proxy\": true } : {}),\n      },\n      methodResponses: [\n        {\n          statusCode: \"200\",\n          responseParameters: {\n            \"method.response.header.Content-Type\": true,\n            \"method.response.header.Content-Length\": true,\n            \"method.response.header.Cache-Control\": true,\n            \"method.response.header.ETag\": true,\n            \"method.response.header.Last-Modified\": true,\n          },\n        },\n        {\n          statusCode: \"304\",\n          responseParameters: {\n            \"method.response.header.Cache-Control\": true,\n            \"method.response.header.ETag\": true,\n            \"method.response.header.Last-Modified\": true,\n          },\n        },\n        {\n          statusCode: \"404\",\n        },\n      ],\n      ...this.props.overrides?.s3MethodOptions,\n    };\n  }\n\n  /**\n   * One resource subtree per function group pattern.\n   *\n   * Unlike CloudFront this needs no ordering: API Gateway matches on a resource\n   * *tree*, so `/api/reports/{proxy+}` beats `/api/{proxy+}` beats `/{proxy+}`\n   * structurally, and \"longest pattern wins\" comes for free. What does need care\n   * is not creating the same path twice — two groups under `/api` share the `api`\n   * resource — so every segment goes through {@link resourceFor}.\n   */\n  private createFunctionGroupIntegrations() {\n    const groups = this.props.functionGroups ?? [];\n    const behaviors = this.props.functionGroupBehaviors ?? [];\n    const unknown = behaviors.find(\n      (behavior) => !groups.some((group) => group.name === behavior.group),\n    );\n    if (unknown) {\n      throw new Error(\n        `${LOG_PREFIX} \\`functionGroupBehaviors\\` routes to function group ` +\n          `\"${unknown.group}\", which is not in \\`functionGroups\\`.`,\n      );\n    }\n    const routeResources = new Set<IResource>();\n    /** Each subtree's base path and the integration its `{proxy+}` got. */\n    const subtrees: [string[], LambdaIntegration][] = [];\n    for (const group of groups) {\n      const integration = new LambdaIntegration(group.function, {\n        responseTransferMode: ResponseTransferMode.STREAM,\n        // One API-wide permission per function; see `createDynamicIntegration`.\n        scopePermissionToMethod: false,\n        ...this.props.overrides?.dynamicIntegrationProps,\n      });\n      // The CloudFront patterns are for the edge; a resource path per route\n      // covers what they do here, a `trailingSlash` form included, since API\n      // Gateway matches `/pricing/` on the `pricing` resource.\n      const own = behaviors.filter((behavior) => behavior.group === group.name);\n      const hasDataRoutes = own.some(({ pattern }) =>\n        pattern.startsWith(\"_next/data/\"),\n      );\n      for (const route of new Set(own.map((behavior) => behavior.route))) {\n        this.assertRoutable(route, group.name);\n        this.assertNoPublicCollision(route, group.name);\n        for (const path of this.resourcePathsFor(route, hasDataRoutes)) {\n          const resource = this.resourceFor(path);\n          resource.addMethod(\"ANY\", integration);\n          routeResources.add(resource);\n          if (path[path.length - 1] === \"{proxy+}\") {\n            subtrees.push([path.slice(0, -1), integration]);\n          }\n        }\n      }\n    }\n    // A parent under another group's subtree belongs to that group, as it does\n    // at the edge and in `assignRoutesToGroups`: with `/api/**` and\n    // `/api/reports/**`, `/api/reports` is the `api` group's. The deepest\n    // covering subtree wins; the rest are left to the default function.\n    for (const [resource, path] of this.groupParentResources) {\n      if (routeResources.has(resource)) {\n        this.groupParentResources.delete(resource);\n        continue;\n      }\n      const owner = subtrees\n        .filter(\n          ([base]) =>\n            base.length < path.length &&\n            base.every((segment, i) => segment === path[i]),\n        )\n        .sort(([a], [b]) => b.length - a.length)[0];\n      if (owner) {\n        resource.addMethod(\"ANY\", owner[1]);\n        this.groupParentResources.delete(resource);\n      }\n    }\n  }\n\n  /**\n   * The group pattern validation accepts every character a CloudFront path\n   * pattern can hold, and API Gateway's path parts hold fewer: `~`, `@`, `+`,\n   * `&` and quotes pass it and then fail `addResource` with an error that names\n   * neither the group nor the pattern. Say which, and what to do instead.\n   */\n  private assertRoutable(route: string, groupName: string) {\n    const segments = (route.endsWith(\"/**\") ? route.slice(0, -3) : route)\n      .split(\"/\")\n      .filter(Boolean);\n    const invalid = segments.find((segment) => !API_PATH_PART.test(segment));\n    if (invalid === undefined) {\n      return;\n    }\n    throw new Error(\n      `${LOG_PREFIX} functionGroups pattern \"${route}\" (group \"${groupName}\") ` +\n        `has a segment, \"${invalid}\", that an API Gateway resource path part ` +\n        \"cannot hold: only [a-zA-Z0-9:._-$] are allowed. Route that path from \" +\n        \"a pattern higher up the tree (e.g. its parent directory with `/**`), \" +\n        \"or use NextjsGlobalFunctions, whose CloudFront behaviors allow it.\",\n    );\n  }\n\n  /**\n   * Refuse a group route that shares a resource with a `public/` entry.\n   *\n   * A public directory `docs` is `docs/{proxy+}` with a `GET` to S3. `/docs/**`\n   * adds `ANY` to that same resource, and API Gateway prefers the `GET`, so\n   * every page load under the group went to S3; `/docs/guide/**` is a more\n   * specific resource instead, and takes `/docs/guide/…` away from the public\n   * files. A public file `pricing` and an exact `/pricing` are the same\n   * resource the same way. `NextjsDistribution` rejects the CloudFront\n   * equivalents.\n   */\n  private assertNoPublicCollision(route: string, groupName: string) {\n    const isSubtree = route.endsWith(\"/**\");\n    const segments = (isSubtree ? route.slice(0, -3) : route)\n      .split(\"/\")\n      .filter(Boolean);\n    const entry = this.props.publicDirEntries.find((it) =>\n      it.isDirectory\n        ? it.name === segments[0] && (isSubtree || segments.length > 1)\n        : !isSubtree && segments.length === 1 && it.name === segments[0],\n    );\n    if (!entry) {\n      return;\n    }\n    throw new Error(\n      `${LOG_PREFIX} functionGroups pattern \"${route}\" (group \"${groupName}\") ` +\n        `overlaps the top-level public/ ${entry.isDirectory ? \"directory\" : \"file\"} ` +\n        `\"${entry.name}\", which API Gateway serves from S3 on the same ` +\n        `resource path, so one of the two would never be reached. Move those ` +\n        `public/ files under a directory no route uses, or group a different ` +\n        `path.`,\n    );\n  }\n\n  /**\n   * Resource paths, as segment arrays, for one group pattern.\n   *\n   * A subtree gets `{proxy+}` as its last segment and so owns everything *under*\n   * the path but not the path itself, matching both the CloudFront translation and\n   * `assignRoutesToGroups`. An exact path gets no proxy segment, which leaves its\n   * children falling through to the root `{proxy+}` — also the CloudFront result.\n   */\n  private resourcePathsFor(route: string, hasDataRoutes?: boolean): string[][] {\n    const isSubtree = route.endsWith(\"/**\");\n    const base = (isSubtree ? route.slice(0, -3) : route)\n      .split(\"/\")\n      .filter(Boolean);\n    const paths = [isSubtree ? [...base, \"{proxy+}\"] : base];\n    if (hasDataRoutes) {\n      // `<buildId>` changes every build, so it is a path parameter rather than a\n      // literal — the integration ignores it, the runtime reads it off the URL.\n      // Unlike CloudFront's `*`, which `NextjsDistribution` had to replace with\n      // the literal ID, a path parameter is exactly one segment, so\n      // `/_next/data/{buildId}/blog/{proxy+}` cannot capture another group's\n      // `/_next/data/<id>/docs/blog/…`. A request for an old build ID reaches\n      // the group, which 404s it just as the default function would.\n      const dataPrefix = [\"_next\", \"data\", \"{buildId}\"];\n      paths.push(\n        isSubtree\n          ? [...dataPrefix, ...base, \"{proxy+}\"]\n          : [\n              ...dataPrefix,\n              ...base.slice(0, -1),\n              `${base[base.length - 1]}.json`,\n            ],\n      );\n    }\n    return paths;\n  }\n\n  /** Walk or create a resource path, reusing whatever already exists. */\n  private resourceFor(segments: string[]): IResource {\n    let resource = this.baseResource;\n    for (const [index, segment] of segments.entries()) {\n      const existing = resource.getResource(segment);\n      resource = existing ?? resource.addResource(segment);\n      if (!existing && index < segments.length - 1) {\n        this.groupParentResources.set(resource, segments.slice(0, index + 1));\n      }\n    }\n    return resource;\n  }\n\n  /**\n   * Create Lambda Proxy integration for all other routes\n   */\n  private createDynamicIntegration(serverFunction: IFunction) {\n    // All other routes use streaming for better performance.\n    //\n    // `scopePermissionToMethod: false` grants the function one permission for\n    // this API's execute-api ARN (`<api>/*/*/*`) instead of two per method (the\n    // method and its console test-invoke). Every group adds resources that the\n    // default function still answers for its parents and data routes, and at\n    // ~350 bytes a statement the per-method policy outgrows Lambda's 20 KB\n    // resource-policy cap after a few dozen `ANY` methods, failing the deploy.\n    const streamingIntegration = new LambdaIntegration(serverFunction, {\n      responseTransferMode: ResponseTransferMode.STREAM,\n      scopePermissionToMethod: false,\n      ...this.props.overrides?.dynamicIntegrationProps,\n    });\n\n    // Add catch-all routes with streaming integration for server-side rendering\n    this.baseResource.addMethod(\"ANY\", streamingIntegration);\n    for (const resource of this.groupParentResources.keys()) {\n      resource.addMethod(\"ANY\", streamingIntegration);\n    }\n    const proxyResource = this.baseResource.addResource(\"{proxy+}\");\n    proxyResource.addMethod(\"ANY\", streamingIntegration);\n  }\n}\n"]}