cdk-nextjs 0.6.1 → 0.7.0

package/lib/lambdas/post-deploy/prune-s3.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pruneS3 = pruneS3;
+exports.processBatch = processBatch;
 // eslint-disable-next-line import/no-extraneous-dependencies
 const client_s3_1 = require("@aws-sdk/client-s3");
 // eslint-disable-next-line import/no-extraneous-dependencies
@@ -13,12 +14,43 @@ const s3Client = new client_s3_1.S3Client();
 // Maximum number of concurrent operations
 const MAX_CONCURRENT_OPERATIONS = 50;
 /**
- * Given `bucketName`, `currentBuildId`, and `msTtl`, list all objects
- * in the bucket and delete any that 1/ do not have a metadata key of "next-build-id"
- * and value of `currentBuildId` and 2/ were created more than `msTtl` ago
+ * The object metadata key holding the build id, as it comes back from
+ * `HeadObject`.
+ *
+ * `NextjsStaticAssets` hands `BucketDeployment` `metadata: { BUILD_ID }`, and CDK
+ * lowercases every user metadata key before putting it on the object
+ * (`mapUserMetadata` in `aws-s3-deployment`, and the deployment Lambda lowercases
+ * again in `create_metadata_args`). The name this file used to read,
+ * "next-build-id", is written by nothing: `objectBuildId` was always `undefined`,
+ * so the keep-guard never kept anything and pruning was purely age-based.
+ */
+const BUILD_ID_METADATA_KEY = "build_id";
+/**
+ * Given `bucketName`, `currentBuildId`, and `msTtl`, list the objects under
+ * `keyPrefix`'s `_next/` and delete any that 1/ carry a build id that is not
+ * `currentBuildId` and 2/ were created more than `msTtl` ago.
+ *
+ * An object with no build id at all is kept. It was not uploaded by this
+ * construct's `BucketDeployment` — which stamps every object it writes — so
+ * nothing here knows whether some other stack is serving it, and deleting a live
+ * asset 404s a page while keeping a stale one only costs storage.
  */
 async function pruneS3(props) {
-    const { bucketName, currentBuildId, msTtl } = props;
+    const { bucketName, currentBuildId, msTtl, keyPrefix } = props;
+    // Surrounding slashes are stripped before use: `NextjsStaticAssets` hands over
+    // a bare prefix, but `overrides.customResourceProperties` lets a user set
+    // `staticAssetsKeyPrefix` directly, and "base/" or "/base" would build a
+    // Prefix ("base//", "/base/") that matches no key at all — pruning would
+    // silently become a no-op.
+    const bare = (keyPrefix || "").replace(/^\/+/, "").replace(/\/+$/, "");
+    // Only `_next/` under the prefix, which is where every build-hashed asset lives
+    // and so where old builds pile up. The prefix alone is not a boundary between
+    // apps: an app with none owns the bucket root, which holds every other app's
+    // `<basePath>/` too, and one at "team" holds another at "team/app". Pruning
+    // those deleted the other app's live assets once they were a month old. A
+    // `public/` file keeps its key from build to build, so leaving it costs only
+    // the storage of one that was removed from the app.
+    const prefix = bare ? `${bare}/_next/` : "_next/";
     const cutoffDate = new Date(Date.now() - msTtl);
     const objectsToDelete = [];
     let continuationToken = undefined;
@@ -28,13 +60,18 @@ async function pruneS3(props) {
         const listObjectsV2Input = {
             Bucket: bucketName,
             ContinuationToken: continuationToken,
+            Prefix: prefix,
         };
         const listResponse = await s3Client.send(new client_s3_1.ListObjectsV2Command(listObjectsV2Input));
-        if (!listResponse.Contents || listResponse.Contents.length === 0) {
-            break;
-        }
+        // No `break` on an empty page: `ListObjectsV2` with a `Prefix` can answer with
+        // no `Contents` and `IsTruncated: true`, having scanned a window of the bucket
+        // that held no matching key. That is exactly the shared-bucket case `keyPrefix`
+        // exists for, and breaking here stopped pruning at the first such window, so
+        // every older asset past it was never deleted. The loop's own token and page
+        // guard below terminate it.
+        const contents = listResponse.Contents ?? [];
         // Filter out objects without keys
-        const oldObjects = listResponse.Contents.filter((obj) => {
+        const oldObjects = contents.filter((obj) => {
             const lastModified = obj.LastModified || new Date();
             return obj.Key && lastModified < cutoffDate;
         });
@@ -48,9 +85,10 @@ async function pruneS3(props) {
                     Bucket: bucketName,
                     Key: object.Key,
                 }));
-                const objectBuildId = headResponse.Metadata?.["next-build-id"];
-                // Return the key if it should be deleted
-                if (objectBuildId !== currentBuildId) {
+                const objectBuildId = headResponse.Metadata?.[BUILD_ID_METADATA_KEY];
+                // Return the key if it should be deleted. An object with no build id
+                // is left alone — see this function's doc comment.
+                if (objectBuildId && objectBuildId !== currentBuildId) {
                     return { Key: object.Key };
                 }
             }
@@ -61,9 +99,10 @@ async function pruneS3(props) {
         });
         // Add valid objects to delete list
         objectsToDelete.push(...checkResults.filter(Boolean));
-        if (listResponse.NextContinuationToken) {
-            continuationToken = listResponse.NextContinuationToken;
-        }
+        // Assigned unconditionally: the last page carries no NextContinuationToken,
+        // and keeping the previous page's token would re-list that same page until
+        // the guard below trips, re-checking every object on it 100 times over.
+        continuationToken = listResponse.NextContinuationToken;
         listObjectsCount++;
         // assume less than 100K objects (100 * 1K objects per ListObjectsV2Command = 100K)
     } while (continuationToken && listObjectsCount <= 100);
