@opennextjs/cloudflare 1.0.4 → 1.2.0

package/dist/api/overrides/tag-cache/do-sharded-tag-cache.d.ts

@@ -2,6 +2,9 @@ import type { NextModeTagCache } from "@opennextjs/aws/types/overrides.js";
 export declare const DEFAULT_WRITE_RETRIES = 3;
 export declare const DEFAULT_NUM_SHARDS = 4;
 export declare const NAME = "do-sharded-tag-cache";
+export declare const DEFAULT_REGION: "enam";
+export declare const AVAILABLE_REGIONS: readonly ["enam", "weur", "apac", "sam", "afr", "oc"];
+type AllowedDurableObjectRegion = (typeof AVAILABLE_REGIONS)[number];
 interface ShardedDOTagCacheOptions {
     /**
      * The number of shards that will be used.
@@ -49,6 +52,18 @@ interface ShardedDOTagCacheOptions {
     shardReplication?: {
         numberOfSoftReplicas: number;
         numberOfHardReplicas: number;
+        /**
+         * Enable regional replication for the shards.
+         *
+         * If not set, no regional replication will be performed and durable objects will be created without a location hint
+         *
+         * Can be used to reduce latency for users in different regions and to spread the load across multiple regions.
+         *
+         * This will increase the number of durable objects created, as each shard will be replicated in all regions.
+         */
+        regionalReplication?: {
+            defaultRegion: AllowedDurableObjectRegion;
+        };
     };
     /**
      * The number of retries to perform when writing tags
@@ -62,11 +77,13 @@ interface DOIdOptions {
     numberOfReplicas: number;
     shardType: "soft" | "hard";
     replicaId?: number;
+    region?: DurableObjectLocationHint;
 }
 export declare class DOId {
     options: DOIdOptions;
     shardId: string;
     replicaId: number;
+    region?: DurableObjectLocationHint;
     constructor(options: DOIdOptions);
     private generateRandomNumberBetween;
     get key(): string;
@@ -83,6 +100,8 @@ declare class ShardedDOTagCache implements NextModeTagCache {
     readonly numSoftReplicas: number;
     readonly numHardReplicas: number;
     readonly maxWriteRetries: number;
+    readonly enableRegionalReplication: boolean;
+    readonly defaultRegion: AllowedDurableObjectRegion;
     localCache?: Cache;
     constructor(opts?: ShardedDOTagCacheOptions);
     private getDurableObjectStub;
@@ -94,6 +113,7 @@ declare class ShardedDOTagCache implements NextModeTagCache {
      * @returns An array of TagCacheDOId and tag
      */
     private generateDOIdArray;
