basic implementation for composable cache

Author: conico974

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

@@ -0,0 +1,55 @@
+import type {
+  ComposableCacheEntry,
+  ComposableCacheHandler,
+  StoredComposableCacheEntry,
+} from "types/cache";
+import { fromReadableStream, toReadableStream } from "utils/stream";
+import { debug } from "./logger";
+
+export default {
+  async get(cacheKey: string) {
+    try {
+      // TODO: update the type of the incremental cache
+      const result = (await globalThis.incrementalCache.get(
+        cacheKey,
+        true,
+      )) as unknown as StoredComposableCacheEntry;
+
+      debug("composable cache result", result);
+
+      return {
+        ...result.value,
+        value: toReadableStream(result.value.value),
+      };
+    } catch (e) {
+      debug("Cannot read composable cache entry");
+      return undefined;
+    }
+  },
+
+  async set(cacheKey: string, pendingEntry: Promise<ComposableCacheEntry>) {
+    const entry = await pendingEntry;
+    const valueToStore = await fromReadableStream(entry.value);
+    await globalThis.incrementalCache.set(cacheKey, {
+      ...entry,
+      value: valueToStore,
+    } as any);
+  },
+
+  async refreshTags() {
+    // We don't do anything for now, do we want to do something here ???
+    return;
+  },
+  async getExpiration(...tags: string[]) {
+    if (globalThis.tagCache.mode === "nextMode") {
+      return globalThis.tagCache.getLastRevalidated(tags);
+    }
+    //TODO: Not supported for now - I'll need to figure out a way, maybe we'd want to merge both type into one
+    return 0;
+  },
+  async expireTags(...tags: string[]) {
+    if (globalThis.tagCache.mode === "nextMode") {
+      return globalThis.tagCache.writeTags(tags);
+    }
+  },
+} satisfies ComposableCacheHandler;

packages/open-next/src/build/compileCache.ts

@@ -15,19 +15,49 @@ export function compileCache(
 ) {
   const { config } = options;
   const ext = format === "cjs" ? "cjs" : "mjs";
-  const outFile = path.join(options.buildDir, `cache.${ext}`);
+  const compiledCacheFile = path.join(options.buildDir, `cache.${ext}`);
+  const compiledComposableCacheFile = path.join(
+    options.buildDir,
+    `composable-cache.${ext}`,
+  );
 
   const isAfter15 = buildHelper.compareSemver(
     options.nextVersion,
     ">=",
     "15.0.0",
   );
 
+  // Normal cache
   buildHelper.esbuildSync(
     {
       external: ["next", "styled-jsx", "react", "@aws-sdk/*"],
       entryPoints: [path.join(options.openNextDistDir, "adapters", "cache.js")],
-      outfile: outFile,
+      outfile: compiledCacheFile,
+      target: ["node18"],
+      format,
+      banner: {
+        js: [
+          `globalThis.disableIncrementalCache = ${
+            config.dangerous?.disableIncrementalCache ?? false
+          };`,
+          `globalThis.disableDynamoDBCache = ${
+            config.dangerous?.disableTagCache ?? false
+          };`,
+          `globalThis.isNextAfter15 = ${isAfter15};`,
+        ].join(""),
+      },
+    },
+    options,
+  );
+
+  // Composable cache
+  buildHelper.esbuildSync(
+    {
+      external: ["next", "styled-jsx", "react", "@aws-sdk/*"],
+      entryPoints: [
+        path.join(options.openNextDistDir, "adapters", "composable-cache.js"),
+      ],
+      outfile: compiledComposableCacheFile,
       target: ["node18"],
       format,
       banner: {
@@ -44,5 +74,9 @@ export function compileCache(
     },
     options,
   );
-  return outFile;
+
+  return {
+    cache: compiledCacheFile,
+    composableCache: compiledComposableCacheFile,
+  };
 }

packages/open-next/src/build/createServerBundle.ts

@@ -147,10 +147,16 @@ async function generateBundle(
   fs.mkdirSync(outPackagePath, { recursive: true });
 
   const ext = fnOptions.runtime === "deno" ? "mjs" : "cjs";
+  // Normal cache
   fs.copyFileSync(
     path.join(options.buildDir, `cache.${ext}`),
     path.join(outPackagePath, "cache.cjs"),
   );
+  // Composable cache
+  fs.copyFileSync(
+    path.join(options.buildDir, `composable-cache.${ext}`),
+    path.join(outPackagePath, "composable-cache.cjs"),
+  );
 
   if (fnOptions.runtime === "deno") {
     addDenoJson(outputPath, packagePath);
@@ -237,6 +243,12 @@ async function generateBundle(
     "14.2",
   );
 
+  const isAfter152 = buildHelper.compareSemver(
+    options.nextVersion,
+    ">=",
+    "15.2.0",
+  );
+
   const disableRouting = isBefore13413 || config.middleware?.external;
 
   const updater = new ContentUpdater(options);
@@ -265,6 +277,7 @@ async function generateBundle(
         ...(isAfter141
           ? ["experimentalIncrementalCacheHandler"]
           : ["stableIncrementalCache"]),
+        ...(isAfter152 ? [] : ["composableCache"]),
       ],
     }),
 

packages/open-next/src/core/util.ts

@@ -25,6 +25,7 @@ overrideNextjsRequireHooks(NextConfig);
 applyNextjsRequireHooksOverride();
 //#endOverride
 const cacheHandlerPath = require.resolve("./cache.cjs");
+const composableCacheHandlerPath = require.resolve("./composable-cache.cjs");
 // @ts-ignore
 const nextServer = new NextServer.default({
   //#override requestHandlerHost
@@ -52,6 +53,12 @@ const nextServer = new NextServer.default({
       //#override experimentalIncrementalCacheHandler
       incrementalCacheHandlerPath: cacheHandlerPath,
       //#endOverride
+
+      //#override composableCache
+      cacheHandlers: {
+        default: composableCacheHandlerPath,
+      },
+      //#endOverride
     },
   },
   customServer: false,

packages/open-next/src/overrides/tagCache/dynamodb-nextMode.ts

@@ -71,6 +71,10 @@ function buildDynamoObject(tag: string, revalidatedAt?: number) {
 export default {
   name: "ddb-nextMode",
   mode: "nextMode",
+  getLastRevalidated: async (tags: string[]) => {
+    // Not supported for now
+    return 0;
+  },
   hasBeenRevalidated: async (tags: string[], lastModified?: number) => {
     if (globalThis.openNextConfig.dangerous?.disableTagCache) {
       return false;

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

@@ -1,3 +1,5 @@
+import type { ReadableStream } from "node:stream/web";
+
 interface CachedFetchValue {
   kind: "FETCH";
   data: {

packages/open-next/src/types/overrides.ts

@@ -129,6 +129,8 @@ Cons :
 */
 export type NextModeTagCache = BaseTagCache & {
   mode: "nextMode";
+  // Necessary for the composable cache
+  getLastRevalidated(tags: string[]): Promise<number>;
   hasBeenRevalidated(tags: string[], lastModified?: number): Promise<boolean>;
   writeTags(tags: string[]): Promise<void>;
   // Optional method to get paths by tags