cdk-nextjs 0.6.1 → 0.6.2

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

@@ -13,12 +13,20 @@ const s3Client = new client_s3_1.S3Client();
 // Maximum number of concurrent operations
 const MAX_CONCURRENT_OPERATIONS = 50;
 /**
- * Given `bucketName`, `currentBuildId`, and `msTtl`, list all objects
- * in the bucket and delete any that 1/ do not have a metadata key of "next-build-id"
+ * 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
  */
 async function pruneS3(props) {
-    const { bucketName, currentBuildId, msTtl } = props;
+    const { bucketName, currentBuildId, msTtl, keyPrefix } = props;
+    // Surrounding slashes are stripped before use: `NextjsStaticAssets` hands over
+    // a bare prefix, but `overrides.customResourceProperties` lets a user set
+    // `staticAssetsKeyPrefix` directly, and "base/" or "/base" would build a
+    // Prefix ("base//", "/base/") that matches no key at all — pruning would
+    // silently become a no-op.
+    const bare = (keyPrefix || "").replace(/^\/+/, "").replace(/\/+$/, "");
+    // Trailing slash so a prefix of "app" doesn't also match "app-staging/...".
+    const prefix = bare ? `${bare}/` : undefined;
     const cutoffDate = new Date(Date.now() - msTtl);
     const objectsToDelete = [];
     let continuationToken = undefined;
@@ -28,6 +36,7 @@ async function pruneS3(props) {
         const listObjectsV2Input = {
             Bucket: bucketName,
             ContinuationToken: continuationToken,
+            Prefix: prefix,
         };
         const listResponse = await s3Client.send(new client_s3_1.ListObjectsV2Command(listObjectsV2Input));
         if (!listResponse.Contents || listResponse.Contents.length === 0) {
@@ -61,9 +70,10 @@ async function pruneS3(props) {
         });
         // Add valid objects to delete list
         objectsToDelete.push(...checkResults.filter(Boolean));
-        if (listResponse.NextContinuationToken) {
-            continuationToken = listResponse.NextContinuationToken;
-        }
+        // Assigned unconditionally: the last page carries no NextContinuationToken,
+        // and keeping the previous page's token would re-list that same page until
+        // the guard below trips, re-checking every object on it 100 times over.
+        continuationToken = listResponse.NextContinuationToken;
         listObjectsCount++;
         // assume less than 100K objects (100 * 1K objects per ListObjectsV2Command = 100K)
     } while (continuationToken && listObjectsCount <= 100);
@@ -103,4 +113,4 @@ async function processBatch(items, batchSize, processFn) {
     }
     return results;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prune-s3.js","sourceRoot":"","sources":["../../../src/lambdas/post-deploy/prune-s3.ts"],"names":[],"mappings":"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","sourcesContent":["// eslint-disable-next-line import/no-extraneous-dependencies\nimport {\n  S3Client,\n  ListObjectsV2Command,\n  DeleteObjectsCommand,\n  HeadObjectCommand,\n  ListObjectsV2CommandInput,\n} from \"@aws-sdk/client-s3\";\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport getDebug from \"debug\";\n\nconst debug = getDebug(\"cdk-nextjs:post-deploy:prune-s3\");\n\nconst s3Client = new S3Client();\n// Maximum number of concurrent operations\nconst MAX_CONCURRENT_OPERATIONS = 50;\n\ninterface PruneS3Props {\n  bucketName: string;\n  currentBuildId: string;\n  /**\n   * Time to live in milliseconds.\n   */\n  msTtl: number;\n}\n\n/**\n * Given `bucketName`, `currentBuildId`, and `msTtl`, list all objects\n * in the bucket and delete any that 1/ do not have a metadata key of \"next-build-id\"\n * and value of `currentBuildId` and 2/ were created more than `msTtl` ago\n */\nexport async function pruneS3(props: PruneS3Props) {\n  const { bucketName, currentBuildId, msTtl } = props;\n\n  const cutoffDate = new Date(Date.now() - msTtl);\n  const objectsToDelete: { Key: string }[] = [];\n\n  let continuationToken: string | undefined = undefined;\n  let listObjectsCount = 0;\n\n  do {\n    // List objects in the bucket\n    const listObjectsV2Input: ListObjectsV2CommandInput = {\n      Bucket: bucketName,\n      ContinuationToken: continuationToken,\n    };\n    const listResponse = await s3Client.send(\n      new ListObjectsV2Command(listObjectsV2Input),\n    );\n\n    if (!listResponse.Contents || listResponse.Contents.length === 0) {\n      break;\n    }\n\n    // Filter out objects without keys\n    const oldObjects = listResponse.Contents.filter((obj) => {\n      const lastModified = obj.LastModified || new Date();\n      return obj.Key && lastModified < cutoffDate;\n    });\n    debug(\n      `Checking old objects metadata to determine pruning: ${oldObjects.map((o) => o.Key)}`,\n    );\n\n    // Process objects in parallel with controlled concurrency\n    const checkResults = await processBatch(\n      oldObjects,\n      MAX_CONCURRENT_OPERATIONS,\n      async (object) => {\n        if (!object.Key) return null;\n\n        try {\n          const headResponse = await s3Client.send(\n            new HeadObjectCommand({\n              Bucket: bucketName,\n              Key: object.Key,\n            }),\n          );\n\n          const objectBuildId = headResponse.Metadata?.[\"next-build-id\"];\n\n          // Return the key if it should be deleted\n          if (objectBuildId !== currentBuildId) {\n            return { Key: object.Key };\n          }\n        } catch (error) {\n          console.error(`Error checking object ${object.Key}:`, error);\n        }\n\n        return null;\n      },\n    );\n\n    // Add valid objects to delete list\n    objectsToDelete.push(\n      ...(checkResults.filter(Boolean) as { Key: string }[]),\n    );\n\n    if (listResponse.NextContinuationToken) {\n      continuationToken = listResponse.NextContinuationToken;\n    }\n    listObjectsCount++;\n    // assume less than 100K objects (100 * 1K objects per ListObjectsV2Command = 100K)\n  } while (continuationToken && listObjectsCount <= 100);\n\n  // Delete objects in parallel batches (respecting S3's 1000 objects per request limit)\n  if (objectsToDelete.length > 0) {\n    const deleteBatches = [];\n\n    for (let i = 0; i < objectsToDelete.length; i += 1000) {\n      const batch = objectsToDelete.slice(i, i + 1000);\n      deleteBatches.push(batch);\n    }\n\n    await processBatch(\n      deleteBatches,\n      5, // Process up to 5 delete batches in parallel\n      async (batch) => {\n        try {\n          debug(\n            `Deleting objects: ${batch.map((b) => b.Key)} from ${bucketName}`,\n          );\n          await s3Client.send(\n            new DeleteObjectsCommand({\n              Bucket: bucketName,\n              Delete: { Objects: batch },\n            }),\n          );\n          debug(`Deleted ${batch.length} objects from ${bucketName}`);\n        } catch (error) {\n          console.error(\"Error deleting objects:\", error);\n        }\n      },\n    );\n  }\n\n  debug(\n    `Pruning complete. Deleted ${objectsToDelete.length} objects from ${bucketName}`,\n  );\n}\n\n/**\n * Process objects in batches to avoid overwhelming the system\n */\nasync function processBatch<T, R>(\n  items: T[],\n  batchSize: number,\n  processFn: (item: T) => Promise<R>,\n): Promise<R[]> {\n  const results: R[] = [];\n\n  for (let i = 0; i < items.length; i += batchSize) {\n    const batch = items.slice(i, i + batchSize);\n    const batchResults = await Promise.all(batch.map(processFn));\n    results.push(...batchResults);\n  }\n\n  return results;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prune-s3.js","sourceRoot":"","sources":["../../../src/lambdas/post-deploy/prune-s3.ts"],"names":[],"mappings":";;;;;AAsCA,0BAqHC;AA3JD,6DAA6D;AAC7D,kDAM4B;AAC5B,6DAA6D;AAC7D,kDAA6B;AAE7B,MAAM,KAAK,GAAG,IAAA,eAAQ,EAAC,iCAAiC,CAAC,CAAC;AAE1D,MAAM,QAAQ,GAAG,IAAI,oBAAQ,EAAE,CAAC;AAChC,0CAA0C;AAC1C,MAAM,yBAAyB,GAAG,EAAE,CAAC;AAkBrC;;;;GAIG;AACI,KAAK,UAAU,OAAO,CAAC,KAAmB;IAC/C,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,KAAK,CAAC;IAC/D,+EAA+E;IAC/E,0EAA0E;IAC1E,yEAAyE;IACzE,yEAAyE;IACzE,2BAA2B;IAC3B,MAAM,IAAI,GAAG,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IACvE,4EAA4E;IAC5E,MAAM,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;IAE7C,MAAM,UAAU,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC;IAChD,MAAM,eAAe,GAAsB,EAAE,CAAC;IAE9C,IAAI,iBAAiB,GAAuB,SAAS,CAAC;IACtD,IAAI,gBAAgB,GAAG,CAAC,CAAC;IAEzB,GAAG,CAAC;QACF,6BAA6B;QAC7B,MAAM,kBAAkB,GAA8B;YACpD,MAAM,EAAE,UAAU;YAClB,iBAAiB,EAAE,iBAAiB;YACpC,MAAM,EAAE,MAAM;SACf,CAAC;QACF,MAAM,YAAY,GAAG,MAAM,QAAQ,CAAC,IAAI,CACtC,IAAI,gCAAoB,CAAC,kBAAkB,CAAC,CAC7C,CAAC;QAEF,IAAI,CAAC,YAAY,CAAC,QAAQ,IAAI,YAAY,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACjE,MAAM;QACR,CAAC;QAED,kCAAkC;QAClC,MAAM,UAAU,GAAG,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE;YACtD,MAAM,YAAY,GAAG,GAAG,CAAC,YAAY,IAAI,IAAI,IAAI,EAAE,CAAC;YACpD,OAAO,GAAG,CAAC,GAAG,IAAI,YAAY,GAAG,UAAU,CAAC;QAC9C,CAAC,CAAC,CAAC;QACH,KAAK,CACH,uDAAuD,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CACtF,CAAC;QAEF,0DAA0D;QAC1D,MAAM,YAAY,GAAG,MAAM,YAAY,CACrC,UAAU,EACV,yBAAyB,EACzB,KAAK,EAAE,MAAM,EAAE,EAAE;YACf,IAAI,CAAC,MAAM,CAAC,GAAG;gBAAE,OAAO,IAAI,CAAC;YAE7B,IAAI,CAAC;gBACH,MAAM,YAAY,GAAG,MAAM,QAAQ,CAAC,IAAI,CACtC,IAAI,6BAAiB,CAAC;oBACpB,MAAM,EAAE,UAAU;oBAClB,GAAG,EAAE,MAAM,CAAC,GAAG;iBAChB,CAAC,CACH,CAAC;gBAEF,MAAM,aAAa,GAAG,YAAY,CAAC,QAAQ,EAAE,CAAC,eAAe,CAAC,CAAC;gBAE/D,yCAAyC;gBACzC,IAAI,aAAa,KAAK,cAAc,EAAE,CAAC;oBACrC,OAAO,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC;gBAC7B,CAAC;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,OAAO,CAAC,KAAK,CAAC,yBAAyB,MAAM,CAAC,GAAG,GAAG,EAAE,KAAK,CAAC,CAAC;YAC/D,CAAC;YAED,OAAO,IAAI,CAAC;QACd,CAAC,CACF,CAAC;QAEF,mCAAmC;QACnC,eAAe,CAAC,IAAI,CAClB,GAAI,YAAY,CAAC,MAAM,CAAC,OAAO,CAAuB,CACvD,CAAC;QAEF,4EAA4E;QAC5E,2EAA2E;QAC3E,wEAAwE;QACxE,iBAAiB,GAAG,YAAY,CAAC,qBAAqB,CAAC;QACvD,gBAAgB,EAAE,CAAC;QACnB,mFAAmF;IACrF,CAAC,QAAQ,iBAAiB,IAAI,gBAAgB,IAAI,GAAG,EAAE;IAEvD,sFAAsF;IACtF,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC/B,MAAM,aAAa,GAAG,EAAE,CAAC;QAEzB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,eAAe,CAAC,MAAM,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC;YACtD,MAAM,KAAK,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;YACjD,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC;QAED,MAAM,YAAY,CAChB,aAAa,EACb,CAAC,EAAE,6CAA6C;QAChD,KAAK,EAAE,KAAK,EAAE,EAAE;YACd,IAAI,CAAC;gBACH,KAAK,CACH,qBAAqB,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,UAAU,EAAE,CAClE,CAAC;gBACF,MAAM,QAAQ,CAAC,IAAI,CACjB,IAAI,gCAAoB,CAAC;oBACvB,MAAM,EAAE,UAAU;oBAClB,MAAM,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;iBAC3B,CAAC,CACH,CAAC;gBACF,KAAK,CAAC,WAAW,KAAK,CAAC,MAAM,iBAAiB,UAAU,EAAE,CAAC,CAAC;YAC9D,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,OAAO,CAAC,KAAK,CAAC,yBAAyB,EAAE,KAAK,CAAC,CAAC;YAClD,CAAC;QACH,CAAC,CACF,CAAC;IACJ,CAAC;IAED,KAAK,CACH,6BAA6B,eAAe,CAAC,MAAM,iBAAiB,UAAU,EAAE,CACjF,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,YAAY,CACzB,KAAU,EACV,SAAiB,EACjB,SAAkC;IAElC,MAAM,OAAO,GAAQ,EAAE,CAAC;IAExB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,SAAS,EAAE,CAAC;QACjD,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC;QAC5C,MAAM,YAAY,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;QAC7D,OAAO,CAAC,IAAI,CAAC,GAAG,YAAY,CAAC,CAAC;IAChC,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC","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"]}

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

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

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

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+// Only the client is mocked; the command classes stay real so that assertions
+// can read `command.input`. `send` is looked up through the holder at call time
+// because `prune-s3` constructs its client at module scope, before the mock
+// variables here are initialized.
+jest.mock("@aws-sdk/client-s3", () => ({
+    ...jest.requireActual("@aws-sdk/client-s3"),
+    S3Client: jest.fn(() => ({
+        send: (...args) => holder.send(...args),
+    })),
+}));
+const client_s3_1 = require("@aws-sdk/client-s3");
+const prune_s3_1 = require("./prune-s3");
+const holder = { send: jest.fn() };
+const BUCKET = "my-static-assets";
+const CURRENT_BUILD_ID = "build-2";
+const MS_TTL = 1000 * 60 * 60 * 24 * 30;
+/**
+ * One page of listed objects, all old enough to prune and each carrying a stale
+ * build id, so every one of them is a deletion candidate. That isolates the
+ * question this suite is about: which keys `pruneS3` was ever shown.
+ */
+function stubBucketContents(keys, buildId = "build-1") {
+    const longAgo = new Date(Date.now() - MS_TTL * 2);
+    holder.send.mockImplementation((command) => {
+        if (command instanceof client_s3_1.ListObjectsV2Command) {
+            return Promise.resolve({
+                Contents: keys.map((Key) => ({ Key, LastModified: longAgo })),
+            });
+        }
+        if (command instanceof client_s3_1.DeleteObjectsCommand) {
+            return Promise.resolve({});
+        }
+        // HeadObject
+        return Promise.resolve({ Metadata: { "next-build-id": buildId } });
+    });
+}
+/**
+ * Several pages of listed objects, keyed by the continuation token that asks for
+ * each one, so the suite can assert how `pruneS3` walks a paginated listing. The
+ * last page deliberately carries no NextContinuationToken, as S3 returns it.
+ */
+function stubPagedBucketContents(pages) {
+    const longAgo = new Date(Date.now() - MS_TTL * 2);
+    holder.send.mockImplementation((command) => {
+        if (command instanceof client_s3_1.ListObjectsV2Command) {
+            const token = command.input.ContinuationToken;
+            const index = token ? Number(token.replace("page-", "")) : 0;
+            return Promise.resolve({
+                Contents: (pages[index] ?? []).map((Key) => ({
+                    Key,
+                    LastModified: longAgo,
+                })),
+                NextContinuationToken: index + 1 < pages.length ? `page-${index + 1}` : undefined,
+            });
+        }
+        if (command instanceof client_s3_1.DeleteObjectsCommand) {
+            return Promise.resolve({});
+        }
+        // HeadObject
+        return Promise.resolve({ Metadata: { "next-build-id": "build-1" } });
+    });
+}
+function sentCommands(type) {
+    return holder.send.mock.calls
+        .map(([command]) => command)
+        .filter((command) => command instanceof type);
+}
+function listPrefixes() {
+    return sentCommands(client_s3_1.ListObjectsV2Command).map((command) => command.input.Prefix);
+}
+function deletedKeys() {
+    return sentCommands(client_s3_1.DeleteObjectsCommand).flatMap((command) => (command.input.Delete?.Objects ?? []).map((o) => o.Key));
+}
+function prune(keyPrefix) {
+    return (0, prune_s3_1.pruneS3)({
+        bucketName: BUCKET,
+        currentBuildId: CURRENT_BUILD_ID,
+        msTtl: MS_TTL,
+        keyPrefix,
+    });
+}
+describe("pruneS3", () => {
+    beforeEach(() => {
+        holder.send.mockReset();
+    });
+    // Without a Prefix, pruning walks the whole bucket. Two branches sharing one
+    // bucket under different basePaths would then delete each other's assets once
+    // they aged past msTtl, 404ing the other branch.
+    it("scopes the listing to the key prefix", async () => {
+        stubBucketContents(["branch-a/_next/static/old.js"]);
+        await prune("branch-a");
+        expect(listPrefixes()).toEqual(["branch-a/"]);
+    });
+    // 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([]);
+        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/"]);
+    });
+    it("takes a nested prefix as NextjsStaticAssets resolved it", async () => {
+        stubBucketContents([]);
+        await prune("team/app");
+        expect(listPrefixes()).toEqual(["team/app/"]);
+    });
+    // The single-app case, and every deployment predating the prefix being
+    // threaded through: an unset prefix still prunes the whole bucket.
+    it.each([
+        ["omitted", undefined],
+        ["empty", ""],
+    ])("lists the whole bucket when the prefix is %s", async (_label, prefix) => {
+        stubBucketContents([]);
+        await prune(prefix);
+        expect(listPrefixes()).toEqual([undefined]);
+    });
+    it("still deletes stale objects within the prefix", async () => {
+        stubBucketContents([
+            "branch-a/_next/static/old.js",
+            "branch-a/favicon.ico",
+        ]);
+        await prune("branch-a");
+        expect(deletedKeys().sort()).toEqual([
+            "branch-a/_next/static/old.js",
+            "branch-a/favicon.ico",
+        ]);
+    });
+    it("keeps objects carrying the current build id", async () => {
+        stubBucketContents(["branch-a/current.js"], CURRENT_BUILD_ID);
+        await prune("branch-a");
+        expect(deletedKeys()).toEqual([]);
+    });
+    // The construct always hands over a bare prefix, but
+    // `overrides.customResourceProperties.staticAssetsKeyPrefix` reaches this
+    // directly. "base/" would build a Prefix of "base//" and "/base" one of
+    // "/base/", neither of which matches any key, so pruning would silently stop
+    // deleting anything at all.
+    it.each([
+        ["a trailing slash", "branch-a/"],
+        ["a leading slash", "/branch-a"],
+        ["both", "/branch-a/"],
+    ])("normalizes a prefix given with %s", async (_label, prefix) => {
+        stubBucketContents([]);
+        await prune(prefix);
+        expect(listPrefixes()).toEqual(["branch-a/"]);
+    });
+    describe("pagination", () => {
+        it("follows the continuation token across pages", async () => {
+            stubPagedBucketContents([["a/one.js"], ["a/two.js"], ["a/three.js"]]);
+            await prune("a");
+            expect(sentCommands(client_s3_1.ListObjectsV2Command).map((command) => command.input.ContinuationToken)).toEqual([undefined, "page-1", "page-2"]);
+            expect(deletedKeys().sort()).toEqual([
+                "a/one.js",
+                "a/three.js",
+                "a/two.js",
+            ]);
+        });
+        // The last page carries no NextContinuationToken. Holding on to the previous
+        // page's token re-lists that page until the 100-iteration guard trips,
+        // re-HEADing every object on it 100 times over (~100k requests for a full
+        // 1000-key page) and pushing duplicate keys into the delete batches — enough
+        // to blow the post-deploy Lambda's timeout, which leaves the custom resource
+        // waiting on a response that never comes.
+        it("stops listing once a page returns no continuation token", async () => {
+            stubPagedBucketContents([["a/one.js"], ["a/two.js"]]);
+            await prune("a");
+            expect(sentCommands(client_s3_1.ListObjectsV2Command)).toHaveLength(2);
+            expect(deletedKeys()).toEqual(["a/one.js", "a/two.js"]);
+        });
+    });
+});
+//# 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"]}