@@ -103,4 +142,4 @@ async function processBatch(items, batchSize, processFn) {
     }
     return results;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prune-s3.js","sourceRoot":"","sources":["../../../src/lambdas/post-deploy/prune-s3.ts"],"names":[],"mappings":"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","sourcesContent":["// eslint-disable-next-line import/no-extraneous-dependencies\nimport {\n  S3Client,\n  ListObjectsV2Command,\n  DeleteObjectsCommand,\n  HeadObjectCommand,\n  ListObjectsV2CommandInput,\n} from \"@aws-sdk/client-s3\";\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport getDebug from \"debug\";\n\nconst debug = getDebug(\"cdk-nextjs:post-deploy:prune-s3\");\n\nconst s3Client = new S3Client();\n// Maximum number of concurrent operations\nconst MAX_CONCURRENT_OPERATIONS = 50;\n\ninterface PruneS3Props {\n  bucketName: string;\n  currentBuildId: string;\n  /**\n   * Time to live in milliseconds.\n   */\n  msTtl: number;\n}\n\n/**\n * Given `bucketName`, `currentBuildId`, and `msTtl`, list all objects\n * in the bucket and delete any that 1/ do not have a metadata key of \"next-build-id\"\n * and value of `currentBuildId` and 2/ were created more than `msTtl` ago\n */\nexport async function pruneS3(props: PruneS3Props) {\n  const { bucketName, currentBuildId, msTtl } = props;\n\n  const cutoffDate = new Date(Date.now() - msTtl);\n  const objectsToDelete: { Key: string }[] = [];\n\n  let continuationToken: string | undefined = undefined;\n  let listObjectsCount = 0;\n\n  do {\n    // List objects in the bucket\n    const listObjectsV2Input: ListObjectsV2CommandInput = {\n      Bucket: bucketName,\n      ContinuationToken: continuationToken,\n    };\n    const listResponse = await s3Client.send(\n      new ListObjectsV2Command(listObjectsV2Input),\n    );\n\n    if (!listResponse.Contents || listResponse.Contents.length === 0) {\n      break;\n    }\n\n    // Filter out objects without keys\n    const oldObjects = listResponse.Contents.filter((obj) => {\n      const lastModified = obj.LastModified || new Date();\n      return obj.Key && lastModified < cutoffDate;\n    });\n    debug(\n      `Checking old objects metadata to determine pruning: ${oldObjects.map((o) => o.Key)}`,\n    );\n\n    // Process objects in parallel with controlled concurrency\n    const checkResults = await processBatch(\n      oldObjects,\n      MAX_CONCURRENT_OPERATIONS,\n      async (object) => {\n        if (!object.Key) return null;\n\n        try {\n          const headResponse = await s3Client.send(\n            new HeadObjectCommand({\n              Bucket: bucketName,\n              Key: object.Key,\n            }),\n          );\n\n          const objectBuildId = headResponse.Metadata?.[\"next-build-id\"];\n\n          // Return the key if it should be deleted\n          if (objectBuildId !== currentBuildId) {\n            return { Key: object.Key };\n          }\n        } catch (error) {\n          console.error(`Error checking object ${object.Key}:`, error);\n        }\n\n        return null;\n      },\n    );\n\n    // Add valid objects to delete list\n    objectsToDelete.push(\n      ...(checkResults.filter(Boolean) as { Key: string }[]),\n    );\n\n    if (listResponse.NextContinuationToken) {\n      continuationToken = listResponse.NextContinuationToken;\n    }\n    listObjectsCount++;\n    // assume less than 100K objects (100 * 1K objects per ListObjectsV2Command = 100K)\n  } while (continuationToken && listObjectsCount <= 100);\n\n  // Delete objects in parallel batches (respecting S3's 1000 objects per request limit)\n  if (objectsToDelete.length > 0) {\n    const deleteBatches = [];\n\n    for (let i = 0; i < objectsToDelete.length; i += 1000) {\n      const batch = objectsToDelete.slice(i, i + 1000);\n      deleteBatches.push(batch);\n    }\n\n    await processBatch(\n      deleteBatches,\n      5, // Process up to 5 delete batches in parallel\n      async (batch) => {\n        try {\n          debug(\n            `Deleting objects: ${batch.map((b) => b.Key)} from ${bucketName}`,\n          );\n          await s3Client.send(\n            new DeleteObjectsCommand({\n              Bucket: bucketName,\n              Delete: { Objects: batch },\n            }),\n          );\n          debug(`Deleted ${batch.length} objects from ${bucketName}`);\n        } catch (error) {\n          console.error(\"Error deleting objects:\", error);\n        }\n      },\n    );\n  }\n\n  debug(\n    `Pruning complete. Deleted ${objectsToDelete.length} objects from ${bucketName}`,\n  );\n}\n\n/**\n * Process objects in batches to avoid overwhelming the system\n */\nasync function processBatch<T, R>(\n  items: T[],\n  batchSize: number,\n  processFn: (item: T) => Promise<R>,\n): Promise<R[]> {\n  const results: R[] = [];\n\n  for (let i = 0; i < items.length; i += batchSize) {\n    const batch = items.slice(i, i + batchSize);\n    const batchResults = await Promise.all(batch.map(processFn));\n    results.push(...batchResults);\n  }\n\n  return results;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prune-s3.js","sourceRoot":"","sources":["../../../src/lambdas/post-deploy/prune-s3.ts"],"names":[],"mappings":"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","sourcesContent":["// eslint-disable-next-line import/no-extraneous-dependencies\nimport {\n  S3Client,\n  ListObjectsV2Command,\n  DeleteObjectsCommand,\n  HeadObjectCommand,\n  ListObjectsV2CommandInput,\n} from \"@aws-sdk/client-s3\";\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport getDebug from \"debug\";\n\nconst debug = getDebug(\"cdk-nextjs:post-deploy:prune-s3\");\n\nconst s3Client = new S3Client();\n// Maximum number of concurrent operations\nconst MAX_CONCURRENT_OPERATIONS = 50;\n\ninterface PruneS3Props {\n  bucketName: string;\n  currentBuildId: string;\n  /**\n   * Time to live in milliseconds.\n   */\n  msTtl: number;\n  /**\n   * S3 key prefix the app's static assets live under. Surrounding slashes are\n   * normalized away. Scopes pruning to this app's `_next/` objects so that apps\n   * or branches sharing one bucket under different `basePath`s don't delete\n   * each other's assets. Empty or omitted prunes `_next/` at the bucket root.\n   */\n  keyPrefix?: string;\n}\n\n/**\n * The object metadata key holding the build id, as it comes back from\n * `HeadObject`.\n *\n * `NextjsStaticAssets` hands `BucketDeployment` `metadata: { BUILD_ID }`, and CDK\n * lowercases every user metadata key before putting it on the object\n * (`mapUserMetadata` in `aws-s3-deployment`, and the deployment Lambda lowercases\n * again in `create_metadata_args`). The name this file used to read,\n * \"next-build-id\", is written by nothing: `objectBuildId` was always `undefined`,\n * so the keep-guard never kept anything and pruning was purely age-based.\n */\nconst BUILD_ID_METADATA_KEY = \"build_id\";\n\n/**\n * Given `bucketName`, `currentBuildId`, and `msTtl`, list the objects under\n * `keyPrefix`'s `_next/` and delete any that 1/ carry a build id that is not\n * `currentBuildId` and 2/ were created more than `msTtl` ago.\n *\n * An object with no build id at all is kept. It was not uploaded by this\n * construct's `BucketDeployment` — which stamps every object it writes — so\n * nothing here knows whether some other stack is serving it, and deleting a live\n * asset 404s a page while keeping a stale one only costs storage.\n */\nexport async function pruneS3(props: PruneS3Props) {\n  const { bucketName, currentBuildId, msTtl, keyPrefix } = props;\n  // Surrounding slashes are stripped before use: `NextjsStaticAssets` hands over\n  // a bare prefix, but `overrides.customResourceProperties` lets a user set\n  // `staticAssetsKeyPrefix` directly, and \"base/\" or \"/base\" would build a\n  // Prefix (\"base//\", \"/base/\") that matches no key at all — pruning would\n  // silently become a no-op.\n  const bare = (keyPrefix || \"\").replace(/^\\/+/, \"\").replace(/\\/+$/, \"\");\n  // Only `_next/` under the prefix, which is where every build-hashed asset lives\n  // and so where old builds pile up. The prefix alone is not a boundary between\n  // apps: an app with none owns the bucket root, which holds every other app's\n  // `<basePath>/` too, and one at \"team\" holds another at \"team/app\". Pruning\n  // those deleted the other app's live assets once they were a month old. A\n  // `public/` file keeps its key from build to build, so leaving it costs only\n  // the storage of one that was removed from the app.\n  const prefix = bare ? `${bare}/_next/` : \"_next/\";\n\n  const cutoffDate = new Date(Date.now() - msTtl);\n  const objectsToDelete: { Key: string }[] = [];\n\n  let continuationToken: string | undefined = undefined;\n  let listObjectsCount = 0;\n\n  do {\n    // List objects in the bucket\n    const listObjectsV2Input: ListObjectsV2CommandInput = {\n      Bucket: bucketName,\n      ContinuationToken: continuationToken,\n      Prefix: prefix,\n    };\n    const listResponse = await s3Client.send(\n      new ListObjectsV2Command(listObjectsV2Input),\n    );\n\n    // No `break` on an empty page: `ListObjectsV2` with a `Prefix` can answer with\n    // no `Contents` and `IsTruncated: true`, having scanned a window of the bucket\n    // that held no matching key. That is exactly the shared-bucket case `keyPrefix`\n    // exists for, and breaking here stopped pruning at the first such window, so\n    // every older asset past it was never deleted. The loop's own token and page\n    // guard below terminate it.\n    const contents = listResponse.Contents ?? [];\n\n    // Filter out objects without keys\n    const oldObjects = contents.filter((obj) => {\n      const lastModified = obj.LastModified || new Date();\n      return obj.Key && lastModified < cutoffDate;\n    });\n    debug(\n      `Checking old objects metadata to determine pruning: ${oldObjects.map((o) => o.Key)}`,\n    );\n\n    // Process objects in parallel with controlled concurrency\n    const checkResults = await processBatch(\n      oldObjects,\n      MAX_CONCURRENT_OPERATIONS,\n      async (object) => {\n        if (!object.Key) return null;\n\n        try {\n          const headResponse = await s3Client.send(\n            new HeadObjectCommand({\n              Bucket: bucketName,\n              Key: object.Key,\n            }),\n          );\n\n          const objectBuildId = headResponse.Metadata?.[BUILD_ID_METADATA_KEY];\n\n          // Return the key if it should be deleted. An object with no build id\n          // is left alone — see this function's doc comment.\n          if (objectBuildId && objectBuildId !== currentBuildId) {\n            return { Key: object.Key };\n          }\n        } catch (error) {\n          console.error(`Error checking object ${object.Key}:`, error);\n        }\n\n        return null;\n      },\n    );\n\n    // Add valid objects to delete list\n    objectsToDelete.push(\n      ...(checkResults.filter(Boolean) as { Key: string }[]),\n    );\n\n    // Assigned unconditionally: the last page carries no NextContinuationToken,\n    // and keeping the previous page's token would re-list that same page until\n    // the guard below trips, re-checking every object on it 100 times over.\n    continuationToken = listResponse.NextContinuationToken;\n    listObjectsCount++;\n    // assume less than 100K objects (100 * 1K objects per ListObjectsV2Command = 100K)\n  } while (continuationToken && listObjectsCount <= 100);\n\n  // Delete objects in parallel batches (respecting S3's 1000 objects per request limit)\n  if (objectsToDelete.length > 0) {\n    const deleteBatches = [];\n\n    for (let i = 0; i < objectsToDelete.length; i += 1000) {\n      const batch = objectsToDelete.slice(i, i + 1000);\n      deleteBatches.push(batch);\n    }\n\n    await processBatch(\n      deleteBatches,\n      5, // Process up to 5 delete batches in parallel\n      async (batch) => {\n        try {\n          debug(\n            `Deleting objects: ${batch.map((b) => b.Key)} from ${bucketName}`,\n          );\n          await s3Client.send(\n            new DeleteObjectsCommand({\n              Bucket: bucketName,\n              Delete: { Objects: batch },\n            }),\n          );\n          debug(`Deleted ${batch.length} objects from ${bucketName}`);\n        } catch (error) {\n          console.error(\"Error deleting objects:\", error);\n        }\n      },\n    );\n  }\n\n  debug(\n    `Pruning complete. Deleted ${objectsToDelete.length} objects from ${bucketName}`,\n  );\n}\n\n/**\n * Process objects in batches to avoid overwhelming the system\n */\nexport async function processBatch<T, R>(\n  items: T[],\n  batchSize: number,\n  processFn: (item: T) => Promise<R>,\n): Promise<R[]> {\n  const results: R[] = [];\n\n  for (let i = 0; i < items.length; i += batchSize) {\n    const batch = items.slice(i, i + batchSize);\n    const batchResults = await Promise.all(batch.map(processFn));\n    results.push(...batchResults);\n  }\n\n  return results;\n}\n"]}

