@opennextjs/cloudflare 1.0.0-beta.3 → 1.0.0

package/dist/api/overrides/tag-cache/do-sharded-tag-cache.js

@@ -1,4 +1,4 @@
-import { error } from "@opennextjs/aws/adapters/logger.js";
+import { debug, error } from "@opennextjs/aws/adapters/logger.js";
 import { generateShardId } from "@opennextjs/aws/core/routing/queue.js";
 import { IgnorableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context";
@@ -113,6 +113,38 @@ class ShardedDOTagCache {
                 db,
             };
     }
+    async getLastRevalidated(tags) {
+        const { isDisabled } = await this.getConfig();
+        if (isDisabled)
+            return 0;
+        try {
+            const shardedTagGroups = this.groupTagsByDO({ tags });
+            const shardedTagRevalidationOutcomes = await Promise.all(shardedTagGroups.map(async ({ doId, tags }) => {
+                const cachedValue = await this.getFromRegionalCache({ doId, tags, type: "number" });
+                if (cachedValue) {
+                    const cached = await cachedValue.text();
+                    try {
+                        return parseInt(cached, 10);
+                    }
+                    catch (e) {
+                        debug("Error while parsing cached value", e);
+                        // If we can't parse the cached value, we should just ignore it and go to the durable object
+                    }
+                }
+                const stub = this.getDurableObjectStub(doId);
+                const _lastRevalidated = await stub.getLastRevalidated(tags);
+                if (!_lastRevalidated) {
+                    getCloudflareContext().ctx.waitUntil(this.putToRegionalCache({ doId, tags, type: "number" }, _lastRevalidated));
+                }
+                return _lastRevalidated;
+            }));
+            return Math.max(...shardedTagRevalidationOutcomes);
+        }
+        catch (e) {
+            error("Error while checking revalidation", e);
+            return 0;
+        }
+    }
     /**
      * This function checks if the tags have been revalidated
      * It is never supposed to throw and in case of error, it will return false
@@ -127,7 +159,7 @@ class ShardedDOTagCache {
         try {
             const shardedTagGroups = this.groupTagsByDO({ tags });
             const shardedTagRevalidationOutcomes = await Promise.all(shardedTagGroups.map(async ({ doId, tags }) => {
-                const cachedValue = await this.getFromRegionalCache(doId, tags);
+                const cachedValue = await this.getFromRegionalCache({ doId, tags, type: "boolean" });
                 if (cachedValue) {
                     return (await cachedValue.text()) === "true";
                 }
@@ -137,7 +169,7 @@ class ShardedDOTagCache {
                 // If we do so, we risk causing cache MISS even though it has been revalidated elsewhere
                 // On the other hand revalidating a tag that is used in a lot of places will cause a lot of requests
                 if (!_hasBeenRevalidated) {
-                    getCloudflareContext().ctx.waitUntil(this.putToRegionalCache(doId, tags, _hasBeenRevalidated));
+                    getCloudflareContext().ctx.waitUntil(this.putToRegionalCache({ doId, tags, type: "boolean" }, _hasBeenRevalidated));
                 }
                 return _hasBeenRevalidated;
             }));
@@ -170,7 +202,11 @@ class ShardedDOTagCache {
             const stub = this.getDurableObjectStub(doId);
             await stub.writeTags(tags, lastModified);
             // Depending on the shards and the tags, deleting from the regional cache will not work for every tag
-            await this.deleteRegionalCache(doId, tags);
+            // We also need to delete both cache
+            await Promise.all([
+                this.deleteRegionalCache({ doId, tags, type: "boolean" }),
+                this.deleteRegionalCache({ doId, tags, type: "number" }),
+            ]);
         }
         catch (e) {
             error("Error while writing tags", e);
@@ -194,36 +230,42 @@ class ShardedDOTagCache {
         }
         return this.localCache;
     }
-    async getCacheKey(doId, tags) {
-        return new Request(new URL(`shard/${doId.shardId}?tags=${encodeURIComponent(tags.join(";"))}`, "http://local.cache"));
+    getCacheUrlKey(opts) {
+        const { doId, tags, type } = opts;
+        return `http://local.cache/shard/${doId.shardId}?type=${type}&tags=${encodeURIComponent(tags.join(";"))}`;
     }
-    async getFromRegionalCache(doId, tags) {
+    async getFromRegionalCache(opts) {
         try {
             if (!this.opts.regionalCache)
                 return;
             const cache = await this.getCacheInstance();
             if (!cache)
                 return;
-            const key = await this.getCacheKey(doId, tags);
-            return cache.match(key);
+            return cache.match(this.getCacheUrlKey(opts));
         }
         catch (e) {
             error("Error while fetching from regional cache", e);
-            return;
         }
     }
-    async putToRegionalCache(doId, tags, hasBeenRevalidated) {
+    async putToRegionalCache(optsKey, value) {
         if (!this.opts.regionalCache)
             return;
         const cache = await this.getCacheInstance();
         if (!cache)
             return;
-        const key = await this.getCacheKey(doId, tags);
-        await cache.put(key, new Response(`${hasBeenRevalidated}`, {
-            headers: { "cache-control": `max-age=${this.opts.regionalCacheTtlSec ?? 5}` },
+        const tags = optsKey.tags;
+        await cache.put(this.getCacheUrlKey(optsKey), new Response(`${value}`, {
+            headers: {
+                "cache-control": `max-age=${this.opts.regionalCacheTtlSec ?? 5}`,
+                ...(tags.length > 0
+                    ? {
+                        "cache-tag": tags.join(","),
+                    }
+                    : {}),
+            },
         }));
     }
-    async deleteRegionalCache(doId, tags) {
+    async deleteRegionalCache(optsKey) {
         // We never want to crash because of the cache
         try {
             if (!this.opts.regionalCache)
@@ -231,8 +273,7 @@ class ShardedDOTagCache {
             const cache = await this.getCacheInstance();
             if (!cache)
                 return;
-            const key = await this.getCacheKey(doId, tags);
-            await cache.delete(key);
+            await cache.delete(this.getCacheUrlKey(optsKey));
         }
         catch (e) {
             debugCache("Error while deleting from regional cache", e);

package/dist/api/overrides/tag-cache/do-sharded-tag-cache.spec.js

@@ -223,7 +223,11 @@ describe("DOShardedTagCache", () => {
             cache.deleteRegionalCache = vi.fn();
             await cache.writeTags(["tag1"]);
             expect(cache.deleteRegionalCache).toHaveBeenCalled();
-            expect(cache.deleteRegionalCache).toHaveBeenCalledWith(expect.objectContaining({ key: "tag-hard;shard-1;replica-1" }), ["tag1"]);
+            expect(cache.deleteRegionalCache).toHaveBeenCalledWith({
+                doId: expect.objectContaining({ key: "tag-hard;shard-1;replica-1" }),
+                tags: ["tag1"],
+                type: "boolean",
+            });
             // expect(cache.deleteRegionalCache).toHaveBeenCalledWith("tag-hard;shard-1;replica-1", ["tag1"]);
         });
     });
@@ -253,7 +257,7 @@ describe("DOShardedTagCache", () => {
                 numberOfReplicas: 1,
                 shardType: "hard",
             });
-            expect(await cache.getFromRegionalCache(doId, ["tag1"])).toBeUndefined();
+            expect(await cache.getFromRegionalCache({ doId, tags: ["tag1"], type: "boolean" })).toBeUndefined();
         });
         it("should call .match on the cache", async () => {
             // @ts-expect-error - Defined on cloudfare context
@@ -268,7 +272,7 @@ describe("DOShardedTagCache", () => {
                 numberOfReplicas: 1,
                 shardType: "hard",
             });
-            expect(await cache.getFromRegionalCache(doId, ["tag1"])).toBe("response");
+            expect(await cache.getFromRegionalCache({ doId, tags: ["tag1"], type: "boolean" })).toBe("response");
             // @ts-expect-error - Defined on cloudfare context
             globalThis.caches = undefined;
         });
@@ -277,15 +281,13 @@ describe("DOShardedTagCache", () => {
         it("should return the cache key without the random part", async () => {
             const cache = shardedDOTagCache();
             const doId1 = new DOId({ baseShardId: "shard-0", numberOfReplicas: 1, shardType: "hard" });
-            const reqKey = await cache.getCacheKey(doId1, ["_N_T_/tag1"]);
-            expect(reqKey.url).toBe("http://local.cache/shard/tag-hard;shard-0?tags=_N_T_%2Ftag1");
+            expect(cache.getCacheUrlKey({ doId: doId1, tags: ["_N_T_/tag1"], type: "boolean" })).toBe("http://local.cache/shard/tag-hard;shard-0?type=boolean&tags=_N_T_%2Ftag1");
             const doId2 = new DOId({
                 baseShardId: "shard-1",
                 numberOfReplicas: 1,
                 shardType: "hard",
             });
-            const reqKey2 = await cache.getCacheKey(doId2, ["tag1"]);
-            expect(reqKey2.url).toBe("http://local.cache/shard/tag-hard;shard-1?tags=tag1");
+            expect(cache.getCacheUrlKey({ doId: doId2, tags: ["tag1"], type: "boolean" })).toBe("http://local.cache/shard/tag-hard;shard-1?type=boolean&tags=tag1");
         });
     });
     describe("performWriteTagsWithRetry", () => {

package/dist/api/overrides/tag-cache/tag-cache-filter.d.ts

@@ -0,0 +1,26 @@
+import { NextModeTagCache } from "@opennextjs/aws/types/overrides";
+interface WithFilterOptions {
+    /**
+     * The original tag cache.
+     * Call to this will receive only the filtered tags.
+     */
+    tagCache: NextModeTagCache;
+    /**
+     * The function to filter tags.
+     * @param tag The tag to filter.
+     * @returns true if the tag should be forwarded, false otherwise.
+     */
+    filterFn: (tag: string) => boolean;
+}
+/**
+ * Creates a new tag cache that filters tags based on the provided filter function.
+ * This is useful to remove tags that are not used by the app, this could reduce the number of requests to the underlying tag cache.
+ */
+export declare function withFilter({ tagCache, filterFn }: WithFilterOptions): NextModeTagCache;
+/**
+ * Filter function to exclude tags that start with "_N_T_".
+ * This is used to filter out internal soft tags.
+ * Can be used if `revalidatePath` is not used.
+ */
+export declare function softTagFilter(tag: string): boolean;
+export {};

