cdk-nextjs 0.6.2 → 0.7.1

package/lib/adapter/cache-handler.test.js

@@ -3,6 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
 const cache_handler_1 = __importDefault(require("./cache-handler"));
 // Mock AWS SDK clients
 jest.mock("@aws-sdk/client-s3");
@@ -30,12 +34,6 @@ describe("CdkNextjsCacheHandler - Orchestrator Pattern", () => {
         cache_handler_1.default.sharedMemoryHandler = null;
         cache_handler_1.default.sharedS3DynamoHandler = null;
     });
-    describe("Orchestrator Pattern & Initialization", () => {
-        it("should initialize as orchestrator with runtime handlers", () => {
-            expect(cacheHandler).toBeDefined();
-            // Runtime mode - memory and S3/DynamoDB handlers should be available
-        });
-    });
     describe("Orchestrator: Memory + S3/DynamoDB", () => {
         it("should write to both memory and S3/DynamoDB on set", async () => {
             const testData = {
@@ -47,18 +45,81 @@ describe("CdkNextjsCacheHandler - Orchestrator Pattern", () => {
                 segmentData: undefined,
                 status: undefined,
             };
+            const s3 = {
+                set: jest.fn().mockResolvedValue(undefined),
+                get: jest.fn().mockResolvedValue(null),
+                isRevalidated: jest.fn().mockResolvedValue(false),
+            };
+            cacheHandler.s3DynamoHandler = s3;
+            const setCtx = { fetchCache: true, tags: [] };
             // Set cache entry
-            await cacheHandler.set("test-key", testData, {
-                fetchCache: true,
-                tags: [],
-            });
-            // Get should return from memory
+            await cacheHandler.set("test-key", testData, setCtx);
+            // S3/DynamoDB got the write, with the context it needs for tags.
+            expect(s3.set).toHaveBeenCalledWith("test-key", testData, setCtx);
+            // Get should return from memory, without asking S3.
             const result = await cacheHandler.get("test-key", {
                 kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
                 isFallback: false,
             });
             expect(result).not.toBeNull();
             expect(result?.value).toEqual(testData);
+            expect(s3.get).not.toHaveBeenCalled();
+        });
+        it("deletes from both layers on set(key, null)", async () => {
+            const testData = {
+                kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+                html: "<html>gone</html>",
+                rscData: undefined,
+                headers: undefined,
+                postponed: undefined,
+                segmentData: undefined,
+                status: undefined,
+            };
+            const s3 = {
+                set: jest.fn().mockResolvedValue(undefined),
+                get: jest.fn().mockResolvedValue(null),
+                isRevalidated: jest.fn().mockResolvedValue(false),
+            };
+            cacheHandler.s3DynamoHandler = s3;
+            const setCtx = { fetchCache: true, tags: [] };
+            await cacheHandler.set("gone-key", testData, setCtx);
+            await cacheHandler.set("gone-key", null, setCtx);
+            // The S3 layer is told to delete, not skipped.
+            expect(s3.set).toHaveBeenLastCalledWith("gone-key", null, setCtx);
+            // And memory no longer answers: the read falls through to S3.
+            expect(await cacheHandler.get("gone-key", {
+                kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
+                isFallback: false,
+            })).toBeNull();
+            expect(s3.get).toHaveBeenCalledTimes(1);
+        });
+        it("revalidates a tag in S3/DynamoDB, passing the durations through", async () => {
+            const testData = {
+                kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+                html: "<html>tagged</html>",
+                rscData: undefined,
+                headers: { "x-next-cache-tags": "posts" },
+                postponed: undefined,
+                segmentData: undefined,
+                status: undefined,
+            };
+            const s3 = {
+                set: jest.fn().mockResolvedValue(undefined),
+                get: jest.fn().mockResolvedValue(null),
+                isRevalidated: jest.fn().mockResolvedValue(false),
+                revalidateTag: jest.fn().mockResolvedValue(undefined),
+            };
+            cacheHandler.s3DynamoHandler = s3;
+            await cacheHandler.set("tagged-key", testData, {
+                fetchCache: true,
+                tags: ["posts"],
+            });
+            // `revalidateTag(tag, profile)`: the durations decide stale vs expired,
+            // so dropping them turns every soft revalidation into a hard one.
+            await cacheHandler.revalidateTag(["posts"], { expire: 60 });
+            expect(s3.revalidateTag).toHaveBeenCalledWith(["posts"], { expire: 60 });
+            await cacheHandler.revalidateTag("posts");
+            expect(s3.revalidateTag).toHaveBeenLastCalledWith("posts", undefined);
         });
         it("should handle cache misses gracefully", async () => {
             // Get non-existent key
@@ -69,7 +130,137 @@ describe("CdkNextjsCacheHandler - Orchestrator Pattern", () => {
             // Should return null (both memory and S3 miss)
             expect(result).toBeNull();
         });
-        it("should propagate resetRequestCache to memory layer", async () => {
+        it("does not copy a tag-expired S3 entry into memory", async () => {
+            // `lastModified: -1` is the S3 layer saying "a tag revalidation expired
+            // this, re-render before answering". Copied into memory, the expired body
+            // would be answered from there instead of from the re-render.
+            const value = {
+                kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+                html: "<html>expired</html>",
+                rscData: undefined,
+                headers: undefined,
+                postponed: undefined,
+                segmentData: undefined,
+                status: undefined,
+            };
+            const getCtx = {
+                kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
+                isFallback: false,
+            };
+            cacheHandler.s3DynamoHandler = {
+                get: jest.fn().mockResolvedValue({ lastModified: -1, value }),
+            };
+            expect(await cacheHandler.get("isr/1", getCtx)).toEqual({
+                lastModified: -1,
+                value,
+            });
+            // With the S3 layer now silent, a memory copy would answer this as a hit.
+            cacheHandler.s3DynamoHandler = {
+                get: jest.fn().mockResolvedValue(null),
+            };
+            expect(await cacheHandler.get("isr/1", getCtx)).toBeNull();
+        });
+        it("copies a live S3 entry into memory", async () => {
+            const value = {
+                kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+                html: "<html>live</html>",
+                rscData: undefined,
+                headers: undefined,
+                postponed: undefined,
+                segmentData: undefined,
+                status: undefined,
+            };
+            const getCtx = {
+                kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
+                isFallback: false,
+            };
+            cacheHandler.s3DynamoHandler = {
+                get: jest.fn().mockResolvedValue({ lastModified: Date.now(), value }),
+            };
+            await cacheHandler.get("isr/2", getCtx);
+            const s3 = {
+                get: jest.fn().mockResolvedValue(null),
+                isRevalidated: jest.fn().mockResolvedValue(false),
+            };
+            cacheHandler.s3DynamoHandler = s3;
+            expect(await cacheHandler.get("isr/2", getCtx)).toMatchObject({ value });
+            expect(s3.get).not.toHaveBeenCalled();
+        });
+        it("keeps the S3 entry's lastModified when copying it into memory", async () => {
+            // Next.js ages the entry from `lastModified`, and the tag markers are
+            // compared against it. Stamping the time of the copy made a page a soft
+            // `revalidateTag` had made stale look newer than the stale mark.
+            const value = {
+                kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+                html: "<html>old</html>",
+                rscData: undefined,
+                headers: undefined,
+                postponed: undefined,
+                segmentData: undefined,
+                status: undefined,
+            };
+            const getCtx = {
+                kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
+                isFallback: false,
+            };
+            const renderedAt = Date.now() - 60_000;
+            cacheHandler.s3DynamoHandler = {
+                get: jest.fn().mockResolvedValue({ lastModified: renderedAt, value }),
+            };
+            await cacheHandler.get("isr/3", getCtx);
+            const s3 = {
+                get: jest.fn().mockResolvedValue(null),
+                isRevalidated: jest.fn().mockResolvedValue(false),
+            };
+            cacheHandler.s3DynamoHandler = s3;
+            expect(await cacheHandler.get("isr/3", getCtx)).toEqual({
+                lastModified: renderedAt,
+                value,
+            });
+            expect(s3.isRevalidated).toHaveBeenCalledWith({ lastModified: renderedAt, value }, getCtx, "isr/3");
+        });
+        it("does not serve a memory hit another instance's revalidateTag expired", async () => {
+            // `revalidateTag` clears only the memory of the instance that ran it. Any
+            // other instance holding the page in memory answered from it for the
+            // whole memory TTL, and CloudFront - just invalidated - cached the stale
+            // page again. So a memory hit is checked against the tag markers too.
+            const value = {
+                kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+                html: "<html>stale</html>",
+                rscData: undefined,
+                headers: { "x-next-cache-tags": "_N_T_/blog" },
+                postponed: undefined,
+                segmentData: undefined,
+                status: undefined,
+            };
+            const getCtx = {
+                kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
+                isFallback: false,
+            };
+            cacheHandler.s3DynamoHandler = {
+                get: jest.fn().mockResolvedValue({ lastModified: Date.now(), value }),
+            };
+            await cacheHandler.get("blog", getCtx);
+            // Another instance revalidated `_N_T_/blog`: the marker is newer than the
+            // memory copy, and S3 now answers with the entry expired.
+            const s3 = {
+                get: jest.fn().mockResolvedValue({ lastModified: -1, value }),
+                isRevalidated: jest.fn().mockResolvedValue(true),
+            };
+            cacheHandler.s3DynamoHandler = s3;
+            expect(await cacheHandler.get("blog", getCtx)).toEqual({
+                lastModified: -1,
+                value,
+            });
+            expect(s3.isRevalidated).toHaveBeenCalledWith(expect.objectContaining({ value }), getCtx, "blog");
+            expect(s3.get).toHaveBeenCalledTimes(1);
+            // And the memory copy is gone rather than checked again next time.
+            s3.get.mockResolvedValue(null);
+            expect(await cacheHandler.get("blog", getCtx)).toBeNull();
+        });
+        it("keeps memory entries across resetRequestCache", async () => {
+            // Next.js calls it at the start of every request; clearing the shared
+            // memory cache there sent every read to S3.
             const testData = {
                 kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
                 html: "<html>reset</html>",
@@ -86,33 +277,74 @@ describe("CdkNextjsCacheHandler - Orchestrator Pattern", () => {
             });
             // Reset
             await cacheHandler.resetRequestCache();
-            // Verify entry is gone from memory
+            // Still answered from memory, without asking S3.
+            const s3 = {
+                get: jest.fn().mockResolvedValue(null),
+                isRevalidated: jest.fn().mockResolvedValue(false),
+            };
+            cacheHandler.s3DynamoHandler = s3;
             const result = await cacheHandler.get("reset-key", {
                 kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
                 isFallback: false,
             });
-            expect(result).toBeNull();
+            expect(result?.value).toEqual(testData);
+            expect(s3.get).not.toHaveBeenCalled();
         });
     });
     describe("Build-time behavior", () => {
-        it("should initialize local file cache handler during build", () => {
-            // Set build-time environment
+        it("reads back a fetch entry it wrote, from memory and from disk", async () => {
+            // `cacheComponents` prerenders each page twice: the first pass runs the
+            // `fetch` and `set`s it, the second must find it already cached or Next.js
+            // fails the build with "encountered uncached or runtime data during
+            // prerendering". A write-only build-time handler therefore makes
+            // `cache: 'force-cache'` unbuildable - measured against next.js's
+            // `test/e2e/app-dir/resume-data-cache`.
             process.env.NEXT_PHASE = "phase-production-build";
-            process.env.CDK_NEXTJS_BUILD_ID = "test-build-123";
-            const mockContext = createMockContext();
-            const buildHandler = new cache_handler_1.default(mockContext);
-            expect(buildHandler).toBeDefined();
-            // Clean up
-            delete process.env.NEXT_PHASE;
-            delete process.env.CDK_NEXTJS_BUILD_ID;
-        });
-        it("should initialize runtime handlers when not in build mode", () => {
-            // Runtime environment (NEXT_PHASE not set or different value)
-            delete process.env.NEXT_PHASE;
-            const mockContext = createMockContext();
-            const runtimeHandler = new cache_handler_1.default(mockContext);
-            expect(runtimeHandler).toBeDefined();
+            process.env.CDK_NEXTJS_INIT_CACHE_DIR = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), "cdk-nextjs-init-cache-"));
+            try {
+                const data = {
+                    kind: "FETCH" /* CachedRouteKind.FETCH */,
+                    data: {
+                        headers: {},
+                        body: "eyJyYW5kb20iOjF9",
+                        status: 200,
+                        url: "https://example.test/api/random",
+                    },
+                    revalidate: 31536000,
+                };
+                const fetchUrl = "https://example.test/api/random";
+                const setCtx = {
+                    fetchCache: true,
+                    tags: ["test"],
+                    fetchUrl,
+                    fetchIdx: 1,
+                };
+                const getCtx = {
+                    kind: "FETCH" /* IncrementalCacheKind.FETCH */,
+                    revalidate: 31536000,
+                    fetchUrl,
+                    fetchIdx: 1,
+                    tags: ["test"],
+                };
+                const buildHandler = new cache_handler_1.default(createMockContext());
+                await buildHandler.set("fetch-key", data, setCtx);
+                expect(await buildHandler.get("fetch-key", getCtx)).toMatchObject({
+                    value: data,
+                });
+                // A second instance reads the file rather than the map: `next build`
+                // renders pages in worker processes, so the pass that writes and the
+                // pass that reads are not always the same process.
+                const otherWorker = new cache_handler_1.default(createMockContext());
+                expect(await otherWorker.get("fetch-key", getCtx)).toMatchObject({
+                    value: data,
+                });
+                expect(await otherWorker.get("never-written", getCtx)).toBeNull();
+            }
+            finally {
+                delete process.env.NEXT_PHASE;
+                delete process.env.CDK_NEXTJS_INIT_CACHE_DIR;
+            }
         });
     });
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-handler.test.js","sourceRoot":"","sources":["../../src/adapter/cache-handler.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport { CacheHandlerContext } from \"next/dist/server/lib/incremental-cache\";\nimport {\n  IncrementalCacheValue,\n  CachedRouteKind,\n  IncrementalCacheKind,\n} from \"next/dist/server/response-cache\";\nimport CdkNextjsCacheHandler from \"./cache-handler\";\n\n// Mock AWS SDK clients\njest.mock(\"@aws-sdk/client-s3\");\njest.mock(\"@aws-sdk/client-dynamodb\");\n\ndescribe(\"CdkNextjsCacheHandler - Orchestrator Pattern\", () => {\n  let cacheHandler: CdkNextjsCacheHandler;\n\n  const createMockContext = (): CacheHandlerContext => ({\n    dev: false,\n    revalidatedTags: [],\n    _requestHeaders: {},\n  });\n\n  beforeEach(() => {\n    // Suppress expected warnings when env vars are not set\n    jest.spyOn(console, \"warn\").mockImplementation(() => {});\n\n    const mockContext = createMockContext();\n    cacheHandler = new CdkNextjsCacheHandler(mockContext);\n  });\n\n  afterEach(() => {\n    jest.clearAllMocks();\n    jest.restoreAllMocks();\n    // Clean up env vars\n    delete process.env.CDK_NEXTJS_MEMORY_CACHE_TTL_MS;\n    // Reset singleton handlers by accessing the class's static properties\n    // This ensures each test gets fresh handlers\n    (CdkNextjsCacheHandler as any).sharedMemoryHandler = null;\n    (CdkNextjsCacheHandler as any).sharedS3DynamoHandler = null;\n  });\n\n  describe(\"Orchestrator Pattern & Initialization\", () => {\n    it(\"should initialize as orchestrator with runtime handlers\", () => {\n      expect(cacheHandler).toBeDefined();\n      // Runtime mode - memory and S3/DynamoDB handlers should be available\n    });\n  });\n\n  describe(\"Orchestrator: Memory + S3/DynamoDB\", () => {\n    it(\"should write to both memory and S3/DynamoDB on set\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>test</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      // Set cache entry\n      await cacheHandler.set(\"test-key\", testData, {\n        fetchCache: true as const,\n        tags: [],\n      });\n\n      // Get should return from memory\n      const result = await cacheHandler.get(\"test-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n\n      expect(result).not.toBeNull();\n      expect(result?.value).toEqual(testData);\n    });\n\n    it(\"should handle cache misses gracefully\", async () => {\n      // Get non-existent key\n      const result = await cacheHandler.get(\"missing-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n\n      // Should return null (both memory and S3 miss)\n      expect(result).toBeNull();\n    });\n\n    it(\"should propagate resetRequestCache to memory layer\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>reset</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      // Add entry\n      await cacheHandler.set(\"reset-key\", testData, {\n        fetchCache: true as const,\n        tags: [\"reset-tag\"],\n      });\n\n      // Reset\n      await cacheHandler.resetRequestCache();\n\n      // Verify entry is gone from memory\n      const result = await cacheHandler.get(\"reset-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n      expect(result).toBeNull();\n    });\n  });\n\n  describe(\"Build-time behavior\", () => {\n    it(\"should initialize local file cache handler during build\", () => {\n      // Set build-time environment\n      process.env.NEXT_PHASE = \"phase-production-build\";\n      process.env.CDK_NEXTJS_BUILD_ID = \"test-build-123\";\n\n      const mockContext = createMockContext();\n      const buildHandler = new CdkNextjsCacheHandler(mockContext);\n\n      expect(buildHandler).toBeDefined();\n\n      // Clean up\n      delete process.env.NEXT_PHASE;\n      delete process.env.CDK_NEXTJS_BUILD_ID;\n    });\n\n    it(\"should initialize runtime handlers when not in build mode\", () => {\n      // Runtime environment (NEXT_PHASE not set or different value)\n      delete process.env.NEXT_PHASE;\n\n      const mockContext = createMockContext();\n      const runtimeHandler = new CdkNextjsCacheHandler(mockContext);\n\n      expect(runtimeHandler).toBeDefined();\n    });\n  });\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-handler.test.js","sourceRoot":"","sources":["../../src/adapter/cache-handler.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport { mkdtempSync } from \"fs\";\nimport { tmpdir } from \"os\";\nimport { join } from \"path\";\nimport { CacheHandlerContext } from \"next/dist/server/lib/incremental-cache\";\nimport {\n  IncrementalCacheValue,\n  CachedRouteKind,\n  IncrementalCacheKind,\n} from \"next/dist/server/response-cache\";\nimport type { GetIncrementalFetchCacheContext } from \"next/dist/server/response-cache\";\nimport CdkNextjsCacheHandler from \"./cache-handler\";\n\n// Mock AWS SDK clients\njest.mock(\"@aws-sdk/client-s3\");\njest.mock(\"@aws-sdk/client-dynamodb\");\n\ndescribe(\"CdkNextjsCacheHandler - Orchestrator Pattern\", () => {\n  let cacheHandler: CdkNextjsCacheHandler;\n\n  const createMockContext = (): CacheHandlerContext => ({\n    dev: false,\n    revalidatedTags: [],\n    _requestHeaders: {},\n  });\n\n  beforeEach(() => {\n    // Suppress expected warnings when env vars are not set\n    jest.spyOn(console, \"warn\").mockImplementation(() => {});\n\n    const mockContext = createMockContext();\n    cacheHandler = new CdkNextjsCacheHandler(mockContext);\n  });\n\n  afterEach(() => {\n    jest.clearAllMocks();\n    jest.restoreAllMocks();\n    // Clean up env vars\n    delete process.env.CDK_NEXTJS_MEMORY_CACHE_TTL_MS;\n    // Reset singleton handlers by accessing the class's static properties\n    // This ensures each test gets fresh handlers\n    (CdkNextjsCacheHandler as any).sharedMemoryHandler = null;\n    (CdkNextjsCacheHandler as any).sharedS3DynamoHandler = null;\n  });\n\n  describe(\"Orchestrator: Memory + S3/DynamoDB\", () => {\n    it(\"should write to both memory and S3/DynamoDB on set\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>test</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      const s3 = {\n        set: jest.fn().mockResolvedValue(undefined),\n        get: jest.fn().mockResolvedValue(null),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n      const setCtx = { fetchCache: true as const, tags: [] };\n\n      // Set cache entry\n      await cacheHandler.set(\"test-key\", testData, setCtx);\n\n      // S3/DynamoDB got the write, with the context it needs for tags.\n      expect(s3.set).toHaveBeenCalledWith(\"test-key\", testData, setCtx);\n\n      // Get should return from memory, without asking S3.\n      const result = await cacheHandler.get(\"test-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n\n      expect(result).not.toBeNull();\n      expect(result?.value).toEqual(testData);\n      expect(s3.get).not.toHaveBeenCalled();\n    });\n\n    it(\"deletes from both layers on set(key, null)\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>gone</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const s3 = {\n        set: jest.fn().mockResolvedValue(undefined),\n        get: jest.fn().mockResolvedValue(null),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n      const setCtx = { fetchCache: true as const, tags: [] };\n      await cacheHandler.set(\"gone-key\", testData, setCtx);\n\n      await cacheHandler.set(\"gone-key\", null, setCtx);\n\n      // The S3 layer is told to delete, not skipped.\n      expect(s3.set).toHaveBeenLastCalledWith(\"gone-key\", null, setCtx);\n      // And memory no longer answers: the read falls through to S3.\n      expect(\n        await cacheHandler.get(\"gone-key\", {\n          kind: IncrementalCacheKind.APP_PAGE,\n          isFallback: false,\n        }),\n      ).toBeNull();\n      expect(s3.get).toHaveBeenCalledTimes(1);\n    });\n\n    it(\"revalidates a tag in S3/DynamoDB, passing the durations through\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>tagged</html>\",\n        rscData: undefined,\n        headers: { \"x-next-cache-tags\": \"posts\" },\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const s3 = {\n        set: jest.fn().mockResolvedValue(undefined),\n        get: jest.fn().mockResolvedValue(null),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n        revalidateTag: jest.fn().mockResolvedValue(undefined),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n\n      await cacheHandler.set(\"tagged-key\", testData, {\n        fetchCache: true as const,\n        tags: [\"posts\"],\n      });\n      // `revalidateTag(tag, profile)`: the durations decide stale vs expired,\n      // so dropping them turns every soft revalidation into a hard one.\n      await cacheHandler.revalidateTag([\"posts\"], { expire: 60 });\n\n      expect(s3.revalidateTag).toHaveBeenCalledWith([\"posts\"], { expire: 60 });\n\n      await cacheHandler.revalidateTag(\"posts\");\n      expect(s3.revalidateTag).toHaveBeenLastCalledWith(\"posts\", undefined);\n    });\n\n    it(\"should handle cache misses gracefully\", async () => {\n      // Get non-existent key\n      const result = await cacheHandler.get(\"missing-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n\n      // Should return null (both memory and S3 miss)\n      expect(result).toBeNull();\n    });\n\n    it(\"does not copy a tag-expired S3 entry into memory\", async () => {\n      // `lastModified: -1` is the S3 layer saying \"a tag revalidation expired\n      // this, re-render before answering\". Copied into memory, the expired body\n      // would be answered from there instead of from the re-render.\n      const value: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>expired</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const getCtx = {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      } as const;\n\n      (cacheHandler as any).s3DynamoHandler = {\n        get: jest.fn().mockResolvedValue({ lastModified: -1, value }),\n      };\n      expect(await cacheHandler.get(\"isr/1\", getCtx)).toEqual({\n        lastModified: -1,\n        value,\n      });\n\n      // With the S3 layer now silent, a memory copy would answer this as a hit.\n      (cacheHandler as any).s3DynamoHandler = {\n        get: jest.fn().mockResolvedValue(null),\n      };\n      expect(await cacheHandler.get(\"isr/1\", getCtx)).toBeNull();\n    });\n\n    it(\"copies a live S3 entry into memory\", async () => {\n      const value: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>live</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const getCtx = {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      } as const;\n\n      (cacheHandler as any).s3DynamoHandler = {\n        get: jest.fn().mockResolvedValue({ lastModified: Date.now(), value }),\n      };\n      await cacheHandler.get(\"isr/2\", getCtx);\n\n      const s3 = {\n        get: jest.fn().mockResolvedValue(null),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n      expect(await cacheHandler.get(\"isr/2\", getCtx)).toMatchObject({ value });\n      expect(s3.get).not.toHaveBeenCalled();\n    });\n\n    it(\"keeps the S3 entry's lastModified when copying it into memory\", async () => {\n      // Next.js ages the entry from `lastModified`, and the tag markers are\n      // compared against it. Stamping the time of the copy made a page a soft\n      // `revalidateTag` had made stale look newer than the stale mark.\n      const value: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>old</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const getCtx = {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      } as const;\n      const renderedAt = Date.now() - 60_000;\n\n      (cacheHandler as any).s3DynamoHandler = {\n        get: jest.fn().mockResolvedValue({ lastModified: renderedAt, value }),\n      };\n      await cacheHandler.get(\"isr/3\", getCtx);\n\n      const s3 = {\n        get: jest.fn().mockResolvedValue(null),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n      expect(await cacheHandler.get(\"isr/3\", getCtx)).toEqual({\n        lastModified: renderedAt,\n        value,\n      });\n      expect(s3.isRevalidated).toHaveBeenCalledWith(\n        { lastModified: renderedAt, value },\n        getCtx,\n        \"isr/3\",\n      );\n    });\n\n    it(\"does not serve a memory hit another instance's revalidateTag expired\", async () => {\n      // `revalidateTag` clears only the memory of the instance that ran it. Any\n      // other instance holding the page in memory answered from it for the\n      // whole memory TTL, and CloudFront - just invalidated - cached the stale\n      // page again. So a memory hit is checked against the tag markers too.\n      const value: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>stale</html>\",\n        rscData: undefined,\n        headers: { \"x-next-cache-tags\": \"_N_T_/blog\" },\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n      const getCtx = {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      } as const;\n\n      (cacheHandler as any).s3DynamoHandler = {\n        get: jest.fn().mockResolvedValue({ lastModified: Date.now(), value }),\n      };\n      await cacheHandler.get(\"blog\", getCtx);\n\n      // Another instance revalidated `_N_T_/blog`: the marker is newer than the\n      // memory copy, and S3 now answers with the entry expired.\n      const s3 = {\n        get: jest.fn().mockResolvedValue({ lastModified: -1, value }),\n        isRevalidated: jest.fn().mockResolvedValue(true),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n      expect(await cacheHandler.get(\"blog\", getCtx)).toEqual({\n        lastModified: -1,\n        value,\n      });\n      expect(s3.isRevalidated).toHaveBeenCalledWith(\n        expect.objectContaining({ value }),\n        getCtx,\n        \"blog\",\n      );\n      expect(s3.get).toHaveBeenCalledTimes(1);\n\n      // And the memory copy is gone rather than checked again next time.\n      s3.get.mockResolvedValue(null);\n      expect(await cacheHandler.get(\"blog\", getCtx)).toBeNull();\n    });\n\n    it(\"keeps memory entries across resetRequestCache\", async () => {\n      // Next.js calls it at the start of every request; clearing the shared\n      // memory cache there sent every read to S3.\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>reset</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      // Add entry\n      await cacheHandler.set(\"reset-key\", testData, {\n        fetchCache: true as const,\n        tags: [\"reset-tag\"],\n      });\n\n      // Reset\n      await cacheHandler.resetRequestCache();\n\n      // Still answered from memory, without asking S3.\n      const s3 = {\n        get: jest.fn().mockResolvedValue(null),\n        isRevalidated: jest.fn().mockResolvedValue(false),\n      };\n      (cacheHandler as any).s3DynamoHandler = s3;\n      const result = await cacheHandler.get(\"reset-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n      expect(result?.value).toEqual(testData);\n      expect(s3.get).not.toHaveBeenCalled();\n    });\n  });\n\n  describe(\"Build-time behavior\", () => {\n    it(\"reads back a fetch entry it wrote, from memory and from disk\", async () => {\n      // `cacheComponents` prerenders each page twice: the first pass runs the\n      // `fetch` and `set`s it, the second must find it already cached or Next.js\n      // fails the build with \"encountered uncached or runtime data during\n      // prerendering\". A write-only build-time handler therefore makes\n      // `cache: 'force-cache'` unbuildable - measured against next.js's\n      // `test/e2e/app-dir/resume-data-cache`.\n      process.env.NEXT_PHASE = \"phase-production-build\";\n      process.env.CDK_NEXTJS_INIT_CACHE_DIR = mkdtempSync(\n        join(tmpdir(), \"cdk-nextjs-init-cache-\"),\n      );\n      try {\n        const data: IncrementalCacheValue = {\n          kind: CachedRouteKind.FETCH,\n          data: {\n            headers: {},\n            body: \"eyJyYW5kb20iOjF9\",\n            status: 200,\n            url: \"https://example.test/api/random\",\n          },\n          revalidate: 31536000,\n        };\n        const fetchUrl = \"https://example.test/api/random\";\n        const setCtx = {\n          fetchCache: true as const,\n          tags: [\"test\"],\n          fetchUrl,\n          fetchIdx: 1,\n        };\n        const getCtx: GetIncrementalFetchCacheContext = {\n          kind: IncrementalCacheKind.FETCH,\n          revalidate: 31536000,\n          fetchUrl,\n          fetchIdx: 1,\n          tags: [\"test\"],\n        };\n        const buildHandler = new CdkNextjsCacheHandler(createMockContext());\n        await buildHandler.set(\"fetch-key\", data, setCtx);\n        expect(await buildHandler.get(\"fetch-key\", getCtx)).toMatchObject({\n          value: data,\n        });\n\n        // A second instance reads the file rather than the map: `next build`\n        // renders pages in worker processes, so the pass that writes and the\n        // pass that reads are not always the same process.\n        const otherWorker = new CdkNextjsCacheHandler(createMockContext());\n        expect(await otherWorker.get(\"fetch-key\", getCtx)).toMatchObject({\n          value: data,\n        });\n        expect(await otherWorker.get(\"never-written\", getCtx)).toBeNull();\n      } finally {\n        delete process.env.NEXT_PHASE;\n        delete process.env.CDK_NEXTJS_INIT_CACHE_DIR;\n      }\n    });\n  });\n});\n"]}

package/lib/adapter/cache-kinds.d.ts

@@ -0,0 +1,32 @@
+import { CachedRouteKind } from "next/dist/server/response-cache/index.js";
+import type { PrerenderVariants } from "./cache-utils";
+/** The fields of `ctx.outputs` a cache kind is read from. */
+export interface CacheKindOutputs {
+    readonly pages: ReadonlyArray<{
+        id: string;
+    }>;
+    readonly appPages: ReadonlyArray<{
+        id: string;
+    }>;
+    readonly appRoutes: ReadonlyArray<{
+        id: string;
+    }>;
+}
+/**
+ * Returns which kind of cache entry to seed for one prerendered route, or
+ * `undefined` for a route whose owner writes no response-cache entry.
+ *
+ * Read from the prerender's `parentOutputId`, which `next build` sets to the
+ * `id` of the output that renders it — not by matching the pathname against
+ * route templates. Matching had to reimplement Next's dynamic-segment grammar
+ * and got it wrong twice: it required as many segments as the template had, so
+ * no `[...slug]` or `[[...rest]]` prerender ever got a kind and every one was a
+ * MISS on first request; and it knew the Pages Router home page only as the
+ * `/index` its output reports, while its HTML prerender is grouped under `/`, so
+ * that page was never seeded either. The parent link has neither problem, and it
+ * cannot hand a prerender to the wrong one of two templates that both match its
+ * pathname (`/about` against an app route `/[slug]`).
+ */
+export declare function cacheKindResolver(outputs: CacheKindOutputs): (variants: PrerenderVariants<{
+    parentOutputId: string;
+}>) => CachedRouteKind | undefined;

package/lib/adapter/cache-kinds.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheKindResolver = cacheKindResolver;
+/**
+ * Returns which kind of cache entry to seed for one prerendered route, or
+ * `undefined` for a route whose owner writes no response-cache entry.
+ *
+ * Read from the prerender's `parentOutputId`, which `next build` sets to the
+ * `id` of the output that renders it — not by matching the pathname against
+ * route templates. Matching had to reimplement Next's dynamic-segment grammar
+ * and got it wrong twice: it required as many segments as the template had, so
+ * no `[...slug]` or `[[...rest]]` prerender ever got a kind and every one was a
+ * MISS on first request; and it knew the Pages Router home page only as the
+ * `/index` its output reports, while its HTML prerender is grouped under `/`, so
+ * that page was never seeded either. The parent link has neither problem, and it
+ * cannot hand a prerender to the wrong one of two templates that both match its
+ * pathname (`/about` against an app route `/[slug]`).
+ */
+function cacheKindResolver(outputs) {
+    const kindById = new Map();
+    for (const { id } of outputs.pages) {
+        kindById.set(id, "PAGES" /* CachedRouteKind.PAGES */);
+    }
+    for (const { id } of outputs.appPages) {
+        kindById.set(id, "APP_PAGE" /* CachedRouteKind.APP_PAGE */);
+    }
+    for (const { id } of outputs.appRoutes) {
+        kindById.set(id, "APP_ROUTE" /* CachedRouteKind.APP_ROUTE */);
+    }
+    return (variants) => {
+        const source = variants.html ?? variants.rsc ?? variants.data ?? variants.segments[0];
+        return source ? kindById.get(source.parentOutputId) : undefined;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/adapter/cache-kinds.test.d.ts

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

package/lib/adapter/cache-kinds.test.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const app_playground_json_1 = __importDefault(require("./__fixtures__/app-playground.json"));
+const pages_i18n_json_1 = __importDefault(require("./__fixtures__/pages-i18n.json"));
+const cache_kinds_1 = require("./cache-kinds");
+const cache_utils_1 = require("./cache-utils");
+const prerender = (pathname, parentOutputId) => ({
+    pathname,
+    parentOutputId,
+});
+describe("cacheKindResolver", () => {
+    it.each([
+        ["app-playground", app_playground_json_1.default],
+        ["pages-i18n", pages_i18n_json_1.default],
+    ])("gives every prerendered route in %s a kind", (_, fixture) => {
+        const kindOf = (0, cache_kinds_1.cacheKindResolver)(fixture.outputs);
+        const groups = (0, cache_utils_1.groupPrerenders)(fixture.outputs.prerenders);
+        const unkinded = [...groups]
+            .filter(([, variants]) => kindOf(variants) === undefined)
+            .map(([route]) => route);
+        expect(unkinded).toEqual([]);
+    });
+    it("seeds catch-all and optional catch-all prerenders", () => {
+        const kindOf = (0, cache_kinds_1.cacheKindResolver)({
+            pages: [{ id: "/docs/[...slug]" }],
+            appPages: [{ id: "/shop/[[...rest]]" }],
+            appRoutes: [],
+        });
+        const groups = (0, cache_utils_1.groupPrerenders)([
+            prerender("/docs/a/b", "/docs/[...slug]"),
+            prerender("/shop", "/shop/[[...rest]]"),
+            prerender("/shop/x/y/z", "/shop/[[...rest]]"),
+            prerender("/shop/x/y/z.rsc", "/shop/[[...rest]]"),
+        ]);
+        expect(kindOf(groups.get("/docs/a/b"))).toBe("PAGES" /* CachedRouteKind.PAGES */);
+        expect(kindOf(groups.get("/shop"))).toBe("APP_PAGE" /* CachedRouteKind.APP_PAGE */);
+        expect(kindOf(groups.get("/shop/x/y/z"))).toBe("APP_PAGE" /* CachedRouteKind.APP_PAGE */);
+    });
+    it("seeds a Pages Router SSG home page, which its output reports as /index", () => {
+        const kindOf = (0, cache_kinds_1.cacheKindResolver)({
+            pages: [{ id: "/index" }],
+            appPages: [],
+            appRoutes: [],
+        });
+        const groups = (0, cache_utils_1.groupPrerenders)([
+            prerender("/", "/index"),
+            prerender("/_next/data/b/index.json", "/index"),
+        ]);
+        expect([...groups.keys()]).toEqual(["/"]);
+        expect(kindOf(groups.get("/"))).toBe("PAGES" /* CachedRouteKind.PAGES */);
+    });
+    it("takes the kind from the owning output, not from a template the path also matches", () => {
+        const kindOf = (0, cache_kinds_1.cacheKindResolver)({
+            pages: [],
+            appPages: [{ id: "/about" }],
+            appRoutes: [{ id: "/[slug]" }],
+        });
+        const groups = (0, cache_utils_1.groupPrerenders)([
+            prerender("/about", "/about"),
+            prerender("/feed", "/[slug]"),
+        ]);
+        expect(kindOf(groups.get("/about"))).toBe("APP_PAGE" /* CachedRouteKind.APP_PAGE */);
+        expect(kindOf(groups.get("/feed"))).toBe("APP_ROUTE" /* CachedRouteKind.APP_ROUTE */);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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