cdk-nextjs 0.6.2 → 0.7.1

package/lib/lambdas/post-deploy/prune-cache-bucket.js

@@ -10,89 +10,75 @@ const client_s3_1 = require("@aws-sdk/client-s3");
 const debug_1 = __importDefault(require("debug"));
 const debug = (0, debug_1.default)("cdk-nextjs:post-deploy:prune-cache-bucket");
 const s3Client = new client_s3_1.S3Client();
+const PRUNE_BUDGET_MS = 3 * 60_000;
 /**
- * Given `bucketName` and `currentBuildId`, list all objects in the cache bucket
- * and delete any that have BUILD_ID prefixes that don't match the current build ID.
- * Cache objects are prefixed with {buildId}/ pattern (no leading slash).
+ * Given `bucketName` and `currentBuildId`, delete every cache object that isn't
+ * under the current build's `{buildId}/` prefix (no leading slash).
+ *
+ * The top level is listed with a delimiter, so the current build, which can
+ * hold any number of `'use cache: remote'` entries, is never walked. Each old
+ * build prefix is then listed and deleted page by page. Top-level keys outside
+ * any build prefix (legacy objects) are deleted too.
  */
 async function pruneCacheBucket(props) {
     const { bucketName, currentBuildId } = props;
-    const objectsToDelete = [];
-    let continuationToken = undefined;
-    let listObjectsCount = 0;
+    const deadline = Date.now() + PRUNE_BUDGET_MS;
+    const oldPrefixes = [];
+    let deleted = 0;
+    let continuationToken;
     do {
-        // List objects in the bucket
-        const listObjectsV2Input = {
+        const page = await s3Client.send(new client_s3_1.ListObjectsV2Command({
             Bucket: bucketName,
+            Delimiter: "/",
             ContinuationToken: continuationToken,
-        };
-        const listResponse = await s3Client.send(new client_s3_1.ListObjectsV2Command(listObjectsV2Input));
-        if (!listResponse.Contents || listResponse.Contents.length === 0) {
-            break;
+        }));
+        for (const { Prefix } of page.CommonPrefixes ?? []) {
+            if (Prefix && Prefix !== `${currentBuildId}/`)
+                oldPrefixes.push(Prefix);
         }
-        // Filter objects that have old BUILD_ID prefixes
-        const oldCacheObjects = listResponse.Contents.filter((obj) => {
-            if (!obj.Key)
-                return false;
-            // Check if the object key starts with a BUILD_ID prefix pattern
-            // Expected pattern: {buildId}/* (buildId followed by slash, no leading slash)
-            // Regex /^([^\/]+)\// matches: BUILD_ID/... and captures BUILD_ID in group 1
-            // Example: "abc123def456/pages/index.html" captures "abc123def456"
-            const buildIdMatch = obj.Key.match(/^([^\/]+)\//);
-            if (buildIdMatch) {
-                const objectBuildId = buildIdMatch[1]; // Extract BUILD_ID from capture group
-                // Delete if it's not the current build ID
-                return objectBuildId !== currentBuildId;
+        deleted += await deleteObjects(bucketName, page.Contents);
+        continuationToken = page.NextContinuationToken;
+    } while (continuationToken);
+    debug(`Found ${oldPrefixes.length} old build prefixes to delete`);
+    for (const [i, prefix] of oldPrefixes.entries()) {
+        continuationToken = undefined;
+        do {
+            if (Date.now() > deadline) {
+                console.warn(`Cache bucket pruning stopped at its time budget after deleting ${deleted} objects; ${oldPrefixes.length - i} old build prefixes are left for the next deploy`);
+                return;
             }
-            // Also delete objects that don't follow the BUILD_ID prefix pattern
-            // These might be legacy cache objects or objects with leading slashes
-            return true;
-        });
-        debug(`Found ${oldCacheObjects.length} cache objects with old BUILD_ID prefixes to delete`);
-        // Add objects to delete list
-        objectsToDelete.push(...oldCacheObjects
-            .filter((obj) => obj.Key)
-            .map((obj) => ({ Key: obj.Key })));
-        if (listResponse.NextContinuationToken) {
-            continuationToken = listResponse.NextContinuationToken;
-        }
-        listObjectsCount++;
-        // assume less than 100K objects (100 * 1K objects per ListObjectsV2Command = 100K)
-    } while (continuationToken && listObjectsCount <= 100);
-    // Delete objects in parallel batches (respecting S3's 1000 objects per request limit)
-    if (objectsToDelete.length > 0) {
-        const deleteBatches = [];
-        for (let i = 0; i < objectsToDelete.length; i += 1000) {
-            const batch = objectsToDelete.slice(i, i + 1000);
-            deleteBatches.push(batch);
-        }
-        await processBatch(deleteBatches, 5, // Process up to 5 delete batches in parallel
-        async (batch) => {
-            try {
-                debug(`Deleting cache objects: ${batch.map((b) => b.Key)} from ${bucketName}`);
-                await s3Client.send(new client_s3_1.DeleteObjectsCommand({
-                    Bucket: bucketName,
-                    Delete: { Objects: batch },
-                }));
-                debug(`Deleted ${batch.length} cache objects from ${bucketName}`);
-            }
-            catch (error) {
-                console.error("Error deleting cache objects:", error);
-            }
-        });
+            const page = await s3Client.send(new client_s3_1.ListObjectsV2Command({
+                Bucket: bucketName,
+                Prefix: prefix,
+                ContinuationToken: continuationToken,
+            }));
+            deleted += await deleteObjects(bucketName, page.Contents);
+            continuationToken = page.NextContinuationToken;
+        } while (continuationToken);
     }
-    debug(`Cache bucket pruning complete. Deleted ${objectsToDelete.length} objects from ${bucketName}`);
+    debug(`Cache bucket pruning complete. Deleted ${deleted} objects from ${bucketName}`);
 }
 /**
- * Process objects in batches to avoid overwhelming the system
+ * Delete one listed page of objects. ListObjectsV2 returns at most 1000 keys a
+ * page, which is also the DeleteObjects limit, so a page is one request.
+ * Returns how many objects were sent for deletion.
  */
-async function processBatch(items, batchSize, processFn) {
-    const results = [];
-    for (let i = 0; i < items.length; i += batchSize) {
-        const batch = items.slice(i, i + batchSize);
-        const batchResults = await Promise.all(batch.map(processFn));
-        results.push(...batchResults);
+async function deleteObjects(bucketName, contents = []) {
+    const objects = contents
+        .filter((obj) => obj.Key)
+        .map((obj) => ({ Key: obj.Key }));
+    if (objects.length === 0)
+        return 0;
+    try {
+        debug(`Deleting cache objects: ${objects.map((o) => o.Key)} from ${bucketName}`);
+        await s3Client.send(new client_s3_1.DeleteObjectsCommand({
+            Bucket: bucketName,
+            Delete: { Objects: objects },
+        }));
+    }
+    catch (error) {
+        console.error("Error deleting cache objects:", error);
     }
-    return results;
+    return objects.length;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prune-cache-bucket.js","sourceRoot":"","sources":["../../../src/lambdas/post-deploy/prune-cache-bucket.ts"],"names":[],"mappings":"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","sourcesContent":["// eslint-disable-next-line import/no-extraneous-dependencies\nimport {\n  S3Client,\n  ListObjectsV2Command,\n  DeleteObjectsCommand,\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-cache-bucket\");\n\nconst s3Client = new S3Client();\n\ninterface PruneCacheBucketProps {\n  bucketName: string;\n  currentBuildId: string;\n}\n\n/**\n * Given `bucketName` and `currentBuildId`, list all objects in the cache bucket\n * and delete any that have BUILD_ID prefixes that don't match the current build ID.\n * Cache objects are prefixed with {buildId}/ pattern (no leading slash).\n */\nexport async function pruneCacheBucket(props: PruneCacheBucketProps) {\n  const { bucketName, currentBuildId } = props;\n\n  const objectsToDelete: { Key: string }[] = [];\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 objects that have old BUILD_ID prefixes\n    const oldCacheObjects = listResponse.Contents.filter((obj) => {\n      if (!obj.Key) return false;\n\n      // Check if the object key starts with a BUILD_ID prefix pattern\n      // Expected pattern: {buildId}/* (buildId followed by slash, no leading slash)\n      // Regex /^([^\\/]+)\\// matches: BUILD_ID/... and captures BUILD_ID in group 1\n      // Example: \"abc123def456/pages/index.html\" captures \"abc123def456\"\n      const buildIdMatch = obj.Key.match(/^([^\\/]+)\\//);\n      if (buildIdMatch) {\n        const objectBuildId = buildIdMatch[1]; // Extract BUILD_ID from capture group\n        // Delete if it's not the current build ID\n        return objectBuildId !== currentBuildId;\n      }\n\n      // Also delete objects that don't follow the BUILD_ID prefix pattern\n      // These might be legacy cache objects or objects with leading slashes\n      return true;\n    });\n\n    debug(\n      `Found ${oldCacheObjects.length} cache objects with old BUILD_ID prefixes to delete`,\n    );\n\n    // Add objects to delete list\n    objectsToDelete.push(\n      ...oldCacheObjects\n        .filter((obj) => obj.Key)\n        .map((obj) => ({ Key: obj.Key! })),\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 cache 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} cache objects from ${bucketName}`);\n        } catch (error) {\n          console.error(\"Error deleting cache objects:\", error);\n        }\n      },\n    );\n  }\n\n  debug(\n    `Cache bucket 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-cache-bucket.js","sourceRoot":"","sources":["../../../src/lambdas/post-deploy/prune-cache-bucket.ts"],"names":[],"mappings":"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","sourcesContent":["// eslint-disable-next-line import/no-extraneous-dependencies\nimport {\n  S3Client,\n  ListObjectsV2Command,\n  ListObjectsV2CommandOutput,\n  DeleteObjectsCommand,\n  _Object,\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-cache-bucket\");\n\nconst s3Client = new S3Client();\n\nconst PRUNE_BUDGET_MS = 3 * 60_000;\n\ninterface PruneCacheBucketProps {\n  bucketName: string;\n  currentBuildId: string;\n}\n\n/**\n * Given `bucketName` and `currentBuildId`, delete every cache object that isn't\n * under the current build's `{buildId}/` prefix (no leading slash).\n *\n * The top level is listed with a delimiter, so the current build, which can\n * hold any number of `'use cache: remote'` entries, is never walked. Each old\n * build prefix is then listed and deleted page by page. Top-level keys outside\n * any build prefix (legacy objects) are deleted too.\n */\nexport async function pruneCacheBucket(props: PruneCacheBucketProps) {\n  const { bucketName, currentBuildId } = props;\n  const deadline = Date.now() + PRUNE_BUDGET_MS;\n\n  const oldPrefixes: string[] = [];\n  let deleted = 0;\n  let continuationToken: string | undefined;\n  do {\n    const page: ListObjectsV2CommandOutput = await s3Client.send(\n      new ListObjectsV2Command({\n        Bucket: bucketName,\n        Delimiter: \"/\",\n        ContinuationToken: continuationToken,\n      }),\n    );\n    for (const { Prefix } of page.CommonPrefixes ?? []) {\n      if (Prefix && Prefix !== `${currentBuildId}/`) oldPrefixes.push(Prefix);\n    }\n    deleted += await deleteObjects(bucketName, page.Contents);\n    continuationToken = page.NextContinuationToken;\n  } while (continuationToken);\n\n  debug(`Found ${oldPrefixes.length} old build prefixes to delete`);\n\n  for (const [i, prefix] of oldPrefixes.entries()) {\n    continuationToken = undefined;\n    do {\n      if (Date.now() > deadline) {\n        console.warn(\n          `Cache bucket pruning stopped at its time budget after deleting ${deleted} objects; ${oldPrefixes.length - i} old build prefixes are left for the next deploy`,\n        );\n        return;\n      }\n      const page: ListObjectsV2CommandOutput = await s3Client.send(\n        new ListObjectsV2Command({\n          Bucket: bucketName,\n          Prefix: prefix,\n          ContinuationToken: continuationToken,\n        }),\n      );\n      deleted += await deleteObjects(bucketName, page.Contents);\n      continuationToken = page.NextContinuationToken;\n    } while (continuationToken);\n  }\n\n  debug(\n    `Cache bucket pruning complete. Deleted ${deleted} objects from ${bucketName}`,\n  );\n}\n\n/**\n * Delete one listed page of objects. ListObjectsV2 returns at most 1000 keys a\n * page, which is also the DeleteObjects limit, so a page is one request.\n * Returns how many objects were sent for deletion.\n */\nasync function deleteObjects(bucketName: string, contents: _Object[] = []) {\n  const objects = contents\n    .filter((obj) => obj.Key)\n    .map((obj) => ({ Key: obj.Key! }));\n  if (objects.length === 0) return 0;\n  try {\n    debug(\n      `Deleting cache objects: ${objects.map((o) => o.Key)} from ${bucketName}`,\n    );\n    await s3Client.send(\n      new DeleteObjectsCommand({\n        Bucket: bucketName,\n        Delete: { Objects: objects },\n      }),\n    );\n  } catch (error) {\n    console.error(\"Error deleting cache objects:\", error);\n  }\n  return objects.length;\n}\n"]}

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

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

package/lib/lambdas/post-deploy/prune-cache-bucket.test.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+// Only the client is mocked, as in `prune-s3.test.ts`: `prune-cache-bucket`
+// constructs its client at module scope, before the mock variables exist.
+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_cache_bucket_1 = require("./prune-cache-bucket");
+const holder = { send: jest.fn() };
+/**
+ * A fake bucket: ListObjectsV2 honours `Prefix` and `Delimiter`, and pages
+ * `pageSize` keys at a time via the token `<offset>`; the last page carries no
+ * NextContinuationToken, as S3 returns it.
+ */
+function stubBucket(keys, pageSize = 2) {
+    holder.send.mockImplementation((command) => {
+        if (!(command instanceof client_s3_1.ListObjectsV2Command))
+            return Promise.resolve({});
+        const { Prefix = "", Delimiter, ContinuationToken } = command.input;
+        const entries = [];
+        for (const key of keys.filter((k) => k.startsWith(Prefix))) {
+            const cut = Delimiter ? key.indexOf(Delimiter, Prefix.length) : -1;
+            if (cut < 0) {
+                entries.push({ key });
+            }
+            else {
+                const prefix = key.slice(0, cut + 1);
+                if (!entries.some((entry) => entry.prefix === prefix)) {
+                    entries.push({ prefix });
+                }
+            }
+        }
+        const offset = Number(ContinuationToken ?? 0);
+        const page = entries.slice(offset, offset + pageSize);
+        return Promise.resolve({
+            Contents: page.filter((e) => e.key).map((e) => ({ Key: e.key })),
+            CommonPrefixes: page
+                .filter((e) => e.prefix)
+                .map((e) => ({ Prefix: e.prefix })),
+            NextContinuationToken: offset + pageSize < entries.length
+                ? String(offset + pageSize)
+                : undefined,
+        });
+    });
+}
+function sent(type) {
+    return holder.send.mock.calls
+        .map(([command]) => command)
+        .filter((command) => command instanceof type);
+}
+function deletedKeys() {
+    return sent(client_s3_1.DeleteObjectsCommand).flatMap((command) => command.input.Delete.Objects.map((object) => object.Key));
+}
+describe("pruneCacheBucket", () => {
+    beforeEach(() => {
+        holder.send.mockReset();
+    });
+    it("deletes every old build prefix across pages, and loose keys", async () => {
+        stubBucket([
+            "current/a.json",
+            "current/_use-cache/1.entry",
+            "old1/a.json",
+            "old1/_use-cache/1.entry",
+            "old1/_use-cache/2.entry",
+            "old2/a.json",
+            "loose.json",
+            "/leading-slash.json",
+        ]);
+        await (0, prune_cache_bucket_1.pruneCacheBucket)({ bucketName: "cache", currentBuildId: "current" });
+        expect(deletedKeys().sort()).toEqual([
+            "/leading-slash.json",
+            "loose.json",
+            "old1/_use-cache/1.entry",
+            "old1/_use-cache/2.entry",
+            "old1/a.json",
+            "old2/a.json",
+        ].sort());
+    });
+    // The current build can hold unbounded 'use cache: remote' entries, so it
+    // must never be walked: the delimited top-level listing only names it.
+    it("never lists inside the current build", async () => {
+        stubBucket([
+            ...Array.from({ length: 10 }, (_, i) => `current/_use-cache/${i}.entry`),
+            "old/a.json",
+        ]);
+        await (0, prune_cache_bucket_1.pruneCacheBucket)({ bucketName: "cache", currentBuildId: "current" });
+        expect(sent(client_s3_1.ListObjectsV2Command).map(({ input }) => input.Delimiter ?? input.Prefix)).toEqual(["/", "old/"]);
+        expect(deletedKeys()).toEqual(["old/a.json"]);
+    });
+    // A huge old build must not run the Lambda into its timeout, which would
+    // leave CloudFormation waiting on the custom resource.
+    it("stops at its time budget and leaves the rest for the next deploy", async () => {
+        stubBucket(["old/a.json", "old/b.json", "old/c.json"], 1);
+        let clock = 0;
+        const nowSpy = jest.spyOn(Date, "now").mockImplementation(() => clock);
+        const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => { });
+        holder.send.mockImplementation(((stub) => (command) => {
+            if (command instanceof client_s3_1.DeleteObjectsCommand)
+                clock += 2 * 60_000;
+            return stub(command);
+        })(holder.send.getMockImplementation()));
+        await (0, prune_cache_bucket_1.pruneCacheBucket)({ bucketName: "cache", currentBuildId: "current" });
+        expect(deletedKeys()).toEqual(["old/a.json", "old/b.json"]);
+        expect(warnSpy).toHaveBeenCalled();
+        nowSpy.mockRestore();
+        warnSpy.mockRestore();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prune-cache-bucket.test.js","sourceRoot":"","sources":["../../../src/lambdas/post-deploy/prune-cache-bucket.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\n// Only the client is mocked, as in `prune-s3.test.ts`: `prune-cache-bucket`\n// constructs its client at module scope, before the mock variables exist.\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 { DeleteObjectsCommand, ListObjectsV2Command } from \"@aws-sdk/client-s3\";\nimport { pruneCacheBucket } from \"./prune-cache-bucket\";\n\nconst holder = { send: jest.fn() };\n\n/**\n * A fake bucket: ListObjectsV2 honours `Prefix` and `Delimiter`, and pages\n * `pageSize` keys at a time via the token `<offset>`; the last page carries no\n * NextContinuationToken, as S3 returns it.\n */\nfunction stubBucket(keys: string[], pageSize = 2): void {\n  holder.send.mockImplementation((command: unknown) => {\n    if (!(command instanceof ListObjectsV2Command)) return Promise.resolve({});\n    const { Prefix = \"\", Delimiter, ContinuationToken } = command.input;\n    const entries: { key?: string; prefix?: string }[] = [];\n    for (const key of keys.filter((k) => k.startsWith(Prefix))) {\n      const cut = Delimiter ? key.indexOf(Delimiter, Prefix.length) : -1;\n      if (cut < 0) {\n        entries.push({ key });\n      } else {\n        const prefix = key.slice(0, cut + 1);\n        if (!entries.some((entry) => entry.prefix === prefix)) {\n          entries.push({ prefix });\n        }\n      }\n    }\n    const offset = Number(ContinuationToken ?? 0);\n    const page = entries.slice(offset, offset + pageSize);\n    return Promise.resolve({\n      Contents: page.filter((e) => e.key).map((e) => ({ Key: e.key })),\n      CommonPrefixes: page\n        .filter((e) => e.prefix)\n        .map((e) => ({ Prefix: e.prefix })),\n      NextContinuationToken:\n        offset + pageSize < entries.length\n          ? String(offset + pageSize)\n          : undefined,\n    });\n  });\n}\n\nfunction sent<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 deletedKeys(): (string | undefined)[] {\n  return sent(DeleteObjectsCommand).flatMap((command) =>\n    command.input.Delete!.Objects!.map((object) => object.Key),\n  );\n}\n\ndescribe(\"pruneCacheBucket\", () => {\n  beforeEach(() => {\n    holder.send.mockReset();\n  });\n\n  it(\"deletes every old build prefix across pages, and loose keys\", async () => {\n    stubBucket([\n      \"current/a.json\",\n      \"current/_use-cache/1.entry\",\n      \"old1/a.json\",\n      \"old1/_use-cache/1.entry\",\n      \"old1/_use-cache/2.entry\",\n      \"old2/a.json\",\n      \"loose.json\",\n      \"/leading-slash.json\",\n    ]);\n\n    await pruneCacheBucket({ bucketName: \"cache\", currentBuildId: \"current\" });\n\n    expect(deletedKeys().sort()).toEqual(\n      [\n        \"/leading-slash.json\",\n        \"loose.json\",\n        \"old1/_use-cache/1.entry\",\n        \"old1/_use-cache/2.entry\",\n        \"old1/a.json\",\n        \"old2/a.json\",\n      ].sort(),\n    );\n  });\n\n  // The current build can hold unbounded 'use cache: remote' entries, so it\n  // must never be walked: the delimited top-level listing only names it.\n  it(\"never lists inside the current build\", async () => {\n    stubBucket([\n      ...Array.from({ length: 10 }, (_, i) => `current/_use-cache/${i}.entry`),\n      \"old/a.json\",\n    ]);\n\n    await pruneCacheBucket({ bucketName: \"cache\", currentBuildId: \"current\" });\n\n    expect(\n      sent(ListObjectsV2Command).map(\n        ({ input }) => input.Delimiter ?? input.Prefix,\n      ),\n    ).toEqual([\"/\", \"old/\"]);\n    expect(deletedKeys()).toEqual([\"old/a.json\"]);\n  });\n\n  // A huge old build must not run the Lambda into its timeout, which would\n  // leave CloudFormation waiting on the custom resource.\n  it(\"stops at its time budget and leaves the rest for the next deploy\", async () => {\n    stubBucket([\"old/a.json\", \"old/b.json\", \"old/c.json\"], 1);\n    let clock = 0;\n    const nowSpy = jest.spyOn(Date, \"now\").mockImplementation(() => clock);\n    const warnSpy = jest.spyOn(console, \"warn\").mockImplementation(() => {});\n    holder.send.mockImplementation(\n      ((stub) => (command: unknown) => {\n        if (command instanceof DeleteObjectsCommand) clock += 2 * 60_000;\n        return stub(command);\n      })(holder.send.getMockImplementation()!),\n    );\n\n    await pruneCacheBucket({ bucketName: \"cache\", currentBuildId: \"current\" });\n\n    expect(deletedKeys()).toEqual([\"old/a.json\", \"old/b.json\"]);\n    expect(warnSpy).toHaveBeenCalled();\n    nowSpy.mockRestore();\n    warnSpy.mockRestore();\n  });\n});\n"]}

package/lib/lambdas/post-deploy/prune-revalidation-table.d.ts

@@ -8,6 +8,7 @@ interface PruneRevalidationTableProps {
  *
  * Schema:
  * - Revalidation entries: pk=buildId, sk=tag#cacheKey
+ * - Revalidation log rows: pk=buildId#log, sk=timestamp#tag
  * - Metadata entry: pk="METADATA", sk="CURRENT_BUILD", buildId=currentBuildId
  */
 export declare function pruneRevalidationTable(props: PruneRevalidationTableProps): Promise<void>;

package/lib/lambdas/post-deploy/prune-revalidation-table.js

@@ -8,6 +8,7 @@ exports.pruneRevalidationTable = pruneRevalidationTable;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
 // eslint-disable-next-line import/no-extraneous-dependencies
 const debug_1 = __importDefault(require("debug"));
+const prune_s3_1 = require("./prune-s3");
 const debug = (0, debug_1.default)("cdk-nextjs:post-deploy:prune-revalidation-table");
 const dynamoClient = new client_dynamodb_1.DynamoDBClient();
 /**
@@ -16,6 +17,7 @@ const dynamoClient = new client_dynamodb_1.DynamoDBClient();
  *
  * Schema:
  * - Revalidation entries: pk=buildId, sk=tag#cacheKey
+ * - Revalidation log rows: pk=buildId#log, sk=timestamp#tag
  * - Metadata entry: pk="METADATA", sk="CURRENT_BUILD", buildId=currentBuildId
  */
 async function pruneRevalidationTable(props) {
@@ -47,21 +49,23 @@ async function pruneRevalidationTable(props) {
         return;
     }
     debug(`Pruning revalidation entries for previous build: ${previousBuildId}`);
-    // 2. Query all items for previous build ID (efficient partition query)
+    // 2. Query all items for previous build ID (efficient partition queries):
+    // its marker rows, and its revalidation log rows, which a table without TTL
+    // would otherwise keep forever.
     const itemsToDelete = [];
-    let lastEvaluatedKey = undefined;
-    do {
-        const queryCommand = new client_dynamodb_1.QueryCommand({
-            TableName: tableName,
-            KeyConditionExpression: "pk = :pk",
-            ExpressionAttributeValues: {
-                ":pk": { S: previousBuildId },
-            },
-            ExclusiveStartKey: lastEvaluatedKey,
-        });
-        const response = await dynamoClient.send(queryCommand);
-        if (response.Items && response.Items.length > 0) {
-            for (const item of response.Items) {
+    for (const pk of [previousBuildId, `${previousBuildId}#log`]) {
+        let lastEvaluatedKey = undefined;
+        do {
+            const queryCommand = new client_dynamodb_1.QueryCommand({
+                TableName: tableName,
+                KeyConditionExpression: "pk = :pk",
+                ExpressionAttributeValues: {
+                    ":pk": { S: pk },
+                },
+                ExclusiveStartKey: lastEvaluatedKey,
+            });
+            const response = await dynamoClient.send(queryCommand);
+            for (const item of response.Items ?? []) {
                 if (item.pk?.S && item.sk?.S) {
                     itemsToDelete.push({
                         pk: { S: item.pk.S },
@@ -69,9 +73,9 @@ async function pruneRevalidationTable(props) {
                     });
                 }
             }
-        }
-        lastEvaluatedKey = response.LastEvaluatedKey;
-    } while (lastEvaluatedKey);
+            lastEvaluatedKey = response.LastEvaluatedKey;
+        } while (lastEvaluatedKey);
+    }
     debug(`Found ${itemsToDelete.length} revalidation entries to delete for build ${previousBuildId}`);
     // 3. Delete items in batches (respecting DynamoDB's 25 items per batch limit)
     if (itemsToDelete.length > 0) {
@@ -80,7 +84,7 @@ async function pruneRevalidationTable(props) {
             const batch = itemsToDelete.slice(i, i + 25);
             deleteBatches.push(batch);
         }
-        await processBatch(deleteBatches, 5, // Process up to 5 delete batches in parallel
+        await (0, prune_s3_1.processBatch)(deleteBatches, 5, // Process up to 5 delete batches in parallel
         async (batch) => {
             try {
                 const deleteRequests = batch.map((item) => ({
@@ -121,16 +125,4 @@ async function updateMetadata(tableName, currentBuildId) {
     await dynamoClient.send(putCommand);
     debug(`Updated metadata with current build ID: ${currentBuildId}`);
 }
-/**
- * Process items in batches to avoid overwhelming the system
- */
-async function processBatch(items, batchSize, processFn) {
-    const results = [];
-    for (let i = 0; i < items.length; i += batchSize) {
-        const batch = items.slice(i, i + batchSize);
-        const batchResults = await Promise.all(batch.map(processFn));
-        results.push(...batchResults);
-    }
-    return results;
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prune-revalidation-table.js","sourceRoot":"","sources":["../../../src/lambdas/post-deploy/prune-revalidation-table.ts"],"names":[],"mappings":"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","sourcesContent":["// eslint-disable-next-line import/no-extraneous-dependencies\nimport {\n  DynamoDBClient,\n  QueryCommand,\n  GetItemCommand,\n  PutItemCommand,\n  BatchWriteItemCommand,\n} from \"@aws-sdk/client-dynamodb\";\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport getDebug from \"debug\";\n\nconst debug = getDebug(\"cdk-nextjs:post-deploy:prune-revalidation-table\");\n\nconst dynamoClient = new DynamoDBClient();\n\ninterface PruneRevalidationTableProps {\n  tableName: string;\n  currentBuildId: string;\n}\n\n/**\n * Given `tableName` and `currentBuildId`, query the previous build's revalidation entries\n * and delete them efficiently. Uses metadata entry to track current build ID.\n *\n * Schema:\n * - Revalidation entries: pk=buildId, sk=tag#cacheKey\n * - Metadata entry: pk=\"METADATA\", sk=\"CURRENT_BUILD\", buildId=currentBuildId\n */\nexport async function pruneRevalidationTable(\n  props: PruneRevalidationTableProps,\n) {\n  const { tableName, currentBuildId } = props;\n\n  // 1. Read metadata to get previous build ID\n  const getCommand = new GetItemCommand({\n    TableName: tableName,\n    Key: {\n      pk: { S: \"METADATA\" },\n      sk: { S: \"CURRENT_BUILD\" },\n    },\n  });\n\n  let previousBuildId: string | undefined;\n  try {\n    const metadataResponse = await dynamoClient.send(getCommand);\n    previousBuildId = metadataResponse.Item?.buildId?.S;\n  } catch (error) {\n    debug(\"No metadata entry found, this may be the first deployment\");\n  }\n\n  if (!previousBuildId) {\n    debug(\"No previous build to prune\");\n    // Update metadata with current build ID for next deployment\n    await updateMetadata(tableName, currentBuildId);\n    return;\n  }\n\n  if (previousBuildId === currentBuildId) {\n    debug(\n      `Previous build ID matches current build ID (${currentBuildId}), nothing to prune`,\n    );\n    return;\n  }\n\n  debug(`Pruning revalidation entries for previous build: ${previousBuildId}`);\n\n  // 2. Query all items for previous build ID (efficient partition query)\n  const itemsToDelete: Array<{ pk: { S: string }; sk: { S: string } }> = [];\n  let lastEvaluatedKey: Record<string, any> | undefined = undefined;\n\n  do {\n    const queryCommand: QueryCommand = new QueryCommand({\n      TableName: tableName,\n      KeyConditionExpression: \"pk = :pk\",\n      ExpressionAttributeValues: {\n        \":pk\": { S: previousBuildId },\n      },\n      ExclusiveStartKey: lastEvaluatedKey,\n    });\n\n    const response = await dynamoClient.send(queryCommand);\n\n    if (response.Items && response.Items.length > 0) {\n      for (const item of response.Items) {\n        if (item.pk?.S && item.sk?.S) {\n          itemsToDelete.push({\n            pk: { S: item.pk.S },\n            sk: { S: item.sk.S },\n          });\n        }\n      }\n    }\n\n    lastEvaluatedKey = response.LastEvaluatedKey;\n  } while (lastEvaluatedKey);\n\n  debug(\n    `Found ${itemsToDelete.length} revalidation entries to delete for build ${previousBuildId}`,\n  );\n\n  // 3. Delete items in batches (respecting DynamoDB's 25 items per batch limit)\n  if (itemsToDelete.length > 0) {\n    const deleteBatches = [];\n\n    for (let i = 0; i < itemsToDelete.length; i += 25) {\n      const batch = itemsToDelete.slice(i, i + 25);\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          const deleteRequests = batch.map((item) => ({\n            DeleteRequest: {\n              Key: item,\n            },\n          }));\n\n          debug(\n            `Deleting revalidation entries: ${batch.map((b) => `${b.pk.S}/${b.sk.S}`).join(\", \")} from ${tableName}`,\n          );\n\n          await dynamoClient.send(\n            new BatchWriteItemCommand({\n              RequestItems: {\n                [tableName]: deleteRequests,\n              },\n            }),\n          );\n\n          debug(\n            `Deleted ${batch.length} revalidation entries from ${tableName}`,\n          );\n        } catch (error) {\n          console.error(\"Error deleting revalidation entries:\", error);\n        }\n      },\n    );\n  }\n\n  // 4. Update metadata with new build ID\n  await updateMetadata(tableName, currentBuildId);\n\n  debug(\n    `Revalidation table pruning complete. Deleted ${itemsToDelete.length} entries from ${tableName}`,\n  );\n}\n\n/**\n * Update the metadata entry with the current build ID\n */\nasync function updateMetadata(\n  tableName: string,\n  currentBuildId: string,\n): Promise<void> {\n  const putCommand = new PutItemCommand({\n    TableName: tableName,\n    Item: {\n      pk: { S: \"METADATA\" },\n      sk: { S: \"CURRENT_BUILD\" },\n      buildId: { S: currentBuildId },\n      updatedAt: { N: Date.now().toString() },\n    },\n  });\n\n  await dynamoClient.send(putCommand);\n  debug(`Updated metadata with current build ID: ${currentBuildId}`);\n}\n\n/**\n * Process items 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-revalidation-table.js","sourceRoot":"","sources":["../../../src/lambdas/post-deploy/prune-revalidation-table.ts"],"names":[],"mappings":"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","sourcesContent":["// eslint-disable-next-line import/no-extraneous-dependencies\nimport {\n  DynamoDBClient,\n  QueryCommand,\n  GetItemCommand,\n  PutItemCommand,\n  BatchWriteItemCommand,\n} from \"@aws-sdk/client-dynamodb\";\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport getDebug from \"debug\";\nimport { processBatch } from \"./prune-s3\";\n\nconst debug = getDebug(\"cdk-nextjs:post-deploy:prune-revalidation-table\");\n\nconst dynamoClient = new DynamoDBClient();\n\ninterface PruneRevalidationTableProps {\n  tableName: string;\n  currentBuildId: string;\n}\n\n/**\n * Given `tableName` and `currentBuildId`, query the previous build's revalidation entries\n * and delete them efficiently. Uses metadata entry to track current build ID.\n *\n * Schema:\n * - Revalidation entries: pk=buildId, sk=tag#cacheKey\n * - Revalidation log rows: pk=buildId#log, sk=timestamp#tag\n * - Metadata entry: pk=\"METADATA\", sk=\"CURRENT_BUILD\", buildId=currentBuildId\n */\nexport async function pruneRevalidationTable(\n  props: PruneRevalidationTableProps,\n) {\n  const { tableName, currentBuildId } = props;\n\n  // 1. Read metadata to get previous build ID\n  const getCommand = new GetItemCommand({\n    TableName: tableName,\n    Key: {\n      pk: { S: \"METADATA\" },\n      sk: { S: \"CURRENT_BUILD\" },\n    },\n  });\n\n  let previousBuildId: string | undefined;\n  try {\n    const metadataResponse = await dynamoClient.send(getCommand);\n    previousBuildId = metadataResponse.Item?.buildId?.S;\n  } catch (error) {\n    debug(\"No metadata entry found, this may be the first deployment\");\n  }\n\n  if (!previousBuildId) {\n    debug(\"No previous build to prune\");\n    // Update metadata with current build ID for next deployment\n    await updateMetadata(tableName, currentBuildId);\n    return;\n  }\n\n  if (previousBuildId === currentBuildId) {\n    debug(\n      `Previous build ID matches current build ID (${currentBuildId}), nothing to prune`,\n    );\n    return;\n  }\n\n  debug(`Pruning revalidation entries for previous build: ${previousBuildId}`);\n\n  // 2. Query all items for previous build ID (efficient partition queries):\n  // its marker rows, and its revalidation log rows, which a table without TTL\n  // would otherwise keep forever.\n  const itemsToDelete: Array<{ pk: { S: string }; sk: { S: string } }> = [];\n\n  for (const pk of [previousBuildId, `${previousBuildId}#log`]) {\n    let lastEvaluatedKey: Record<string, any> | undefined = undefined;\n    do {\n      const queryCommand: QueryCommand = new QueryCommand({\n        TableName: tableName,\n        KeyConditionExpression: \"pk = :pk\",\n        ExpressionAttributeValues: {\n          \":pk\": { S: pk },\n        },\n        ExclusiveStartKey: lastEvaluatedKey,\n      });\n\n      const response = await dynamoClient.send(queryCommand);\n\n      for (const item of response.Items ?? []) {\n        if (item.pk?.S && item.sk?.S) {\n          itemsToDelete.push({\n            pk: { S: item.pk.S },\n            sk: { S: item.sk.S },\n          });\n        }\n      }\n\n      lastEvaluatedKey = response.LastEvaluatedKey;\n    } while (lastEvaluatedKey);\n  }\n\n  debug(\n    `Found ${itemsToDelete.length} revalidation entries to delete for build ${previousBuildId}`,\n  );\n\n  // 3. Delete items in batches (respecting DynamoDB's 25 items per batch limit)\n  if (itemsToDelete.length > 0) {\n    const deleteBatches = [];\n\n    for (let i = 0; i < itemsToDelete.length; i += 25) {\n      const batch = itemsToDelete.slice(i, i + 25);\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          const deleteRequests = batch.map((item) => ({\n            DeleteRequest: {\n              Key: item,\n            },\n          }));\n\n          debug(\n            `Deleting revalidation entries: ${batch.map((b) => `${b.pk.S}/${b.sk.S}`).join(\", \")} from ${tableName}`,\n          );\n\n          await dynamoClient.send(\n            new BatchWriteItemCommand({\n              RequestItems: {\n                [tableName]: deleteRequests,\n              },\n            }),\n          );\n\n          debug(\n            `Deleted ${batch.length} revalidation entries from ${tableName}`,\n          );\n        } catch (error) {\n          console.error(\"Error deleting revalidation entries:\", error);\n        }\n      },\n    );\n  }\n\n  // 4. Update metadata with new build ID\n  await updateMetadata(tableName, currentBuildId);\n\n  debug(\n    `Revalidation table pruning complete. Deleted ${itemsToDelete.length} entries from ${tableName}`,\n  );\n}\n\n/**\n * Update the metadata entry with the current build ID\n */\nasync function updateMetadata(\n  tableName: string,\n  currentBuildId: string,\n): Promise<void> {\n  const putCommand = new PutItemCommand({\n    TableName: tableName,\n    Item: {\n      pk: { S: \"METADATA\" },\n      sk: { S: \"CURRENT_BUILD\" },\n      buildId: { S: currentBuildId },\n      updatedAt: { N: Date.now().toString() },\n    },\n  });\n\n  await dynamoClient.send(putCommand);\n  debug(`Updated metadata with current build ID: ${currentBuildId}`);\n}\n"]}

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

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

package/lib/lambdas/post-deploy/prune-revalidation-table.test.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+// Only the client is mocked, as in `prune-cache-bucket.test.ts`: the module
+// constructs its client at module scope, before the mock variables exist.
+jest.mock("@aws-sdk/client-dynamodb", () => ({
+    ...jest.requireActual("@aws-sdk/client-dynamodb"),
+    DynamoDBClient: jest.fn(() => ({
+        send: (...args) => holder.send(...args),
+    })),
+}));
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const prune_revalidation_table_1 = require("./prune-revalidation-table");
+const holder = { send: jest.fn() };
+/**
+ * A fake table whose metadata names `previousBuildId`; each Query pages
+ * `pageSize` rows at a time of the partition asked for.
+ */
+function stubTable(previousBuildId, rows, pageSize = 2) {
+    holder.send.mockImplementation((command) => {
+        if (command instanceof client_dynamodb_1.GetItemCommand) {
+            return Promise.resolve({ Item: { buildId: { S: previousBuildId } } });
+        }
+        if (command instanceof client_dynamodb_1.QueryCommand) {
+            const pk = command.input.ExpressionAttributeValues[":pk"].S;
+            const offset = Number(command.input.ExclusiveStartKey?.offset.N ?? 0);
+            const sks = rows[pk] ?? [];
+            return Promise.resolve({
+                Items: sks
+                    .slice(offset, offset + pageSize)
+                    .map((sk) => ({ pk: { S: pk }, sk: { S: sk } })),
+                LastEvaluatedKey: offset + pageSize < sks.length
+                    ? { offset: { N: String(offset + pageSize) } }
+                    : undefined,
+            });
+        }
+        return Promise.resolve({});
+    });
+}
+function sent(type) {
+    return holder.send.mock.calls
+        .map(([command]) => command)
+        .filter((command) => command instanceof type);
+}
+describe("pruneRevalidationTable", () => {
+    beforeEach(() => {
+        holder.send.mockReset();
+    });
+    it("deletes the previous build's marker and log rows, then records the current build", async () => {
+        stubTable("old", {
+            old: ["tag-a", "tag-b", "tag-c"],
+            "old#log": ["000000000000001#tag-a", "000000000000002#tag-b"],
+            current: ["tag-a"],
+            "current#log": ["000000000000003#tag-a"],
+        });
+        await (0, prune_revalidation_table_1.pruneRevalidationTable)({
+            tableName: "table",
+            currentBuildId: "current",
+        });
+        const deleted = sent(client_dynamodb_1.BatchWriteItemCommand).flatMap((command) => command.input.RequestItems.table.map((request) => `${request.DeleteRequest.Key.pk.S}/${request.DeleteRequest.Key.sk.S}`));
+        expect(deleted.sort()).toEqual([
+            "old/tag-a",
+            "old/tag-b",
+            "old/tag-c",
+            "old#log/000000000000001#tag-a",
+            "old#log/000000000000002#tag-b",
+        ].sort());
+        expect(sent(client_dynamodb_1.PutItemCommand)[0].input.Item.buildId.S).toBe("current");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -7,16 +7,25 @@ interface PruneS3Props {
     msTtl: number;
     /**
      * S3 key prefix the app's static assets live under. Surrounding slashes are
-     * normalized away. Scopes pruning to this app's objects so that apps or
-     * branches sharing one bucket under different `basePath`s don't delete each
-     * other's assets. Empty or omitted prunes the whole bucket.
+     * normalized away. Scopes pruning to this app's `_next/` objects so that apps
+     * or branches sharing one bucket under different `basePath`s don't delete
+     * each other's assets. Empty or omitted prunes `_next/` at the bucket root.
      */
     keyPrefix?: string;
 }
 /**
  * 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.
  */
 export declare function pruneS3(props: PruneS3Props): Promise<void>;
+/**
+ * Process objects in batches to avoid overwhelming the system
+ */
+export declare function processBatch<T, R>(items: T[], batchSize: number, processFn: (item: T) => Promise<R>): Promise<R[]>;
 export {};