package/lib/nextjs-api.d.ts

@@ -89,6 +89,11 @@ export declare class NextjsApi extends Construct {
     private createRestApi;
     /**
      * Create base resource path if needed. Important if `basePath` is set.
+     *
+     * A nested `basePath` ("/team/app") has to become one resource per segment:
+     * API Gateway path parts can't contain "/", so passing the whole thing to a
+     * single `addResource` fails validation at synth. `resolveBasePath` accepts
+     * nested values, so this is reachable.
      */
     private createBaseResource;
     private createStaticIntegrationRole;

package/lib/nextjs-api.js

@@ -11,7 +11,7 @@ const base_path_1 = require("./utils/base-path");
  * Creates an API Gateway REST API for Next.js applications
  */
 class NextjsApi extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsApi", version: "0.6.1" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsApi", version: "0.6.2" };
     /**
      * The API Gateway REST API
      */
@@ -81,11 +81,21 @@ class NextjsApi extends constructs_1.Construct {
     }
     /**
      * Create base resource path if needed. Important if `basePath` is set.
+     *
+     * A nested `basePath` ("/team/app") has to become one resource per segment:
+     * API Gateway path parts can't contain "/", so passing the whole thing to a
+     * single `addResource` fails validation at synth. `resolveBasePath` accepts
+     * nested values, so this is reachable.
      */
     createBaseResource(basePath) {
         // Create base resource path if needed
         const normalized = (0, base_path_1.normalizeBasePath)(basePath);
-        return normalized ? this.api.root.addResource(normalized) : this.api.root;
+        if (!normalized) {
+            return this.api.root;
+        }
+        return normalized
+            .split("/")
+            .reduce((parent, segment) => parent.addResource(segment), this.api.root);
     }
     createStaticIntegrationRole() {
         // Create S3 integration role
@@ -229,4 +239,4 @@ class NextjsApi extends constructs_1.Construct {
     }
 }
 exports.NextjsApi = NextjsApi;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-api.js","sourceRoot":"","sources":["../src/nextjs-api.ts"],"names":[],"mappings":"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","sourcesContent":["import { Size, Stack } from \"aws-cdk-lib\";\nimport {\n  RestApi,\n  LambdaIntegration,\n  AwsIntegration,\n  MethodOptions,\n  IResource,\n  EndpointType,\n  RestApiProps,\n  AwsIntegrationProps,\n  LambdaIntegrationOptions,\n  PassthroughBehavior,\n  ResponseTransferMode,\n} from \"aws-cdk-lib/aws-apigateway\";\nimport { IVpc } from \"aws-cdk-lib/aws-ec2\";\nimport {\n  Role,\n  ServicePrincipal,\n  PolicyStatement,\n  IRole,\n} from \"aws-cdk-lib/aws-iam\";\nimport { IFunction } from \"aws-cdk-lib/aws-lambda\";\nimport { IBucket } from \"aws-cdk-lib/aws-s3\";\nimport { Construct } from \"constructs\";\nimport { PublicDirEntry } from \"./nextjs-build/nextjs-build\";\nimport { joinPath, normalizeBasePath } from \"./utils/base-path\";\n\nexport interface NextjsApiOverrides {\n  readonly restApiProps?: RestApiProps;\n  readonly staticIntegrationProps?: AwsIntegrationProps;\n  readonly s3MethodOptions?: MethodOptions;\n  readonly dynamicIntegrationProps?: LambdaIntegrationOptions;\n  readonly imageIntegrationProps?: LambdaIntegrationOptions;\n}\n\nexport interface NextjsApiProps {\n  /**\n   * Optional base path for the application\n   */\n  readonly basePath?: string;\n  /**\n   * Override props for every construct.\n   */\n  readonly overrides?: NextjsApiOverrides;\n  /**\n   * Path to directory of Next.js app's public directory. Used to add resources\n   * to API Gateway REST API for public directory to go directly to S3.\n   */\n  readonly publicDirEntries: PublicDirEntry[];\n  /**\n   * Required if `NextjsRegionalFunctions`. The Lambda function for server-side rendering\n   */\n  readonly serverFunction?: IFunction;\n  /**\n   * Dedicated image optimization Lambda for the `_next/image` route. When\n   * omitted, no `_next/image` resource is created and those requests fall\n   * through to `serverFunction` via the `{proxy+}` catch-all.\n   *\n   * When provided, it is assumed to support Lambda response streaming (as the\n   * dedicated image Lambda this package builds does) and is invoked with\n   * `ResponseTransferMode.STREAM` accordingly. If you supply a custom\n   * `imageFunction` that doesn't support streaming, override\n   * `responseTransferMode` to `BUFFERED` via `overrides.imageIntegrationProps`,\n   * otherwise API Gateway returns a 502.\n   */\n  readonly imageFunction?: IFunction;\n  /**\n   * The S3 bucket containing static assets\n   */\n  readonly staticAssetsBucket: IBucket;\n  /**\n   * S3 key prefix the static assets were uploaded under, i.e.\n   * `NextjsStaticAssets.keyPrefix`, which namespaces a shared bucket.\n   *\n   * Independent of `basePath` above: that one is the URL prefix the REST API\n   * serves the app at (commonly the API Gateway stage), while this one is where\n   * the objects live in the bucket. `_next/static` and public directory\n   * requests are mapped to S3 keys directly, so they 404 unless this prefix is\n   * applied.\n   */\n  readonly staticAssetsKeyPrefix?: string;\n  /**\n   * [Future] Required if `NextjsRegionalContainers`. VPC to create VPC Link and ECS Service Discovery\n   */\n  readonly vpc?: IVpc;\n}\n\n/**\n * Creates an API Gateway REST API for Next.js applications\n */\nexport class NextjsApi extends Construct {\n  /**\n   * The API Gateway REST API\n   */\n  public readonly api: RestApi;\n\n  /**\n   * Public URL of the app, including every path segment the API nests it under.\n   * Prefers a custom domain configured through `overrides.restApiProps.domainName`\n   * over the execute-api endpoint.\n   *\n   * A domain attached after this construct is created (`api.addDomainName()`) is\n   * still used for the host, but CDK keeps its base path mappings private, so a\n   * mapping added that way won't show up here.\n   */\n  get url(): string {\n    const customDomain = this.api.domainName;\n    // A custom domain reaches the stage through a base path mapping, so the\n    // stage name isn't in the path there; the mapping may be, when set.\n    const [origin, prefix] = customDomain\n      ? [\n          `https://${customDomain.domainName}`,\n          this.props.overrides?.restApiProps?.domainName?.basePath,\n        ]\n      : [\n          `https://${this.api.restApiId}.execute-api.${Stack.of(this).region}.amazonaws.com`,\n          this.api.deploymentStage.stageName,\n        ];\n    return joinPath(origin, prefix, this.props.basePath);\n  }\n\n  private readonly baseResource: IResource;\n  private readonly nextResource: IResource;\n  private readonly props: NextjsApiProps;\n  private staticIntegrationRole: IRole;\n\n  constructor(scope: Construct, id: string, props: NextjsApiProps) {\n    super(scope, id);\n    this.props = props;\n\n    this.validateProps(props);\n    this.api = this.createRestApi();\n    this.baseResource = this.createBaseResource(props.basePath);\n    this.nextResource = this.baseResource.addResource(\"_next\");\n    this.staticIntegrationRole = this.createStaticIntegrationRole();\n    this.createStaticIntegrations();\n    if (props.serverFunction) {\n      // Without a dedicated image function, `_next/image` falls through to the\n      // `{proxy+}` catch-all on the server function.\n      if (props.imageFunction) {\n        this.createImageIntegration(props.imageFunction);\n      }\n      this.createDynamicIntegration(props.serverFunction);\n    } else if (props.vpc) {\n      // [Future] create integration with ECS via VPC Link and ECS Service Discovery\n    }\n  }\n\n  private validateProps(props: NextjsApiProps) {\n    if (!props.serverFunction && !props.vpc) {\n      throw new Error(\"serverFunction or vpc must be set in NextjsApiProps\");\n    }\n  }\n\n  private createRestApi(): RestApi {\n    return new RestApi(this, \"RestApi\", {\n      binaryMediaTypes: [\"*/*\"],\n      description: `cdk-nextjs REST API for ${Stack.of(this).stackName}`,\n      endpointTypes: [EndpointType.REGIONAL],\n      minCompressionSize: Size.bytes(0), // compress all responses for better perf\n      ...this.props.overrides?.restApiProps,\n    });\n  }\n\n  /**\n   * Create base resource path if needed. Important if `basePath` is set.\n   */\n  private createBaseResource(basePath?: string): IResource {\n    // Create base resource path if needed\n    const normalized = normalizeBasePath(basePath);\n    return normalized ? this.api.root.addResource(normalized) : this.api.root;\n  }\n\n  private createStaticIntegrationRole() {\n    // Create S3 integration role\n    const staticIntegrationRole = new Role(this, \"StaticIntegrationRole\", {\n      assumedBy: new ServicePrincipal(\"apigateway.amazonaws.com\"),\n    });\n\n    staticIntegrationRole.addToPolicy(\n      new PolicyStatement({\n        actions: [\"s3:GetObject\", \"s3:ListBucket\"],\n        resources: [\n          this.props.staticAssetsBucket.bucketArn,\n          `${this.props.staticAssetsBucket.bucketArn}/*`,\n        ],\n      }),\n    );\n    return staticIntegrationRole;\n  }\n\n  private createStaticIntegrations() {\n    this.nextResource\n      .addResource(\"static\")\n      .addResource(\"{proxy+}\")\n      .addMethod(\n        \"GET\",\n        this.createS3Integration({ key: this.s3Key(\"_next/static/{key}\") }),\n        this.getStaticMethodOptions({ proxy: true }),\n      );\n    // add public directory files/directories that exist at top level but need to go to S3.\n    for (const publicDirEntry of this.props.publicDirEntries) {\n      if (publicDirEntry.isDirectory) {\n        this.baseResource\n          .addResource(publicDirEntry.name)\n          .addResource(\"{proxy+}\")\n          .addMethod(\n            \"GET\",\n            this.createS3Integration({\n              key: this.s3Key(`${publicDirEntry.name}/{key}`),\n            }),\n            this.getStaticMethodOptions({ proxy: true }),\n          );\n      } else {\n        this.baseResource\n          .addResource(publicDirEntry.name)\n          .addMethod(\n            \"GET\",\n            this.createS3Integration({ key: this.s3Key(publicDirEntry.name) }),\n            this.getStaticMethodOptions(),\n          );\n      }\n    }\n  }\n\n  /**\n   * Prefixes a request path with the key prefix the assets were uploaded under,\n   * since the S3 integrations address objects by key rather than by URL.\n   */\n  private s3Key(key: string): string {\n    return joinPath(this.props.staticAssetsKeyPrefix, key);\n  }\n\n  /**\n   * Maps API request to S3 request.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-parameter-mapping-sources.html\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/integrating-api-with-aws-services-s3.html#api-items-in-folder-as-s3-objects-in-bucket\n   */\n  private createS3Integration({ key }: { key: string }) {\n    const s3Integration = new AwsIntegration({\n      service: \"s3\",\n      integrationHttpMethod: \"GET\",\n      path: `${this.props.staticAssetsBucket.bucketName}/${key}`,\n      options: {\n        credentialsRole: this.staticIntegrationRole,\n        passthroughBehavior: PassthroughBehavior.WHEN_NO_TEMPLATES, // recommended\n        requestParameters: key.includes(\"{key}\")\n          ? {\n              \"integration.request.path.key\": \"method.request.path.proxy\",\n            }\n          : undefined,\n        integrationResponses: [\n          {\n            statusCode: \"200\",\n            responseParameters: {\n              \"method.response.header.Content-Type\":\n                \"integration.response.header.Content-Type\",\n              \"method.response.header.Content-Length\":\n                \"integration.response.header.Content-Length\",\n              \"method.response.header.Cache-Control\":\n                \"integration.response.header.Cache-Control\",\n              \"method.response.header.ETag\": \"integration.response.header.ETag\",\n              \"method.response.header.Last-Modified\":\n                \"integration.response.header.Last-Modified\",\n            },\n          },\n          {\n            statusCode: \"404\",\n            selectionPattern: \"404\",\n          },\n        ],\n      },\n      ...this.props.overrides?.staticIntegrationProps,\n    });\n    return s3Integration;\n  }\n\n  private getStaticMethodOptions({ proxy } = { proxy: false }): MethodOptions {\n    return {\n      requestParameters: proxy\n        ? {\n            \"method.request.path.proxy\": true,\n          }\n        : undefined,\n      methodResponses: [\n        {\n          statusCode: \"200\",\n          responseParameters: {\n            \"method.response.header.Content-Type\": true,\n            \"method.response.header.Content-Length\": true,\n            \"method.response.header.Cache-Control\": true,\n            \"method.response.header.ETag\": true,\n            \"method.response.header.Last-Modified\": true,\n          },\n        },\n        {\n          statusCode: \"404\",\n        },\n      ],\n      ...this.props.overrides?.s3MethodOptions,\n    };\n  }\n\n  /**\n   * Create Lambda Proxy integration for the `_next/image` route.\n   */\n  private createImageIntegration(imageFunction: IFunction) {\n    // imageFunction is assumed to be the dedicated, streaming-capable image\n    // Lambda (see its doc comment); override responseTransferMode via\n    // imageIntegrationProps if that assumption doesn't hold for a custom\n    // imageFunction, otherwise API Gateway returns a 502. Deliberately\n    // doesn't inherit dynamicIntegrationProps: that's for serverFunction,\n    // a different Lambda with different (and possibly conflicting, e.g.\n    // BUFFERED for a non-streaming Lambda Web Adapter setup) streaming\n    // requirements than the always-streaming dedicated image Lambda.\n    const imageIntegration = new LambdaIntegration(imageFunction, {\n      responseTransferMode: ResponseTransferMode.STREAM,\n      ...this.props.overrides?.imageIntegrationProps,\n    });\n    const imageResource = this.nextResource.addResource(\"image\");\n    imageResource.addMethod(\"ANY\", imageIntegration);\n  }\n\n  /**\n   * Create Lambda Proxy integration for all other routes\n   */\n  private createDynamicIntegration(serverFunction: IFunction) {\n    // All other routes use streaming for better performance\n    const streamingIntegration = new LambdaIntegration(serverFunction, {\n      responseTransferMode: ResponseTransferMode.STREAM,\n      ...this.props.overrides?.dynamicIntegrationProps,\n    });\n\n    // Add catch-all routes with streaming integration for server-side rendering\n    this.baseResource.addMethod(\"ANY\", streamingIntegration);\n    const proxyResource = this.baseResource.addResource(\"{proxy+}\");\n    proxyResource.addMethod(\"ANY\", streamingIntegration);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-api.js","sourceRoot":"","sources":["../src/nextjs-api.ts"],"names":[],"mappings":"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","sourcesContent":["import { Size, Stack } from \"aws-cdk-lib\";\nimport {\n  RestApi,\n  LambdaIntegration,\n  AwsIntegration,\n  MethodOptions,\n  IResource,\n  EndpointType,\n  RestApiProps,\n  AwsIntegrationProps,\n  LambdaIntegrationOptions,\n  PassthroughBehavior,\n  ResponseTransferMode,\n} from \"aws-cdk-lib/aws-apigateway\";\nimport { IVpc } from \"aws-cdk-lib/aws-ec2\";\nimport {\n  Role,\n  ServicePrincipal,\n  PolicyStatement,\n  IRole,\n} from \"aws-cdk-lib/aws-iam\";\nimport { IFunction } from \"aws-cdk-lib/aws-lambda\";\nimport { IBucket } from \"aws-cdk-lib/aws-s3\";\nimport { Construct } from \"constructs\";\nimport { PublicDirEntry } from \"./nextjs-build/nextjs-build\";\nimport { joinPath, normalizeBasePath } from \"./utils/base-path\";\n\nexport interface NextjsApiOverrides {\n  readonly restApiProps?: RestApiProps;\n  readonly staticIntegrationProps?: AwsIntegrationProps;\n  readonly s3MethodOptions?: MethodOptions;\n  readonly dynamicIntegrationProps?: LambdaIntegrationOptions;\n  readonly imageIntegrationProps?: LambdaIntegrationOptions;\n}\n\nexport interface NextjsApiProps {\n  /**\n   * Optional base path for the application\n   */\n  readonly basePath?: string;\n  /**\n   * Override props for every construct.\n   */\n  readonly overrides?: NextjsApiOverrides;\n  /**\n   * Path to directory of Next.js app's public directory. Used to add resources\n   * to API Gateway REST API for public directory to go directly to S3.\n   */\n  readonly publicDirEntries: PublicDirEntry[];\n  /**\n   * Required if `NextjsRegionalFunctions`. The Lambda function for server-side rendering\n   */\n  readonly serverFunction?: IFunction;\n  /**\n   * Dedicated image optimization Lambda for the `_next/image` route. When\n   * omitted, no `_next/image` resource is created and those requests fall\n   * through to `serverFunction` via the `{proxy+}` catch-all.\n   *\n   * When provided, it is assumed to support Lambda response streaming (as the\n   * dedicated image Lambda this package builds does) and is invoked with\n   * `ResponseTransferMode.STREAM` accordingly. If you supply a custom\n   * `imageFunction` that doesn't support streaming, override\n   * `responseTransferMode` to `BUFFERED` via `overrides.imageIntegrationProps`,\n   * otherwise API Gateway returns a 502.\n   */\n  readonly imageFunction?: IFunction;\n  /**\n   * The S3 bucket containing static assets\n   */\n  readonly staticAssetsBucket: IBucket;\n  /**\n   * S3 key prefix the static assets were uploaded under, i.e.\n   * `NextjsStaticAssets.keyPrefix`, which namespaces a shared bucket.\n   *\n   * Independent of `basePath` above: that one is the URL prefix the REST API\n   * serves the app at (commonly the API Gateway stage), while this one is where\n   * the objects live in the bucket. `_next/static` and public directory\n   * requests are mapped to S3 keys directly, so they 404 unless this prefix is\n   * applied.\n   */\n  readonly staticAssetsKeyPrefix?: string;\n  /**\n   * [Future] Required if `NextjsRegionalContainers`. VPC to create VPC Link and ECS Service Discovery\n   */\n  readonly vpc?: IVpc;\n}\n\n/**\n * Creates an API Gateway REST API for Next.js applications\n */\nexport class NextjsApi extends Construct {\n  /**\n   * The API Gateway REST API\n   */\n  public readonly api: RestApi;\n\n  /**\n   * Public URL of the app, including every path segment the API nests it under.\n   * Prefers a custom domain configured through `overrides.restApiProps.domainName`\n   * over the execute-api endpoint.\n   *\n   * A domain attached after this construct is created (`api.addDomainName()`) is\n   * still used for the host, but CDK keeps its base path mappings private, so a\n   * mapping added that way won't show up here.\n   */\n  get url(): string {\n    const customDomain = this.api.domainName;\n    // A custom domain reaches the stage through a base path mapping, so the\n    // stage name isn't in the path there; the mapping may be, when set.\n    const [origin, prefix] = customDomain\n      ? [\n          `https://${customDomain.domainName}`,\n          this.props.overrides?.restApiProps?.domainName?.basePath,\n        ]\n      : [\n          `https://${this.api.restApiId}.execute-api.${Stack.of(this).region}.amazonaws.com`,\n          this.api.deploymentStage.stageName,\n        ];\n    return joinPath(origin, prefix, this.props.basePath);\n  }\n\n  private readonly baseResource: IResource;\n  private readonly nextResource: IResource;\n  private readonly props: NextjsApiProps;\n  private staticIntegrationRole: IRole;\n\n  constructor(scope: Construct, id: string, props: NextjsApiProps) {\n    super(scope, id);\n    this.props = props;\n\n    this.validateProps(props);\n    this.api = this.createRestApi();\n    this.baseResource = this.createBaseResource(props.basePath);\n    this.nextResource = this.baseResource.addResource(\"_next\");\n    this.staticIntegrationRole = this.createStaticIntegrationRole();\n    this.createStaticIntegrations();\n    if (props.serverFunction) {\n      // Without a dedicated image function, `_next/image` falls through to the\n      // `{proxy+}` catch-all on the server function.\n      if (props.imageFunction) {\n        this.createImageIntegration(props.imageFunction);\n      }\n      this.createDynamicIntegration(props.serverFunction);\n    } else if (props.vpc) {\n      // [Future] create integration with ECS via VPC Link and ECS Service Discovery\n    }\n  }\n\n  private validateProps(props: NextjsApiProps) {\n    if (!props.serverFunction && !props.vpc) {\n      throw new Error(\"serverFunction or vpc must be set in NextjsApiProps\");\n    }\n  }\n\n  private createRestApi(): RestApi {\n    return new RestApi(this, \"RestApi\", {\n      binaryMediaTypes: [\"*/*\"],\n      description: `cdk-nextjs REST API for ${Stack.of(this).stackName}`,\n      endpointTypes: [EndpointType.REGIONAL],\n      minCompressionSize: Size.bytes(0), // compress all responses for better perf\n      ...this.props.overrides?.restApiProps,\n    });\n  }\n\n  /**\n   * Create base resource path if needed. Important if `basePath` is set.\n   *\n   * A nested `basePath` (\"/team/app\") has to become one resource per segment:\n   * API Gateway path parts can't contain \"/\", so passing the whole thing to a\n   * single `addResource` fails validation at synth. `resolveBasePath` accepts\n   * nested values, so this is reachable.\n   */\n  private createBaseResource(basePath?: string): IResource {\n    // Create base resource path if needed\n    const normalized = normalizeBasePath(basePath);\n    if (!normalized) {\n      return this.api.root;\n    }\n    return normalized\n      .split(\"/\")\n      .reduce<IResource>(\n        (parent, segment) => parent.addResource(segment),\n        this.api.root,\n      );\n  }\n\n  private createStaticIntegrationRole() {\n    // Create S3 integration role\n    const staticIntegrationRole = new Role(this, \"StaticIntegrationRole\", {\n      assumedBy: new ServicePrincipal(\"apigateway.amazonaws.com\"),\n    });\n\n    staticIntegrationRole.addToPolicy(\n      new PolicyStatement({\n        actions: [\"s3:GetObject\", \"s3:ListBucket\"],\n        resources: [\n          this.props.staticAssetsBucket.bucketArn,\n          `${this.props.staticAssetsBucket.bucketArn}/*`,\n        ],\n      }),\n    );\n    return staticIntegrationRole;\n  }\n\n  private createStaticIntegrations() {\n    this.nextResource\n      .addResource(\"static\")\n      .addResource(\"{proxy+}\")\n      .addMethod(\n        \"GET\",\n        this.createS3Integration({ key: this.s3Key(\"_next/static/{key}\") }),\n        this.getStaticMethodOptions({ proxy: true }),\n      );\n    // add public directory files/directories that exist at top level but need to go to S3.\n    for (const publicDirEntry of this.props.publicDirEntries) {\n      if (publicDirEntry.isDirectory) {\n        this.baseResource\n          .addResource(publicDirEntry.name)\n          .addResource(\"{proxy+}\")\n          .addMethod(\n            \"GET\",\n            this.createS3Integration({\n              key: this.s3Key(`${publicDirEntry.name}/{key}`),\n            }),\n            this.getStaticMethodOptions({ proxy: true }),\n          );\n      } else {\n        this.baseResource\n          .addResource(publicDirEntry.name)\n          .addMethod(\n            \"GET\",\n            this.createS3Integration({ key: this.s3Key(publicDirEntry.name) }),\n            this.getStaticMethodOptions(),\n          );\n      }\n    }\n  }\n\n  /**\n   * Prefixes a request path with the key prefix the assets were uploaded under,\n   * since the S3 integrations address objects by key rather than by URL.\n   */\n  private s3Key(key: string): string {\n    return joinPath(this.props.staticAssetsKeyPrefix, key);\n  }\n\n  /**\n   * Maps API request to S3 request.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-parameter-mapping-sources.html\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/integrating-api-with-aws-services-s3.html#api-items-in-folder-as-s3-objects-in-bucket\n   */\n  private createS3Integration({ key }: { key: string }) {\n    const s3Integration = new AwsIntegration({\n      service: \"s3\",\n      integrationHttpMethod: \"GET\",\n      path: `${this.props.staticAssetsBucket.bucketName}/${key}`,\n      options: {\n        credentialsRole: this.staticIntegrationRole,\n        passthroughBehavior: PassthroughBehavior.WHEN_NO_TEMPLATES, // recommended\n        requestParameters: key.includes(\"{key}\")\n          ? {\n              \"integration.request.path.key\": \"method.request.path.proxy\",\n            }\n          : undefined,\n        integrationResponses: [\n          {\n            statusCode: \"200\",\n            responseParameters: {\n              \"method.response.header.Content-Type\":\n                \"integration.response.header.Content-Type\",\n              \"method.response.header.Content-Length\":\n                \"integration.response.header.Content-Length\",\n              \"method.response.header.Cache-Control\":\n                \"integration.response.header.Cache-Control\",\n              \"method.response.header.ETag\": \"integration.response.header.ETag\",\n              \"method.response.header.Last-Modified\":\n                \"integration.response.header.Last-Modified\",\n            },\n          },\n          {\n            statusCode: \"404\",\n            selectionPattern: \"404\",\n          },\n        ],\n      },\n      ...this.props.overrides?.staticIntegrationProps,\n    });\n    return s3Integration;\n  }\n\n  private getStaticMethodOptions({ proxy } = { proxy: false }): MethodOptions {\n    return {\n      requestParameters: proxy\n        ? {\n            \"method.request.path.proxy\": true,\n          }\n        : undefined,\n      methodResponses: [\n        {\n          statusCode: \"200\",\n          responseParameters: {\n            \"method.response.header.Content-Type\": true,\n            \"method.response.header.Content-Length\": true,\n            \"method.response.header.Cache-Control\": true,\n            \"method.response.header.ETag\": true,\n            \"method.response.header.Last-Modified\": true,\n          },\n        },\n        {\n          statusCode: \"404\",\n        },\n      ],\n      ...this.props.overrides?.s3MethodOptions,\n    };\n  }\n\n  /**\n   * Create Lambda Proxy integration for the `_next/image` route.\n   */\n  private createImageIntegration(imageFunction: IFunction) {\n    // imageFunction is assumed to be the dedicated, streaming-capable image\n    // Lambda (see its doc comment); override responseTransferMode via\n    // imageIntegrationProps if that assumption doesn't hold for a custom\n    // imageFunction, otherwise API Gateway returns a 502. Deliberately\n    // doesn't inherit dynamicIntegrationProps: that's for serverFunction,\n    // a different Lambda with different (and possibly conflicting, e.g.\n    // BUFFERED for a non-streaming Lambda Web Adapter setup) streaming\n    // requirements than the always-streaming dedicated image Lambda.\n    const imageIntegration = new LambdaIntegration(imageFunction, {\n      responseTransferMode: ResponseTransferMode.STREAM,\n      ...this.props.overrides?.imageIntegrationProps,\n    });\n    const imageResource = this.nextResource.addResource(\"image\");\n    imageResource.addMethod(\"ANY\", imageIntegration);\n  }\n\n  /**\n   * Create Lambda Proxy integration for all other routes\n   */\n  private createDynamicIntegration(serverFunction: IFunction) {\n    // All other routes use streaming for better performance\n    const streamingIntegration = new LambdaIntegration(serverFunction, {\n      responseTransferMode: ResponseTransferMode.STREAM,\n      ...this.props.overrides?.dynamicIntegrationProps,\n    });\n\n    // Add catch-all routes with streaming integration for server-side rendering\n    this.baseResource.addMethod(\"ANY\", streamingIntegration);\n    const proxyResource = this.baseResource.addResource(\"{proxy+}\");\n    proxyResource.addMethod(\"ANY\", streamingIntegration);\n  }\n}\n"]}