+    getClosestRegion(): "enam" | "sam" | "weur" | "apac" | "oc" | "afr";
     /**
      * Same tags are guaranteed to be in the same shard
      * @param tags

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

@@ -2,26 +2,30 @@ 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";
-import { debugCache } from "../internal";
+import { debugCache, purgeCacheByTags } from "../internal";
 export const DEFAULT_WRITE_RETRIES = 3;
 export const DEFAULT_NUM_SHARDS = 4;
 export const NAME = "do-sharded-tag-cache";
 const SOFT_TAG_PREFIX = "_N_T_/";
+export const DEFAULT_REGION = "enam";
+export const AVAILABLE_REGIONS = ["enam", "weur", "apac", "sam", "afr", "oc"];
 export class DOId {
     options;
     shardId;
     replicaId;
+    region;
     constructor(options) {
         this.options = options;
-        const { baseShardId, shardType, numberOfReplicas, replicaId } = options;
+        const { baseShardId, shardType, numberOfReplicas, replicaId, region } = options;
         this.shardId = `tag-${shardType};${baseShardId}`;
         this.replicaId = replicaId ?? this.generateRandomNumberBetween(1, numberOfReplicas);
+        this.region = region;
     }
     generateRandomNumberBetween(min, max) {
         return Math.floor(Math.random() * (max - min + 1) + min);
     }
     get key() {
-        return `${this.shardId};replica-${this.replicaId}`;
+        return `${this.shardId};replica-${this.replicaId}${this.region ? `;region-${this.region}` : ""}`;
     }
 }
 class ShardedDOTagCache {
@@ -31,19 +35,27 @@ class ShardedDOTagCache {
     numSoftReplicas;
     numHardReplicas;
     maxWriteRetries;
+    enableRegionalReplication;
+    defaultRegion;
     localCache;
     constructor(opts = { baseShardSize: DEFAULT_NUM_SHARDS }) {
         this.opts = opts;
         this.numSoftReplicas = opts.shardReplication?.numberOfSoftReplicas ?? 1;
         this.numHardReplicas = opts.shardReplication?.numberOfHardReplicas ?? 1;
         this.maxWriteRetries = opts.maxWriteRetries ?? DEFAULT_WRITE_RETRIES;
+        this.enableRegionalReplication = Boolean(opts.shardReplication?.regionalReplication);
+        this.defaultRegion = opts.shardReplication?.regionalReplication?.defaultRegion ?? DEFAULT_REGION;
     }
     getDurableObjectStub(doId) {
         const durableObject = getCloudflareContext().env.NEXT_TAG_CACHE_DO_SHARDED;
         if (!durableObject)
             throw new IgnorableError("No durable object binding for cache revalidation");
         const id = durableObject.idFromName(doId.key);
-        return durableObject.get(id);
+        debug("[shardedTagCache] - Accessing Durable Object : ", {
+            key: doId.key,
+            region: doId.region,
+        });
+        return durableObject.get(id, { locationHint: doId.region });
     }
     /**
      * Generates a list of DO ids for the shards and replicas
@@ -55,9 +67,14 @@ class ShardedDOTagCache {
     generateDOIdArray({ tags, shardType, generateAllReplicas = false, }) {
         let replicaIndexes = [1];
         const isSoft = shardType === "soft";
-        const numReplicas = isSoft ? this.numSoftReplicas : this.numHardReplicas;
-        replicaIndexes = generateAllReplicas ? Array.from({ length: numReplicas }, (_, i) => i + 1) : [undefined];
-        return replicaIndexes.flatMap((replicaId) => {
+        let numReplicas = 1;
+        if (this.opts.shardReplication) {
+            numReplicas = isSoft ? this.numSoftReplicas : this.numHardReplicas;
+            replicaIndexes = generateAllReplicas
+                ? Array.from({ length: numReplicas }, (_, i) => i + 1)
+                : [undefined];
+        }
+        const regionalReplicas = replicaIndexes.flatMap((replicaId) => {
             return tags
                 .filter((tag) => (isSoft ? tag.startsWith(SOFT_TAG_PREFIX) : !tag.startsWith(SOFT_TAG_PREFIX)))
                 .map((tag) => {
@@ -72,6 +89,51 @@ class ShardedDOTagCache {
                 };
             });
         });
+        if (!this.enableRegionalReplication)
+            return regionalReplicas;
+        // If we have regional replication enabled, we need to further duplicate the shards in all the regions
+        const regionalReplicasInAllRegions = generateAllReplicas
+            ? regionalReplicas.flatMap(({ doId, tag }) => {
+                return AVAILABLE_REGIONS.map((region) => {
+                    return {
+                        doId: new DOId({
+                            baseShardId: doId.options.baseShardId,
+                            numberOfReplicas: numReplicas,
+                            shardType,
+                            replicaId: doId.replicaId,
+                            region,
+                        }),
+                        tag,
+                    };
+                });
+            })
+            : regionalReplicas.map(({ doId, tag }) => {
+                doId.region = this.getClosestRegion();
+                return { doId, tag };
+            });
+        return regionalReplicasInAllRegions;
+    }
+    getClosestRegion() {
+        const continent = getCloudflareContext().cf?.continent;
+        if (!continent)
+            return this.defaultRegion;
+        debug("[shardedTagCache] - Continent : ", continent);
+        switch (continent) {
+            case "AF":
+                return "afr";
+            case "AS":
+                return "apac";
+            case "EU":
+                return "weur";
+            case "NA":
+                return "enam";
+            case "OC":
+                return "oc";
+            case "SA":
+                return "sam";
+            default:
+                return this.defaultRegion;
+        }
     }
     /**
      * Same tags are guaranteed to be in the same shard
@@ -196,6 +258,7 @@ class ShardedDOTagCache {
         await Promise.all(shardedTagGroups.map(async ({ doId, tags }) => {
             await this.performWriteTagsWithRetry(doId, tags, currentTime);
         }));
+        await purgeCacheByTags(tags);
     }
     async performWriteTagsWithRetry(doId, tags, lastModified, retryNumber = 0) {
         try {

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

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import shardedDOTagCache, { DOId } from "./do-sharded-tag-cache";
+import shardedDOTagCache, { AVAILABLE_REGIONS, DOId } from "./do-sharded-tag-cache";
 const hasBeenRevalidatedMock = vi.fn();
 const writeTagsMock = vi.fn();
 const idFromNameMock = vi.fn();
@@ -7,6 +7,8 @@ const getMock = vi
     .fn()
     .mockReturnValue({ hasBeenRevalidated: hasBeenRevalidatedMock, writeTags: writeTagsMock });
 const waitUntilMock = vi.fn().mockImplementation(async (fn) => fn());
+// @ts-expect-error - We define it here only for the test
+globalThis.continent = undefined;
 const sendDLQMock = vi.fn();
 vi.mock("../../cloudflare-context", () => ({
     getCloudflareContext: () => ({
@@ -17,6 +19,10 @@ vi.mock("../../cloudflare-context", () => ({
             },
         },
         ctx: { waitUntil: waitUntilMock },
+        cf: {
+            // @ts-expect-error - We define it here only for the test
+            continent: globalThis.continent,
+        },
     }),
 }));
 describe("DOShardedTagCache", () => {
@@ -96,6 +102,80 @@ describe("DOShardedTagCache", () => {
                 expect(secondDOId?.replicaId).toBeGreaterThanOrEqual(1);
                 expect(secondDOId?.replicaId).toBeLessThanOrEqual(2);
             });
+            it("should generate one doIds, but in the default region", () => {
+                const cache = shardedDOTagCache({
+                    baseShardSize: 4,
+                    shardReplication: {
+                        numberOfSoftReplicas: 2,
+                        numberOfHardReplicas: 2,
+                        regionalReplication: {
+                            defaultRegion: "enam",
+                        },
+                    },
+                });
+                const shardedTagCollection = cache.groupTagsByDO({
+                    tags: ["tag1", "_N_T_/tag1"],
+                    generateAllReplicas: false,
+                });
+                expect(shardedTagCollection.length).toBe(2);
+                const firstDOId = shardedTagCollection[0]?.doId;
+                const secondDOId = shardedTagCollection[1]?.doId;
+                expect(firstDOId?.shardId).toBe("tag-soft;shard-3");
+                expect(firstDOId?.region).toBe("enam");
+                expect(secondDOId?.shardId).toBe("tag-hard;shard-1");
+                expect(secondDOId?.region).toBe("enam");
+                // We still need to check if the last part is between the correct boundaries
+                expect(firstDOId?.replicaId).toBeGreaterThanOrEqual(1);
+                expect(firstDOId?.replicaId).toBeLessThanOrEqual(2);
+                expect(secondDOId?.replicaId).toBeGreaterThanOrEqual(1);
+                expect(secondDOId?.replicaId).toBeLessThanOrEqual(2);
+            });
+            it("should generate one doIds, but in the correct region", () => {
+                // @ts-expect-error - We define it here only for the test
+                globalThis.continent = "EU";
+                const cache = shardedDOTagCache({
+                    baseShardSize: 4,
+                    shardReplication: {
+                        numberOfSoftReplicas: 2,
+                        numberOfHardReplicas: 2,
+                        regionalReplication: {
+                            defaultRegion: "enam",
+                        },
+                    },
+                });
+                const shardedTagCollection = cache.groupTagsByDO({
+                    tags: ["tag1", "_N_T_/tag1"],
+                    generateAllReplicas: false,
+                });
+                expect(shardedTagCollection.length).toBe(2);
+                expect(shardedTagCollection[0]?.doId.region).toBe("weur");
+                expect(shardedTagCollection[1]?.doId.region).toBe("weur");
+                //@ts-expect-error - We need to reset the global variable
+                globalThis.continent = undefined;
+            });
+            it("should generate all the appropriate replicas in all the regions with enableRegionalReplication", () => {
+                const cache = shardedDOTagCache({
+                    baseShardSize: 4,
+                    shardReplication: {
+                        numberOfSoftReplicas: 2,
+                        numberOfHardReplicas: 2,
+                        regionalReplication: {
+                            defaultRegion: "enam",
+                        },
+                    },
+                });
+                const shardedTagCollection = cache.groupTagsByDO({
+                    tags: ["tag1", "_N_T_/tag1"],
+                    generateAllReplicas: true,
+                });
+                // 6 regions times 4 shards replica
+                expect(shardedTagCollection.length).toBe(24);
+                shardedTagCollection.forEach(({ doId }) => {
+                    expect(AVAILABLE_REGIONS).toContain(doId.region);
+                    // It should end with the region
+                    expect(doId.key).toMatch(/tag-(soft|hard);shard-\d;replica-\d;region-(enam|weur|sam|afr|apac|oc)$/);
+                });
+            });
         });
     });
     describe("hasBeenRevalidated", () => {

package/dist/cli/build/bundle-server.d.ts

@@ -6,7 +6,7 @@ export declare function bundleServer(buildOpts: BuildOptions): Promise<void>;
 /**
  * This function applies patches required for the code to run on workers.
  */
