cdk-nextjs 0.6.1 → 0.7.0

package/lib/lambdas/redeploy-stage/redeploy-stage.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REDEPLOY_DESCRIPTION_PREFIX = void 0;
+exports.redeployStage = redeployStage;
+/* eslint-disable import/no-extraneous-dependencies */
+const client_api_gateway_1 = require("@aws-sdk/client-api-gateway");
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)("cdk-nextjs:redeploy-stage");
+/**
+ * Marks the deployments this function makes, so a later run prunes only its
+ * own. CloudFormation owns every other deployment on the API and deletes them
+ * itself.
+ */
+exports.REDEPLOY_DESCRIPTION_PREFIX = "cdk-nextjs: redeploy after";
+const apiGateway = new client_api_gateway_1.APIGatewayClient({});
+/**
+ * Deploys `stageName` again from the API as it is now, then deletes the
+ * deployments earlier runs made that no stage still points at.
+ *
+ * Why: CloudFormation creates the new `AWS::ApiGateway::Deployment` while
+ * resources removed from the template still exist (it deletes them only in
+ * `UPDATE_COMPLETE_CLEANUP_IN_PROGRESS`), so that snapshot keeps them. A
+ * removed function group's `/api/{proxy+}` stays routable, to a Lambda that is
+ * then deleted, and API Gateway answers 500 until the next deployment. This
+ * runs on `UPDATE_COMPLETE`, after cleanup, so its snapshot is the real tree.
+ */
+async function redeployStage({ restApiId, stageName, stackStatus, }) {
+    const created = await apiGateway.send(new client_api_gateway_1.CreateDeploymentCommand({
+        restApiId,
+        stageName,
+        description: `${exports.REDEPLOY_DESCRIPTION_PREFIX} ${stackStatus}`,
+    }));
+    const deploymentId = created.id;
+    debug(`Deployed ${restApiId}/${stageName} as ${deploymentId}`);
+    const { item: stages = [] } = await apiGateway.send(new client_api_gateway_1.GetStagesCommand({ restApiId }));
+    const referenced = new Set(stages.map((stage) => stage.deploymentId));
+    let position;
+    do {
+        const page = await apiGateway.send(new client_api_gateway_1.GetDeploymentsCommand({ restApiId, position, limit: 500 }));
+        for (const deployment of page.items ?? []) {
+            if (!deployment.id ||
+                deployment.id === deploymentId ||
+                referenced.has(deployment.id) ||
+                !deployment.description?.startsWith(exports.REDEPLOY_DESCRIPTION_PREFIX)) {
+                continue;
+            }
+            try {
+                await apiGateway.send(new client_api_gateway_1.DeleteDeploymentCommand({
+                    restApiId,
+                    deploymentId: deployment.id,
+                }));
+                debug(`Deleted previous redeploy ${deployment.id}`);
+            }
+            catch (error) {
+                // Pruning is housekeeping: the stage already serves the new deployment.
+                // A stage created meanwhile can reference it (400), or another run got
+                // there first (404); either way the next run tries again.
+                console.warn(`Could not delete deployment ${deployment.id} of ${restApiId}:`, error);
+            }
+        }
+        position = page.position;
+    } while (position);
+    return deploymentId;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/lambdas/redeploy-stage/redeploy-stage.lambda.d.ts

@@ -0,0 +1,20 @@
+import type { EventBridgeHandler } from "aws-lambda";
+/**
+ * The `detail` of a "CloudFormation Stack Status Change" event, as documented
+ * in the CloudFormation User Guide ("Stack Status Change event detail").
+ */
+interface StackStatusChangeDetail {
+    readonly "stack-id": string;
+    readonly "status-details": {
+        readonly status: string;
+        readonly "status-reason"?: string;
+    };
+}
+/**
+ * Invoked by `NextjsApi`'s EventBridge rule when its stack finishes an update;
+ * see {@link redeployStage}. The API and stage come from the environment rather
+ * than the event: the rule only matches this stack, and the event names the
+ * stack, not the API.
+ */
+export declare const handler: EventBridgeHandler<"CloudFormation Stack Status Change", StackStatusChangeDetail, void>;
+export {};

package/lib/lambdas/redeploy-stage/redeploy-stage.lambda.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const redeploy_stage_1 = require("./redeploy-stage");
+/**
+ * Invoked by `NextjsApi`'s EventBridge rule when its stack finishes an update;
+ * see {@link redeployStage}. The API and stage come from the environment rather
+ * than the event: the rule only matches this stack, and the event names the
+ * stack, not the API.
+ */
+const handler = async (event) => {
+    const restApiId = process.env.REST_API_ID;
+    const stageName = process.env.STAGE_NAME;
+    if (!restApiId || !stageName) {
+        throw new Error("REST_API_ID and STAGE_NAME must be set.");
+    }
+    await (0, redeploy_stage_1.redeployStage)({
+        restApiId,
+        stageName,
+        stackStatus: event.detail["status-details"].status,
+    });
+};
+exports.handler = handler;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/lambdas/redeploy-stage/redeploy-stage.test.d.ts

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

package/lib/lambdas/redeploy-stage/redeploy-stage.test.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+// Only the client is mocked; the command classes stay real so assertions can
+// read `command.input`. `send` goes through the holder because the module
+// constructs its client at import time.
+jest.mock("@aws-sdk/client-api-gateway", () => ({
+    ...jest.requireActual("@aws-sdk/client-api-gateway"),
+    APIGatewayClient: jest.fn(() => ({
+        send: (...args) => holder.send(...args),
+    })),
+}));
+const client_api_gateway_1 = require("@aws-sdk/client-api-gateway");
+const redeploy_stage_1 = require("./redeploy-stage");
+const holder = { send: jest.fn() };
+const input = {
+    restApiId: "api1",
+    stageName: "prod",
+    stackStatus: "UPDATE_COMPLETE",
+};
+/** The API as it is: its deployments (pages of them) and its stages. */
+function stubApi(pages, stages) {
+    holder.send.mockImplementation((command) => {
+        if (command instanceof client_api_gateway_1.CreateDeploymentCommand) {
+            return Promise.resolve({ id: "new" });
+        }
+        if (command instanceof client_api_gateway_1.GetStagesCommand) {
+            return Promise.resolve({ item: stages });
+        }
+        if (command instanceof client_api_gateway_1.GetDeploymentsCommand) {
+            const index = Number(command.input.position ?? 0);
+            return Promise.resolve({
+                items: pages[index],
+                position: index + 1 < pages.length ? String(index + 1) : undefined,
+            });
+        }
+        return Promise.resolve({});
+    });
+}
+function sent(type) {
+    return holder.send.mock.calls
+        .map(([command]) => command)
+        .filter((command) => command instanceof type);
+}
+beforeEach(() => holder.send.mockReset());
+it("deploys the stage from the live API", async () => {
+    stubApi([[]], [{ stageName: "prod", deploymentId: "new" }]);
+    await expect((0, redeploy_stage_1.redeployStage)(input)).resolves.toBe("new");
+    expect(sent(client_api_gateway_1.CreateDeploymentCommand).map((c) => c.input)).toEqual([
+        {
+            restApiId: "api1",
+            stageName: "prod",
+            description: `${redeploy_stage_1.REDEPLOY_DESCRIPTION_PREFIX} UPDATE_COMPLETE`,
+        },
+    ]);
+});
+it("deletes only its own earlier deployments no stage references", async () => {
+    const ours = (id) => ({
+        id,
+        description: `${redeploy_stage_1.REDEPLOY_DESCRIPTION_PREFIX} UPDATE_COMPLETE`,
+    });
+    stubApi([
+        // CloudFormation's own, its previous run's, and the new one.
+        [
+            {
+                id: "cfn",
+                description: "Automatically created by the RestApi construct",
+            },
+            ours("prev"),
+        ],
+        // A run whose deployment another stage still serves, on a second page.
+        [ours("pinned"), ours("new")],
+    ], [
+        { stageName: "prod", deploymentId: "new" },
+        { stageName: "canary", deploymentId: "pinned" },
+    ]);
+    await (0, redeploy_stage_1.redeployStage)(input);
+    expect(sent(client_api_gateway_1.DeleteDeploymentCommand).map((c) => c.input)).toEqual([
+        { restApiId: "api1", deploymentId: "prev" },
+    ]);
+});
+it("does not fail the run when a prune is rejected", async () => {
+    stubApi([[{ id: "prev", description: `${redeploy_stage_1.REDEPLOY_DESCRIPTION_PREFIX} x` }]], []);
+    const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+    const send = holder.send.getMockImplementation();
+    holder.send.mockImplementation((command) => command instanceof client_api_gateway_1.DeleteDeploymentCommand
+        ? Promise.reject(new Error("BadRequestException"))
+        : send(command));
+    await expect((0, redeploy_stage_1.redeployStage)(input)).resolves.toBe("new");
+    expect(warn).toHaveBeenCalled();
+    warn.mockRestore();
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"redeploy-stage.test.js","sourceRoot":"","sources":["../../../src/lambdas/redeploy-stage/redeploy-stage.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\n// Only the client is mocked; the command classes stay real so assertions can\n// read `command.input`. `send` goes through the holder because the module\n// constructs its client at import time.\njest.mock(\"@aws-sdk/client-api-gateway\", () => ({\n  ...jest.requireActual(\"@aws-sdk/client-api-gateway\"),\n  APIGatewayClient: jest.fn(() => ({\n    send: (...args: unknown[]) => holder.send(...args),\n  })),\n}));\n\nimport {\n  CreateDeploymentCommand,\n  DeleteDeploymentCommand,\n  GetDeploymentsCommand,\n  GetStagesCommand,\n} from \"@aws-sdk/client-api-gateway\";\nimport { REDEPLOY_DESCRIPTION_PREFIX, redeployStage } from \"./redeploy-stage\";\n\nconst holder = { send: jest.fn() };\n\nconst input = {\n  restApiId: \"api1\",\n  stageName: \"prod\",\n  stackStatus: \"UPDATE_COMPLETE\",\n};\n\n/** The API as it is: its deployments (pages of them) and its stages. */\nfunction stubApi(\n  pages: { id: string; description?: string }[][],\n  stages: { stageName: string; deploymentId: string }[],\n) {\n  holder.send.mockImplementation((command: unknown) => {\n    if (command instanceof CreateDeploymentCommand) {\n      return Promise.resolve({ id: \"new\" });\n    }\n    if (command instanceof GetStagesCommand) {\n      return Promise.resolve({ item: stages });\n    }\n    if (command instanceof GetDeploymentsCommand) {\n      const index = Number(command.input.position ?? 0);\n      return Promise.resolve({\n        items: pages[index],\n        position: index + 1 < pages.length ? String(index + 1) : undefined,\n      });\n    }\n    return Promise.resolve({});\n  });\n}\n\nfunction sent<T>(type: new (...args: never[]) => T): T[] {\n  return holder.send.mock.calls\n    .map(([command]) => command)\n    .filter((command): command is T => command instanceof type);\n}\n\nbeforeEach(() => holder.send.mockReset());\n\nit(\"deploys the stage from the live API\", async () => {\n  stubApi([[]], [{ stageName: \"prod\", deploymentId: \"new\" }]);\n\n  await expect(redeployStage(input)).resolves.toBe(\"new\");\n\n  expect(sent(CreateDeploymentCommand).map((c) => c.input)).toEqual([\n    {\n      restApiId: \"api1\",\n      stageName: \"prod\",\n      description: `${REDEPLOY_DESCRIPTION_PREFIX} UPDATE_COMPLETE`,\n    },\n  ]);\n});\n\nit(\"deletes only its own earlier deployments no stage references\", async () => {\n  const ours = (id: string) => ({\n    id,\n    description: `${REDEPLOY_DESCRIPTION_PREFIX} UPDATE_COMPLETE`,\n  });\n  stubApi(\n    [\n      // CloudFormation's own, its previous run's, and the new one.\n      [\n        {\n          id: \"cfn\",\n          description: \"Automatically created by the RestApi construct\",\n        },\n        ours(\"prev\"),\n      ],\n      // A run whose deployment another stage still serves, on a second page.\n      [ours(\"pinned\"), ours(\"new\")],\n    ],\n    [\n      { stageName: \"prod\", deploymentId: \"new\" },\n      { stageName: \"canary\", deploymentId: \"pinned\" },\n    ],\n  );\n\n  await redeployStage(input);\n\n  expect(sent(DeleteDeploymentCommand).map((c) => c.input)).toEqual([\n    { restApiId: \"api1\", deploymentId: \"prev\" },\n  ]);\n});\n\nit(\"does not fail the run when a prune is rejected\", async () => {\n  stubApi(\n    [[{ id: \"prev\", description: `${REDEPLOY_DESCRIPTION_PREFIX} x` }]],\n    [],\n  );\n  const warn = jest.spyOn(console, \"warn\").mockImplementation(() => {});\n  const send = holder.send.getMockImplementation()!;\n  holder.send.mockImplementation((command: unknown) =>\n    command instanceof DeleteDeploymentCommand\n      ? Promise.reject(new Error(\"BadRequestException\"))\n      : send(command),\n  );\n\n  await expect(redeployStage(input)).resolves.toBe(\"new\");\n  expect(warn).toHaveBeenCalled();\n  warn.mockRestore();\n});\n"]}

package/lib/nextjs-api.d.ts

@@ -1,15 +1,22 @@
 import { RestApi, MethodOptions, RestApiProps, AwsIntegrationProps, LambdaIntegrationOptions } from "aws-cdk-lib/aws-apigateway";
 import { IVpc } from "aws-cdk-lib/aws-ec2";
-import { IFunction } from "aws-cdk-lib/aws-lambda";
+import { Rule } from "aws-cdk-lib/aws-events";
+import { Function as LambdaFunction, IFunction } from "aws-cdk-lib/aws-lambda";
 import { IBucket } from "aws-cdk-lib/aws-s3";
 import { Construct } from "constructs";
-import { PublicDirEntry } from "./nextjs-build/nextjs-build";
+import { OptionalFunctionProps } from "./generated-structs/OptionalFunctionProps";
+import { NextjsFunctionGroupBehavior, PublicDirEntry } from "./nextjs-build/nextjs-build";
 export interface NextjsApiOverrides {
     readonly restApiProps?: RestApiProps;
     readonly staticIntegrationProps?: AwsIntegrationProps;
     readonly s3MethodOptions?: MethodOptions;
     readonly dynamicIntegrationProps?: LambdaIntegrationOptions;
-    readonly imageIntegrationProps?: LambdaIntegrationOptions;
+    /**
+     * Props for the function that deploys the stage again after each stack
+     * update.
+     * @see NextjsApiProps.redeployAfterUpdate
+     */
+    readonly redeployFunctionProps?: OptionalFunctionProps;
 }
 export interface NextjsApiProps {
     /**
@@ -29,19 +36,6 @@ export interface NextjsApiProps {
      * Required if `NextjsRegionalFunctions`. The Lambda function for server-side rendering
      */
     readonly serverFunction?: IFunction;
-    /**
-     * Dedicated image optimization Lambda for the `_next/image` route. When
-     * omitted, no `_next/image` resource is created and those requests fall
-     * through to `serverFunction` via the `{proxy+}` catch-all.
-     *
-     * When provided, it is assumed to support Lambda response streaming (as the
-     * dedicated image Lambda this package builds does) and is invoked with
-     * `ResponseTransferMode.STREAM` accordingly. If you supply a custom
-     * `imageFunction` that doesn't support streaming, override
-     * `responseTransferMode` to `BUFFERED` via `overrides.imageIntegrationProps`,
-     * otherwise API Gateway returns a 502.
-     */
-    readonly imageFunction?: IFunction;
     /**
      * The S3 bucket containing static assets
      */
@@ -61,6 +55,40 @@ export interface NextjsApiProps {
      * [Future] Required if `NextjsRegionalContainers`. VPC to create VPC Link and ECS Service Discovery
      */
     readonly vpc?: IVpc;
+    /**
+     * The non-`default` function groups, the Lambdas
+     * {@link functionGroupBehaviors} route to.
+     * @default - no splitting; `{proxy+}` serves every dynamic route
+     */
+    readonly functionGroups?: NextjsApiFunctionGroup[];
+    /**
+     * `NextjsBuild.functionGroupBehaviors`: each distinct `route` becomes a
+     * resource subtree integrated with its group, so the routes each group was
+     * packaged with reach it rather than {@link serverFunction}.
+     * @default - none
+     */
+    readonly functionGroupBehaviors?: NextjsFunctionGroupBehavior[];
+    /**
+     * Deploy the stage again once each stack update has finished, so it serves
+     * the API as it is after the update.
+     *
+     * CloudFormation snapshots the API into a new deployment while resources
+     * removed from the template still exist — it deletes them only during
+     * cleanup — so the stage keeps serving them. After removing a function
+     * group, its routes then point at a deleted Lambda and answer 500 until the
+     * next deployment. An EventBridge rule on this stack's `UPDATE_COMPLETE`
+     * (and `UPDATE_ROLLBACK_COMPLETE`) invokes a small function that deploys the
+     * stage from the live API and deletes the deployments its earlier runs made.
+     *
+     * Ignored when `overrides.restApiProps.deploy` is `false`: there is no stage.
+     * @default true
+     */
+    readonly redeployAfterUpdate?: boolean;
+}
+/** A non-default function group and the Lambda its routes must reach. */
+export interface NextjsApiFunctionGroup {
+    readonly name: string;
+    readonly function: IFunction;
 }
 /**
  * Creates an API Gateway REST API for Next.js applications
@@ -80,15 +108,40 @@ export declare class NextjsApi extends Construct {
      * mapping added that way won't show up here.
      */
     get url(): string;
+    /**
+     * Deploys the stage again after each stack update.
+     * @see NextjsApiProps.redeployAfterUpdate
+     */
+    readonly redeployFunction?: LambdaFunction;
+    /**
+     * Matches this stack's `UPDATE_COMPLETE` and `UPDATE_ROLLBACK_COMPLETE` and
+     * invokes {@link redeployFunction}.
+     */
+    readonly redeployRule?: Rule;
     private readonly baseResource;
     private readonly 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.
+     */
+    private readonly groupParentResources;
     private readonly props;
     private staticIntegrationRole;
     constructor(scope: Construct, id: string, props: NextjsApiProps);
+    /** @see NextjsApiProps.redeployAfterUpdate */
+    private createRedeploy;
     private validateProps;
     private createRestApi;
     /**
      * Create base resource path if needed. Important if `basePath` is set.
+     *
+     * A nested `basePath` ("/team/app") has to become one resource per segment:
+     * API Gateway path parts can't contain "/", so passing the whole thing to a
+     * single `addResource` fails validation at synth. `resolveBasePath` accepts
+     * nested values, so this is reachable.
      */
     private createBaseResource;
     private createStaticIntegrationRole;
@@ -106,9 +159,45 @@ export declare class NextjsApi extends Construct {
     private createS3Integration;
     private getStaticMethodOptions;
     /**
-     * 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}.
+     */
+    private createFunctionGroupIntegrations;
+    /**
+     * 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.
+     */
+    private assertRoutable;
+    /**
+     * 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.
+     */
+    private assertNoPublicCollision;
+    /**
+     * 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.
      */
-    private createImageIntegration;
+    private resourcePathsFor;
+    /** Walk or create a resource path, reusing whatever already exists. */
+    private resourceFor;
     /**
      * Create Lambda Proxy integration for all other routes
      */