cdk-nextjs 0.6.1 → 0.7.0

package/lib/nextjs-api.test.js

@@ -6,7 +6,26 @@ const assertions_1 = require("aws-cdk-lib/assertions");
 const aws_certificatemanager_1 = require("aws-cdk-lib/aws-certificatemanager");
 const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
 const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const function_groups_1 = require("./adapter/function-groups");
 const nextjs_api_1 = require("./nextjs-api");
+/**
+ * `functionGroups` and the `functionGroupBehaviors` the build would record for
+ * them: `routes` as routed (an optional catch-all's parent listed by hand),
+ * with data-URL behaviors for a group that owns a Pages Router page.
+ */
+function grouped(groups) {
+    return {
+        functionGroups: groups.map(({ name, function: fn }) => ({
+            name,
+            function: fn,
+        })),
+        functionGroupBehaviors: groups.flatMap((group) => group.routes.flatMap((route) => (0, function_groups_1.pathPatternsFor)(route, {
+            hasDataRoutes: group.hasDataRoutes ?? false,
+            trailingSlash: group.trailingSlash,
+            buildId: "abc123",
+        }).map((pattern) => ({ group: group.name, route, pattern })))),
+    };
+}
 describe("NextjsApi", () => {
     let stack;
     beforeEach(() => {
@@ -61,6 +80,46 @@ describe("NextjsApi", () => {
         createApi("/branch-x/");
         expect(s3IntegrationKeys()).toContain("branch-x/_next/static/{key}");
     });
+    /** The statements of the API Gateway → S3 integration role's policy. */
+    function staticIntegrationStatements() {
+        const policies = assertions_1.Template.fromStack(stack).findResources("AWS::IAM::Policy", {
+            Properties: {
+                Roles: [{ Ref: assertions_1.Match.stringLikeRegexp("StaticIntegrationRole") }],
+            },
+        });
+        return Object.values(policies).flatMap((policy) => policy.Properties.PolicyDocument.Statement);
+    }
+    it("scopes the S3 integration role to the static assets key prefix", () => {
+        // A shared bucket holds other apps' assets under their own prefixes.
+        createApi("/branch-x/");
+        const bucketArn = {
+            "Fn::Join": ["", ["arn:", { Ref: "AWS::Partition" }, ":s3:::my-bucket"]],
+        };
+        expect(staticIntegrationStatements()).toEqual([
+            {
+                Action: "s3:GetObject",
+                Effect: "Allow",
+                Resource: {
+                    "Fn::Join": [
+                        "",
+                        ["arn:", { Ref: "AWS::Partition" }, ":s3:::my-bucket/branch-x/*"],
+                    ],
+                },
+            },
+            {
+                // Unconditioned: S3 checks it during a GetObject, with no `s3:prefix`.
+                Action: "s3:ListBucket",
+                Effect: "Allow",
+                Resource: bucketArn,
+            },
+        ]);
+    });
+    it("lets the S3 integration role read the whole bucket without a key prefix", () => {
+        createApi();
+        const statements = staticIntegrationStatements();
+        expect(statements).toHaveLength(2);
+        expect(statements[0].Resource["Fn::Join"][1]).toContain(":s3:::my-bucket/*");
+    });
     it("keeps the key prefix independent of basePath, which is the URL prefix", () => {
         // A NextjsRegionalFunctions app whose `basePath` matches the API Gateway
         // stage still has its assets at the bucket root.
@@ -78,6 +137,51 @@ describe("NextjsApi", () => {
         // ...served under the stage-matching URL prefix.
         assertions_1.Template.fromStack(stack).hasResourceProperties("AWS::ApiGateway::Resource", { PathPart: "prod" });
     });
+    // API Gateway path parts can't contain "/", so a nested basePath passed whole
+    // to `addResource` fails CDK's `validateResourcePathPart` at synth. It's
+    // reachable: `resolveBasePath` accepts a nested prop for REGIONAL_FUNCTIONS as
+    // long as the app's basePath ends with it.
+    describe("nested basePath", () => {
+        function pathParts() {
+            const resources = assertions_1.Template.fromStack(stack).findResources("AWS::ApiGateway::Resource");
+            return Object.values(resources).map((resource) => resource.Properties.PathPart);
+        }
+        function createApiWithBasePath(basePath) {
+            return new nextjs_api_1.NextjsApi(stack, "NextjsApi", {
+                staticAssetsBucket: aws_s3_1.Bucket.fromBucketName(stack, "Bucket", "my-bucket"),
+                basePath,
+                serverFunction: new aws_lambda_1.Function(stack, "ServerFn", {
+                    runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                    handler: "index.handler",
+                    code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                }),
+                publicDirEntries: [],
+            });
+        }
+        it("creates one resource per segment", () => {
+            expect(() => createApiWithBasePath("/team/app")).not.toThrow();
+            expect(pathParts()).toEqual(expect.arrayContaining(["team", "app", "_next", "{proxy+}"]));
+            // Not the unsplit value, which API Gateway would reject.
+            expect(pathParts()).not.toContain("team/app");
+        });
+        it("nests the segments so the app is reachable under the full path", () => {
+            createApiWithBasePath("/team/app");
+            const resources = assertions_1.Template.fromStack(stack).findResources("AWS::ApiGateway::Resource");
+            const byPathPart = Object.fromEntries(Object.entries(resources).map(([logicalId, resource]) => [
+                resource.Properties.PathPart,
+                { logicalId, parentId: resource.Properties.ParentId },
+            ]));
+            // "app" hangs off "team", not off the API root.
+            expect(byPathPart.app.parentId).toEqual({
+                Ref: byPathPart.team.logicalId,
+            });
+            expect(byPathPart.team.parentId).toHaveProperty("Fn::GetAtt");
+        });
+        it("still creates a single resource for a flat basePath", () => {
+            createApiWithBasePath("/base");
+            expect(pathParts()).toContain("base");
+        });
+    });
     describe("url", () => {
         function createApiWithOverrides(props = {}) {
             return new nextjs_api_1.NextjsApi(stack, "NextjsApi", {
@@ -140,5 +244,482 @@ describe("NextjsApi", () => {
             }))).toBe("https://{NextjsApiRestApiCustomDomain}/team-a");
         });
     });
+    describe("functionGroups resource tree", () => {
+        /** Lambda functions that `ANY` on the resource at `pathPart` invokes. */
+        function anyTargets(pathPart) {
+            const template = assertions_1.Template.fromStack(stack);
+            const resources = template.findResources("AWS::ApiGateway::Resource", {
+                Properties: { PathPart: pathPart },
+            });
+            const ids = Object.keys(resources);
+            expect(ids).toHaveLength(1);
+            const methods = template.findResources("AWS::ApiGateway::Method", {
+                Properties: { HttpMethod: "ANY", ResourceId: { Ref: ids[0] } },
+            });
+            return Object.values(methods).map((method) => JSON.stringify(method.Properties.Integration.Uri).match(/(ServerFn|GroupFn|ReportsFn)[A-F0-9]+/)[1]);
+        }
+        it("sends a group's parent paths to the default function", () => {
+            // API Gateway answers a methodless resource with 403 rather than falling
+            // back to the root `{proxy+}`, so `/api` and `/api/reports` need one.
+            new nextjs_api_1.NextjsApi(stack, "NextjsApi", {
+                staticAssetsBucket: aws_s3_1.Bucket.fromBucketName(stack, "Bucket", "my-bucket"),
+                serverFunction: new aws_lambda_1.Function(stack, "ServerFn", {
+                    runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                    handler: "index.handler",
+                    code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                }),
+                publicDirEntries: [],
+                ...grouped([
+                    {
+                        name: "reports",
+                        routes: ["/api/reports/**", "/api/export"],
+                        function: new aws_lambda_1.Function(stack, "GroupFn", {
+                            runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                            handler: "index.handler",
+                            code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                        }),
+                    },
+                ]),
+            });
+            expect(anyTargets("api")).toEqual(["ServerFn"]);
+            expect(anyTargets("reports")).toEqual(["ServerFn"]);
+            expect(anyTargets("export")).toEqual(["GroupFn"]);
+        });
+        it("sends a parent under another group's subtree to that group", () => {
+            // `assignRoutesToGroups` packages `/api/reports` into `api`, and
+            // CloudFront's `api/*` sends it there; so must API Gateway.
+            new nextjs_api_1.NextjsApi(stack, "NextjsApi", {
+                staticAssetsBucket: aws_s3_1.Bucket.fromBucketName(stack, "Bucket", "my-bucket"),
+                serverFunction: new aws_lambda_1.Function(stack, "ServerFn", {
+                    runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                    handler: "index.handler",
+                    code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                }),
+                publicDirEntries: [],
+                ...grouped([
+                    {
+                        name: "api",
+                        routes: ["/api/**"],
+                        hasDataRoutes: true,
+                        function: new aws_lambda_1.Function(stack, "GroupFn", {
+                            runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                            handler: "index.handler",
+                            code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                        }),
+                    },
+                    {
+                        name: "reports",
+                        routes: ["/api/reports/q1/**"],
+                        hasDataRoutes: true,
+                        function: new aws_lambda_1.Function(stack, "ReportsFn", {
+                            runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                            handler: "index.handler",
+                            code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                        }),
+                    },
+                ]),
+            });
+            // Each path part below appears twice, under `/` and under the data
+            // prefix, so check the tree by path.
+            const targets = anyTargetsByPath();
+            expect(targets["/api"]).toEqual(["ServerFn"]);
+            expect(targets["/api/reports"]).toEqual(["GroupFn"]);
+            expect(targets["/api/reports/q1"]).toEqual(["GroupFn"]);
+            expect(targets["/api/reports/q1/{proxy+}"]).toEqual(["ReportsFn"]);
+            expect(targets["/_next/data/{buildId}/api/reports"]).toEqual(["GroupFn"]);
+            expect(targets["/_next/data/{buildId}"]).toEqual(["ServerFn"]);
+        });
+        function createGroupedApi(hasDataRoutes) {
+            new nextjs_api_1.NextjsApi(stack, "NextjsApi", {
+                staticAssetsBucket: aws_s3_1.Bucket.fromBucketName(stack, "Bucket", "my-bucket"),
+                serverFunction: new aws_lambda_1.Function(stack, "ServerFn", {
+                    runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                    handler: "index.handler",
+                    code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                }),
+                publicDirEntries: [],
+                ...grouped([
+                    {
+                        name: "reports",
+                        routes: ["/reports/**", "/docs/intro"],
+                        hasDataRoutes,
+                        function: new aws_lambda_1.Function(stack, "GroupFn", {
+                            runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                            handler: "index.handler",
+                            code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                        }),
+                    },
+                ]),
+            });
+        }
+        /** Every resource path in the API, e.g. `/_next/data/{buildId}/x.json`. */
+        function resourcePaths() {
+            const resources = assertions_1.Template.fromStack(stack).findResources("AWS::ApiGateway::Resource");
+            const pathOf = (id) => {
+                const { ParentId, PathPart } = resources[id].Properties;
+                const parent = ParentId.Ref;
+                return parent && resources[parent]
+                    ? `${pathOf(parent)}/${PathPart}`
+                    : `/${PathPart}`;
+            };
+            return Object.keys(resources).map(pathOf).sort();
+        }
+        /** Resource path → the Lambda functions `ANY` on it invokes. */
+        function anyTargetsByPath() {
+            const template = assertions_1.Template.fromStack(stack);
+            const resources = template.findResources("AWS::ApiGateway::Resource");
+            const pathOf = (id) => {
+                const { ParentId, PathPart } = resources[id].Properties;
+                const parent = ParentId.Ref;
+                return parent && resources[parent]
+                    ? `${pathOf(parent)}/${PathPart}`
+                    : `/${PathPart}`;
+            };
+            const methods = template.findResources("AWS::ApiGateway::Method", {
+                Properties: { HttpMethod: "ANY" },
+            });
+            const targets = {};
+            for (const method of Object.values(methods)) {
+                const id = method.Properties.ResourceId?.Ref;
+                if (!id || !resources[id])
+                    continue;
+                (targets[pathOf(id)] ??= []).push(JSON.stringify(method.Properties.Integration.Uri).match(/(ServerFn|GroupFn|ReportsFn)[A-F0-9]+/)[1]);
+            }
+            return targets;
+        }
+        it("routes a group's Pages Router data URLs to it too", () => {
+            createGroupedApi(true);
+            const paths = resourcePaths();
+            expect(paths).toContain("/_next/data/{buildId}/reports/{proxy+}");
+            expect(paths).toContain("/_next/data/{buildId}/docs/intro.json");
+            expect(anyTargets("intro.json")).toEqual(["GroupFn"]);
+            // A methodless parent answers 403, so the data prefix needs the default.
+            expect(anyTargets("{buildId}")).toEqual(["ServerFn"]);
+        });
+        it("keeps each group's data URLs to its own subtree (A)", () => {
+            // `{buildId}` is one path segment, where CloudFront's `*` crossed `/`:
+            // `/_next/data/<id>/docs/blog/x.json` has no way into blog's resource.
+            new nextjs_api_1.NextjsApi(stack, "NextjsApi", {
+                staticAssetsBucket: aws_s3_1.Bucket.fromBucketName(stack, "Bucket", "my-bucket"),
+                serverFunction: new aws_lambda_1.Function(stack, "ServerFn", {
+                    runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                    handler: "index.handler",
+                    code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                }),
+                publicDirEntries: [],
+                ...grouped([
+                    {
+                        name: "blog",
+                        routes: ["/blog/**"],
+                        hasDataRoutes: true,
+                        function: new aws_lambda_1.Function(stack, "GroupFn", {
+                            runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                            handler: "index.handler",
+                            code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                        }),
+                    },
+                ]),
+            });
+            expect(resourcePaths().filter((path) => path.startsWith("/_next/data"))).toEqual([
+                "/_next/data",
+                "/_next/data/{buildId}",
+                "/_next/data/{buildId}/blog",
+                "/_next/data/{buildId}/blog/{proxy+}",
+            ]);
+        });
+        it("routes an optional catch-all's parent to the group when it is listed (B)", () => {
+            // The build routes `/shop` alongside `/shop/**` when the group owns
+            // `shop/[[...slug]]` (see `routedPatterns`): `{proxy+}` does not match
+            // the parent, which would otherwise reach the default function.
+            new nextjs_api_1.NextjsApi(stack, "NextjsApi", {
+                staticAssetsBucket: aws_s3_1.Bucket.fromBucketName(stack, "Bucket", "my-bucket"),
+                serverFunction: new aws_lambda_1.Function(stack, "ServerFn", {
+                    runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                    handler: "index.handler",
+                    code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                }),
+                publicDirEntries: [],
+                ...grouped([
+                    {
+                        name: "shop",
+                        routes: ["/shop/**", "/shop"],
+                        function: new aws_lambda_1.Function(stack, "GroupFn", {
+                            runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                            handler: "index.handler",
+                            code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                        }),
+                    },
+                ]),
+            });
+            expect(anyTargets("shop")).toEqual(["GroupFn"]);
+        });
+        it.each([
+            [{ name: "docs", isDirectory: true }, "/docs/**", "directory"],
+            [{ name: "docs", isDirectory: true }, "/docs/guide/**", "directory"],
+            [{ name: "robots.txt", isDirectory: false }, "/robots.txt", "file"],
+        ])("rejects a group route on a public/ entry's resource: %p with %p (E)", (entry, route, kind) => {
+            expect(() => new nextjs_api_1.NextjsApi(stack, "NextjsApi", {
+                staticAssetsBucket: aws_s3_1.Bucket.fromBucketName(stack, "Bucket", "my-bucket"),
+                serverFunction: new aws_lambda_1.Function(stack, "ServerFn", {
+                    runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                    handler: "index.handler",
+                    code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                }),
+                publicDirEntries: [entry],
+                ...grouped([
+                    {
+                        name: "g",
+                        routes: [route],
+                        function: new aws_lambda_1.Function(stack, "GroupFn", {
+                            runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                            handler: "index.handler",
+                            code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                        }),
+                    },
+                ]),
+            })).toThrow(`overlaps the top-level public/ ${kind} "${entry.name}"`);
+        });
+        it("allows an exact route named like a public/ directory, which is not under it", () => {
+            expect(() => new nextjs_api_1.NextjsApi(stack, "NextjsApi", {
+                staticAssetsBucket: aws_s3_1.Bucket.fromBucketName(stack, "Bucket", "my-bucket"),
+                serverFunction: new aws_lambda_1.Function(stack, "ServerFn", {
+                    runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                    handler: "index.handler",
+                    code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                }),
+                publicDirEntries: [{ name: "docs", isDirectory: true }],
+                ...grouped([
+                    {
+                        name: "g",
+                        routes: ["/docs"],
+                        function: new aws_lambda_1.Function(stack, "GroupFn", {
+                            runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                            handler: "index.handler",
+                            code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                        }),
+                    },
+                ]),
+            })).not.toThrow();
+        });
+        it("routes an exact route's trailingSlash form through its one resource", () => {
+            // CloudFront needs `pricing/` as a behavior of its own; API Gateway
+            // matches `/pricing/` on the `pricing` resource, so the variant adds
+            // nothing here and must not add the resource twice.
+            new nextjs_api_1.NextjsApi(stack, "NextjsApi", {
+                staticAssetsBucket: aws_s3_1.Bucket.fromBucketName(stack, "Bucket", "my-bucket"),
+                serverFunction: new aws_lambda_1.Function(stack, "ServerFn", {
+                    runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                    handler: "index.handler",
+                    code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                }),
+                publicDirEntries: [],
+                ...grouped([
+                    {
+                        name: "pricing",
+                        routes: ["/pricing"],
+                        trailingSlash: true,
+                        function: new aws_lambda_1.Function(stack, "GroupFn", {
+                            runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                            handler: "index.handler",
+                            code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                        }),
+                    },
+                ]),
+            });
+            expect(resourcePaths().filter((path) => !path.startsWith("/_next/static"))).toEqual(["/_next", "/pricing", "/{proxy+}"]);
+            expect(anyTargetsByPath()).toEqual({
+                "/pricing": ["GroupFn"],
+                "/{proxy+}": ["ServerFn"],
+            });
+        });
+        it("rejects a behavior for a group it was not given", () => {
+            const { functionGroupBehaviors } = grouped([
+                {
+                    name: "api",
+                    routes: ["/api/**"],
+                    function: new aws_lambda_1.Function(stack, "GroupFn", {
+                        runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                        handler: "index.handler",
+                        code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                    }),
+                },
+            ]);
+            expect(() => new nextjs_api_1.NextjsApi(stack, "NextjsApi", {
+                staticAssetsBucket: aws_s3_1.Bucket.fromBucketName(stack, "Bucket", "my-bucket"),
+                serverFunction: new aws_lambda_1.Function(stack, "ServerFn", {
+                    runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                    handler: "index.handler",
+                    code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                }),
+                publicDirEntries: [],
+                functionGroupBehaviors,
+            })).toThrow(/routes to function group "api", which is not in/);
+        });
+        it("adds no data routes for an app without Pages Router routes", () => {
+            createGroupedApi(false);
+            expect(resourcePaths().filter((path) => path.startsWith("/_next/data"))).toEqual([]);
+        });
+        it("grants each function one API-scoped permission, not two per method", () => {
+            // Per-method permissions put two statements in the function's resource
+            // policy for every `ANY`, which outgrows Lambda's 20 KB cap.
+            createGroupedApi(true);
+            const permissions = Object.values(assertions_1.Template.fromStack(stack).findResources("AWS::Lambda::Permission", {
+                Properties: { Principal: "apigateway.amazonaws.com" },
+            }));
+            expect(permissions).toHaveLength(2);
+            for (const permission of permissions) {
+                const sourceArn = JSON.stringify(permission.Properties.SourceArn);
+                expect(sourceArn).toContain(":execute-api:");
+                expect(sourceArn).toContain("/*/*/*");
+            }
+        });
+    });
+    it("names the group and pattern API Gateway cannot route", () => {
+        expect(() => new nextjs_api_1.NextjsApi(stack, "NextjsApi", {
+            staticAssetsBucket: aws_s3_1.Bucket.fromBucketName(stack, "Bucket", "my-bucket"),
+            serverFunction: new aws_lambda_1.Function(stack, "ServerFn", {
+                runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                handler: "index.handler",
+                code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+            }),
+            publicDirEntries: [],
+            ...grouped([
+                {
+                    name: "about",
+                    routes: ["/about~us"],
+                    function: new aws_lambda_1.Function(stack, "GroupFn", {
+                        runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                        handler: "index.handler",
+                        code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                    }),
+                },
+            ]),
+        })).toThrow(/pattern "\/about~us" \(group "about"\) has a segment/);
+    });
+    describe("a public/ entry API Gateway cannot address", () => {
+        it("warns and skips it instead of failing the synth", () => {
+            // `public/hello world.jpg` is a valid Next.js asset that `addResource`
+            // rejects outright, taking the whole app's synth with it. The Global types
+            // serve it with a wildcard path pattern; here the honest outcome is one
+            // 404ing asset and a warning that names it.
+            const api = new nextjs_api_1.NextjsApi(stack, "NextjsApi", {
+                staticAssetsBucket: aws_s3_1.Bucket.fromBucketName(stack, "Bucket", "my-bucket"),
+                serverFunction: new aws_lambda_1.Function(stack, "ServerFn", {
+                    runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                    handler: "index.handler",
+                    code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+                }),
+                publicDirEntries: [
+                    { name: "hello world.jpg", isDirectory: false },
+                    { name: "äöüščří.png", isDirectory: false },
+                    { name: "favicon.ico", isDirectory: false },
+                ],
+            });
+            const message = assertions_1.Annotations.fromStack(stack)
+                .findWarning(`/${api.node.path}`, assertions_1.Match.anyValue())
+                .map((warning) => warning.entry.data)
+                .join("\n");
+            expect(message).toContain('"hello world.jpg"');
+            expect(message).toContain('"äöüščří.png"');
+            expect(message).not.toContain('"favicon.ico"');
+            // The expressible one is still served.
+            expect(s3IntegrationKeys()).toContain("favicon.ico");
+        });
+    });
+});
+describe("NextjsApi redeploy after update", () => {
+    function synth(props = {}) {
+        const stack = new aws_cdk_lib_1.Stack(new aws_cdk_lib_1.App(), "TestStack", {
+            env: { account: "123456789012", region: "us-east-1" },
+        });
+        new nextjs_api_1.NextjsApi(stack, "NextjsApi", {
+            staticAssetsBucket: aws_s3_1.Bucket.fromBucketName(stack, "Bucket", "my-bucket"),
+            serverFunction: new aws_lambda_1.Function(stack, "ServerFn", {
+                runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+                handler: "index.handler",
+                code: aws_lambda_1.Code.fromInline("exports.handler = async () => {};"),
+            }),
+            publicDirEntries: [],
+            ...props,
+        });
+        return assertions_1.Template.fromStack(stack);
+    }
+    /** The `Fn::Join` parts of every resource the redeploy role is granted. */
+    function grantedResources(template) {
+        const [policy] = Object.values(template.findResources("AWS::IAM::Policy", {
+            Properties: {
+                PolicyName: assertions_1.Match.stringLikeRegexp("RedeployFn"),
+            },
+        }));
+        return policy.Properties.PolicyDocument.Statement.map((statement) => ({
+            action: statement.Action,
+            resources: JSON.stringify(statement.Resource),
+        }));
+    }
+    it("redeploys the stage on this stack's UPDATE_COMPLETE", () => {
+        const template = synth();
+        template.hasResourceProperties("AWS::Events::Rule", {
+            EventPattern: {
+                source: ["aws.cloudformation"],
+                "detail-type": ["CloudFormation Stack Status Change"],
+                detail: {
+                    "stack-id": [{ Ref: "AWS::StackId" }],
+                    "status-details": {
+                        status: ["UPDATE_COMPLETE", "UPDATE_ROLLBACK_COMPLETE"],
+                    },
+                },
+            },
+            Targets: [
+                assertions_1.Match.objectLike({
+                    Arn: { "Fn::GetAtt": [assertions_1.Match.stringLikeRegexp("RedeployFn"), "Arn"] },
+                }),
+            ],
+        });
+        template.hasResourceProperties("AWS::Lambda::Function", {
+            Handler: "index.handler",
+            Environment: {
+                Variables: {
+                    REST_API_ID: { Ref: assertions_1.Match.stringLikeRegexp("RestApi") },
+                    STAGE_NAME: { Ref: assertions_1.Match.stringLikeRegexp("DeploymentStage") },
+                },
+            },
+        });
+    });
+    it("scopes its API Gateway access to this REST API", () => {
+        const statements = grantedResources(synth());
+        expect(statements.map((s) => s.action)).toEqual([
+            "apigateway:POST",
+            "apigateway:GET",
+            "apigateway:DELETE",
+        ]);
+        for (const { resources } of statements) {
+            expect(resources).toContain("/restapis/");
+            expect(resources).toMatch(/"Ref":"NextjsApiRestApi[0-9A-F]+"/);
+            expect(resources).not.toMatch(/restapis\/\*/);
+        }
+        expect(statements[0].resources).toContain("/deployments");
+        expect(statements[2].resources).toContain("/deployments/*");
+    });
+    it("is off when redeployAfterUpdate is false", () => {
+        const template = synth({ redeployAfterUpdate: false });
+        template.resourceCountIs("AWS::Events::Rule", 0);
+    });
+    it("is off when the API deploys no stage", () => {
+        const template = synth({
+            overrides: { restApiProps: { deploy: false } },
+        });
+        template.resourceCountIs("AWS::Events::Rule", 0);
+    });
+    it("takes function overrides", () => {
+        const template = synth({
+            overrides: { redeployFunctionProps: { memorySize: 512 } },
+        });
+        template.hasResourceProperties("AWS::Lambda::Function", {
+            MemorySize: 512,
+            Environment: {
+                Variables: { REST_API_ID: assertions_1.Match.anyValue() },
+            },
+        });
+    });
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-api.test.js","sourceRoot":"","sources":["../src/nextjs-api.test.ts"],"names":[],"mappings":";;AAAA,sDAAsD;AACtD,6CAAyC;AACzC,uDAAkD;AAClD,+EAAiE;AACjE,uDAIgC;AAChC,+CAA4C;AAC5C,6CAAyD;AAEzD,QAAQ,CAAC,WAAW,EAAE,GAAG,EAAE;IACzB,IAAI,KAAY,CAAC;IAEjB,UAAU,CAAC,GAAG,EAAE;QACd,KAAK,GAAG,IAAI,mBAAK,CAAC,IAAI,iBAAG,EAAE,EAAE,WAAW,EAAE;YACxC,GAAG,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE;SACtD,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,SAAS,SAAS,CAAC,qBAA8B;QAC/C,OAAO,IAAI,sBAAS,CAAC,KAAK,EAAE,WAAW,EAAE;YACvC,kBAAkB,EAAE,eAAM,CAAC,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,CAAC;YACvE,qBAAqB;YACrB,cAAc,EAAE,IAAI,qBAAc,CAAC,KAAK,EAAE,UAAU,EAAE;gBACpD,OAAO,EAAE,oBAAO,CAAC,WAAW;gBAC5B,OAAO,EAAE,eAAe;gBACxB,IAAI,EAAE,iBAAI,CAAC,UAAU,CAAC,mCAAmC,CAAC;aAC3D,CAAC;YACF,gBAAgB,EAAE;gBAChB,EAAE,IAAI,EAAE,aAAa,EAAE,WAAW,EAAE,KAAK,EAAE;gBAC3C,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE;aACtC;SACF,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,SAAS,iBAAiB;QACxB,MAAM,OAAO,GAAG,qBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,aAAa,CACrD,yBAAyB,CAC1B,CAAC;QACF,MAAM,MAAM,GAAG,oBAAoB,CAAC;QACpC,OAAO,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;aAC1B,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;aACrE,MAAM,CACL,CAAC,IAAa,EAAkB,EAAE,CAChC,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CACpD;aACA,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1C,CAAC;IAED,EAAE,CAAC,gEAAgE,EAAE,GAAG,EAAE;QACxE,SAAS,EAAE,CAAC;QAEZ,MAAM,CAAC,iBAAiB,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC;YACzC,oBAAoB;YACpB,aAAa;YACb,cAAc;SACf,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,qEAAqE,EAAE,GAAG,EAAE;QAC7E,SAAS,CAAC,UAAU,CAAC,CAAC;QAEtB,MAAM,CAAC,iBAAiB,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC;YACzC,6BAA6B;YAC7B,sBAAsB;YACtB,uBAAuB;SACxB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,kDAAkD,EAAE,GAAG,EAAE;QAC1D,SAAS,CAAC,YAAY,CAAC,CAAC;QAExB,MAAM,CAAC,iBAAiB,EAAE,CAAC,CAAC,SAAS,CAAC,6BAA6B,CAAC,CAAC;IACvE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uEAAuE,EAAE,GAAG,EAAE;QAC/E,yEAAyE;QACzE,iDAAiD;QACjD,IAAI,sBAAS,CAAC,KAAK,EAAE,WAAW,EAAE;YAChC,kBAAkB,EAAE,eAAM,CAAC,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,CAAC;YACvE,QAAQ,EAAE,OAAO;YACjB,cAAc,EAAE,IAAI,qBAAc,CAAC,KAAK,EAAE,UAAU,EAAE;gBACpD,OAAO,EAAE,oBAAO,CAAC,WAAW;gBAC5B,OAAO,EAAE,eAAe;gBACxB,IAAI,EAAE,iBAAI,CAAC,UAAU,CAAC,mCAAmC,CAAC;aAC3D,CAAC;YACF,gBAAgB,EAAE,EAAE;SACrB,CAAC,CAAC;QAEH,MAAM,CAAC,iBAAiB,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC;QAC5D,iDAAiD;QACjD,qBAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,qBAAqB,CAC7C,2BAA2B,EAC3B,EAAE,QAAQ,EAAE,MAAM,EAAE,CACrB,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE;QACnB,SAAS,sBAAsB,CAC7B,QAAiC,EAAE;YAEnC,OAAO,IAAI,sBAAS,CAAC,KAAK,EAAE,WAAW,EAAE;gBACvC,kBAAkB,EAAE,eAAM,CAAC,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,CAAC;gBACvE,cAAc,EAAE,IAAI,qBAAc,CAAC,KAAK,EAAE,UAAU,EAAE;oBACpD,OAAO,EAAE,oBAAO,CAAC,WAAW;oBAC5B,OAAO,EAAE,eAAe;oBACxB,IAAI,EAAE,iBAAI,CAAC,UAAU,CAAC,mCAAmC,CAAC;iBAC3D,CAAC;gBACF,gBAAgB,EAAE,EAAE;gBACpB,GAAG,KAAK;aACT,CAAC,CAAC;QACL,CAAC;QAED,SAAS,UAAU,CAAC,QAAiB;YACnC,OAAO;gBACL,UAAU,EAAE,iBAAiB;gBAC7B,WAAW,EAAE,oCAAW,CAAC,kBAAkB,CACzC,KAAK,EACL,MAAM,EACN,oDAAoD,CACrD;gBACD,QAAQ;aACT,CAAC;QACJ,CAAC;QAED;;;;;;WAMG;QACH,SAAS,UAAU,CAAC,GAAc;YAChC,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACxC,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;gBACjC,OAAO,QAAQ,CAAC;YAClB,CAAC;YACD,OAAO,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;iBAC3B,GAAG,CAAC,CAAC,IAAa,EAAE,EAAE,CACrB,OAAO,IAAI,KAAK,QAAQ;gBACtB,CAAC,CAAC,IAAI;gBACN,CAAC,CAAC,IAAK,IAAwB,CAAC,GAAG,CAAC,OAAO,CAAC,cAAc,EAAE,EAAE,CAAC,GAAG,CACrE;iBACA,IAAI,CAAC,EAAE,CAAC,CAAC;QACd,CAAC;QAED,EAAE,CAAC,wFAAwF,EAAE,GAAG,EAAE;YAChG,oEAAoE;YACpE,8DAA8D;YAC9D,MAAM,CAAC,UAAU,CAAC,sBAAsB,EAAE,CAAC,CAAC,CAAC,IAAI,CAC/C,sGAAsG,CACvG,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,2DAA2D,EAAE,GAAG,EAAE;YACnE,MAAM,CACJ,UAAU,CAAC,sBAAsB,CAAC,EAAE,QAAQ,EAAE,eAAe,EAAE,CAAC,CAAC,CAClE,CAAC,IAAI,CACJ,mHAAmH,CACpH,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,2DAA2D,EAAE,GAAG,EAAE;YACnE,0EAA0E;YAC1E,4EAA4E;YAC5E,0DAA0D;YAC1D,MAAM,CACJ,UAAU,CACR,sBAAsB,CAAC;gBACrB,SAAS,EAAE,EAAE,YAAY,EAAE,EAAE,UAAU,EAAE,UAAU,EAAE,EAAE,EAAE;aAC1D,CAAC,CACH,CACF,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;QACnD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,8CAA8C,EAAE,GAAG,EAAE;YACtD,sEAAsE;YACtE,oCAAoC;YACpC,MAAM,CACJ,UAAU,CACR,sBAAsB,CAAC;gBACrB,SAAS,EAAE,EAAE,YAAY,EAAE,EAAE,UAAU,EAAE,UAAU,CAAC,QAAQ,CAAC,EAAE,EAAE;aAClE,CAAC,CACH,CACF,CAAC,IAAI,CAAC,+CAA+C,CAAC,CAAC;QAC1D,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport { App, Stack } from \"aws-cdk-lib\";\nimport { Template } from \"aws-cdk-lib/assertions\";\nimport { Certificate } from \"aws-cdk-lib/aws-certificatemanager\";\nimport {\n  Code,\n  Function as LambdaFunction,\n  Runtime,\n} from \"aws-cdk-lib/aws-lambda\";\nimport { Bucket } from \"aws-cdk-lib/aws-s3\";\nimport { NextjsApi, NextjsApiProps } from \"./nextjs-api\";\n\ndescribe(\"NextjsApi\", () => {\n  let stack: Stack;\n\n  beforeEach(() => {\n    stack = new Stack(new App(), \"TestStack\", {\n      env: { account: \"123456789012\", region: \"us-east-1\" },\n    });\n  });\n\n  function createApi(staticAssetsKeyPrefix?: string) {\n    return new NextjsApi(stack, \"NextjsApi\", {\n      staticAssetsBucket: Bucket.fromBucketName(stack, \"Bucket\", \"my-bucket\"),\n      staticAssetsKeyPrefix,\n      serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n        runtime: Runtime.NODEJS_22_X,\n        handler: \"index.handler\",\n        code: Code.fromInline(\"exports.handler = async () => {};\"),\n      }),\n      publicDirEntries: [\n        { name: \"favicon.ico\", isDirectory: false },\n        { name: \"images\", isDirectory: true },\n      ],\n    });\n  }\n\n  /**\n   * The S3 integrations address objects by key, so the uploaded key prefix has\n   * to appear in the integration URI or every static request 404s.\n   */\n  function s3IntegrationKeys(): string[] {\n    const methods = Template.fromStack(stack).findResources(\n      \"AWS::ApiGateway::Method\",\n    );\n    const marker = \"s3:path/my-bucket/\";\n    return Object.values(methods)\n      .flatMap((method) => method.Properties.Integration.Uri[\"Fn::Join\"][1])\n      .filter(\n        (part: unknown): part is string =>\n          typeof part === \"string\" && part.includes(marker),\n      )\n      .map((part) => part.split(marker)[1]);\n  }\n\n  it(\"addresses objects at the bucket root when no key prefix is set\", () => {\n    createApi();\n\n    expect(s3IntegrationKeys().sort()).toEqual([\n      \"_next/static/{key}\",\n      \"favicon.ico\",\n      \"images/{key}\",\n    ]);\n  });\n\n  it(\"prefixes every S3 integration key with the static assets key prefix\", () => {\n    createApi(\"branch-x\");\n\n    expect(s3IntegrationKeys().sort()).toEqual([\n      \"branch-x/_next/static/{key}\",\n      \"branch-x/favicon.ico\",\n      \"branch-x/images/{key}\",\n    ]);\n  });\n\n  it(\"normalizes surrounding slashes on the key prefix\", () => {\n    createApi(\"/branch-x/\");\n\n    expect(s3IntegrationKeys()).toContain(\"branch-x/_next/static/{key}\");\n  });\n\n  it(\"keeps the key prefix independent of basePath, which is the URL prefix\", () => {\n    // A NextjsRegionalFunctions app whose `basePath` matches the API Gateway\n    // stage still has its assets at the bucket root.\n    new NextjsApi(stack, \"NextjsApi\", {\n      staticAssetsBucket: Bucket.fromBucketName(stack, \"Bucket\", \"my-bucket\"),\n      basePath: \"/prod\",\n      serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n        runtime: Runtime.NODEJS_22_X,\n        handler: \"index.handler\",\n        code: Code.fromInline(\"exports.handler = async () => {};\"),\n      }),\n      publicDirEntries: [],\n    });\n\n    expect(s3IntegrationKeys()).toEqual([\"_next/static/{key}\"]);\n    // ...served under the stage-matching URL prefix.\n    Template.fromStack(stack).hasResourceProperties(\n      \"AWS::ApiGateway::Resource\",\n      { PathPart: \"prod\" },\n    );\n  });\n\n  describe(\"url\", () => {\n    function createApiWithOverrides(\n      props: Partial<NextjsApiProps> = {},\n    ): NextjsApi {\n      return new NextjsApi(stack, \"NextjsApi\", {\n        staticAssetsBucket: Bucket.fromBucketName(stack, \"Bucket\", \"my-bucket\"),\n        serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n          runtime: Runtime.NODEJS_22_X,\n          handler: \"index.handler\",\n          code: Code.fromInline(\"exports.handler = async () => {};\"),\n        }),\n        publicDirEntries: [],\n        ...props,\n      });\n    }\n\n    function domainName(basePath?: string) {\n      return {\n        domainName: \"app.example.com\",\n        certificate: Certificate.fromCertificateArn(\n          stack,\n          \"Cert\",\n          \"arn:aws:acm:us-east-1:123456789012:certificate/abc\",\n        ),\n        basePath,\n      };\n    }\n\n    /**\n     * The REST API id, the stage name and the domain name are all tokens that\n     * only resolve at deploy time, so flatten the resolved `Fn::Join` and stand\n     * each reference in for the resource it points at (minus CDK's logical id\n     * hash suffix). That keeps the assertions about *which* resource supplies\n     * each part of the URL, which is the whole question here.\n     */\n    function resolveUrl(api: NextjsApi): string {\n      const resolved = stack.resolve(api.url);\n      if (typeof resolved === \"string\") {\n        return resolved;\n      }\n      return resolved[\"Fn::Join\"][1]\n        .map((part: unknown) =>\n          typeof part === \"string\"\n            ? part\n            : `{${(part as { Ref: string }).Ref.replace(/[0-9A-F]{8}$/, \"\")}}`,\n        )\n        .join(\"\");\n    }\n\n    it(\"reports the execute-api endpoint with the stage appended when there's no custom domain\", () => {\n      // The stage is in the path only here, which is the whole reason the\n      // regional-functions example sets an app basePath of \"/prod\".\n      expect(resolveUrl(createApiWithOverrides())).toBe(\n        \"https://{NextjsApiRestApi}.execute-api.us-east-1.amazonaws.com/{NextjsApiRestApiDeploymentStageprod}\",\n      );\n    });\n\n    it(\"appends basePath, which nests every resource a level down\", () => {\n      expect(\n        resolveUrl(createApiWithOverrides({ basePath: \"/my-base-path\" })),\n      ).toBe(\n        \"https://{NextjsApiRestApi}.execute-api.us-east-1.amazonaws.com/{NextjsApiRestApiDeploymentStageprod}/my-base-path\",\n      );\n    });\n\n    it(\"prefers a custom domain and drops the stage from the path\", () => {\n      // A domain mapped at the root is the cleanest Regional setup: no stage in\n      // the URL means no basePath and no stage workarounds anywhere. The stage is\n      // reached through the domain's base path mapping instead.\n      expect(\n        resolveUrl(\n          createApiWithOverrides({\n            overrides: { restApiProps: { domainName: domainName() } },\n          }),\n        ),\n      ).toBe(\"https://{NextjsApiRestApiCustomDomain}\");\n    });\n\n    it(\"includes a custom domain's base path mapping\", () => {\n      // CDK rejects surrounding slashes on a mapping, so it's always a bare\n      // segment by the time it gets here.\n      expect(\n        resolveUrl(\n          createApiWithOverrides({\n            overrides: { restApiProps: { domainName: domainName(\"team-a\") } },\n          }),\n        ),\n      ).toBe(\"https://{NextjsApiRestApiCustomDomain}/team-a\");\n    });\n  });\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-api.test.js","sourceRoot":"","sources":["../src/nextjs-api.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport { App, Stack } from \"aws-cdk-lib\";\nimport { Annotations, Match, Template } from \"aws-cdk-lib/assertions\";\nimport { Certificate } from \"aws-cdk-lib/aws-certificatemanager\";\nimport {\n  Code,\n  Function as LambdaFunction,\n  IFunction,\n  Runtime,\n} from \"aws-cdk-lib/aws-lambda\";\nimport { Bucket } from \"aws-cdk-lib/aws-s3\";\nimport { pathPatternsFor } from \"./adapter/function-groups\";\nimport { NextjsApi, NextjsApiProps } from \"./nextjs-api\";\n\n/**\n * `functionGroups` and the `functionGroupBehaviors` the build would record for\n * them: `routes` as routed (an optional catch-all's parent listed by hand),\n * with data-URL behaviors for a group that owns a Pages Router page.\n */\nfunction grouped(\n  groups: {\n    name: string;\n    routes: string[];\n    hasDataRoutes?: boolean;\n    trailingSlash?: boolean;\n    function: IFunction;\n  }[],\n): Pick<NextjsApiProps, \"functionGroups\" | \"functionGroupBehaviors\"> {\n  return {\n    functionGroups: groups.map(({ name, function: fn }) => ({\n      name,\n      function: fn,\n    })),\n    functionGroupBehaviors: groups.flatMap((group) =>\n      group.routes.flatMap((route) =>\n        pathPatternsFor(route, {\n          hasDataRoutes: group.hasDataRoutes ?? false,\n          trailingSlash: group.trailingSlash,\n          buildId: \"abc123\",\n        }).map((pattern) => ({ group: group.name, route, pattern })),\n      ),\n    ),\n  };\n}\n\ndescribe(\"NextjsApi\", () => {\n  let stack: Stack;\n\n  beforeEach(() => {\n    stack = new Stack(new App(), \"TestStack\", {\n      env: { account: \"123456789012\", region: \"us-east-1\" },\n    });\n  });\n\n  function createApi(staticAssetsKeyPrefix?: string) {\n    return new NextjsApi(stack, \"NextjsApi\", {\n      staticAssetsBucket: Bucket.fromBucketName(stack, \"Bucket\", \"my-bucket\"),\n      staticAssetsKeyPrefix,\n      serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n        runtime: Runtime.NODEJS_22_X,\n        handler: \"index.handler\",\n        code: Code.fromInline(\"exports.handler = async () => {};\"),\n      }),\n      publicDirEntries: [\n        { name: \"favicon.ico\", isDirectory: false },\n        { name: \"images\", isDirectory: true },\n      ],\n    });\n  }\n\n  /**\n   * The S3 integrations address objects by key, so the uploaded key prefix has\n   * to appear in the integration URI or every static request 404s.\n   */\n  function s3IntegrationKeys(): string[] {\n    const methods = Template.fromStack(stack).findResources(\n      \"AWS::ApiGateway::Method\",\n    );\n    const marker = \"s3:path/my-bucket/\";\n    return Object.values(methods)\n      .flatMap((method) => method.Properties.Integration.Uri[\"Fn::Join\"][1])\n      .filter(\n        (part: unknown): part is string =>\n          typeof part === \"string\" && part.includes(marker),\n      )\n      .map((part) => part.split(marker)[1]);\n  }\n\n  it(\"addresses objects at the bucket root when no key prefix is set\", () => {\n    createApi();\n\n    expect(s3IntegrationKeys().sort()).toEqual([\n      \"_next/static/{key}\",\n      \"favicon.ico\",\n      \"images/{key}\",\n    ]);\n  });\n\n  it(\"prefixes every S3 integration key with the static assets key prefix\", () => {\n    createApi(\"branch-x\");\n\n    expect(s3IntegrationKeys().sort()).toEqual([\n      \"branch-x/_next/static/{key}\",\n      \"branch-x/favicon.ico\",\n      \"branch-x/images/{key}\",\n    ]);\n  });\n\n  it(\"normalizes surrounding slashes on the key prefix\", () => {\n    createApi(\"/branch-x/\");\n\n    expect(s3IntegrationKeys()).toContain(\"branch-x/_next/static/{key}\");\n  });\n\n  /** The statements of the API Gateway → S3 integration role's policy. */\n  function staticIntegrationStatements() {\n    const policies = Template.fromStack(stack).findResources(\n      \"AWS::IAM::Policy\",\n      {\n        Properties: {\n          Roles: [{ Ref: Match.stringLikeRegexp(\"StaticIntegrationRole\") }],\n        },\n      },\n    );\n    return Object.values(policies).flatMap(\n      (policy) => policy.Properties.PolicyDocument.Statement,\n    );\n  }\n\n  it(\"scopes the S3 integration role to the static assets key prefix\", () => {\n    // A shared bucket holds other apps' assets under their own prefixes.\n    createApi(\"/branch-x/\");\n\n    const bucketArn = {\n      \"Fn::Join\": [\"\", [\"arn:\", { Ref: \"AWS::Partition\" }, \":s3:::my-bucket\"]],\n    };\n    expect(staticIntegrationStatements()).toEqual([\n      {\n        Action: \"s3:GetObject\",\n        Effect: \"Allow\",\n        Resource: {\n          \"Fn::Join\": [\n            \"\",\n            [\"arn:\", { Ref: \"AWS::Partition\" }, \":s3:::my-bucket/branch-x/*\"],\n          ],\n        },\n      },\n      {\n        // Unconditioned: S3 checks it during a GetObject, with no `s3:prefix`.\n        Action: \"s3:ListBucket\",\n        Effect: \"Allow\",\n        Resource: bucketArn,\n      },\n    ]);\n  });\n\n  it(\"lets the S3 integration role read the whole bucket without a key prefix\", () => {\n    createApi();\n\n    const statements = staticIntegrationStatements();\n    expect(statements).toHaveLength(2);\n    expect(statements[0].Resource[\"Fn::Join\"][1]).toContain(\n      \":s3:::my-bucket/*\",\n    );\n  });\n\n  it(\"keeps the key prefix independent of basePath, which is the URL prefix\", () => {\n    // A NextjsRegionalFunctions app whose `basePath` matches the API Gateway\n    // stage still has its assets at the bucket root.\n    new NextjsApi(stack, \"NextjsApi\", {\n      staticAssetsBucket: Bucket.fromBucketName(stack, \"Bucket\", \"my-bucket\"),\n      basePath: \"/prod\",\n      serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n        runtime: Runtime.NODEJS_22_X,\n        handler: \"index.handler\",\n        code: Code.fromInline(\"exports.handler = async () => {};\"),\n      }),\n      publicDirEntries: [],\n    });\n\n    expect(s3IntegrationKeys()).toEqual([\"_next/static/{key}\"]);\n    // ...served under the stage-matching URL prefix.\n    Template.fromStack(stack).hasResourceProperties(\n      \"AWS::ApiGateway::Resource\",\n      { PathPart: \"prod\" },\n    );\n  });\n\n  // API Gateway path parts can't contain \"/\", so a nested basePath passed whole\n  // to `addResource` fails CDK's `validateResourcePathPart` at synth. It's\n  // reachable: `resolveBasePath` accepts a nested prop for REGIONAL_FUNCTIONS as\n  // long as the app's basePath ends with it.\n  describe(\"nested basePath\", () => {\n    function pathParts(): string[] {\n      const resources = Template.fromStack(stack).findResources(\n        \"AWS::ApiGateway::Resource\",\n      );\n      return Object.values(resources).map(\n        (resource) => resource.Properties.PathPart,\n      );\n    }\n\n    function createApiWithBasePath(basePath: string) {\n      return new NextjsApi(stack, \"NextjsApi\", {\n        staticAssetsBucket: Bucket.fromBucketName(stack, \"Bucket\", \"my-bucket\"),\n        basePath,\n        serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n          runtime: Runtime.NODEJS_22_X,\n          handler: \"index.handler\",\n          code: Code.fromInline(\"exports.handler = async () => {};\"),\n        }),\n        publicDirEntries: [],\n      });\n    }\n\n    it(\"creates one resource per segment\", () => {\n      expect(() => createApiWithBasePath(\"/team/app\")).not.toThrow();\n\n      expect(pathParts()).toEqual(\n        expect.arrayContaining([\"team\", \"app\", \"_next\", \"{proxy+}\"]),\n      );\n      // Not the unsplit value, which API Gateway would reject.\n      expect(pathParts()).not.toContain(\"team/app\");\n    });\n\n    it(\"nests the segments so the app is reachable under the full path\", () => {\n      createApiWithBasePath(\"/team/app\");\n\n      const resources = Template.fromStack(stack).findResources(\n        \"AWS::ApiGateway::Resource\",\n      );\n      const byPathPart = Object.fromEntries(\n        Object.entries(resources).map(([logicalId, resource]) => [\n          resource.Properties.PathPart,\n          { logicalId, parentId: resource.Properties.ParentId },\n        ]),\n      );\n      // \"app\" hangs off \"team\", not off the API root.\n      expect(byPathPart.app.parentId).toEqual({\n        Ref: byPathPart.team.logicalId,\n      });\n      expect(byPathPart.team.parentId).toHaveProperty(\"Fn::GetAtt\");\n    });\n\n    it(\"still creates a single resource for a flat basePath\", () => {\n      createApiWithBasePath(\"/base\");\n\n      expect(pathParts()).toContain(\"base\");\n    });\n  });\n\n  describe(\"url\", () => {\n    function createApiWithOverrides(\n      props: Partial<NextjsApiProps> = {},\n    ): NextjsApi {\n      return new NextjsApi(stack, \"NextjsApi\", {\n        staticAssetsBucket: Bucket.fromBucketName(stack, \"Bucket\", \"my-bucket\"),\n        serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n          runtime: Runtime.NODEJS_22_X,\n          handler: \"index.handler\",\n          code: Code.fromInline(\"exports.handler = async () => {};\"),\n        }),\n        publicDirEntries: [],\n        ...props,\n      });\n    }\n\n    function domainName(basePath?: string) {\n      return {\n        domainName: \"app.example.com\",\n        certificate: Certificate.fromCertificateArn(\n          stack,\n          \"Cert\",\n          \"arn:aws:acm:us-east-1:123456789012:certificate/abc\",\n        ),\n        basePath,\n      };\n    }\n\n    /**\n     * The REST API id, the stage name and the domain name are all tokens that\n     * only resolve at deploy time, so flatten the resolved `Fn::Join` and stand\n     * each reference in for the resource it points at (minus CDK's logical id\n     * hash suffix). That keeps the assertions about *which* resource supplies\n     * each part of the URL, which is the whole question here.\n     */\n    function resolveUrl(api: NextjsApi): string {\n      const resolved = stack.resolve(api.url);\n      if (typeof resolved === \"string\") {\n        return resolved;\n      }\n      return resolved[\"Fn::Join\"][1]\n        .map((part: unknown) =>\n          typeof part === \"string\"\n            ? part\n            : `{${(part as { Ref: string }).Ref.replace(/[0-9A-F]{8}$/, \"\")}}`,\n        )\n        .join(\"\");\n    }\n\n    it(\"reports the execute-api endpoint with the stage appended when there's no custom domain\", () => {\n      // The stage is in the path only here, which is the whole reason the\n      // regional-functions example sets an app basePath of \"/prod\".\n      expect(resolveUrl(createApiWithOverrides())).toBe(\n        \"https://{NextjsApiRestApi}.execute-api.us-east-1.amazonaws.com/{NextjsApiRestApiDeploymentStageprod}\",\n      );\n    });\n\n    it(\"appends basePath, which nests every resource a level down\", () => {\n      expect(\n        resolveUrl(createApiWithOverrides({ basePath: \"/my-base-path\" })),\n      ).toBe(\n        \"https://{NextjsApiRestApi}.execute-api.us-east-1.amazonaws.com/{NextjsApiRestApiDeploymentStageprod}/my-base-path\",\n      );\n    });\n\n    it(\"prefers a custom domain and drops the stage from the path\", () => {\n      // A domain mapped at the root is the cleanest Regional setup: no stage in\n      // the URL means no basePath and no stage workarounds anywhere. The stage is\n      // reached through the domain's base path mapping instead.\n      expect(\n        resolveUrl(\n          createApiWithOverrides({\n            overrides: { restApiProps: { domainName: domainName() } },\n          }),\n        ),\n      ).toBe(\"https://{NextjsApiRestApiCustomDomain}\");\n    });\n\n    it(\"includes a custom domain's base path mapping\", () => {\n      // CDK rejects surrounding slashes on a mapping, so it's always a bare\n      // segment by the time it gets here.\n      expect(\n        resolveUrl(\n          createApiWithOverrides({\n            overrides: { restApiProps: { domainName: domainName(\"team-a\") } },\n          }),\n        ),\n      ).toBe(\"https://{NextjsApiRestApiCustomDomain}/team-a\");\n    });\n  });\n\n  describe(\"functionGroups resource tree\", () => {\n    /** Lambda functions that `ANY` on the resource at `pathPart` invokes. */\n    function anyTargets(pathPart: string): string[] {\n      const template = Template.fromStack(stack);\n      const resources = template.findResources(\"AWS::ApiGateway::Resource\", {\n        Properties: { PathPart: pathPart },\n      });\n      const ids = Object.keys(resources);\n      expect(ids).toHaveLength(1);\n      const methods = template.findResources(\"AWS::ApiGateway::Method\", {\n        Properties: { HttpMethod: \"ANY\", ResourceId: { Ref: ids[0] } },\n      });\n      return Object.values(methods).map(\n        (method) =>\n          JSON.stringify(method.Properties.Integration.Uri).match(\n            /(ServerFn|GroupFn|ReportsFn)[A-F0-9]+/,\n          )![1],\n      );\n    }\n\n    it(\"sends a group's parent paths to the default function\", () => {\n      // API Gateway answers a methodless resource with 403 rather than falling\n      // back to the root `{proxy+}`, so `/api` and `/api/reports` need one.\n      new NextjsApi(stack, \"NextjsApi\", {\n        staticAssetsBucket: Bucket.fromBucketName(stack, \"Bucket\", \"my-bucket\"),\n        serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n          runtime: Runtime.NODEJS_22_X,\n          handler: \"index.handler\",\n          code: Code.fromInline(\"exports.handler = async () => {};\"),\n        }),\n        publicDirEntries: [],\n        ...grouped([\n          {\n            name: \"reports\",\n            routes: [\"/api/reports/**\", \"/api/export\"],\n            function: new LambdaFunction(stack, \"GroupFn\", {\n              runtime: Runtime.NODEJS_22_X,\n              handler: \"index.handler\",\n              code: Code.fromInline(\"exports.handler = async () => {};\"),\n            }),\n          },\n        ]),\n      });\n\n      expect(anyTargets(\"api\")).toEqual([\"ServerFn\"]);\n      expect(anyTargets(\"reports\")).toEqual([\"ServerFn\"]);\n      expect(anyTargets(\"export\")).toEqual([\"GroupFn\"]);\n    });\n\n    it(\"sends a parent under another group's subtree to that group\", () => {\n      // `assignRoutesToGroups` packages `/api/reports` into `api`, and\n      // CloudFront's `api/*` sends it there; so must API Gateway.\n      new NextjsApi(stack, \"NextjsApi\", {\n        staticAssetsBucket: Bucket.fromBucketName(stack, \"Bucket\", \"my-bucket\"),\n        serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n          runtime: Runtime.NODEJS_22_X,\n          handler: \"index.handler\",\n          code: Code.fromInline(\"exports.handler = async () => {};\"),\n        }),\n        publicDirEntries: [],\n        ...grouped([\n          {\n            name: \"api\",\n            routes: [\"/api/**\"],\n            hasDataRoutes: true,\n            function: new LambdaFunction(stack, \"GroupFn\", {\n              runtime: Runtime.NODEJS_22_X,\n              handler: \"index.handler\",\n              code: Code.fromInline(\"exports.handler = async () => {};\"),\n            }),\n          },\n          {\n            name: \"reports\",\n            routes: [\"/api/reports/q1/**\"],\n            hasDataRoutes: true,\n            function: new LambdaFunction(stack, \"ReportsFn\", {\n              runtime: Runtime.NODEJS_22_X,\n              handler: \"index.handler\",\n              code: Code.fromInline(\"exports.handler = async () => {};\"),\n            }),\n          },\n        ]),\n      });\n\n      // Each path part below appears twice, under `/` and under the data\n      // prefix, so check the tree by path.\n      const targets = anyTargetsByPath();\n      expect(targets[\"/api\"]).toEqual([\"ServerFn\"]);\n      expect(targets[\"/api/reports\"]).toEqual([\"GroupFn\"]);\n      expect(targets[\"/api/reports/q1\"]).toEqual([\"GroupFn\"]);\n      expect(targets[\"/api/reports/q1/{proxy+}\"]).toEqual([\"ReportsFn\"]);\n      expect(targets[\"/_next/data/{buildId}/api/reports\"]).toEqual([\"GroupFn\"]);\n      expect(targets[\"/_next/data/{buildId}\"]).toEqual([\"ServerFn\"]);\n    });\n\n    function createGroupedApi(hasDataRoutes: boolean) {\n      new NextjsApi(stack, \"NextjsApi\", {\n        staticAssetsBucket: Bucket.fromBucketName(stack, \"Bucket\", \"my-bucket\"),\n        serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n          runtime: Runtime.NODEJS_22_X,\n          handler: \"index.handler\",\n          code: Code.fromInline(\"exports.handler = async () => {};\"),\n        }),\n        publicDirEntries: [],\n        ...grouped([\n          {\n            name: \"reports\",\n            routes: [\"/reports/**\", \"/docs/intro\"],\n            hasDataRoutes,\n            function: new LambdaFunction(stack, \"GroupFn\", {\n              runtime: Runtime.NODEJS_22_X,\n              handler: \"index.handler\",\n              code: Code.fromInline(\"exports.handler = async () => {};\"),\n            }),\n          },\n        ]),\n      });\n    }\n\n    /** Every resource path in the API, e.g. `/_next/data/{buildId}/x.json`. */\n    function resourcePaths(): string[] {\n      const resources = Template.fromStack(stack).findResources(\n        \"AWS::ApiGateway::Resource\",\n      );\n      const pathOf = (id: string): string => {\n        const { ParentId, PathPart } = resources[id].Properties;\n        const parent = ParentId.Ref;\n        return parent && resources[parent]\n          ? `${pathOf(parent)}/${PathPart}`\n          : `/${PathPart}`;\n      };\n      return Object.keys(resources).map(pathOf).sort();\n    }\n\n    /** Resource path → the Lambda functions `ANY` on it invokes. */\n    function anyTargetsByPath(): Record<string, string[]> {\n      const template = Template.fromStack(stack);\n      const resources = template.findResources(\"AWS::ApiGateway::Resource\");\n      const pathOf = (id: string): string => {\n        const { ParentId, PathPart } = resources[id].Properties;\n        const parent = ParentId.Ref;\n        return parent && resources[parent]\n          ? `${pathOf(parent)}/${PathPart}`\n          : `/${PathPart}`;\n      };\n      const methods = template.findResources(\"AWS::ApiGateway::Method\", {\n        Properties: { HttpMethod: \"ANY\" },\n      });\n      const targets: Record<string, string[]> = {};\n      for (const method of Object.values(methods)) {\n        const id = method.Properties.ResourceId?.Ref;\n        if (!id || !resources[id]) continue;\n        (targets[pathOf(id)] ??= []).push(\n          JSON.stringify(method.Properties.Integration.Uri).match(\n            /(ServerFn|GroupFn|ReportsFn)[A-F0-9]+/,\n          )![1],\n        );\n      }\n      return targets;\n    }\n\n    it(\"routes a group's Pages Router data URLs to it too\", () => {\n      createGroupedApi(true);\n\n      const paths = resourcePaths();\n      expect(paths).toContain(\"/_next/data/{buildId}/reports/{proxy+}\");\n      expect(paths).toContain(\"/_next/data/{buildId}/docs/intro.json\");\n      expect(anyTargets(\"intro.json\")).toEqual([\"GroupFn\"]);\n      // A methodless parent answers 403, so the data prefix needs the default.\n      expect(anyTargets(\"{buildId}\")).toEqual([\"ServerFn\"]);\n    });\n\n    it(\"keeps each group's data URLs to its own subtree (A)\", () => {\n      // `{buildId}` is one path segment, where CloudFront's `*` crossed `/`:\n      // `/_next/data/<id>/docs/blog/x.json` has no way into blog's resource.\n      new NextjsApi(stack, \"NextjsApi\", {\n        staticAssetsBucket: Bucket.fromBucketName(stack, \"Bucket\", \"my-bucket\"),\n        serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n          runtime: Runtime.NODEJS_22_X,\n          handler: \"index.handler\",\n          code: Code.fromInline(\"exports.handler = async () => {};\"),\n        }),\n        publicDirEntries: [],\n        ...grouped([\n          {\n            name: \"blog\",\n            routes: [\"/blog/**\"],\n            hasDataRoutes: true,\n            function: new LambdaFunction(stack, \"GroupFn\", {\n              runtime: Runtime.NODEJS_22_X,\n              handler: \"index.handler\",\n              code: Code.fromInline(\"exports.handler = async () => {};\"),\n            }),\n          },\n        ]),\n      });\n      expect(\n        resourcePaths().filter((path) => path.startsWith(\"/_next/data\")),\n      ).toEqual([\n        \"/_next/data\",\n        \"/_next/data/{buildId}\",\n        \"/_next/data/{buildId}/blog\",\n        \"/_next/data/{buildId}/blog/{proxy+}\",\n      ]);\n    });\n\n    it(\"routes an optional catch-all's parent to the group when it is listed (B)\", () => {\n      // The build routes `/shop` alongside `/shop/**` when the group owns\n      // `shop/[[...slug]]` (see `routedPatterns`): `{proxy+}` does not match\n      // the parent, which would otherwise reach the default function.\n      new NextjsApi(stack, \"NextjsApi\", {\n        staticAssetsBucket: Bucket.fromBucketName(stack, \"Bucket\", \"my-bucket\"),\n        serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n          runtime: Runtime.NODEJS_22_X,\n          handler: \"index.handler\",\n          code: Code.fromInline(\"exports.handler = async () => {};\"),\n        }),\n        publicDirEntries: [],\n        ...grouped([\n          {\n            name: \"shop\",\n            routes: [\"/shop/**\", \"/shop\"],\n            function: new LambdaFunction(stack, \"GroupFn\", {\n              runtime: Runtime.NODEJS_22_X,\n              handler: \"index.handler\",\n              code: Code.fromInline(\"exports.handler = async () => {};\"),\n            }),\n          },\n        ]),\n      });\n      expect(anyTargets(\"shop\")).toEqual([\"GroupFn\"]);\n    });\n\n    it.each([\n      [{ name: \"docs\", isDirectory: true }, \"/docs/**\", \"directory\"],\n      [{ name: \"docs\", isDirectory: true }, \"/docs/guide/**\", \"directory\"],\n      [{ name: \"robots.txt\", isDirectory: false }, \"/robots.txt\", \"file\"],\n    ])(\n      \"rejects a group route on a public/ entry's resource: %p with %p (E)\",\n      (entry, route, kind) => {\n        expect(\n          () =>\n            new NextjsApi(stack, \"NextjsApi\", {\n              staticAssetsBucket: Bucket.fromBucketName(\n                stack,\n                \"Bucket\",\n                \"my-bucket\",\n              ),\n              serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n                runtime: Runtime.NODEJS_22_X,\n                handler: \"index.handler\",\n                code: Code.fromInline(\"exports.handler = async () => {};\"),\n              }),\n              publicDirEntries: [entry],\n              ...grouped([\n                {\n                  name: \"g\",\n                  routes: [route],\n                  function: new LambdaFunction(stack, \"GroupFn\", {\n                    runtime: Runtime.NODEJS_22_X,\n                    handler: \"index.handler\",\n                    code: Code.fromInline(\"exports.handler = async () => {};\"),\n                  }),\n                },\n              ]),\n            }),\n        ).toThrow(`overlaps the top-level public/ ${kind} \"${entry.name}\"`);\n      },\n    );\n\n    it(\"allows an exact route named like a public/ directory, which is not under it\", () => {\n      expect(\n        () =>\n          new NextjsApi(stack, \"NextjsApi\", {\n            staticAssetsBucket: Bucket.fromBucketName(\n              stack,\n              \"Bucket\",\n              \"my-bucket\",\n            ),\n            serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n              runtime: Runtime.NODEJS_22_X,\n              handler: \"index.handler\",\n              code: Code.fromInline(\"exports.handler = async () => {};\"),\n            }),\n            publicDirEntries: [{ name: \"docs\", isDirectory: true }],\n            ...grouped([\n              {\n                name: \"g\",\n                routes: [\"/docs\"],\n                function: new LambdaFunction(stack, \"GroupFn\", {\n                  runtime: Runtime.NODEJS_22_X,\n                  handler: \"index.handler\",\n                  code: Code.fromInline(\"exports.handler = async () => {};\"),\n                }),\n              },\n            ]),\n          }),\n      ).not.toThrow();\n    });\n\n    it(\"routes an exact route's trailingSlash form through its one resource\", () => {\n      // CloudFront needs `pricing/` as a behavior of its own; API Gateway\n      // matches `/pricing/` on the `pricing` resource, so the variant adds\n      // nothing here and must not add the resource twice.\n      new NextjsApi(stack, \"NextjsApi\", {\n        staticAssetsBucket: Bucket.fromBucketName(stack, \"Bucket\", \"my-bucket\"),\n        serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n          runtime: Runtime.NODEJS_22_X,\n          handler: \"index.handler\",\n          code: Code.fromInline(\"exports.handler = async () => {};\"),\n        }),\n        publicDirEntries: [],\n        ...grouped([\n          {\n            name: \"pricing\",\n            routes: [\"/pricing\"],\n            trailingSlash: true,\n            function: new LambdaFunction(stack, \"GroupFn\", {\n              runtime: Runtime.NODEJS_22_X,\n              handler: \"index.handler\",\n              code: Code.fromInline(\"exports.handler = async () => {};\"),\n            }),\n          },\n        ]),\n      });\n      expect(\n        resourcePaths().filter((path) => !path.startsWith(\"/_next/static\")),\n      ).toEqual([\"/_next\", \"/pricing\", \"/{proxy+}\"]);\n      expect(anyTargetsByPath()).toEqual({\n        \"/pricing\": [\"GroupFn\"],\n        \"/{proxy+}\": [\"ServerFn\"],\n      });\n    });\n\n    it(\"rejects a behavior for a group it was not given\", () => {\n      const { functionGroupBehaviors } = grouped([\n        {\n          name: \"api\",\n          routes: [\"/api/**\"],\n          function: new LambdaFunction(stack, \"GroupFn\", {\n            runtime: Runtime.NODEJS_22_X,\n            handler: \"index.handler\",\n            code: Code.fromInline(\"exports.handler = async () => {};\"),\n          }),\n        },\n      ]);\n      expect(\n        () =>\n          new NextjsApi(stack, \"NextjsApi\", {\n            staticAssetsBucket: Bucket.fromBucketName(\n              stack,\n              \"Bucket\",\n              \"my-bucket\",\n            ),\n            serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n              runtime: Runtime.NODEJS_22_X,\n              handler: \"index.handler\",\n              code: Code.fromInline(\"exports.handler = async () => {};\"),\n            }),\n            publicDirEntries: [],\n            functionGroupBehaviors,\n          }),\n      ).toThrow(/routes to function group \"api\", which is not in/);\n    });\n\n    it(\"adds no data routes for an app without Pages Router routes\", () => {\n      createGroupedApi(false);\n\n      expect(\n        resourcePaths().filter((path) => path.startsWith(\"/_next/data\")),\n      ).toEqual([]);\n    });\n\n    it(\"grants each function one API-scoped permission, not two per method\", () => {\n      // Per-method permissions put two statements in the function's resource\n      // policy for every `ANY`, which outgrows Lambda's 20 KB cap.\n      createGroupedApi(true);\n\n      const permissions = Object.values(\n        Template.fromStack(stack).findResources(\"AWS::Lambda::Permission\", {\n          Properties: { Principal: \"apigateway.amazonaws.com\" },\n        }),\n      );\n      expect(permissions).toHaveLength(2);\n      for (const permission of permissions) {\n        const sourceArn = JSON.stringify(permission.Properties.SourceArn);\n        expect(sourceArn).toContain(\":execute-api:\");\n        expect(sourceArn).toContain(\"/*/*/*\");\n      }\n    });\n  });\n\n  it(\"names the group and pattern API Gateway cannot route\", () => {\n    expect(\n      () =>\n        new NextjsApi(stack, \"NextjsApi\", {\n          staticAssetsBucket: Bucket.fromBucketName(\n            stack,\n            \"Bucket\",\n            \"my-bucket\",\n          ),\n          serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n            runtime: Runtime.NODEJS_22_X,\n            handler: \"index.handler\",\n            code: Code.fromInline(\"exports.handler = async () => {};\"),\n          }),\n          publicDirEntries: [],\n          ...grouped([\n            {\n              name: \"about\",\n              routes: [\"/about~us\"],\n              function: new LambdaFunction(stack, \"GroupFn\", {\n                runtime: Runtime.NODEJS_22_X,\n                handler: \"index.handler\",\n                code: Code.fromInline(\"exports.handler = async () => {};\"),\n              }),\n            },\n          ]),\n        }),\n    ).toThrow(/pattern \"\\/about~us\" \\(group \"about\"\\) has a segment/);\n  });\n\n  describe(\"a public/ entry API Gateway cannot address\", () => {\n    it(\"warns and skips it instead of failing the synth\", () => {\n      // `public/hello world.jpg` is a valid Next.js asset that `addResource`\n      // rejects outright, taking the whole app's synth with it. The Global types\n      // serve it with a wildcard path pattern; here the honest outcome is one\n      // 404ing asset and a warning that names it.\n      const api = new NextjsApi(stack, \"NextjsApi\", {\n        staticAssetsBucket: Bucket.fromBucketName(stack, \"Bucket\", \"my-bucket\"),\n        serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n          runtime: Runtime.NODEJS_22_X,\n          handler: \"index.handler\",\n          code: Code.fromInline(\"exports.handler = async () => {};\"),\n        }),\n        publicDirEntries: [\n          { name: \"hello world.jpg\", isDirectory: false },\n          { name: \"äöüščří.png\", isDirectory: false },\n          { name: \"favicon.ico\", isDirectory: false },\n        ],\n      });\n\n      const message = Annotations.fromStack(stack)\n        .findWarning(`/${api.node.path}`, Match.anyValue())\n        .map((warning) => warning.entry.data as string)\n        .join(\"\\n\");\n      expect(message).toContain('\"hello world.jpg\"');\n      expect(message).toContain('\"äöüščří.png\"');\n      expect(message).not.toContain('\"favicon.ico\"');\n      // The expressible one is still served.\n      expect(s3IntegrationKeys()).toContain(\"favicon.ico\");\n    });\n  });\n});\n\ndescribe(\"NextjsApi redeploy after update\", () => {\n  function synth(props: Partial<NextjsApiProps> = {}) {\n    const stack = new Stack(new App(), \"TestStack\", {\n      env: { account: \"123456789012\", region: \"us-east-1\" },\n    });\n    new NextjsApi(stack, \"NextjsApi\", {\n      staticAssetsBucket: Bucket.fromBucketName(stack, \"Bucket\", \"my-bucket\"),\n      serverFunction: new LambdaFunction(stack, \"ServerFn\", {\n        runtime: Runtime.NODEJS_22_X,\n        handler: \"index.handler\",\n        code: Code.fromInline(\"exports.handler = async () => {};\"),\n      }),\n      publicDirEntries: [],\n      ...props,\n    });\n    return Template.fromStack(stack);\n  }\n\n  /** The `Fn::Join` parts of every resource the redeploy role is granted. */\n  function grantedResources(template: Template) {\n    const [policy] = Object.values(\n      template.findResources(\"AWS::IAM::Policy\", {\n        Properties: {\n          PolicyName: Match.stringLikeRegexp(\"RedeployFn\"),\n        },\n      }),\n    );\n    return policy.Properties.PolicyDocument.Statement.map(\n      (statement: { Action: string; Resource: unknown }) => ({\n        action: statement.Action,\n        resources: JSON.stringify(statement.Resource),\n      }),\n    );\n  }\n\n  it(\"redeploys the stage on this stack's UPDATE_COMPLETE\", () => {\n    const template = synth();\n\n    template.hasResourceProperties(\"AWS::Events::Rule\", {\n      EventPattern: {\n        source: [\"aws.cloudformation\"],\n        \"detail-type\": [\"CloudFormation Stack Status Change\"],\n        detail: {\n          \"stack-id\": [{ Ref: \"AWS::StackId\" }],\n          \"status-details\": {\n            status: [\"UPDATE_COMPLETE\", \"UPDATE_ROLLBACK_COMPLETE\"],\n          },\n        },\n      },\n      Targets: [\n        Match.objectLike({\n          Arn: { \"Fn::GetAtt\": [Match.stringLikeRegexp(\"RedeployFn\"), \"Arn\"] },\n        }),\n      ],\n    });\n    template.hasResourceProperties(\"AWS::Lambda::Function\", {\n      Handler: \"index.handler\",\n      Environment: {\n        Variables: {\n          REST_API_ID: { Ref: Match.stringLikeRegexp(\"RestApi\") },\n          STAGE_NAME: { Ref: Match.stringLikeRegexp(\"DeploymentStage\") },\n        },\n      },\n    });\n  });\n\n  it(\"scopes its API Gateway access to this REST API\", () => {\n    const statements = grantedResources(synth());\n\n    expect(statements.map((s: { action: string }) => s.action)).toEqual([\n      \"apigateway:POST\",\n      \"apigateway:GET\",\n      \"apigateway:DELETE\",\n    ]);\n    for (const { resources } of statements) {\n      expect(resources).toContain(\"/restapis/\");\n      expect(resources).toMatch(/\"Ref\":\"NextjsApiRestApi[0-9A-F]+\"/);\n      expect(resources).not.toMatch(/restapis\\/\\*/);\n    }\n    expect(statements[0].resources).toContain(\"/deployments\");\n    expect(statements[2].resources).toContain(\"/deployments/*\");\n  });\n\n  it(\"is off when redeployAfterUpdate is false\", () => {\n    const template = synth({ redeployAfterUpdate: false });\n\n    template.resourceCountIs(\"AWS::Events::Rule\", 0);\n  });\n\n  it(\"is off when the API deploys no stage\", () => {\n    const template = synth({\n      overrides: { restApiProps: { deploy: false } },\n    });\n\n    template.resourceCountIs(\"AWS::Events::Rule\", 0);\n  });\n\n  it(\"takes function overrides\", () => {\n    const template = synth({\n      overrides: { redeployFunctionProps: { memorySize: 512 } },\n    });\n\n    template.hasResourceProperties(\"AWS::Lambda::Function\", {\n      MemorySize: 512,\n      Environment: {\n        Variables: { REST_API_ID: Match.anyValue() },\n      },\n    });\n  });\n});\n"]}