package/dist/api/overrides/tag-cache/tag-cache-filter.js

@@ -0,0 +1,48 @@
+/**
+ * Creates a new tag cache that filters tags based on the provided filter function.
+ * This is useful to remove tags that are not used by the app, this could reduce the number of requests to the underlying tag cache.
+ */
+export function withFilter({ tagCache, filterFn }) {
+    return {
+        name: `filtered-${tagCache.name}`,
+        mode: "nextMode",
+        getLastRevalidated: async (tags) => {
+            const filteredTags = tags.filter(filterFn);
+            if (filteredTags.length === 0) {
+                return 0;
+            }
+            return tagCache.getLastRevalidated(filteredTags);
+        },
+        getPathsByTags: tagCache.getPathsByTags
+            ? async (tags) => {
+                const filteredTags = tags.filter(filterFn);
+                if (filteredTags.length === 0) {
+                    return [];
+                }
+                return tagCache.getPathsByTags(filteredTags);
+            }
+            : undefined,
+        hasBeenRevalidated: async (tags, lastModified) => {
+            const filteredTags = tags.filter(filterFn);
+            if (filteredTags.length === 0) {
+                return false;
+            }
+            return tagCache.hasBeenRevalidated(filteredTags, lastModified);
+        },
+        writeTags: async (tags) => {
+            const filteredTags = tags.filter(filterFn);
+            if (filteredTags.length === 0) {
+                return;
+            }
+            return tagCache.writeTags(filteredTags);
+        },
+    };
+}
+/**
+ * Filter function to exclude tags that start with "_N_T_".
+ * This is used to filter out internal soft tags.
+ * Can be used if `revalidatePath` is not used.
+ */
+export function softTagFilter(tag) {
+    return !tag.startsWith("_N_T_");
+}