-export declare function updateWorkerBundledCode(workerOutputFile: string, buildOpts: BuildOptions): Promise<void>;
+export declare function updateWorkerBundledCode(workerOutputFile: string): Promise<void>;
 /**
  * Gets the path of the worker.js file generated by the build process
  *

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

@@ -9,12 +9,12 @@ 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";
-import { inlineBuildId } from "./patches/plugins/build-id.js";
 import { inlineDynamicRequires } from "./patches/plugins/dynamic-requires.js";
-import { inlineEvalManifest } from "./patches/plugins/eval-manifest.js";
 import { inlineFindDir } from "./patches/plugins/find-dir.js";
 import { patchInstrumentation } from "./patches/plugins/instrumentation.js";
 import { inlineLoadManifest } from "./patches/plugins/load-manifest.js";
+import { patchNextServer } from "./patches/plugins/next-server.js";
+import { patchResolveCache } from "./patches/plugins/open-next.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";
@@ -80,31 +80,28 @@ export async function bundleServer(buildOpts) {
             handleOptionalDependencies(optionalDependencies),
             patchInstrumentation(updater, buildOpts),
             patchPagesRouterContext(buildOpts),
-            inlineEvalManifest(updater, buildOpts),
             inlineFindDir(updater, buildOpts),
             inlineLoadManifest(updater, buildOpts),
-            inlineBuildId(updater),
+            patchNextServer(updater, buildOpts),
             patchDepdDeprecations(updater),
+            patchResolveCache(updater, buildOpts),
             // Apply updater updates, must be the last plugin
             updater.plugin,
         ],
         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
-            //       we do this to both save on bundle size (there isn't really any benefit in us shipping the node-fetch code)
-            //       and also get rid of a warning in the terminal caused by the package (because it performs an === comparison with -0)
+            // Workers have `fetch` so the `node-fetch` polyfill is not needed
             "next/dist/compiled/node-fetch": path.join(buildOpts.outputDir, "cloudflare-templates/shims/fetch.js"),
-            // Note: we apply an empty shim to next/dist/compiled/ws because it generates two `eval`s:
-            //   eval("require")("bufferutil");
-            //   eval("require")("utf-8-validate");
+            // Workers have builtin Web Sockets
             "next/dist/compiled/ws": path.join(buildOpts.outputDir, "cloudflare-templates/shims/empty.js"),
-            // Note: we apply an empty shim to next/dist/compiled/edge-runtime since (amongst others) it generated the following `eval`:
-            //   eval(getModuleCode)(module, module.exports, throwingRequire, params.context, ...Object.values(params.scopedContext));
-            //   which comes from https://github.com/vercel/edge-runtime/blob/6e96b55f/packages/primitives/src/primitives/load.js#L57-L63
+            // The toolbox optimizer pulls severals MB of dependencies (`caniuse-lite`, `terser`, `acorn`, ...)
+            // Drop it to optimize the code size
+            // See https://github.com/vercel/next.js/blob/6eb235c/packages/next/src/server/optimize-amp.ts
+            "next/dist/compiled/@ampproject/toolbox-optimizer": path.join(buildOpts.outputDir, "cloudflare-templates/shims/throw.js"),
+            // The edge runtime is not supported
             "next/dist/compiled/edge-runtime": path.join(buildOpts.outputDir, "cloudflare-templates/shims/empty.js"),
-            // `@next/env` is a library Next.js uses for loading dotenv files, for obvious reasons we need to stub it here
-            // source: https://github.com/vercel/next.js/tree/0ac10d79720/packages/next-env
+            // `@next/env` is used by Next to load environment variables from files.
+            // OpenNext inlines the values at build time so this is not needed.
             "@next/env": path.join(buildOpts.outputDir, "cloudflare-templates/shims/env.js"),
         },
         define: {
@@ -133,7 +130,7 @@ export async function bundleServer(buildOpts) {
         platform: "node",
     });
     fs.writeFileSync(openNextServerBundle + ".meta.json", JSON.stringify(result.metafile, null, 2));
-    await updateWorkerBundledCode(openNextServerBundle, buildOpts);
+    await updateWorkerBundledCode(openNextServerBundle);
     const isMonorepo = monorepoRoot !== appPath;
     if (isMonorepo) {
         fs.writeFileSync(path.join(outputPath, "handler.mjs"), `export { handler } from "./${normalizePath(packagePath)}/handler.mjs";`);
@@ -143,28 +140,9 @@ export async function bundleServer(buildOpts) {
 /**
  * This function applies patches required for the code to run on workers.
  */