package/lib/lambdas/post-deploy/prune-s3.test.d.ts

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

package/lib/lambdas/post-deploy/prune-s3.test.js

@@ -0,0 +1,255 @@
+"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 that assertions
+// can read `command.input`. `send` is looked up through the holder at call time
+// because `prune-s3` constructs its client at module scope, before the mock
+// variables here are initialized.
+jest.mock("@aws-sdk/client-s3", () => ({
+    ...jest.requireActual("@aws-sdk/client-s3"),
+    S3Client: jest.fn(() => ({
+        send: (...args) => holder.send(...args),
+    })),
+}));
+const client_s3_1 = require("@aws-sdk/client-s3");
+const prune_s3_1 = require("./prune-s3");
+const holder = { send: jest.fn() };
+const BUCKET = "my-static-assets";
+const CURRENT_BUILD_ID = "build-2";
+const MS_TTL = 1000 * 60 * 60 * 24 * 30;
+/**
+ * One page of listed objects, all old enough to prune and each carrying a stale
+ * build id, so every one of them is a deletion candidate. That isolates the
+ * question this suite is about: which keys `pruneS3` was ever shown.
+ */
+function stubBucketContents(keys, buildId = "build-1") {
+    const longAgo = new Date(Date.now() - MS_TTL * 2);
+    holder.send.mockImplementation((command) => {
+        if (command instanceof client_s3_1.ListObjectsV2Command) {
+            return Promise.resolve({
+                Contents: keys.map((Key) => ({ Key, LastModified: longAgo })),
+            });
+        }
+        if (command instanceof client_s3_1.DeleteObjectsCommand) {
+            return Promise.resolve({});
+        }
+        // HeadObject
+        return Promise.resolve({ Metadata: { build_id: buildId } });
+    });
+}
+/**
+ * Several pages of listed objects, keyed by the continuation token that asks for
+ * each one, so the suite can assert how `pruneS3` walks a paginated listing. The
+ * last page deliberately carries no NextContinuationToken, as S3 returns it.
+ */
+function stubPagedBucketContents(pages) {
+    const longAgo = new Date(Date.now() - MS_TTL * 2);
+    holder.send.mockImplementation((command) => {
+        if (command instanceof client_s3_1.ListObjectsV2Command) {
+            const token = command.input.ContinuationToken;
+            const index = token ? Number(token.replace("page-", "")) : 0;
+            return Promise.resolve({
+                Contents: (pages[index] ?? []).map((Key) => ({
+                    Key,
+                    LastModified: longAgo,
+                })),
+                NextContinuationToken: index + 1 < pages.length ? `page-${index + 1}` : undefined,
+            });
+        }
+        if (command instanceof client_s3_1.DeleteObjectsCommand) {
+            return Promise.resolve({});
+        }
+        // HeadObject
+        return Promise.resolve({ Metadata: { build_id: "build-1" } });
+    });
+}
+function sentCommands(type) {
+    return holder.send.mock.calls
+        .map(([command]) => command)
+        .filter((command) => command instanceof type);
+}
+function listPrefixes() {
+    return sentCommands(client_s3_1.ListObjectsV2Command).map((command) => command.input.Prefix);
+}
+function deletedKeys() {
+    return sentCommands(client_s3_1.DeleteObjectsCommand).flatMap((command) => (command.input.Delete?.Objects ?? []).map((o) => o.Key));
+}
+function prune(keyPrefix) {
+    return (0, prune_s3_1.pruneS3)({
+        bucketName: BUCKET,
+        currentBuildId: CURRENT_BUILD_ID,
+        msTtl: MS_TTL,
+        keyPrefix,
+    });
+}
+describe("pruneS3", () => {
+    beforeEach(() => {
+        holder.send.mockReset();
+    });
+    // Without a Prefix, pruning walks the whole bucket. Two branches sharing one
+    // bucket under different basePaths would then delete each other's assets once
+    // they aged past msTtl, 404ing the other branch.
+    it("scopes the listing to the key prefix", async () => {
+        stubBucketContents(["branch-a/_next/static/old.js"]);
+        await prune("branch-a");
+        expect(listPrefixes()).toEqual(["branch-a/_next/"]);
+    });
+    // A sibling app whose prefix starts with this one's ("branch-a-staging") is a
+    // different app's objects, even though its keys start with "branch-a".
+    it("leaves a sibling prefix's assets alone", async () => {
+        const longAgo = new Date(Date.now() - MS_TTL * 2);
+        const bucket = [
+            "branch-a/_next/static/old.js",
+            "branch-a-staging/_next/static/old.js",
+        ];
+        holder.send.mockImplementation((command) => {
+            if (command instanceof client_s3_1.ListObjectsV2Command) {
+                return Promise.resolve({
+                    Contents: bucket
+                        .filter((Key) => Key.startsWith(command.input.Prefix ?? ""))
+                        .map((Key) => ({ Key, LastModified: longAgo })),
+                });
+            }
+            if (command instanceof client_s3_1.DeleteObjectsCommand) {
+                return Promise.resolve({});
+            }
+            return Promise.resolve({ Metadata: { build_id: "build-1" } });
+        });
+        await prune("branch-a");
+        expect(deletedKeys()).toEqual(["branch-a/_next/static/old.js"]);
+    });
+    it("takes a nested prefix as NextjsStaticAssets resolved it", async () => {
+        stubBucketContents([]);
+        await prune("team/app");
+        expect(listPrefixes()).toEqual(["team/app/_next/"]);
+    });
+    // The single-app case, and every deployment predating the prefix being
+    // threaded through: an unset prefix prunes `_next/` at the bucket root. Not
+    // the whole bucket, which holds every other app's `<basePath>/` as well.
+    it.each([
+        ["omitted", undefined],
+        ["empty", ""],
+    ])("lists the root `_next/` when the prefix is %s", async (_label, prefix) => {
+        stubBucketContents([]);
+        await prune(prefix);
+        expect(listPrefixes()).toEqual(["_next/"]);
+    });
+    // An app at "team" shares its prefix with one at "team/app", whose
+    // `team/app/_next/` is not under `team/_next/`.
+    it("leaves a nested app's assets out of the listing", async () => {
+        stubBucketContents([]);
+        await prune("team");
+        expect(listPrefixes()).toEqual(["team/_next/"]);
+    });
+    it("still deletes stale objects within the prefix", async () => {
+        stubBucketContents([
+            "branch-a/_next/static/old.js",
+            "branch-a/_next/static/older.css",
+        ]);
+        await prune("branch-a");
+        expect(deletedKeys().sort()).toEqual([
+            "branch-a/_next/static/old.js",
+            "branch-a/_next/static/older.css",
+        ]);
+    });
+    it("keeps objects carrying the current build id", async () => {
+        stubBucketContents(["branch-a/current.js"], CURRENT_BUILD_ID);
+        await prune("branch-a");
+        expect(deletedKeys()).toEqual([]);
+    });
+    // Asserted on the literal key rather than through a shared constant: the name
+    // is a contract with CDK, which lowercases the `metadata: { BUILD_ID }` that
+    // `NextjsStaticAssets` passes `BucketDeployment`. Reading any other name — this
+    // file read "next-build-id" for a long time — makes `objectBuildId` always
+    // `undefined`, and a guard that never fires cannot be told from one that has
+    // nothing to keep.
+    it("reads the build id from the metadata key BucketDeployment writes", async () => {
+        const longAgo = new Date(Date.now() - MS_TTL * 2);
+        holder.send.mockImplementation((command) => {
+            if (command instanceof client_s3_1.ListObjectsV2Command) {
+                return Promise.resolve({
+                    Contents: [{ Key: "branch-a/current.js", LastModified: longAgo }],
+                });
+            }
+            if (command instanceof client_s3_1.DeleteObjectsCommand) {
+                return Promise.resolve({});
+            }
+            return Promise.resolve({
+                Metadata: { build_id: CURRENT_BUILD_ID },
+            });
+        });
+        await prune("branch-a");
+        expect(deletedKeys()).toEqual([]);
+    });
+    // Not this construct's object: `BucketDeployment` stamps every file it uploads,
+    // so an unstamped one belongs to something else sharing the bucket. Deleting it
+    // 404s whatever serves it, while keeping it only costs storage.
+    it("keeps an object that carries no build id at all", async () => {
+        const longAgo = new Date(Date.now() - MS_TTL * 2);
+        holder.send.mockImplementation((command) => {
+            if (command instanceof client_s3_1.ListObjectsV2Command) {
+                return Promise.resolve({
+                    Contents: [
+                        { Key: "branch-a/someone-elses.js", LastModified: longAgo },
+                    ],
+                });
+            }
+            if (command instanceof client_s3_1.DeleteObjectsCommand) {
+                return Promise.resolve({});
+            }
+            return Promise.resolve({ Metadata: {} });
+        });
+        await prune("branch-a");
+        expect(deletedKeys()).toEqual([]);
+    });
+    // The construct always hands over a bare prefix, but
+    // `overrides.customResourceProperties.staticAssetsKeyPrefix` reaches this
+    // directly. "base/" would build a Prefix of "base//" and "/base" one of
+    // "/base/", neither of which matches any key, so pruning would silently stop
+    // deleting anything at all.
+    it.each([
+        ["a trailing slash", "branch-a/"],
+        ["a leading slash", "/branch-a"],
+        ["both", "/branch-a/"],
+    ])("normalizes a prefix given with %s", async (_label, prefix) => {
+        stubBucketContents([]);
+        await prune(prefix);
+        expect(listPrefixes()).toEqual(["branch-a/_next/"]);
+    });
+    describe("pagination", () => {
+        it("follows the continuation token across pages", async () => {
+            stubPagedBucketContents([["a/one.js"], ["a/two.js"], ["a/three.js"]]);
+            await prune("a");
+            expect(sentCommands(client_s3_1.ListObjectsV2Command).map((command) => command.input.ContinuationToken)).toEqual([undefined, "page-1", "page-2"]);
+            expect(deletedKeys().sort()).toEqual([
+                "a/one.js",
+                "a/three.js",
+                "a/two.js",
+            ]);
+        });
+        // The last page carries no NextContinuationToken. Holding on to the previous
+        // page's token re-lists that page until the 100-iteration guard trips,
+        // re-HEADing every object on it 100 times over (~100k requests for a full
+        // 1000-key page) and pushing duplicate keys into the delete batches — enough
+        // to blow the post-deploy Lambda's timeout, which leaves the custom resource
+        // waiting on a response that never comes.
+        it("stops listing once a page returns no continuation token", async () => {
+            stubPagedBucketContents([["a/one.js"], ["a/two.js"]]);
+            await prune("a");
+            expect(sentCommands(client_s3_1.ListObjectsV2Command)).toHaveLength(2);
+            expect(deletedKeys()).toEqual(["a/one.js", "a/two.js"]);
+        });
+        // S3 scans a window of the bucket per request and filters by `Prefix`
+        // afterwards, so a page can come back with no `Contents` and still have a
+        // continuation token — exactly the shared-bucket case `keyPrefix` exists for.
+        // Stopping there left every older asset past that window undeleted, and the
+        // bucket grew without bound with nothing in the logs to say so.
+        it("keeps listing past a page whose window held no matching key", async () => {
+            stubPagedBucketContents([["a/one.js"], [], ["a/three.js"]]);
+            await prune("a");
+            expect(sentCommands(client_s3_1.ListObjectsV2Command)).toHaveLength(3);
+            expect(deletedKeys().sort()).toEqual(["a/one.js", "a/three.js"]);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prune-s3.test.js","sourceRoot":"","sources":["../../../src/lambdas/post-deploy/prune-s3.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 that assertions\n// can read `command.input`. `send` is looked up through the holder at call time\n// because `prune-s3` constructs its client at module scope, before the mock\n// variables here are initialized.\njest.mock(\"@aws-sdk/client-s3\", () => ({\n  ...jest.requireActual(\"@aws-sdk/client-s3\"),\n  S3Client: jest.fn(() => ({\n    send: (...args: unknown[]) => holder.send(...args),\n  })),\n}));\n\nimport { ListObjectsV2Command, DeleteObjectsCommand } from \"@aws-sdk/client-s3\";\nimport { pruneS3 } from \"./prune-s3\";\n\nconst holder = { send: jest.fn() };\n\nconst BUCKET = \"my-static-assets\";\nconst CURRENT_BUILD_ID = \"build-2\";\nconst MS_TTL = 1000 * 60 * 60 * 24 * 30;\n\n/**\n * One page of listed objects, all old enough to prune and each carrying a stale\n * build id, so every one of them is a deletion candidate. That isolates the\n * question this suite is about: which keys `pruneS3` was ever shown.\n */\nfunction stubBucketContents(keys: string[], buildId = \"build-1\"): void {\n  const longAgo = new Date(Date.now() - MS_TTL * 2);\n  holder.send.mockImplementation((command: unknown) => {\n    if (command instanceof ListObjectsV2Command) {\n      return Promise.resolve({\n        Contents: keys.map((Key) => ({ Key, LastModified: longAgo })),\n      });\n    }\n    if (command instanceof DeleteObjectsCommand) {\n      return Promise.resolve({});\n    }\n    // HeadObject\n    return Promise.resolve({ Metadata: { build_id: buildId } });\n  });\n}\n\n/**\n * Several pages of listed objects, keyed by the continuation token that asks for\n * each one, so the suite can assert how `pruneS3` walks a paginated listing. The\n * last page deliberately carries no NextContinuationToken, as S3 returns it.\n */\nfunction stubPagedBucketContents(pages: string[][]): void {\n  const longAgo = new Date(Date.now() - MS_TTL * 2);\n  holder.send.mockImplementation((command: unknown) => {\n    if (command instanceof ListObjectsV2Command) {\n      const token = command.input.ContinuationToken;\n      const index = token ? Number(token.replace(\"page-\", \"\")) : 0;\n      return Promise.resolve({\n        Contents: (pages[index] ?? []).map((Key) => ({\n          Key,\n          LastModified: longAgo,\n        })),\n        NextContinuationToken:\n          index + 1 < pages.length ? `page-${index + 1}` : undefined,\n      });\n    }\n    if (command instanceof DeleteObjectsCommand) {\n      return Promise.resolve({});\n    }\n    // HeadObject\n    return Promise.resolve({ Metadata: { build_id: \"build-1\" } });\n  });\n}\n\nfunction sentCommands<T>(type: new (...args: any[]) => T): T[] {\n  return holder.send.mock.calls\n    .map(([command]) => command)\n    .filter((command): command is T => command instanceof type);\n}\n\nfunction listPrefixes(): (string | undefined)[] {\n  return sentCommands(ListObjectsV2Command).map(\n    (command) => command.input.Prefix,\n  );\n}\n\nfunction deletedKeys(): string[] {\n  return sentCommands(DeleteObjectsCommand).flatMap((command) =>\n    (command.input.Delete?.Objects ?? []).map((o) => o.Key as string),\n  );\n}\n\nfunction prune(keyPrefix?: string) {\n  return pruneS3({\n    bucketName: BUCKET,\n    currentBuildId: CURRENT_BUILD_ID,\n    msTtl: MS_TTL,\n    keyPrefix,\n  });\n}\n\ndescribe(\"pruneS3\", () => {\n  beforeEach(() => {\n    holder.send.mockReset();\n  });\n\n  // Without a Prefix, pruning walks the whole bucket. Two branches sharing one\n  // bucket under different basePaths would then delete each other's assets once\n  // they aged past msTtl, 404ing the other branch.\n  it(\"scopes the listing to the key prefix\", async () => {\n    stubBucketContents([\"branch-a/_next/static/old.js\"]);\n\n    await prune(\"branch-a\");\n\n    expect(listPrefixes()).toEqual([\"branch-a/_next/\"]);\n  });\n\n  // A sibling app whose prefix starts with this one's (\"branch-a-staging\") is a\n  // different app's objects, even though its keys start with \"branch-a\".\n  it(\"leaves a sibling prefix's assets alone\", async () => {\n    const longAgo = new Date(Date.now() - MS_TTL * 2);\n    const bucket = [\n      \"branch-a/_next/static/old.js\",\n      \"branch-a-staging/_next/static/old.js\",\n    ];\n    holder.send.mockImplementation((command: unknown) => {\n      if (command instanceof ListObjectsV2Command) {\n        return Promise.resolve({\n          Contents: bucket\n            .filter((Key) => Key.startsWith(command.input.Prefix ?? \"\"))\n            .map((Key) => ({ Key, LastModified: longAgo })),\n        });\n      }\n      if (command instanceof DeleteObjectsCommand) {\n        return Promise.resolve({});\n      }\n      return Promise.resolve({ Metadata: { build_id: \"build-1\" } });\n    });\n\n    await prune(\"branch-a\");\n\n    expect(deletedKeys()).toEqual([\"branch-a/_next/static/old.js\"]);\n  });\n\n  it(\"takes a nested prefix as NextjsStaticAssets resolved it\", async () => {\n    stubBucketContents([]);\n\n    await prune(\"team/app\");\n\n    expect(listPrefixes()).toEqual([\"team/app/_next/\"]);\n  });\n\n  // The single-app case, and every deployment predating the prefix being\n  // threaded through: an unset prefix prunes `_next/` at the bucket root. Not\n  // the whole bucket, which holds every other app's `<basePath>/` as well.\n  it.each([\n    [\"omitted\", undefined],\n    [\"empty\", \"\"],\n  ])(\n    \"lists the root `_next/` when the prefix is %s\",\n    async (_label, prefix) => {\n      stubBucketContents([]);\n\n      await prune(prefix);\n\n      expect(listPrefixes()).toEqual([\"_next/\"]);\n    },\n  );\n\n  // An app at \"team\" shares its prefix with one at \"team/app\", whose\n  // `team/app/_next/` is not under `team/_next/`.\n  it(\"leaves a nested app's assets out of the listing\", async () => {\n    stubBucketContents([]);\n\n    await prune(\"team\");\n\n    expect(listPrefixes()).toEqual([\"team/_next/\"]);\n  });\n\n  it(\"still deletes stale objects within the prefix\", async () => {\n    stubBucketContents([\n      \"branch-a/_next/static/old.js\",\n      \"branch-a/_next/static/older.css\",\n    ]);\n\n    await prune(\"branch-a\");\n\n    expect(deletedKeys().sort()).toEqual([\n      \"branch-a/_next/static/old.js\",\n      \"branch-a/_next/static/older.css\",\n    ]);\n  });\n\n  it(\"keeps objects carrying the current build id\", async () => {\n    stubBucketContents([\"branch-a/current.js\"], CURRENT_BUILD_ID);\n\n    await prune(\"branch-a\");\n\n    expect(deletedKeys()).toEqual([]);\n  });\n\n  // Asserted on the literal key rather than through a shared constant: the name\n  // is a contract with CDK, which lowercases the `metadata: { BUILD_ID }` that\n  // `NextjsStaticAssets` passes `BucketDeployment`. Reading any other name — this\n  // file read \"next-build-id\" for a long time — makes `objectBuildId` always\n  // `undefined`, and a guard that never fires cannot be told from one that has\n  // nothing to keep.\n  it(\"reads the build id from the metadata key BucketDeployment writes\", async () => {\n    const longAgo = new Date(Date.now() - MS_TTL * 2);\n    holder.send.mockImplementation((command: unknown) => {\n      if (command instanceof ListObjectsV2Command) {\n        return Promise.resolve({\n          Contents: [{ Key: \"branch-a/current.js\", LastModified: longAgo }],\n        });\n      }\n      if (command instanceof DeleteObjectsCommand) {\n        return Promise.resolve({});\n      }\n      return Promise.resolve({\n        Metadata: { build_id: CURRENT_BUILD_ID },\n      });\n    });\n\n    await prune(\"branch-a\");\n\n    expect(deletedKeys()).toEqual([]);\n  });\n\n  // Not this construct's object: `BucketDeployment` stamps every file it uploads,\n  // so an unstamped one belongs to something else sharing the bucket. Deleting it\n  // 404s whatever serves it, while keeping it only costs storage.\n  it(\"keeps an object that carries no build id at all\", async () => {\n    const longAgo = new Date(Date.now() - MS_TTL * 2);\n    holder.send.mockImplementation((command: unknown) => {\n      if (command instanceof ListObjectsV2Command) {\n        return Promise.resolve({\n          Contents: [\n            { Key: \"branch-a/someone-elses.js\", LastModified: longAgo },\n          ],\n        });\n      }\n      if (command instanceof DeleteObjectsCommand) {\n        return Promise.resolve({});\n      }\n      return Promise.resolve({ Metadata: {} });\n    });\n\n    await prune(\"branch-a\");\n\n    expect(deletedKeys()).toEqual([]);\n  });\n\n  // The construct always hands over a bare prefix, but\n  // `overrides.customResourceProperties.staticAssetsKeyPrefix` reaches this\n  // directly. \"base/\" would build a Prefix of \"base//\" and \"/base\" one of\n  // \"/base/\", neither of which matches any key, so pruning would silently stop\n  // deleting anything at all.\n  it.each([\n    [\"a trailing slash\", \"branch-a/\"],\n    [\"a leading slash\", \"/branch-a\"],\n    [\"both\", \"/branch-a/\"],\n  ])(\"normalizes a prefix given with %s\", async (_label, prefix) => {\n    stubBucketContents([]);\n\n    await prune(prefix);\n\n    expect(listPrefixes()).toEqual([\"branch-a/_next/\"]);\n  });\n\n  describe(\"pagination\", () => {\n    it(\"follows the continuation token across pages\", async () => {\n      stubPagedBucketContents([[\"a/one.js\"], [\"a/two.js\"], [\"a/three.js\"]]);\n\n      await prune(\"a\");\n\n      expect(\n        sentCommands(ListObjectsV2Command).map(\n          (command) => command.input.ContinuationToken,\n        ),\n      ).toEqual([undefined, \"page-1\", \"page-2\"]);\n      expect(deletedKeys().sort()).toEqual([\n        \"a/one.js\",\n        \"a/three.js\",\n        \"a/two.js\",\n      ]);\n    });\n\n    // The last page carries no NextContinuationToken. Holding on to the previous\n    // page's token re-lists that page until the 100-iteration guard trips,\n    // re-HEADing every object on it 100 times over (~100k requests for a full\n    // 1000-key page) and pushing duplicate keys into the delete batches — enough\n    // to blow the post-deploy Lambda's timeout, which leaves the custom resource\n    // waiting on a response that never comes.\n    it(\"stops listing once a page returns no continuation token\", async () => {\n      stubPagedBucketContents([[\"a/one.js\"], [\"a/two.js\"]]);\n\n      await prune(\"a\");\n\n      expect(sentCommands(ListObjectsV2Command)).toHaveLength(2);\n      expect(deletedKeys()).toEqual([\"a/one.js\", \"a/two.js\"]);\n    });\n\n    // S3 scans a window of the bucket per request and filters by `Prefix`\n    // afterwards, so a page can come back with no `Contents` and still have a\n    // continuation token — exactly the shared-bucket case `keyPrefix` exists for.\n    // Stopping there left every older asset past that window undeleted, and the\n    // bucket grew without bound with nothing in the logs to say so.\n    it(\"keeps listing past a page whose window held no matching key\", async () => {\n      stubPagedBucketContents([[\"a/one.js\"], [], [\"a/three.js\"]]);\n\n      await prune(\"a\");\n\n      expect(sentCommands(ListObjectsV2Command)).toHaveLength(3);\n      expect(deletedKeys().sort()).toEqual([\"a/one.js\", \"a/three.js\"]);\n    });\n  });\n});\n"]}

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

@@ -0,0 +1,13 @@
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import { Construct } from 'constructs';
+/**
+ * Props for RedeployStageFunction
+ */
+export interface RedeployStageFunctionProps extends lambda.FunctionOptions {
+}
+/**
+ * An AWS Lambda function which executes src/lambdas/redeploy-stage/redeploy-stage.
+ */
+export declare class RedeployStageFunction extends lambda.Function {
+    constructor(scope: Construct, id: string, props?: RedeployStageFunctionProps);
+}

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

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedeployStageFunction = void 0;
+// ~~ Generated by projen. To modify, edit .projenrc.ts and run "pnpm dlx projen".
+const path = __importStar(require("path"));
+const lambda = __importStar(require("aws-cdk-lib/aws-lambda"));
+/**
+ * An AWS Lambda function which executes src/lambdas/redeploy-stage/redeploy-stage.
+ */
+class RedeployStageFunction extends lambda.Function {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            description: 'src/lambdas/redeploy-stage/redeploy-stage.lambda.ts',
+            ...props,
+            runtime: new lambda.Runtime('nodejs24.x', lambda.RuntimeFamily.NODEJS),
+            handler: 'index.handler',
+            code: lambda.Code.fromAsset(path.join(__dirname, '../../../assets/lambdas/redeploy-stage/redeploy-stage.lambda')),
+        });
+    }
+}
+exports.RedeployStageFunction = RedeployStageFunction;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ */
+export declare const REDEPLOY_DESCRIPTION_PREFIX = "cdk-nextjs: redeploy after";
+export interface RedeployStageInput {
+    readonly restApiId: string;
+    readonly stageName: string;
+    /** The stack status that triggered the run, for the description. */
+    readonly stackStatus: string;
+}
+/**
+ * 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.
+ */
+export declare function redeployStage({ restApiId, stageName, stackStatus, }: RedeployStageInput): Promise<string>;