package/dist/api/overrides/tag-cache/tag-cache-filter.spec.d.ts

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

package/dist/api/overrides/tag-cache/tag-cache-filter.spec.js

@@ -0,0 +1,97 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { softTagFilter, withFilter } from "./tag-cache-filter";
+const mockedTagCache = {
+    name: "mocked",
+    mode: "nextMode",
+    getLastRevalidated: vi.fn(),
+    getPathsByTags: vi.fn(),
+    hasBeenRevalidated: vi.fn(),
+    writeTags: vi.fn(),
+};
+const filterFn = (tag) => tag.startsWith("valid_");
+describe("withFilter", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should filter out tags based on writeTags", async () => {
+        const tagCache = withFilter({
+            tagCache: mockedTagCache,
+            filterFn,
+        });
+        const tags = ["valid_tag", "invalid_tag"];
+        await tagCache.writeTags(tags);
+        expect(mockedTagCache.writeTags).toHaveBeenCalledWith(["valid_tag"]);
+    });
+    it("should not call writeTags if no tags are valid", async () => {
+        const tagCache = withFilter({
+            tagCache: mockedTagCache,
+            filterFn,
+        });
+        const tags = ["invalid_tag"];
+        await tagCache.writeTags(tags);
+        expect(mockedTagCache.writeTags).not.toHaveBeenCalled();
+    });
+    it("should filter out tags based on hasBeenRevalidated", async () => {
+        const tagCache = withFilter({
+            tagCache: mockedTagCache,
+            filterFn,
+        });
+        const tags = ["valid_tag", "invalid_tag"];
+        const lastModified = Date.now();
+        await tagCache.hasBeenRevalidated(tags, lastModified);
+        expect(mockedTagCache.hasBeenRevalidated).toHaveBeenCalledWith(["valid_tag"], lastModified);
+    });
+    it("should not call hasBeenRevalidated if no tags are valid", async () => {
+        const tagCache = withFilter({
+            tagCache: mockedTagCache,
+            filterFn,
+        });
+        const tags = ["invalid_tag"];
+        const lastModified = Date.now();
+        await tagCache.hasBeenRevalidated(tags, lastModified);
+        expect(mockedTagCache.hasBeenRevalidated).not.toHaveBeenCalled();
+    });
+    it("should filter out tags based on getPathsByTags", async () => {
+        const tagCache = withFilter({
+            tagCache: mockedTagCache,
+            filterFn,
+        });
+        const tags = ["valid_tag", "invalid_tag"];
+        await tagCache.getPathsByTags?.(tags);
+        expect(mockedTagCache.getPathsByTags).toHaveBeenCalledWith(["valid_tag"]);
+    });
+    it("should not call getPathsByTags if no tags are valid", async () => {
+        const tagCache = withFilter({
+            tagCache: mockedTagCache,
+            filterFn,
+        });
+        const tags = ["invalid_tag"];
+        await tagCache.getPathsByTags?.(tags);
+        expect(mockedTagCache.getPathsByTags).not.toHaveBeenCalled();
+    });
+    it("should return the correct name", () => {
+        const tagCache = withFilter({
+            tagCache: mockedTagCache,
+            filterFn,
+        });
+        expect(tagCache.name).toBe("filtered-mocked");
+    });
+    it("should not create a function if getPathsByTags is not defined", async () => {
+        const tagCache = withFilter({
+            tagCache: {
+                ...mockedTagCache,
+                getPathsByTags: undefined,
+            },
+            filterFn,
+        });
+        expect(tagCache.getPathsByTags).toBeUndefined();
+    });
+    it("should filter soft tags", () => {
+        const tagCache = withFilter({
+            tagCache: mockedTagCache,
+            filterFn: softTagFilter,
+        });
+        tagCache.writeTags(["valid_tag", "_N_T_/", "_N_T_/test", "_N_T_/layout"]);
+        expect(mockedTagCache.writeTags).toHaveBeenCalledWith(["valid_tag"]);
+    });
+});

