cdk-nextjs 0.5.14 → 0.5.15

package/lib/adapter/memory-cache-handler.d.ts

@@ -64,7 +64,7 @@ export declare class MemoryCacheHandler implements CacheHandler {
     private readonly maxEntries;
     constructor(options: MemoryCacheHandlerOptions);
     get(cacheKey: string, ctx: GetIncrementalFetchCacheContext | GetIncrementalResponseCacheContext): Promise<CacheHandlerValue | null>;
-    set(cacheKey: string, data: IncrementalCacheValue | null, _ctx: SetIncrementalFetchCacheContext | SetIncrementalResponseCacheContext): Promise<void>;
+    set(cacheKey: string, data: IncrementalCacheValue | null, ctx: SetIncrementalFetchCacheContext | SetIncrementalResponseCacheContext): Promise<void>;
     revalidateTag(tag: string | string[]): Promise<void>;
     resetRequestCache(): Promise<void>;
     /**

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

@@ -9,6 +9,7 @@ exports.MemoryCacheHandler = void 0;
 */
 /* eslint-disable import/no-extraneous-dependencies */
 const debug_1 = __importDefault(require("debug"));
+const cache_utils_1 = require("./cache-utils");
 class MemoryCacheHandler {
     inMemoryCache = new Map();
     debug = (0, debug_1.default)("cdk-nextjs:cache-handler:memory");
@@ -106,7 +107,7 @@ class MemoryCacheHandler {
         this.debug(`MEMORY CACHE MISS: ${cacheKey}`);
         return null;
     }
-    async set(cacheKey, data, _ctx) {
+    async set(cacheKey, data, ctx) {
         if (!data) {
             // Delete from memory cache
             this.debug(`MEMORY CACHE DELETE: ${cacheKey}`);
@@ -123,6 +124,7 @@ class MemoryCacheHandler {
         const entry = {
             value: cacheHandlerValue,
             expiresAt: Date.now() + this.ttlMs,
+            tags: (0, cache_utils_1.getTags)(ctx) || [],
         };
         // Clean up expired entries before adding new one
         this.cleanupExpired();
@@ -136,15 +138,19 @@ class MemoryCacheHandler {
     }
     async revalidateTag(tag) {
         const tags = Array.isArray(tag) ? tag : [tag];
-        this.debug(`MEMORY REVALIDATE TAGS (no-op): [${tags.join(", ")}]`);
-        // Memory cache does not track tags because:
-        // 1. In distributed environments (multiple Lambda functions or Fargate containers),
-        //    tag revalidation only clears cache on the current instance. Other instances
-        //    would continue serving stale data until their TTL expires anyway.
-        // 2. The S3 cache handler with DynamoDB provides the authoritative source of truth
-        //    for tag revalidations across all instances.
-        // 3. Memory cache relies on TTL-based expiration for simplicity and consistency.
-        //    If strong consistency is required, set CDK_NEXTJS_MEMORY_CACHE_TTL_MS=0.
+        let invalidatedCount = 0;
+        for (const [key, entry] of this.inMemoryCache.entries()) {
+            if (entry.tags.some((entryTag) => tags.includes(entryTag))) {
+                this.inMemoryCache.delete(key);
+                invalidatedCount++;
+            }
+        }
+        this.debug(`MEMORY REVALIDATE TAGS: [${tags.join(", ")}] removed ${invalidatedCount} entries`);
+        // Note: this only clears the cache on the instance handling this request.
+        // In distributed environments (multiple Lambda functions or Fargate containers),
+        // other instances continue serving their own memory-cached entries until those
+        // entries expire (ttlMs). Set CDK_NEXTJS_MEMORY_CACHE_TTL_MS=0 to disable the
+        // memory cache entirely if strong cross-instance consistency is required.
     }
     async resetRequestCache() {
         // Clear in-memory cache
@@ -186,4 +192,4 @@ class MemoryCacheHandler {
     }
 }
 exports.MemoryCacheHandler = MemoryCacheHandler;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"memory-cache-handler.js","sourceRoot":"","sources":["../../src/adapter/memory-cache-handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  In-memory cache handler with tag management\n*/\n/* eslint-disable import/no-extraneous-dependencies */\nimport getDebug from \"debug\";\nimport {\n  CacheHandler,\n  CacheHandlerValue,\n  CacheHandlerContext,\n} from \"next/dist/server/lib/incremental-cache\";\nimport {\n  IncrementalCacheValue,\n  GetIncrementalFetchCacheContext,\n  GetIncrementalResponseCacheContext,\n  SetIncrementalResponseCacheContext,\n  SetIncrementalFetchCacheContext,\n} from \"next/dist/server/response-cache\";\n\ninterface MemoryCacheEntry {\n  value: CacheHandlerValue;\n  expiresAt: number; // Timestamp in milliseconds\n}\n\nexport interface MemoryCacheHandlerOptions {\n  context: CacheHandlerContext;\n}\n\nexport class MemoryCacheHandler implements CacheHandler {\n  private inMemoryCache: Map<string, MemoryCacheEntry> = new Map();\n  private debug = getDebug(\"cdk-nextjs:cache-handler:memory\");\n\n  /**\n   * Time to live in milliseconds for cache entries.\n   * After this duration, entries expire and are removed from the cache.\n   *\n   * **Important**: Due to the distributed nature of compute instances (Lambda functions,\n   * ECS Fargate containers, etc.), this cache only provides eventual consistency across\n   * instances. Tag revalidations will clear the cache on the instance that processes\n   * the revalidation, but other instances may serve stale data until their cache entries expire.\n   *\n   * @example\n   * // Short TTL (5 minutes) - for frequently changing data\n   * ttlMs = 5 * 60 * 1000;\n   *\n   * @example\n   * // Medium TTL (1 hour) - balanced between freshness and performance\n   * ttlMs = 60 * 60 * 1000;\n   *\n   * @example\n   * // Long TTL (24 hours) - for mostly static content\n   * ttlMs = 24 * 60 * 60 * 1000;\n   *\n   * **Why adjust this?**\n   * - Lower values: More cache misses, fresher data, higher S3/DynamoDB costs\n   * - Higher values: Fewer cache misses, better performance, but longer stale data windows\n   *\n   * Set via environment variable: `CDK_NEXTJS_MEMORY_CACHE_TTL_MS`\n   */\n  private readonly ttlMs: number;\n\n  /**\n   * Maximum number of cache entries to store in memory.\n   * When this limit is reached, the least recently used (LRU) entry is evicted.\n   *\n   * @example\n   * // Small cache (100 entries) - minimal memory footprint for simple apps\n   * maxEntries = 100;\n   *\n   * @example\n   * // Medium cache (1000 entries) - good balance for typical applications\n   * maxEntries = 1000;\n   *\n   * @example\n   * // Large cache (10000 entries) - for high-traffic apps with many unique pages\n   * maxEntries = 10000;\n   *\n   * **Why adjust this?**\n   * - Lower values: Less memory usage, more cache evictions\n   * - Higher values: More memory usage, fewer cache evictions, better hit rates\n   *\n   * **Memory considerations**: Each entry stores the full cache value (HTML, JSON, etc.)\n   * A typical page cache might be 10-100KB, so 1000 entries ≈ 10-100MB of memory.\n   * Consider your compute environment's memory limits (Lambda: 128MB-10GB, Fargate: 512MB-30GB)\n   * and size accordingly.\n   *\n   * Set via environment variable: `CDK_NEXTJS_MEMORY_CACHE_MAX_ENTRIES`\n   */\n  private readonly maxEntries: number;\n\n  constructor(options: MemoryCacheHandlerOptions) {\n    // Read configuration from environment variables with fallback defaults\n    const ttlFromEnv = process.env.CDK_NEXTJS_MEMORY_CACHE_TTL_MS;\n    const maxEntriesFromEnv = process.env.CDK_NEXTJS_MEMORY_CACHE_MAX_ENTRIES;\n\n    // Default to 1 hour TTL and 1000 max entries\n    this.ttlMs = ttlFromEnv ? parseInt(ttlFromEnv, 10) : 60 * 60 * 1000; // 1 hour\n    this.maxEntries = maxEntriesFromEnv\n      ? parseInt(maxEntriesFromEnv, 10)\n      : 1000;\n\n    // Log the options for debugging (optional usage to avoid unused parameter warning)\n    if (options.context.dev) {\n      this.debug(\"MemoryCacheHandler initialized in development mode\");\n    }\n    this.debug(`TTL: ${this.ttlMs / 1000}s, Max entries: ${this.maxEntries}`);\n  }\n\n  async get(\n    cacheKey: string,\n    ctx: GetIncrementalFetchCacheContext | GetIncrementalResponseCacheContext,\n  ): Promise<CacheHandlerValue | null> {\n    // Log context for debugging (optional usage to avoid unused parameter warning)\n    if (ctx.kind) {\n      this.debug(\n        `Memory cache get operation for ${cacheKey} with kind: ${ctx.kind}`,\n      );\n    }\n\n    // Check in-memory cache\n    const memoryEntry = this.inMemoryCache.get(cacheKey);\n    if (memoryEntry) {\n      // Check if expired\n      if (Date.now() > memoryEntry.expiresAt) {\n        this.debug(`MEMORY CACHE EXPIRED: ${cacheKey}`);\n        this.inMemoryCache.delete(cacheKey);\n        return null;\n      }\n\n      // Move to end (most recently used) by deleting and re-inserting\n      this.inMemoryCache.delete(cacheKey);\n      this.inMemoryCache.set(cacheKey, memoryEntry);\n\n      this.debug(`MEMORY CACHE HIT: ${cacheKey}`);\n      return memoryEntry.value;\n    }\n\n    this.debug(`MEMORY CACHE MISS: ${cacheKey}`);\n    return null;\n  }\n\n  async set(\n    cacheKey: string,\n    data: IncrementalCacheValue | null,\n    _ctx: SetIncrementalFetchCacheContext | SetIncrementalResponseCacheContext,\n  ): Promise<void> {\n    if (!data) {\n      // Delete from memory cache\n      this.debug(`MEMORY CACHE DELETE: ${cacheKey}`);\n      this.inMemoryCache.delete(cacheKey);\n      return;\n    }\n\n    // Debug logging for memory cache set\n    this.debug(`MEMORY CACHE SET: ${cacheKey} (${data.kind})`);\n\n    // Store in memory cache with proper CacheHandlerValue structure\n    const cacheHandlerValue: CacheHandlerValue = {\n      lastModified: Date.now(),\n      value: data,\n    };\n\n    const entry: MemoryCacheEntry = {\n      value: cacheHandlerValue,\n      expiresAt: Date.now() + this.ttlMs,\n    };\n\n    // Clean up expired entries before adding new one\n    this.cleanupExpired();\n\n    // If we're at max capacity, evict oldest entry\n    if (this.inMemoryCache.size >= this.maxEntries) {\n      this.evictOldest();\n    }\n\n    // Add new entry\n    this.inMemoryCache.set(cacheKey, entry);\n\n    this.debug(`Cache entries: ${this.inMemoryCache.size}/${this.maxEntries}`);\n  }\n\n  async revalidateTag(tag: string | string[]): Promise<void> {\n    const tags = Array.isArray(tag) ? tag : [tag];\n    this.debug(`MEMORY REVALIDATE TAGS (no-op): [${tags.join(\", \")}]`);\n    // Memory cache does not track tags because:\n    // 1. In distributed environments (multiple Lambda functions or Fargate containers),\n    //    tag revalidation only clears cache on the current instance. Other instances\n    //    would continue serving stale data until their TTL expires anyway.\n    // 2. The S3 cache handler with DynamoDB provides the authoritative source of truth\n    //    for tag revalidations across all instances.\n    // 3. Memory cache relies on TTL-based expiration for simplicity and consistency.\n    //    If strong consistency is required, set CDK_NEXTJS_MEMORY_CACHE_TTL_MS=0.\n  }\n\n  async resetRequestCache(): Promise<void> {\n    // Clear in-memory cache\n    this.inMemoryCache.clear();\n  }\n\n  /**\n   * Remove all expired cache entries\n   */\n  private cleanupExpired(): void {\n    const now = Date.now();\n    let expiredCount = 0;\n\n    for (const [key, entry] of this.inMemoryCache.entries()) {\n      if (now > entry.expiresAt) {\n        this.inMemoryCache.delete(key);\n        expiredCount++;\n      }\n    }\n\n    if (expiredCount > 0) {\n      this.debug(`Cleaned up ${expiredCount} expired entries`);\n    }\n  }\n\n  /**\n   * Evict the oldest (least recently used) cache entry\n   * Map maintains insertion order, so first entry is oldest\n   */\n  private evictOldest(): void {\n    const firstKey = this.inMemoryCache.keys().next().value;\n    if (firstKey) {\n      this.debug(`MAX CAPACITY EVICT (LRU): ${firstKey}`);\n      this.inMemoryCache.delete(firstKey);\n    }\n  }\n\n  // Public methods for testing and monitoring\n  public getCacheSize(): number {\n    return this.inMemoryCache.size;\n  }\n\n  public clearCache(): void {\n    this.inMemoryCache.clear();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"memory-cache-handler.js","sourceRoot":"","sources":["../../src/adapter/memory-cache-handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  In-memory cache handler with tag management\n*/\n/* eslint-disable import/no-extraneous-dependencies */\nimport getDebug from \"debug\";\nimport {\n  CacheHandler,\n  CacheHandlerValue,\n  CacheHandlerContext,\n} from \"next/dist/server/lib/incremental-cache\";\nimport {\n  IncrementalCacheValue,\n  GetIncrementalFetchCacheContext,\n  GetIncrementalResponseCacheContext,\n  SetIncrementalResponseCacheContext,\n  SetIncrementalFetchCacheContext,\n} from \"next/dist/server/response-cache\";\nimport { getTags } from \"./cache-utils\";\n\ninterface MemoryCacheEntry {\n  value: CacheHandlerValue;\n  expiresAt: number; // Timestamp in milliseconds\n  tags: string[];\n}\n\nexport interface MemoryCacheHandlerOptions {\n  context: CacheHandlerContext;\n}\n\nexport class MemoryCacheHandler implements CacheHandler {\n  private inMemoryCache: Map<string, MemoryCacheEntry> = new Map();\n  private debug = getDebug(\"cdk-nextjs:cache-handler:memory\");\n\n  /**\n   * Time to live in milliseconds for cache entries.\n   * After this duration, entries expire and are removed from the cache.\n   *\n   * **Important**: Due to the distributed nature of compute instances (Lambda functions,\n   * ECS Fargate containers, etc.), this cache only provides eventual consistency across\n   * instances. Tag revalidations will clear the cache on the instance that processes\n   * the revalidation, but other instances may serve stale data until their cache entries expire.\n   *\n   * @example\n   * // Short TTL (5 minutes) - for frequently changing data\n   * ttlMs = 5 * 60 * 1000;\n   *\n   * @example\n   * // Medium TTL (1 hour) - balanced between freshness and performance\n   * ttlMs = 60 * 60 * 1000;\n   *\n   * @example\n   * // Long TTL (24 hours) - for mostly static content\n   * ttlMs = 24 * 60 * 60 * 1000;\n   *\n   * **Why adjust this?**\n   * - Lower values: More cache misses, fresher data, higher S3/DynamoDB costs\n   * - Higher values: Fewer cache misses, better performance, but longer stale data windows\n   *\n   * Set via environment variable: `CDK_NEXTJS_MEMORY_CACHE_TTL_MS`\n   */\n  private readonly ttlMs: number;\n\n  /**\n   * Maximum number of cache entries to store in memory.\n   * When this limit is reached, the least recently used (LRU) entry is evicted.\n   *\n   * @example\n   * // Small cache (100 entries) - minimal memory footprint for simple apps\n   * maxEntries = 100;\n   *\n   * @example\n   * // Medium cache (1000 entries) - good balance for typical applications\n   * maxEntries = 1000;\n   *\n   * @example\n   * // Large cache (10000 entries) - for high-traffic apps with many unique pages\n   * maxEntries = 10000;\n   *\n   * **Why adjust this?**\n   * - Lower values: Less memory usage, more cache evictions\n   * - Higher values: More memory usage, fewer cache evictions, better hit rates\n   *\n   * **Memory considerations**: Each entry stores the full cache value (HTML, JSON, etc.)\n   * A typical page cache might be 10-100KB, so 1000 entries ≈ 10-100MB of memory.\n   * Consider your compute environment's memory limits (Lambda: 128MB-10GB, Fargate: 512MB-30GB)\n   * and size accordingly.\n   *\n   * Set via environment variable: `CDK_NEXTJS_MEMORY_CACHE_MAX_ENTRIES`\n   */\n  private readonly maxEntries: number;\n\n  constructor(options: MemoryCacheHandlerOptions) {\n    // Read configuration from environment variables with fallback defaults\n    const ttlFromEnv = process.env.CDK_NEXTJS_MEMORY_CACHE_TTL_MS;\n    const maxEntriesFromEnv = process.env.CDK_NEXTJS_MEMORY_CACHE_MAX_ENTRIES;\n\n    // Default to 1 hour TTL and 1000 max entries\n    this.ttlMs = ttlFromEnv ? parseInt(ttlFromEnv, 10) : 60 * 60 * 1000; // 1 hour\n    this.maxEntries = maxEntriesFromEnv\n      ? parseInt(maxEntriesFromEnv, 10)\n      : 1000;\n\n    // Log the options for debugging (optional usage to avoid unused parameter warning)\n    if (options.context.dev) {\n      this.debug(\"MemoryCacheHandler initialized in development mode\");\n    }\n    this.debug(`TTL: ${this.ttlMs / 1000}s, Max entries: ${this.maxEntries}`);\n  }\n\n  async get(\n    cacheKey: string,\n    ctx: GetIncrementalFetchCacheContext | GetIncrementalResponseCacheContext,\n  ): Promise<CacheHandlerValue | null> {\n    // Log context for debugging (optional usage to avoid unused parameter warning)\n    if (ctx.kind) {\n      this.debug(\n        `Memory cache get operation for ${cacheKey} with kind: ${ctx.kind}`,\n      );\n    }\n\n    // Check in-memory cache\n    const memoryEntry = this.inMemoryCache.get(cacheKey);\n    if (memoryEntry) {\n      // Check if expired\n      if (Date.now() > memoryEntry.expiresAt) {\n        this.debug(`MEMORY CACHE EXPIRED: ${cacheKey}`);\n        this.inMemoryCache.delete(cacheKey);\n        return null;\n      }\n\n      // Move to end (most recently used) by deleting and re-inserting\n      this.inMemoryCache.delete(cacheKey);\n      this.inMemoryCache.set(cacheKey, memoryEntry);\n\n      this.debug(`MEMORY CACHE HIT: ${cacheKey}`);\n      return memoryEntry.value;\n    }\n\n    this.debug(`MEMORY CACHE MISS: ${cacheKey}`);\n    return null;\n  }\n\n  async set(\n    cacheKey: string,\n    data: IncrementalCacheValue | null,\n    ctx: SetIncrementalFetchCacheContext | SetIncrementalResponseCacheContext,\n  ): Promise<void> {\n    if (!data) {\n      // Delete from memory cache\n      this.debug(`MEMORY CACHE DELETE: ${cacheKey}`);\n      this.inMemoryCache.delete(cacheKey);\n      return;\n    }\n\n    // Debug logging for memory cache set\n    this.debug(`MEMORY CACHE SET: ${cacheKey} (${data.kind})`);\n\n    // Store in memory cache with proper CacheHandlerValue structure\n    const cacheHandlerValue: CacheHandlerValue = {\n      lastModified: Date.now(),\n      value: data,\n    };\n\n    const entry: MemoryCacheEntry = {\n      value: cacheHandlerValue,\n      expiresAt: Date.now() + this.ttlMs,\n      tags: getTags(ctx) || [],\n    };\n\n    // Clean up expired entries before adding new one\n    this.cleanupExpired();\n\n    // If we're at max capacity, evict oldest entry\n    if (this.inMemoryCache.size >= this.maxEntries) {\n      this.evictOldest();\n    }\n\n    // Add new entry\n    this.inMemoryCache.set(cacheKey, entry);\n\n    this.debug(`Cache entries: ${this.inMemoryCache.size}/${this.maxEntries}`);\n  }\n\n  async revalidateTag(tag: string | string[]): Promise<void> {\n    const tags = Array.isArray(tag) ? tag : [tag];\n    let invalidatedCount = 0;\n\n    for (const [key, entry] of this.inMemoryCache.entries()) {\n      if (entry.tags.some((entryTag) => tags.includes(entryTag))) {\n        this.inMemoryCache.delete(key);\n        invalidatedCount++;\n      }\n    }\n\n    this.debug(\n      `MEMORY REVALIDATE TAGS: [${tags.join(\", \")}] removed ${invalidatedCount} entries`,\n    );\n\n    // Note: this only clears the cache on the instance handling this request.\n    // In distributed environments (multiple Lambda functions or Fargate containers),\n    // other instances continue serving their own memory-cached entries until those\n    // entries expire (ttlMs). Set CDK_NEXTJS_MEMORY_CACHE_TTL_MS=0 to disable the\n    // memory cache entirely if strong cross-instance consistency is required.\n  }\n\n  async resetRequestCache(): Promise<void> {\n    // Clear in-memory cache\n    this.inMemoryCache.clear();\n  }\n\n  /**\n   * Remove all expired cache entries\n   */\n  private cleanupExpired(): void {\n    const now = Date.now();\n    let expiredCount = 0;\n\n    for (const [key, entry] of this.inMemoryCache.entries()) {\n      if (now > entry.expiresAt) {\n        this.inMemoryCache.delete(key);\n        expiredCount++;\n      }\n    }\n\n    if (expiredCount > 0) {\n      this.debug(`Cleaned up ${expiredCount} expired entries`);\n    }\n  }\n\n  /**\n   * Evict the oldest (least recently used) cache entry\n   * Map maintains insertion order, so first entry is oldest\n   */\n  private evictOldest(): void {\n    const firstKey = this.inMemoryCache.keys().next().value;\n    if (firstKey) {\n      this.debug(`MAX CAPACITY EVICT (LRU): ${firstKey}`);\n      this.inMemoryCache.delete(firstKey);\n    }\n  }\n\n  // Public methods for testing and monitoring\n  public getCacheSize(): number {\n    return this.inMemoryCache.size;\n  }\n\n  public clearCache(): void {\n    this.inMemoryCache.clear();\n  }\n}\n"]}

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

@@ -64,6 +64,62 @@ describe("MemoryCacheHandler", () => {
             expect(result?.value).toEqual(testData);
         });
     });
+    describe("revalidateTag", () => {
+        const testData = {
+            kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+            html: "<html>tagged</html>",
+            rscData: undefined,
+            headers: undefined,
+            postponed: undefined,
+            segmentData: undefined,
+            status: undefined,
+        };
+        it("should remove entries tagged with the revalidated tag", async () => {
+            await handler.set("tagged-key", testData, {
+                fetchCache: true,
+                tags: ["collection"],
+            });
+            await handler.revalidateTag("collection");
+            const result = await handler.get("tagged-key", {
+                kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
+                isFallback: false,
+            });
+            expect(result).toBeNull();
+            expect(handler.getCacheSize()).toBe(0);
+        });
+        it("should not remove entries with unrelated tags", async () => {
+            await handler.set("unrelated-key", testData, {
+                fetchCache: true,
+                tags: ["other-tag"],
+            });
+            await handler.revalidateTag("collection");
+            const result = await handler.get("unrelated-key", {
+                kind: "APP_PAGE" /* IncrementalCacheKind.APP_PAGE */,
+                isFallback: false,
+            });
+            expect(result).not.toBeNull();
+            expect(handler.getCacheSize()).toBe(1);
+        });
+        it("should accept an array of tags and remove any matching entries", async () => {
+            await handler.set("key-a", testData, {
+                fetchCache: true,
+                tags: ["tag-a"],
+            });
+            await handler.set("key-b", testData, {
+                fetchCache: true,
+                tags: ["tag-b"],
+            });
+            await handler.revalidateTag(["tag-a", "tag-b"]);
+            expect(handler.getCacheSize()).toBe(0);
+        });
+        it("should be a no-op when no entries match the tag", async () => {
+            await handler.set("untagged-key", testData, {
+                fetchCache: true,
+            });
+            await expect(handler.revalidateTag("nonexistent-tag")).resolves.not.toThrow();
+            expect(handler.getCacheSize()).toBe(1);
+        });
+    });
     describe("resetRequestCache", () => {
         it("should clear all caches", async () => {
             const testData = {
@@ -84,4 +140,4 @@ describe("MemoryCacheHandler", () => {
         });
     });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"memory-cache-handler.test.js","sourceRoot":"","sources":["../../src/adapter/memory-cache-handler.test.ts"],"names":[],"mappings":";;AAOA,iEAA4D;AAE5D,QAAQ,CAAC,oBAAoB,EAAE,GAAG,EAAE;IAClC,IAAI,OAA2B,CAAC;IAChC,IAAI,WAAgC,CAAC;IAErC,UAAU,CAAC,GAAG,EAAE;QACd,WAAW,GAAG,EAAE,GAAG,EAAE,KAAK,EAAyB,CAAC;QAEpD,OAAO,GAAG,IAAI,yCAAkB,CAAC;YAC/B,OAAO,EAAE,WAAW;SACrB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,SAAS,CAAC,GAAG,EAAE;QACb,OAAO,CAAC,UAAU,EAAE,CAAC;IACvB,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE;QACnB,EAAE,CAAC,+CAA+C,EAAE,KAAK,IAAI,EAAE;YAC7D,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE;gBAC/C,IAAI,gDAA+B;gBACnC,UAAU,EAAE,KAAK;aAClB,CAAC,CAAC;YACH,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,wCAAwC,EAAE,KAAK,IAAI,EAAE;YACtD,MAAM,QAAQ,GAA0B;gBACtC,IAAI,2CAA0B;gBAC9B,IAAI,EAAE,mBAAmB;gBACzB,OAAO,EAAE,SAAS;gBAClB,OAAO,EAAE,SAAS;gBAClB,SAAS,EAAE,SAAS;gBACpB,WAAW,EAAE,SAAS;gBACtB,MAAM,EAAE,SAAS;aAClB,CAAC;YAEF,MAAM,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,QAAQ,EAAE;gBACtC,UAAU,EAAE,IAAa;aAC1B,CAAC,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE;gBAC3C,IAAI,gDAA+B;gBACnC,UAAU,EAAE,KAAK;aAClB,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC;YAC9B,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE;QACnB,EAAE,CAAC,oCAAoC,EAAE,KAAK,IAAI,EAAE;YAClD,MAAM,QAAQ,GAA0B;gBACtC,IAAI,2CAA0B;gBAC9B,IAAI,EAAE,uBAAuB;gBAC7B,OAAO,EAAE,SAAS;gBAClB,OAAO,EAAE,SAAS;gBAClB,SAAS,EAAE,SAAS;gBACpB,WAAW,EAAE,SAAS;gBACtB,MAAM,EAAE,SAAS;aAClB,CAAC;YAEF,MAAM,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,EAAE;gBACrC,UAAU,EAAE,IAAa;aAC1B,CAAC,CAAC;YAEH,MAAM,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAEvC,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE;gBAC1C,IAAI,gDAA+B;gBACnC,UAAU,EAAE,KAAK;aAClB,CAAC,CAAC;YACH,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE;QAC7B,MAAM,QAAQ,GAA0B;YACtC,IAAI,2CAA0B;YAC9B,IAAI,EAAE,qBAAqB;YAC3B,OAAO,EAAE,SAAS;YAClB,OAAO,EAAE,SAAS;YAClB,SAAS,EAAE,SAAS;YACpB,WAAW,EAAE,SAAS;YACtB,MAAM,EAAE,SAAS;SAClB,CAAC;QAEF,EAAE,CAAC,uDAAuD,EAAE,KAAK,IAAI,EAAE;YACrE,MAAM,OAAO,CAAC,GAAG,CAAC,YAAY,EAAE,QAAQ,EAAE;gBACxC,UAAU,EAAE,IAAa;gBACzB,IAAI,EAAE,CAAC,YAAY,CAAC;aACrB,CAAC,CAAC;YAEH,MAAM,OAAO,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;YAE1C,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,YAAY,EAAE;gBAC7C,IAAI,gDAA+B;gBACnC,UAAU,EAAE,KAAK;aAClB,CAAC,CAAC;YACH,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC;YAC1B,MAAM,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACzC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,+CAA+C,EAAE,KAAK,IAAI,EAAE;YAC7D,MAAM,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,QAAQ,EAAE;gBAC3C,UAAU,EAAE,IAAa;gBACzB,IAAI,EAAE,CAAC,WAAW,CAAC;aACpB,CAAC,CAAC;YAEH,MAAM,OAAO,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;YAE1C,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE;gBAChD,IAAI,gDAA+B;gBACnC,UAAU,EAAE,KAAK;aAClB,CAAC,CAAC;YACH,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC;YAC9B,MAAM,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACzC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,gEAAgE,EAAE,KAAK,IAAI,EAAE;YAC9E,MAAM,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,EAAE;gBACnC,UAAU,EAAE,IAAa;gBACzB,IAAI,EAAE,CAAC,OAAO,CAAC;aAChB,CAAC,CAAC;YACH,MAAM,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,EAAE;gBACnC,UAAU,EAAE,IAAa;gBACzB,IAAI,EAAE,CAAC,OAAO,CAAC;aAChB,CAAC,CAAC;YAEH,MAAM,OAAO,CAAC,aAAa,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;YAEhD,MAAM,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACzC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,iDAAiD,EAAE,KAAK,IAAI,EAAE;YAC/D,MAAM,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,QAAQ,EAAE;gBAC1C,UAAU,EAAE,IAAa;aAC1B,CAAC,CAAC;YAEH,MAAM,MAAM,CACV,OAAO,CAAC,aAAa,CAAC,iBAAiB,CAAC,CACzC,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;YACzB,MAAM,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACzC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,mBAAmB,EAAE,GAAG,EAAE;QACjC,EAAE,CAAC,yBAAyB,EAAE,KAAK,IAAI,EAAE;YACvC,MAAM,QAAQ,GAA0B;gBACtC,IAAI,2CAA0B;gBAC9B,IAAI,EAAE,yBAAyB;gBAC/B,OAAO,EAAE,SAAS;gBAClB,OAAO,EAAE,SAAS;gBAClB,SAAS,EAAE,SAAS;gBACpB,WAAW,EAAE,SAAS;gBACtB,MAAM,EAAE,SAAS;aAClB,CAAC;YAEF,MAAM,OAAO,CAAC,GAAG,CAAC,WAAW,EAAE,QAAQ,EAAE;gBACvC,UAAU,EAAE,IAAa;aAC1B,CAAC,CAAC;YAEH,MAAM,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAEvC,MAAM,OAAO,CAAC,iBAAiB,EAAE,CAAC;YAElC,MAAM,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACzC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","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 { MemoryCacheHandler } from \"./memory-cache-handler\";\n\ndescribe(\"MemoryCacheHandler\", () => {\n  let handler: MemoryCacheHandler;\n  let mockContext: CacheHandlerContext;\n\n  beforeEach(() => {\n    mockContext = { dev: false } as CacheHandlerContext;\n\n    handler = new MemoryCacheHandler({\n      context: mockContext,\n    });\n  });\n\n  afterEach(() => {\n    handler.clearCache();\n  });\n\n  describe(\"get\", () => {\n    it(\"should return null for non-existent cache key\", async () => {\n      const result = await handler.get(\"non-existent\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n      expect(result).toBeNull();\n    });\n\n    it(\"should return cached value from memory\", 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      await handler.set(\"test-key\", testData, {\n        fetchCache: true as const,\n      });\n      const result = await handler.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\n  describe(\"set\", () => {\n    it(\"should store value in memory cache\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>set test</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      await handler.set(\"set-key\", testData, {\n        fetchCache: true as const,\n      });\n\n      expect(handler.getCacheSize()).toBe(1);\n\n      const result = await handler.get(\"set-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n      expect(result?.value).toEqual(testData);\n    });\n  });\n\n  describe(\"revalidateTag\", () => {\n    const testData: IncrementalCacheValue = {\n      kind: CachedRouteKind.APP_PAGE,\n      html: \"<html>tagged</html>\",\n      rscData: undefined,\n      headers: undefined,\n      postponed: undefined,\n      segmentData: undefined,\n      status: undefined,\n    };\n\n    it(\"should remove entries tagged with the revalidated tag\", async () => {\n      await handler.set(\"tagged-key\", testData, {\n        fetchCache: true as const,\n        tags: [\"collection\"],\n      });\n\n      await handler.revalidateTag(\"collection\");\n\n      const result = await handler.get(\"tagged-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n      expect(result).toBeNull();\n      expect(handler.getCacheSize()).toBe(0);\n    });\n\n    it(\"should not remove entries with unrelated tags\", async () => {\n      await handler.set(\"unrelated-key\", testData, {\n        fetchCache: true as const,\n        tags: [\"other-tag\"],\n      });\n\n      await handler.revalidateTag(\"collection\");\n\n      const result = await handler.get(\"unrelated-key\", {\n        kind: IncrementalCacheKind.APP_PAGE,\n        isFallback: false,\n      });\n      expect(result).not.toBeNull();\n      expect(handler.getCacheSize()).toBe(1);\n    });\n\n    it(\"should accept an array of tags and remove any matching entries\", async () => {\n      await handler.set(\"key-a\", testData, {\n        fetchCache: true as const,\n        tags: [\"tag-a\"],\n      });\n      await handler.set(\"key-b\", testData, {\n        fetchCache: true as const,\n        tags: [\"tag-b\"],\n      });\n\n      await handler.revalidateTag([\"tag-a\", \"tag-b\"]);\n\n      expect(handler.getCacheSize()).toBe(0);\n    });\n\n    it(\"should be a no-op when no entries match the tag\", async () => {\n      await handler.set(\"untagged-key\", testData, {\n        fetchCache: true as const,\n      });\n\n      await expect(\n        handler.revalidateTag(\"nonexistent-tag\"),\n      ).resolves.not.toThrow();\n      expect(handler.getCacheSize()).toBe(1);\n    });\n  });\n\n  describe(\"resetRequestCache\", () => {\n    it(\"should clear all caches\", async () => {\n      const testData: IncrementalCacheValue = {\n        kind: CachedRouteKind.APP_PAGE,\n        html: \"<html>reset test</html>\",\n        rscData: undefined,\n        headers: undefined,\n        postponed: undefined,\n        segmentData: undefined,\n        status: undefined,\n      };\n\n      await handler.set(\"reset-key\", testData, {\n        fetchCache: true as const,\n      });\n\n      expect(handler.getCacheSize()).toBe(1);\n\n      await handler.resetRequestCache();\n\n      expect(handler.getCacheSize()).toBe(0);\n    });\n  });\n});\n"]}

package/lib/adapter/s3-cache-handler.d.ts

@@ -10,22 +10,55 @@ interface DynamoDBRevalidationConfig {
     region: string;
     buildId: string;
 }
+interface CloudFrontInvalidationConfig {
+    /**
+     * Name (not value) of the SSM Parameter holding the distribution ID.
+     *
+     * The distribution ID itself can't be passed as a plain env var: CDK
+     * constructs the Lambda/Fargate task before the distribution exists (the
+     * distribution's origin references the compute's function URL/ALB), so
+     * embedding the distribution's physical ID directly in the compute's
+     * environment or IAM policy would create a circular CloudFormation
+     * dependency. The parameter *name* is static and known at synth time, so
+     * it can be safely embedded; only its *value* depends on the distribution.
+     */
+    distributionIdParameterName: string;
+    region: string;
+}
 export interface S3CacheHandlerOptions {
     context: CacheHandlerContext;
     s3Config?: Partial<S3CacheConfig>;
     dynamoConfig?: Partial<DynamoDBRevalidationConfig>;
+    cloudFrontConfig?: Partial<CloudFrontInvalidationConfig>;
 }
 export declare class S3CacheHandler implements CacheHandler {
     private s3Client;
     private dynamoClient;
+    private cloudFrontClient;
+    private ssmClient;
     private s3Config;
     private dynamoConfig;
+    private cloudFrontConfig;
     private debug;
+    private cachedDistributionId;
     constructor(options: S3CacheHandlerOptions);
     get(cacheKey: string, ctx: GetIncrementalFetchCacheContext | GetIncrementalResponseCacheContext): Promise<CacheHandlerValue | null>;
     set(cacheKey: string, data: IncrementalCacheValue | null, ctx: SetIncrementalFetchCacheContext | SetIncrementalResponseCacheContext): Promise<void>;
     revalidateTag(tag: string | string[]): Promise<void>;
     private revalidateSingleTag;
+    /**
+     * Reverses `buildS3Key` to recover the request path CloudFront cached the
+     * response under. Fetch-cache entries (opaque hash keys, not page routes)
+     * translate to a path that won't match anything cached, which is harmless.
+     */
+    private s3KeyToInvalidationPath;
+    private invalidateCloudFrontPaths;
+    /**
+     * Resolves the distribution's physical ID via SSM Parameter Store, caching
+     * it for the lifetime of this instance. See `CloudFrontInvalidationConfig`
+     * for why this indirection (rather than a plain env var) is necessary.
+     */
+    private getDistributionId;
     resetRequestCache(): Promise<void>;
     private buildS3Key;
     private storeDynamoDBTagMappings;