-export async function updateWorkerBundledCode(workerOutputFile, buildOpts) {
+export async function updateWorkerBundledCode(workerOutputFile) {
     const code = await readFile(workerOutputFile, "utf8");
-    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),
-            { isOptional: true },
-        ],
-        [
-            "`require.resolve` call",
-            // 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"'),
-        ],
-    ]);
+    const patchedCode = await patchCodeWithValidations(code, [["require", patches.patchRequire]]);
     await writeFile(workerOutputFile, patchedCode);
 }
 /**

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

@@ -7,6 +7,7 @@ export function compileDurableObjects(buildOpts) {
     const entryPoints = [
         _require.resolve("@opennextjs/cloudflare/durable-objects/queue"),
         _require.resolve("@opennextjs/cloudflare/durable-objects/sharded-tag-cache"),
+        _require.resolve("@opennextjs/cloudflare/durable-objects/bucket-cache-purge"),
     ];
     const { outputDir } = buildOpts;
     const baseManifestPath = path.join(outputDir, "server-functions/default", getPackagePath(buildOpts), ".next");

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

@@ -10,9 +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, 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 * as awsPatches from "@opennextjs/aws/build/patch/patches/index.js";
 import logger from "@opennextjs/aws/logger.js";
 import { minifyAll } from "@opennextjs/aws/minimize-js.js";
 import { openNextEdgePlugins } from "@opennextjs/aws/plugins/edge.js";
@@ -133,13 +131,14 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
     }
     const additionalCodePatches = codeCustomization?.additionalCodePatches ?? [];
     await applyCodePatches(options, tracedFiles, manifests, [
-        patchFetchCacheSetMissingWaitUntil,
-        patchFetchCacheForISR,
-        patchUnstableCacheForISR,
-        patchUseCacheForISR,
-        patchNextServer,
-        patchEnvVars,
-        patchBackgroundRevalidation,
+        awsPatches.patchFetchCacheSetMissingWaitUntil,
+        awsPatches.patchFetchCacheForISR,
+        awsPatches.patchUnstableCacheForISR,
+        awsPatches.patchUseCacheForISR,
+        awsPatches.patchNextServer,
+        awsPatches.patchEnvVars,
+        awsPatches.patchBackgroundRevalidation,
+        awsPatches.patchDropBabel,
         // Cloudflare specific patches
         patchResRevalidate,
         patchUseCacheIO,

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

@@ -1,2 +1 @@
 export * from "./investigated/index.js";
-export * from "./to-investigate/inline-middleware-manifest.js";

package/dist/cli/build/patches/index.js

@@ -1,2 +1 @@
 export * from "./investigated/index.js";
-export * from "./to-investigate/inline-middleware-manifest.js";

package/dist/cli/build/patches/investigated/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./copy-package-cli-files.js";
-export * from "./patch-cache.js";
 export * from "./patch-require.js";

package/dist/cli/build/patches/investigated/index.js

@@ -1,3 +1,2 @@
 export * from "./copy-package-cli-files.js";
-export * from "./patch-cache.js";
 export * from "./patch-require.js";

package/dist/cli/build/patches/plugins/load-manifest.d.ts

@@ -1,5 +1,7 @@
 /**
- * Inline `loadManifest` as it relies on `readFileSync` that is not supported by workerd.
+ * Inline `loadManifest` and `evalManifest` from `load-manifest.js`
+ *
+ * They rely on `readFileSync` that is not supported by workerd.
  */
 import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
 import type { ContentUpdater, Plugin } from "@opennextjs/aws/plugins/content-updater.js";

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