package/dist/cli/args.d.ts

@@ -7,10 +7,12 @@ export type Arguments = ({
 } | {
     command: "preview" | "deploy" | "upload";
     passthroughArgs: string[];
+    cacheChunkSize?: number;
 } | {
     command: "populateCache";
     target: WranglerTarget;
     environment?: string;
+    cacheChunkSize?: number;
 }) & {
     outputDir?: string;
 };

package/dist/cli/args.js

@@ -9,6 +9,7 @@ export function getArgs() {
             output: { type: "string", short: "o" },
             noMinify: { type: "boolean", default: false },
             skipWranglerConfigCheck: { type: "boolean", default: false },
+            cacheChunkSize: { type: "string" },
         },
         allowPositionals: true,
     });
@@ -33,6 +34,7 @@ export function getArgs() {
                 command: positionals[0],
                 outputDir,
                 passthroughArgs,
+                ...(values.cacheChunkSize && { cacheChunkSize: Number(values.cacheChunkSize) }),
             };
         case "populateCache":
             if (!isWranglerTarget(positionals[1])) {
@@ -43,6 +45,7 @@ export function getArgs() {
                 outputDir,
                 target: positionals[1],
                 environment: getWranglerEnvironmentFlag(passthroughArgs),
+                ...(values.cacheChunkSize && { cacheChunkSize: Number(values.cacheChunkSize) }),
             };
         default:
             throw new Error("Error: invalid command, expected 'build' | 'preview' | 'deploy' | 'upload' | 'populateCache'");

package/dist/cli/build/build.d.ts

@@ -1,5 +1,5 @@
 import { BuildOptions } from "@opennextjs/aws/build/helper.js";
-import { OpenNextConfig } from "@opennextjs/aws/types/open-next.js";
+import { OpenNextConfig } from "../../api/config.js";
 import type { ProjectOptions } from "../project-options.js";
 /**
  * Builds the application in a format that can be passed to workerd

package/dist/cli/build/bundle-server.js

@@ -5,6 +5,7 @@ import { fileURLToPath } from "node:url";
 import { getPackagePath } from "@opennextjs/aws/build/helper.js";
 import { ContentUpdater } from "@opennextjs/aws/plugins/content-updater.js";
 import { build } from "esbuild";
+import { getOpenNextConfig } from "../../api/config.js";
 import { patchVercelOgLibrary } from "./patches/ast/patch-vercel-og-library.js";
 import { patchWebpackRuntime } from "./patches/ast/webpack-runtime.js";
 import * as patches from "./patches/index.js";
@@ -15,6 +16,7 @@ import { inlineFindDir } from "./patches/plugins/find-dir.js";
 import { patchInstrumentation } from "./patches/plugins/instrumentation.js";
 import { inlineLoadManifest } from "./patches/plugins/load-manifest.js";
 import { handleOptionalDependencies } from "./patches/plugins/optional-deps.js";
+import { patchPagesRouterContext } from "./patches/plugins/pages-router-context.js";
 import { patchDepdDeprecations } from "./patches/plugins/patch-depd-deprecations.js";
 import { fixRequire } from "./patches/plugins/require.js";
 import { shimRequireHook } from "./patches/plugins/require-hook.js";
@@ -63,13 +65,13 @@ export async function bundleServer(buildOpts) {
         // Next traces files using the default conditions from `nft` (`node`, `require`, `import` and `default`)
         //
         // Because we use the `node` platform for this build, the "module" condition is used when no conditions are defined.
-        // We explicitly set the conditions to an empty array to disable the "module" condition in order to match Next tracing.
+        // The conditions are always set (should it be to an empty array) to disable the "module" condition.
         //
         // See:
         // - default nft conditions: https://github.com/vercel/nft/blob/2b55b01/readme.md#exports--imports
         // - Next no explicit override: https://github.com/vercel/next.js/blob/2efcf11/packages/next/src/build/collect-build-traces.ts#L287
         // - ESBuild `node` platform: https://esbuild.github.io/api/#platform
-        conditions: [],
+        conditions: getOpenNextConfig(buildOpts).cloudflare?.useWorkerdCondition === false ? [] : ["workerd"],
         plugins: [
             shimRequireHook(buildOpts),
             inlineDynamicRequires(updater, buildOpts),
@@ -77,6 +79,7 @@ export async function bundleServer(buildOpts) {
             fixRequire(updater),
             handleOptionalDependencies(optionalDependencies),
             patchInstrumentation(updater, buildOpts),
+            patchPagesRouterContext(buildOpts),
             inlineEvalManifest(updater, buildOpts),
             inlineFindDir(updater, buildOpts),
             inlineLoadManifest(updater, buildOpts),
@@ -85,7 +88,7 @@ export async function bundleServer(buildOpts) {
             // Apply updater updates, must be the last plugin
             updater.plugin,
         ],
-        external: ["./middleware/handler.mjs", "*.wasm"],
+        external: ["./middleware/handler.mjs"],
         alias: {
             // Note: it looks like node-fetch is actually not necessary for us, so we could replace it with an empty shim
             //       but just to be safe we replace it with a module that re-exports the native fetch
@@ -122,6 +125,11 @@ export async function bundleServer(buildOpts) {
             // This define should be safe to use for Next 14.2+, earlier versions (13.5 and less) will cause trouble
             "process.env.__NEXT_EXPERIMENTAL_REACT": `${needsExperimentalReact(nextConfig)}`,
         },
+        banner: {
+            // We need to import them here, assigning them to `globalThis` does not work because node:timers use `globalThis` and thus create an infinite loop
+            // See https://github.com/cloudflare/workerd/blob/d6a764c/src/node/internal/internal_timers.ts#L56-L70
+            js: `import {setInterval, clearInterval, setTimeout, clearTimeout, setImmediate, clearImmediate} from "node:timers"`,
+        },
         platform: "node",
     });
     fs.writeFileSync(openNextServerBundle + ".meta.json", JSON.stringify(result.metafile, null, 2));
@@ -130,7 +138,7 @@ export async function bundleServer(buildOpts) {
     if (isMonorepo) {
         fs.writeFileSync(path.join(outputPath, "handler.mjs"), `export { handler } from "./${normalizePath(packagePath)}/handler.mjs";`);
     }
-    console.log(`\x1b[35mWorker saved in \`${getOutputWorkerPath(buildOpts)}\` 🚀\n\x1b[0m`);
+    console.log(`\x1b[35mWorker saved in \`${path.relative(buildOpts.appPath, getOutputWorkerPath(buildOpts))}\` 🚀\n\x1b[0m`);
 }
 /**
  * This function applies patches required for the code to run on workers.
@@ -140,6 +148,7 @@ export async function updateWorkerBundledCode(workerOutputFile, buildOpts) {
     const patchedCode = await patchCodeWithValidations(code, [
         ["require", patches.patchRequire],
         ["cacheHandler", (code) => patches.patchCache(code, buildOpts)],
+        ["composableCache", (code) => patches.patchComposableCache(code, buildOpts), { isOptional: true }],
         [
             "'require(this.middlewareManifestPath)'",
             (code) => patches.inlineMiddlewareManifestRequire(code, buildOpts),
@@ -150,6 +159,11 @@ export async function updateWorkerBundledCode(workerOutputFile, buildOpts) {
             // workers do not support dynamic require nor require.resolve
             (code) => code.replace('require.resolve("./cache.cjs")', '"unused"'),
         ],
+        [
+            "`require.resolve composable cache` call",
+            // workers do not support dynamic require nor require.resolve
+            (code) => code.replace('require.resolve("./composable-cache.cjs")', '"unused"'),
+        ],
     ]);
     await writeFile(workerOutputFile, patchedCode);
 }

package/dist/cli/build/open-next/createServerBundle.js

@@ -10,7 +10,7 @@ import { copyMiddlewareResources, generateEdgeBundle } from "@opennextjs/aws/bui
 import * as buildHelper from "@opennextjs/aws/build/helper.js";
 import { installDependencies } from "@opennextjs/aws/build/installDeps.js";
 import { applyCodePatches } from "@opennextjs/aws/build/patch/codePatcher.js";
-import { patchEnvVars, patchFetchCacheForISR, patchFetchCacheSetMissingWaitUntil, patchNextServer, patchUnstableCacheForISR, } from "@opennextjs/aws/build/patch/patches/index.js";
+import { patchEnvVars, patchFetchCacheForISR, patchFetchCacheSetMissingWaitUntil, patchNextServer, patchUnstableCacheForISR, patchUseCacheForISR, } from "@opennextjs/aws/build/patch/patches/index.js";
 // TODO: import from patches/index.js when https://github.com/opennextjs/opennextjs-aws/pull/827 is released
 import { patchBackgroundRevalidation } from "@opennextjs/aws/build/patch/patches/patchBackgroundRevalidation.js";
 import logger from "@opennextjs/aws/logger.js";
@@ -20,8 +20,10 @@ import { openNextExternalMiddlewarePlugin } from "@opennextjs/aws/plugins/extern
 import { openNextReplacementPlugin } from "@opennextjs/aws/plugins/replacement.js";
 import { openNextResolvePlugin } from "@opennextjs/aws/plugins/resolve.js";
 import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
+import { getOpenNextConfig } from "../../../api/config.js";
 import { patchResRevalidate } from "../patches/plugins/res-revalidate.js";
 import { normalizePath } from "../utils/index.js";
+import { copyWorkerdPackages } from "../utils/workerd.js";
 export async function createServerBundle(options, codeCustomization) {
     const { config } = options;
     const foundRoutes = new Set();
@@ -91,7 +93,10 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
     const outPackagePath = path.join(outputPath, packagePath);
     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);
     }
@@ -113,18 +118,24 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
     // Copy env files
     buildHelper.copyEnvFile(appBuildOutputPath, packagePath, outputPath);
     // Copy all necessary traced files
-    const { tracedFiles, manifests } = await copyTracedFiles({
+    const { tracedFiles, manifests, nodePackages } = await copyTracedFiles({
         buildOutputPath: appBuildOutputPath,
         packagePath,
         outputDir: outputPath,
         routes: fnOptions.routes ?? ["app/page.tsx"],
         bundledNextServer: isBundled,
     });
+    if (getOpenNextConfig(options).cloudflare?.useWorkerdCondition !== false) {
+        // Next does not trace the "workerd" build condition
+        // So we need to copy the whole packages using the condition
+        await copyWorkerdPackages(options, nodePackages);
+    }
     const additionalCodePatches = codeCustomization?.additionalCodePatches ?? [];
     await applyCodePatches(options, tracedFiles, manifests, [
         patchFetchCacheSetMissingWaitUntil,
         patchFetchCacheForISR,
         patchUnstableCacheForISR,
+        patchUseCacheForISR,
         patchNextServer,
         patchEnvVars,
         patchBackgroundRevalidation,
@@ -142,6 +153,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
     const isBefore13413 = buildHelper.compareSemver(options.nextVersion, "<=", "13.4.13");
     const isAfter141 = buildHelper.compareSemver(options.nextVersion, ">=", "14.1");
     const isAfter142 = buildHelper.compareSemver(options.nextVersion, ">=", "14.2");
+    const isAfter152 = buildHelper.compareSemver(options.nextVersion, ">=", "15.2.0");
     const disableRouting = isBefore13413 || config.middleware?.external;
     const plugins = [
         openNextReplacementPlugin({
@@ -161,6 +173,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
                 ...(disableNextPrebundledReact ? ["requireHooks"] : []),
                 ...(isBefore13413 ? ["trustHostHeader"] : ["requestHandlerHost"]),
                 ...(isAfter141 ? ["experimentalIncrementalCacheHandler"] : ["stableIncrementalCache"]),
+                ...(isAfter152 ? [""] : ["composableCache"]),
             ],
         }),
         openNextResolvePlugin({

package/dist/cli/build/patches/investigated/patch-cache.d.ts

@@ -11,3 +11,4 @@ import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
  * instantiated with a dynamic require that uses a string literal for the path.
  */
 export declare function patchCache(code: string, buildOpts: BuildOptions): Promise<string>;
+export declare function patchComposableCache(code: string, buildOpts: BuildOptions): Promise<string>;

package/dist/cli/build/patches/investigated/patch-cache.js

@@ -22,3 +22,19 @@ const cacheHandler = null;
 CacheHandler = require('${normalizePath(cacheFile)}').default;
 `);
 }
+export async function patchComposableCache(code, buildOpts) {
+    const { outputDir } = buildOpts;
+    // TODO: switch to mjs
+    const outputPath = path.join(outputDir, "server-functions/default");
+    const cacheFile = path.join(outputPath, getPackagePath(buildOpts), "composable-cache.cjs");
+    //TODO: Do we want to move this to the new CodePatcher ?
+    return code.replace("const { cacheHandlers } = this.nextConfig.experimental", `
+const cacheHandlers = null;
+const handlersSymbol = Symbol.for('@next/cache-handlers');
+const handlersMapSymbol = Symbol.for('@next/cache-handlers-map');
+const handlersSetSymbol = Symbol.for('@next/cache-handlers-set');
+globalThis[handlersMapSymbol] = new Map();
+globalThis[handlersMapSymbol].set("default", require('${normalizePath(cacheFile)}').default);
+globalThis[handlersSetSymbol] = new Set(globalThis[handlersMapSymbol].values());
+`);
+}

package/dist/cli/build/patches/plugins/eval-manifest.js

@@ -12,7 +12,7 @@ export function inlineEvalManifest(updater, buildOpts) {
     return updater.updateContent("inline-eval-manifest", [
         {
             field: {
-                filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/load-manifest\.js$`, {
+                filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/load-manifest(\.external)?\.js$`, {
                     escape: false,
                 }),
                 contentFilter: /function evalManifest\(/,

package/dist/cli/build/patches/plugins/load-manifest.js

@@ -12,7 +12,7 @@ export function inlineLoadManifest(updater, buildOpts) {
     return updater.updateContent("inline-load-manifest", [
         {
             field: {
-                filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/load-manifest\.js$`, {
+                filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/load-manifest(\.external)?\.js$`, {
                     escape: false,
                 }),
                 contentFilter: /function loadManifest\(/,

package/dist/cli/build/patches/plugins/pages-router-context.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ESBuild plugin to handle pages router context.
+ *
+ * We need to change the import path for the pages router context to use the one provided in `pages-runtime.prod.js`
+ */
+import { BuildOptions } from "@opennextjs/aws/build/helper.js";
+import type { PluginBuild } from "esbuild";
+export declare function patchPagesRouterContext(buildOpts: BuildOptions): {
+    name: string;
+    setup: (build: PluginBuild) => void;
+};