cdk-nextjs 0.6.2 → 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
@@ -12,10 +13,27 @@ const debug = (0, debug_1.default)("cdk-nextjs:post-deploy:prune-s3");
 const s3Client = new client_s3_1.S3Client();
 // Maximum number of concurrent operations
 const MAX_CONCURRENT_OPERATIONS = 50;
+/**
+ * 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` 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
+ * `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, keyPrefix } = props;
@@ -25,8 +43,14 @@ async function pruneS3(props) {
     // Prefix ("base//", "/base/") that matches no key at all — pruning would
     // silently become a no-op.
     const bare = (keyPrefix || "").replace(/^\/+/, "").replace(/\/+$/, "");
-    // Trailing slash so a prefix of "app" doesn't also match "app-staging/...".
-    const prefix = bare ? `${bare}/` : undefined;
+    // 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;
@@ -39,11 +63,15 @@ async function pruneS3(props) {
             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;
         });
@@ -57,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 };
                 }
             }
@@ -113,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   * S3 key prefix the app's static assets live under. Surrounding slashes are\n   * normalized away. Scopes pruning to this app's objects so that apps or\n   * branches sharing one bucket under different `basePath`s don't delete each\n   * other's assets. Empty or omitted prunes the whole bucket.\n   */\n  keyPrefix?: string;\n}\n\n/**\n * Given `bucketName`, `currentBuildId`, and `msTtl`, list the objects under\n * `keyPrefix` 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, 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  // Trailing slash so a prefix of \"app\" doesn't also match \"app-staging/...\".\n  const prefix = bare ? `${bare}/` : undefined;\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    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    // 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 */\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.js

@@ -34,7 +34,7 @@ function stubBucketContents(keys, buildId = "build-1") {
             return Promise.resolve({});
         }
         // HeadObject