@@ -1,5 +1,7 @@
 /**
- * Inline `loadManifest` as it relies on `readFileSync` that is not supported by workerd.
+ * Inline `loadManifest` and `evalManifest` from `load-manifest.js`
+ *
+ * They rely on `readFileSync` that is not supported by workerd.
  */
 import { readFile } from "node:fs/promises";
 import { join, posix, relative, sep } from "node:path";
@@ -16,21 +18,24 @@ export function inlineLoadManifest(updater, buildOpts) {
                     escape: false,
                 }),
                 contentFilter: /function loadManifest\(/,
-                callback: async ({ contents }) => patchCode(contents, await getRule(buildOpts)),
+                callback: async ({ contents }) => {
+                    contents = await patchCode(contents, await getLoadManifestRule(buildOpts));
+                    contents = await patchCode(contents, await getEvalManifestRule(buildOpts));
+                    return contents;
+                },
             },
         },
     ]);
 }
-async function getRule(buildOpts) {
+async function getLoadManifestRule(buildOpts) {
     const { outputDir } = buildOpts;
     const baseDir = join(outputDir, "server-functions/default", getPackagePath(buildOpts));
     const dotNextDir = join(baseDir, ".next");
     const manifests = await glob(join(dotNextDir, "**/*-manifest.json"), { windowsPathsNoEscape: true });
     const returnManifests = (await Promise.all(manifests.map(async (manifest) => `
-            if ($PATH.endsWith("${normalizePath("/" + relative(dotNextDir, manifest))}")) {
-              return ${await readFile(manifest, "utf-8")};
-            }
-          `))).join("\n");
+if ($PATH.endsWith("${normalizePath("/" + relative(dotNextDir, manifest))}")) {
+  return ${await readFile(manifest, "utf-8")};
+}`))).join("\n");
     return {
         rule: {
             pattern: `
@@ -46,3 +51,40 @@ function loadManifest($PATH, $$$ARGS) {
 }`,
     };
 }
+async function getEvalManifestRule(buildOpts) {
+    const { outputDir } = buildOpts;
+    const baseDir = join(outputDir, "server-functions/default", getPackagePath(buildOpts), ".next");
+    const appDir = join(baseDir, "server/app");
+    const manifests = await glob(join(baseDir, "**/*_client-reference-manifest.js"), {
+        windowsPathsNoEscape: true,
+    });
+    const returnManifests = manifests
+        .map((manifest) => {
+        const endsWith = normalizePath(relative(baseDir, manifest));
+        const key = normalizePath("/" + relative(appDir, manifest)).replace("_client-reference-manifest.js", "");
+        return `
+if ($PATH.endsWith("${endsWith}")) {
+  require(${JSON.stringify(manifest)});
+  return {
+    __RSC_MANIFEST: {
+    "${key}": globalThis.__RSC_MANIFEST["${key}"],
+    },
+  };
+}`;
+    })
+        .join("\n");
+    return {
+        rule: {
+            pattern: `
+function evalManifest($PATH, $$$ARGS) {
+  $$$_
+}`,
+        },
+        fix: `
+function evalManifest($PATH, $$$ARGS) {
+  $PATH = $PATH.replaceAll(${JSON.stringify(sep)}, ${JSON.stringify(posix.sep)});
+  ${returnManifests}
+  throw new Error(\`Unexpected evalManifest(\${$PATH}) call!\`);
+}`,
+    };
+}

package/dist/cli/build/patches/plugins/next-server.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Misc patches for `next-server.js`
+ *
+ * Note: we will probably need to revisit the patches when the Next adapter API lands
+ *
+ * - Inline `getBuildId` as it relies on `readFileSync` that is not supported by workerd
+ * - Inline the middleware manifest
+ * - Override the cache and composable cache handlers
+ */
+import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
+import type { ContentUpdater, Plugin } from "@opennextjs/aws/plugins/content-updater.js";
+export declare function patchNextServer(updater: ContentUpdater, buildOpts: BuildOptions): Plugin;
+export declare const buildIdRule = "\nrule:\n  pattern:\n    selector: method_definition\n    context: \"class { getBuildId($$$PARAMS) { $$$_ } }\"\nfix: |-\n  getBuildId($$$PARAMS) {\n    return process.env.NEXT_BUILD_ID;\n  }\n";
+export declare function createMiddlewareManifestRule(manifest: unknown): string;
+/**
+ * The cache handler used by Next.js is normally defined in the config file as a path. At runtime,
+ * Next.js would then do a dynamic require on a transformed version of the path to retrieve the
+ * cache handler and create a new instance of it.
+ *
+ * This is problematic in workerd due to the dynamic import of the file that is not known from
+ * build-time. Therefore, we have to manually override the default way that the cache handler is
+ * instantiated with a dynamic require that uses a string literal for the path.
+ */
+export declare function createCacheHandlerRule(handlerPath: string): string;
+export declare function createComposableCacheHandlersRule(handlerPath: string): string;