review fix

Author: Nicolas Dorseuil

.changeset/slow-walls-allow.md

@@ -4,4 +4,5 @@
 
 Add an option to keep the data cache persistent between deployments.
 
-BREAKING CHANGE: Incremental cache keys are now an object of type `CacheKey` instead of a string. The new type includes properties like `baseKey`, `buildId`, and `cacheType`. Build_id is automatically provided according to the cache type and the `dangerous.persistentDataCache` option. Up to the Incremental Cache implementation to use it as they see fit.
+BREAKING CHANGE: Incremental cache keys are now an object of type `CacheKey` instead of a string. The new type includes properties like `baseKey`, `buildId`, and `cacheType`. Build_id is automatically provided according to the cache type and the `dangerous.persistentDataCache` option. Up to the Incremental Cache implementation to use it as they see fit.
+**Custom Incremental cache will need to be updated**

packages/open-next/src/adapters/composable-cache.ts

@@ -1,42 +1,15 @@
 import type { ComposableCacheEntry, ComposableCacheHandler } from "types/cache";
 import type { CacheKey } from "types/overrides";
-import { writeTags } from "utils/cache";
+import { createCacheKey, writeTags } from "utils/cache";
 import { fromReadableStream, toReadableStream } from "utils/stream";
 import { debug, warn } from "./logger";
 
 const pendingWritePromiseMap = new Map<string, Promise<ComposableCacheEntry>>();
-/**
- * Get the cache key for a composable entry.
- * Composable cache keys are a special cases as they are a stringified version of a tuple composed of a representation of the BUILD_ID and the actual key.
- * @param key The composable cache key
- * @returns The composable cache key.
- */
-function getComposableCacheKey(key: string): CacheKey<"composable"> {
-  try {
-    const shouldPrependBuildId =
-      globalThis.openNextConfig.dangerous?.persistentDataCache !== true;
-    const [_buildId, ...rest] = JSON.parse(key);
-    return {
-      cacheType: "composable",
-      buildId: shouldPrependBuildId ? _buildId : undefined,
-      baseKey: JSON.stringify(rest),
-    } as CacheKey<"composable">;
-  } catch (e) {
-    warn("Error while parsing composable cache key", e);
-    // If we fail to parse the key, we just return it as is
-    // This is not ideal, but we don't want to crash the application
-    return {
-      cacheType: "composable",
-      buildId: process.env.NEXT_BUILD_ID ?? "undefined-build-id",
-      baseKey: key,
-    };
-  }
-}
 
 export default {
   async get(key: string) {
     try {
-      const cacheKey = getComposableCacheKey(key);
+      const cacheKey = createCacheKey({ key, type: "composable" });
       // We first check if we have a pending write for this cache key
       // If we do, we return the pending promise instead of fetching the cache
       if (pendingWritePromiseMap.has(cacheKey.baseKey)) {
@@ -82,7 +55,7 @@ export default {
   },
 
   async set(key: string, pendingEntry: Promise<ComposableCacheEntry>) {
-    const cacheKey = getComposableCacheKey(key);
+    const cacheKey = createCacheKey({ key, type: "composable" });
     pendingWritePromiseMap.set(cacheKey.baseKey, pendingEntry);
     const entry = await pendingEntry.finally(() => {
       pendingWritePromiseMap.delete(cacheKey.baseKey);

packages/open-next/src/overrides/incrementalCache/fs-dev.ts

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 
-import type { IncrementalCache } from "types/overrides.js";
+import type { CacheKey, IncrementalCache } from "types/overrides.js";
 import { getMonorepoRelativePath } from "utils/normalize-path";
 
 const basePath = path.join(getMonorepoRelativePath(), "cache");
@@ -12,7 +12,9 @@ const getCacheKey = (key: string) => {
 
 const cache: IncrementalCache = {
   name: "fs-dev",
-  get: async ({ baseKey }) => {
+  get: async (cacheKey: CacheKey) => {
+    // This cache is always shared across build (the build id is not used)
+    const { baseKey } = cacheKey; 
     const fileData = await fs.readFile(getCacheKey(baseKey), "utf-8");
     const data = JSON.parse(fileData);
     const { mtime } = await fs.stat(getCacheKey(baseKey));

packages/open-next/src/overrides/incrementalCache/multi-tier-ddb-s3.ts

@@ -42,7 +42,7 @@ const awsFetch = (body: RequestInit["body"], type: "get" | "set" = "get") => {
 };
 
 const buildDynamoKey = (key: CacheKey<CacheEntryType>) => {
-  return `__meta_${key.buildId ? `${key.buildId}_` : ""}${key.baseKey}`;
+  return `__meta_${key.buildId ?? ""}_${key.baseKey}`;
 };
 
 /**

packages/open-next/src/utils/cache.ts

@@ -5,7 +5,7 @@ import type {
   OriginalTagCacheWriteInput,
   WithLastModified,
 } from "types/overrides";
-import { debug } from "../adapters/logger";
+import { debug, warn } from "../adapters/logger";
 
 export async function hasBeenRevalidated(
   key: string,
@@ -100,6 +100,18 @@ export function createCacheKey<CacheType extends CacheEntryType>({
       baseKey: key,
     } as CacheKey<CacheType>;
   }
+  let baseKey = key;
+  if (type === "composable") {
+    try {
+      const [_buildId, ...rest] = JSON.parse(key);
+      baseKey = JSON.stringify(rest);
+    } catch (e) {
+      warn("Error while parsing composable cache key", e);
+      // If we fail to parse the key, we just return it as is
+      // This is not ideal, but we don't want to crash the application
+      baseKey = key;  
+    }
+  }
   if (shouldPrependBuildId) {
     return {
       cacheType: type,