-        return Promise.resolve({ Metadata: { "next-build-id": buildId } });
+        return Promise.resolve({ Metadata: { build_id: buildId } });
     });
 }
 /**
@@ -60,7 +60,7 @@ function stubPagedBucketContents(pages) {
             return Promise.resolve({});
         }
         // HeadObject
-        return Promise.resolve({ Metadata: { "next-build-id": "build-1" } });
+        return Promise.resolve({ Metadata: { build_id: "build-1" } });
     });
 }
 function sentCommands(type) {
@@ -92,41 +92,64 @@ describe("pruneS3", () => {
     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/"]);
+        expect(listPrefixes()).toEqual(["branch-a/_next/"]);
     });
-    // A bare "branch-a" prefix also matches "branch-a-staging/...", which is a
-    // different app's objects.
-    it("terminates the prefix with a slash", async () => {
-        stubBucketContents([]);
+    // 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");
-        // Asserted as an exact value: a bare "branch-a", and an absent prefix, both
-        // reach objects belonging to another app.
-        expect(listPrefixes()).toEqual(["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/"]);
+        expect(listPrefixes()).toEqual(["team/app/_next/"]);
     });
     // The single-app case, and every deployment predating the prefix being
-    // threaded through: an unset prefix still prunes the whole bucket.
+    // 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 whole bucket when the prefix is %s", async (_label, prefix) => {
+    ])("lists the root `_next/` when the prefix is %s", async (_label, prefix) => {
         stubBucketContents([]);
         await prune(prefix);
-        expect(listPrefixes()).toEqual([undefined]);
+        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/favicon.ico",
+            "branch-a/_next/static/older.css",
         ]);
         await prune("branch-a");
         expect(deletedKeys().sort()).toEqual([
             "branch-a/_next/static/old.js",
-            "branch-a/favicon.ico",
+            "branch-a/_next/static/older.css",
         ]);
     });
     it("keeps objects carrying the current build id", async () => {
@@ -134,6 +157,51 @@ describe("pruneS3", () => {
         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
@@ -146,7 +214,7 @@ describe("pruneS3", () => {
     ])("normalizes a prefix given with %s", async (_label, prefix) => {
         stubBucketContents([]);
         await prune(prefix);
-        expect(listPrefixes()).toEqual(["branch-a/"]);
+        expect(listPrefixes()).toEqual(["branch-a/_next/"]);
     });
     describe("pagination", () => {
         it("follows the continuation token across pages", async () => {
@@ -171,6 +239,17 @@ describe("pruneS3", () => {
             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: { \"next-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: { \"next-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/\"]);\n  });\n\n  // A bare \"branch-a\" prefix also matches \"branch-a-staging/...\", which is a\n  // different app's objects.\n  it(\"terminates the prefix with a slash\", async () => {\n    stubBucketContents([]);\n\n    await prune(\"branch-a\");\n\n    // Asserted as an exact value: a bare \"branch-a\", and an absent prefix, both\n    // reach objects belonging to another app.\n    expect(listPrefixes()).toEqual([\"branch-a/\"]);\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/\"]);\n  });\n\n  // The single-app case, and every deployment predating the prefix being\n  // threaded through: an unset prefix still prunes the whole bucket.\n  it.each([\n    [\"omitted\", undefined],\n    [\"empty\", \"\"],\n  ])(\"lists the whole bucket when the prefix is %s\", async (_label, prefix) => {\n    stubBucketContents([]);\n\n    await prune(prefix);\n\n    expect(listPrefixes()).toEqual([undefined]);\n  });\n\n  it(\"still deletes stale objects within the prefix\", async () => {\n    stubBucketContents([\n      \"branch-a/_next/static/old.js\",\n      \"branch-a/favicon.ico\",\n    ]);\n\n    await prune(\"branch-a\");\n\n    expect(deletedKeys().sort()).toEqual([\n      \"branch-a/_next/static/old.js\",\n      \"branch-a/favicon.ico\",\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  // 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/\"]);\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});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prune-s3.test.js","sourceRoot":"","sources":["../../../src/lambdas/post-deploy/prune-s3.test.ts"],"names":[],"mappings":";;AAAA,sDAAsD;AACtD,8EAA8E;AAC9E,gFAAgF;AAChF,4EAA4E;AAC5E,kCAAkC;AAClC,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE,GAAG,EAAE,CAAC,CAAC;IACrC,GAAG,IAAI,CAAC,aAAa,CAAC,oBAAoB,CAAC;IAC3C,QAAQ,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;QACvB,IAAI,EAAE,CAAC,GAAG,IAAe,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;KACnD,CAAC,CAAC;CACJ,CAAC,CAAC,CAAC;AAEJ,kDAAgF;AAChF,yCAAqC;AAErC,MAAM,MAAM,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC;AAEnC,MAAM,MAAM,GAAG,kBAAkB,CAAC;AAClC,MAAM,gBAAgB,GAAG,SAAS,CAAC;AACnC,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;AAExC;;;;GAIG;AACH,SAAS,kBAAkB,CAAC,IAAc,EAAE,OAAO,GAAG,SAAS;IAC7D,MAAM,OAAO,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC;IAClD,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,OAAgB,EAAE,EAAE;QAClD,IAAI,OAAO,YAAY,gCAAoB,EAAE,CAAC;YAC5C,OAAO,OAAO,CAAC,OAAO,CAAC;gBACrB,QAAQ,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,CAAC;aAC9D,CAAC,CAAC;QACL,CAAC;QACD,IAAI,OAAO,YAAY,gCAAoB,EAAE,CAAC;YAC5C,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QAC7B,CAAC;QACD,aAAa;QACb,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC;IAC9D,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;GAIG;AACH,SAAS,uBAAuB,CAAC,KAAiB;IAChD,MAAM,OAAO,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC;IAClD,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,OAAgB,EAAE,EAAE;QAClD,IAAI,OAAO,YAAY,gCAAoB,EAAE,CAAC;YAC5C,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,iBAAiB,CAAC;YAC9C,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC7D,OAAO,OAAO,CAAC,OAAO,CAAC;gBACrB,QAAQ,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;oBAC3C,GAAG;oBACH,YAAY,EAAE,OAAO;iBACtB,CAAC,CAAC;gBACH,qBAAqB,EACnB,KAAK,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,KAAK,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS;aAC7D,CAAC,CAAC;QACL,CAAC;QACD,IAAI,OAAO,YAAY,gCAAoB,EAAE,CAAC;YAC5C,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QAC7B,CAAC;QACD,aAAa;QACb,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC;IAChE,CAAC,CAAC,CAAC;AACL,CAAC;AAED,SAAS,YAAY,CAAI,IAA+B;IACtD,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK;SAC1B,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC;SAC3B,MAAM,CAAC,CAAC,OAAO,EAAgB,EAAE,CAAC,OAAO,YAAY,IAAI,CAAC,CAAC;AAChE,CAAC;AAED,SAAS,YAAY;IACnB,OAAO,YAAY,CAAC,gCAAoB,CAAC,CAAC,GAAG,CAC3C,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,CAClC,CAAC;AACJ,CAAC;AAED,SAAS,WAAW;IAClB,OAAO,YAAY,CAAC,gCAAoB,CAAC,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAC5D,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAa,CAAC,CAClE,CAAC;AACJ,CAAC;AAED,SAAS,KAAK,CAAC,SAAkB;IAC/B,OAAO,IAAA,kBAAO,EAAC;QACb,UAAU,EAAE,MAAM;QAClB,cAAc,EAAE,gBAAgB;QAChC,KAAK,EAAE,MAAM;QACb,SAAS;KACV,CAAC,CAAC;AACL,CAAC;AAED,QAAQ,CAAC,SAAS,EAAE,GAAG,EAAE;IACvB,UAAU,CAAC,GAAG,EAAE;QACd,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;IAC1B,CAAC,CAAC,CAAC;IAEH,6EAA6E;IAC7E,8EAA8E;IAC9E,iDAAiD;IACjD,EAAE,CAAC,sCAAsC,EAAE,KAAK,IAAI,EAAE;QACpD,kBAAkB,CAAC,CAAC,8BAA8B,CAAC,CAAC,CAAC;QAErD,MAAM,KAAK,CAAC,UAAU,CAAC,CAAC;QAExB,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACtD,CAAC,CAAC,CAAC;IAEH,8EAA8E;IAC9E,uEAAuE;IACvE,EAAE,CAAC,wCAAwC,EAAE,KAAK,IAAI,EAAE;QACtD,MAAM,OAAO,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC;QAClD,MAAM,MAAM,GAAG;YACb,8BAA8B;YAC9B,sCAAsC;SACvC,CAAC;QACF,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,OAAgB,EAAE,EAAE;YAClD,IAAI,OAAO,YAAY,gCAAoB,EAAE,CAAC;gBAC5C,OAAO,OAAO,CAAC,OAAO,CAAC;oBACrB,QAAQ,EAAE,MAAM;yBACb,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;yBAC3D,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,CAAC;iBAClD,CAAC,CAAC;YACL,CAAC;YACD,IAAI,OAAO,YAAY,gCAAoB,EAAE,CAAC;gBAC5C,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;YAC7B,CAAC;YACD,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC;QAChE,CAAC,CAAC,CAAC;QAEH,MAAM,KAAK,CAAC,UAAU,CAAC,CAAC;QAExB,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,8BAA8B,CAAC,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yDAAyD,EAAE,KAAK,IAAI,EAAE;QACvE,kBAAkB,CAAC,EAAE,CAAC,CAAC;QAEvB,MAAM,KAAK,CAAC,UAAU,CAAC,CAAC;QAExB,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACtD,CAAC,CAAC,CAAC;IAEH,uEAAuE;IACvE,4EAA4E;IAC5E,yEAAyE;IACzE,EAAE,CAAC,IAAI,CAAC;QACN,CAAC,SAAS,EAAE,SAAS,CAAC;QACtB,CAAC,OAAO,EAAE,EAAE,CAAC;KACd,CAAC,CACA,+CAA+C,EAC/C,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE;QACvB,kBAAkB,CAAC,EAAE,CAAC,CAAC;QAEvB,MAAM,KAAK,CAAC,MAAM,CAAC,CAAC;QAEpB,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC7C,CAAC,CACF,CAAC;IAEF,mEAAmE;IACnE,gDAAgD;IAChD,EAAE,CAAC,iDAAiD,EAAE,KAAK,IAAI,EAAE;QAC/D,kBAAkB,CAAC,EAAE,CAAC,CAAC;QAEvB,MAAM,KAAK,CAAC,MAAM,CAAC,CAAC;QAEpB,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC;IAClD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+CAA+C,EAAE,KAAK,IAAI,EAAE;QAC7D,kBAAkB,CAAC;YACjB,8BAA8B;YAC9B,iCAAiC;SAClC,CAAC,CAAC;QAEH,MAAM,KAAK,CAAC,UAAU,CAAC,CAAC;QAExB,MAAM,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC;YACnC,8BAA8B;YAC9B,iCAAiC;SAClC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,6CAA6C,EAAE,KAAK,IAAI,EAAE;QAC3D,kBAAkB,CAAC,CAAC,qBAAqB,CAAC,EAAE,gBAAgB,CAAC,CAAC;QAE9D,MAAM,KAAK,CAAC,UAAU,CAAC,CAAC;QAExB,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IACpC,CAAC,CAAC,CAAC;IAEH,8EAA8E;IAC9E,6EAA6E;IAC7E,gFAAgF;IAChF,2EAA2E;IAC3E,6EAA6E;IAC7E,mBAAmB;IACnB,EAAE,CAAC,kEAAkE,EAAE,KAAK,IAAI,EAAE;QAChF,MAAM,OAAO,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC;QAClD,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,OAAgB,EAAE,EAAE;YAClD,IAAI,OAAO,YAAY,gCAAoB,EAAE,CAAC;gBAC5C,OAAO,OAAO,CAAC,OAAO,CAAC;oBACrB,QAAQ,EAAE,CAAC,EAAE,GAAG,EAAE,qBAAqB,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC;iBAClE,CAAC,CAAC;YACL,CAAC;YACD,IAAI,OAAO,YAAY,gCAAoB,EAAE,CAAC;gBAC5C,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;YAC7B,CAAC;YACD,OAAO,OAAO,CAAC,OAAO,CAAC;gBACrB,QAAQ,EAAE,EAAE,QAAQ,EAAE,gBAAgB,EAAE;aACzC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,MAAM,KAAK,CAAC,UAAU,CAAC,CAAC;QAExB,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IACpC,CAAC,CAAC,CAAC;IAEH,gFAAgF;IAChF,gFAAgF;IAChF,gEAAgE;IAChE,EAAE,CAAC,iDAAiD,EAAE,KAAK,IAAI,EAAE;QAC/D,MAAM,OAAO,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC;QAClD,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,OAAgB,EAAE,EAAE;YAClD,IAAI,OAAO,YAAY,gCAAoB,EAAE,CAAC;gBAC5C,OAAO,OAAO,CAAC,OAAO,CAAC;oBACrB,QAAQ,EAAE;wBACR,EAAE,GAAG,EAAE,2BAA2B,EAAE,YAAY,EAAE,OAAO,EAAE;qBAC5D;iBACF,CAAC,CAAC;YACL,CAAC;YACD,IAAI,OAAO,YAAY,gCAAoB,EAAE,CAAC;gBAC5C,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;YAC7B,CAAC;YACD,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;QAEH,MAAM,KAAK,CAAC,UAAU,CAAC,CAAC;QAExB,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IACpC,CAAC,CAAC,CAAC;IAEH,qDAAqD;IACrD,0EAA0E;IAC1E,wEAAwE;IACxE,6EAA6E;IAC7E,4BAA4B;IAC5B,EAAE,CAAC,IAAI,CAAC;QACN,CAAC,kBAAkB,EAAE,WAAW,CAAC;QACjC,CAAC,iBAAiB,EAAE,WAAW,CAAC;QAChC,CAAC,MAAM,EAAE,YAAY,CAAC;KACvB,CAAC,CAAC,mCAAmC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE;QAC/D,kBAAkB,CAAC,EAAE,CAAC,CAAC;QAEvB,MAAM,KAAK,CAAC,MAAM,CAAC,CAAC;QAEpB,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACtD,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,EAAE,GAAG,EAAE;QAC1B,EAAE,CAAC,6CAA6C,EAAE,KAAK,IAAI,EAAE;YAC3D,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YAEtE,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;YAEjB,MAAM,CACJ,YAAY,CAAC,gCAAoB,CAAC,CAAC,GAAG,CACpC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,iBAAiB,CAC7C,CACF,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;YAC3C,MAAM,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC;gBACnC,UAAU;gBACV,YAAY;gBACZ,UAAU;aACX,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,6EAA6E;QAC7E,uEAAuE;QACvE,0EAA0E;QAC1E,6EAA6E;QAC7E,6EAA6E;QAC7E,0CAA0C;QAC1C,EAAE,CAAC,yDAAyD,EAAE,KAAK,IAAI,EAAE;YACvE,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAEtD,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;YAEjB,MAAM,CAAC,YAAY,CAAC,gCAAoB,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YAC3D,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC;QAC1D,CAAC,CAAC,CAAC;QAEH,sEAAsE;QACtE,0EAA0E;QAC1E,8EAA8E;QAC9E,4EAA4E;QAC5E,gEAAgE;QAChE,EAAE,CAAC,6DAA6D,EAAE,KAAK,IAAI,EAAE;YAC3E,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YAE5D,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;YAEjB,MAAM,CAAC,YAAY,CAAC,gCAAoB,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YAC3D,MAAM,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC,CAAC;QACnE,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","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>;

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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