@opennextjs/cloudflare 0.4.8 → 0.5.0

package/dist/api/memory-queue.d.ts

@@ -0,0 +1,18 @@
+import type { Queue, QueueMessage } from "@opennextjs/aws/types/overrides.js";
+export declare const DEFAULT_REVALIDATION_TIMEOUT_MS = 10000;
+/**
+ * The Memory Queue offers basic ISR revalidation by directly requesting a revalidation of a route.
+ *
+ * It offers basic support for in-memory de-duping per isolate.
+ */
+export declare class MemoryQueue implements Queue {
+    private opts;
+    readonly name = "memory-queue";
+    revalidatedPaths: Map<string, NodeJS.Timeout>;
+    constructor(opts?: {
+        revalidationTimeoutMs: number;
+    });
+    send({ MessageBody: { host, url }, MessageGroupId }: QueueMessage): Promise<void>;
+}
+declare const _default: MemoryQueue;
+export default _default;

package/dist/api/memory-queue.js

@@ -0,0 +1,43 @@
+import logger from "@opennextjs/aws/logger.js";
+export const DEFAULT_REVALIDATION_TIMEOUT_MS = 10_000;
+/**
+ * The Memory Queue offers basic ISR revalidation by directly requesting a revalidation of a route.
+ *
+ * It offers basic support for in-memory de-duping per isolate.
+ */
+export class MemoryQueue {
+    opts;
+    name = "memory-queue";
+    revalidatedPaths = new Map();
+    constructor(opts = { revalidationTimeoutMs: DEFAULT_REVALIDATION_TIMEOUT_MS }) {
+        this.opts = opts;
+    }
+    async send({ MessageBody: { host, url }, MessageGroupId }) {
+        if (this.revalidatedPaths.has(MessageGroupId))
+            return;
+        this.revalidatedPaths.set(MessageGroupId, 
+        // force remove to allow new revalidations incase something went wrong
+        setTimeout(() => this.revalidatedPaths.delete(MessageGroupId), this.opts.revalidationTimeoutMs));
+        try {
+            const protocol = host.includes("localhost") ? "http" : "https";
+            // TODO: Drop the import - https://github.com/opennextjs/opennextjs-cloudflare/issues/361
+            // @ts-ignore
+            const manifest = await import("./.next/prerender-manifest.json");
+            await globalThis.internalFetch(`${protocol}://${host}${url}`, {
+                method: "HEAD",
+                headers: {
+                    "x-prerender-revalidate": manifest.preview.previewModeId,
+                    "x-isr": "1",
+                },
+            });
+        }
+        catch (e) {
+            logger.error(e);
+        }
+        finally {
+            clearTimeout(this.revalidatedPaths.get(MessageGroupId));
+            this.revalidatedPaths.delete(MessageGroupId);
+        }
+    }
+}
+export default new MemoryQueue();

package/dist/api/memory-queue.spec.d.ts

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

package/dist/api/memory-queue.spec.js

@@ -0,0 +1,64 @@
+import { generateMessageGroupId } from "@opennextjs/aws/core/routing/queue.js";
+import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
+import cache, { DEFAULT_REVALIDATION_TIMEOUT_MS } from "./memory-queue";
+vi.mock("./.next/prerender-manifest.json", () => Promise.resolve({ preview: { previewModeId: "id" } }));
+describe("MemoryQueue", () => {
+    beforeAll(() => {
+        vi.useFakeTimers();
+        globalThis.internalFetch = vi.fn().mockReturnValue(new Promise((res) => setTimeout(() => res(true), 1)));
+    });
+    afterEach(() => vi.clearAllMocks());
+    it("should process revalidations for a path", async () => {
+        const firstRequest = cache.send({
+            MessageBody: { host: "test.local", url: "/test" },
+            MessageGroupId: generateMessageGroupId("/test"),
+            MessageDeduplicationId: "",
+        });
+        vi.advanceTimersByTime(DEFAULT_REVALIDATION_TIMEOUT_MS);
+        await firstRequest;
+        expect(globalThis.internalFetch).toHaveBeenCalledTimes(1);
+        const secondRequest = cache.send({
+            MessageBody: { host: "test.local", url: "/test" },
+            MessageGroupId: generateMessageGroupId("/test"),
+            MessageDeduplicationId: "",
+        });
+        vi.advanceTimersByTime(1);
+        await secondRequest;
+        expect(globalThis.internalFetch).toHaveBeenCalledTimes(2);
+    });
+    it("should process revalidations for multiple paths", async () => {
+        const firstRequest = cache.send({
+            MessageBody: { host: "test.local", url: "/test" },
+            MessageGroupId: generateMessageGroupId("/test"),
+            MessageDeduplicationId: "",
+        });
+        vi.advanceTimersByTime(1);
+        await firstRequest;
+        expect(globalThis.internalFetch).toHaveBeenCalledTimes(1);
+        const secondRequest = cache.send({
+            MessageBody: { host: "test.local", url: "/test" },
+            MessageGroupId: generateMessageGroupId("/other"),
+            MessageDeduplicationId: "",
+        });
+        vi.advanceTimersByTime(1);
+        await secondRequest;
+        expect(globalThis.internalFetch).toHaveBeenCalledTimes(2);
+    });
+    it("should de-dupe revalidations", async () => {
+        const requests = [
+            cache.send({
+                MessageBody: { host: "test.local", url: "/test" },
+                MessageGroupId: generateMessageGroupId("/test"),
+                MessageDeduplicationId: "",
+            }),
+            cache.send({
+                MessageBody: { host: "test.local", url: "/test" },
+                MessageGroupId: generateMessageGroupId("/test"),
+                MessageDeduplicationId: "",
+            }),
+        ];
+        vi.advanceTimersByTime(1);
+        await Promise.all(requests);
+        expect(globalThis.internalFetch).toHaveBeenCalledTimes(1);
+    });
+});

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

@@ -8,6 +8,7 @@ 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 { ContentUpdater } from "./patches/plugins/content-updater.js";
+import { patchFetchCacheSetMissingWaitUntil } from "./patches/plugins/fetch-cache-wait-until.js";
 import { patchLoadInstrumentation } from "./patches/plugins/load-instrumentation.js";
 import { handleOptionalDependencies } from "./patches/plugins/optional-deps.js";
 import { fixRequire } from "./patches/plugins/require.js";
@@ -71,6 +72,7 @@ export async function bundleServer(buildOpts) {
             fixRequire(updater),
             handleOptionalDependencies(optionalDependencies),
             patchLoadInstrumentation(updater),
+            patchFetchCacheSetMissingWaitUntil(updater),
             // Apply updater updaters, must be the last plugin
             updater.plugin,
         ],

package/dist/cli/build/patches/plugins/content-updater.d.ts

@@ -4,11 +4,21 @@
  * The updater allows multiple plugins to update the content.
  */
 import { type OnLoadOptions, type Plugin, type PluginBuild } from "esbuild";
+/**
+ * The callbacks returns either an updated content or undefined if the content is unchanged.
+ */
 export type Callback = (args: {
     contents: string;
     path: string;
 }) => string | undefined | Promise<string | undefined>;
-export type Updater = OnLoadOptions & {
+/**
+ * The callback is called only when `contentFilter` matches the content.
+ * It can be used as a fast heuristic to prevent an expensive update.
+ */
+export type OnUpdateOptions = OnLoadOptions & {
+    contentFilter: RegExp;
+};
+export type Updater = OnUpdateOptions & {
     callback: Callback;
 };
 export declare class ContentUpdater {
@@ -19,11 +29,11 @@ export declare class ContentUpdater {
      * The callbacks are called in order of registration.
      *
      * @param name The name of the plugin (must be unique).
-     * @param options Same options as the `onLoad` hook to restrict updates.
+     * @param options Options.
      * @param callback The callback updating the content.
      * @returns A noop ESBuild plugin.
      */
-    updateContent(name: string, options: OnLoadOptions, callback: Callback): Plugin;
+    updateContent(name: string, options: OnUpdateOptions, callback: Callback): Plugin;
     /**
      * Returns an ESBuild plugin applying the registered updates.
      */

package/dist/cli/build/patches/plugins/content-updater.js

@@ -12,7 +12,7 @@ export class ContentUpdater {
      * The callbacks are called in order of registration.
      *
      * @param name The name of the plugin (must be unique).
-     * @param options Same options as the `onLoad` hook to restrict updates.
+     * @param options Options.
      * @param callback The callback updating the content.
      * @returns A noop ESBuild plugin.
      */
@@ -35,11 +35,14 @@ export class ContentUpdater {
             setup: async (build) => {
                 build.onLoad({ filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/ }, async (args) => {
                     let contents = await readFile(args.path, "utf-8");
-                    for (const { filter, namespace, callback } of this.updaters.values()) {
+                    for (const { filter, namespace, contentFilter, callback } of this.updaters.values()) {
                         if (namespace !== undefined && args.namespace !== namespace) {
                             continue;
                         }
-                        if (!filter.test(args.path)) {
+                        if (!args.path.match(filter)) {
+                            continue;
+                        }
+                        if (!contents.match(contentFilter)) {
                             continue;
                         }
                         contents = (await callback({ contents, path: args.path })) ?? contents;

package/dist/cli/build/patches/plugins/fetch-cache-wait-until.d.ts

@@ -0,0 +1,14 @@
+import type { ContentUpdater } from "./content-updater.js";
+/**
+ * The following Next.js code sets values in the incremental cache for fetch calls:
+ *  https://github.com/vercel/next.js/blob/e5fc495e3d4/packages/next/src/server/lib/patch-fetch.ts#L690-L728
+ *
+ * The issue here is that this promise is never awaited in the Next.js code (since in a standard node.js server
+ * the promise will eventually simply just run) but we do need to run it inside `waitUntil` (so that the worker
+ * is not killed before the promise is fully executed), without that this promise gets discarded and values
+ * don't get saved in the incremental cache.
+ *
+ * This function wraps the promise in a `waitUntil` call (retrieved from `globalThis.__openNextAls.getStore()`).
+ */
+export declare function patchFetchCacheSetMissingWaitUntil(updater: ContentUpdater): import("esbuild").Plugin;
+export declare const rule = "\nrule:\n  kind: call_expression\n  pattern: $PROMISE\n  all:\n    - has: { pattern: $_.arrayBuffer().then, stopBy: end }\n    - has: { pattern: \"Buffer.from\", stopBy: end }\n    - any:\n        - inside:\n            kind: sequence_expression\n            inside:\n                kind: return_statement\n        - inside:\n            kind: expression_statement\n            precedes:\n                kind: return_statement\n    - has: { pattern: $_.FETCH, stopBy: end }\n\nfix: |\n  globalThis.__openNextAls?.getStore()?.waitUntil?.($PROMISE)\n";

package/dist/cli/build/patches/plugins/fetch-cache-wait-until.js

@@ -0,0 +1,40 @@
+import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
+import { patchCode } from "../ast/util.js";
+/**
+ * The following Next.js code sets values in the incremental cache for fetch calls:
+ *  https://github.com/vercel/next.js/blob/e5fc495e3d4/packages/next/src/server/lib/patch-fetch.ts#L690-L728
+ *
+ * The issue here is that this promise is never awaited in the Next.js code (since in a standard node.js server
+ * the promise will eventually simply just run) but we do need to run it inside `waitUntil` (so that the worker
+ * is not killed before the promise is fully executed), without that this promise gets discarded and values
+ * don't get saved in the incremental cache.
+ *
+ * This function wraps the promise in a `waitUntil` call (retrieved from `globalThis.__openNextAls.getStore()`).
+ */
+export function patchFetchCacheSetMissingWaitUntil(updater) {
+    return updater.updateContent("patch-fetch-cache-set-missing-wait-until", {
+        filter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|patch-fetch\.js)$`, { escape: false }),
+        contentFilter: /arrayBuffer\(\)\s*\.then/,
+    }, ({ contents }) => patchCode(contents, rule));
+}
+export const rule = `
+rule:
+  kind: call_expression
+  pattern: $PROMISE
+  all:
+    - has: { pattern: $_.arrayBuffer().then, stopBy: end }
+    - has: { pattern: "Buffer.from", stopBy: end }
+    - any:
+        - inside:
+            kind: sequence_expression
+            inside:
+                kind: return_statement
+        - inside:
+            kind: expression_statement
+            precedes:
+                kind: return_statement
+    - has: { pattern: $_.FETCH, stopBy: end }
+
+fix: |
+  globalThis.__openNextAls?.getStore()?.waitUntil?.($PROMISE)
+`;

package/dist/cli/build/patches/plugins/fetch-cache-wait-until.spec.d.ts

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

package/dist/cli/build/patches/plugins/fetch-cache-wait-until.spec.js

@@ -0,0 +1,453 @@
+import { describe, expect, test } from "vitest";
+import { patchCode } from "../ast/util.js";
+import { rule } from "./fetch-cache-wait-until.js";
+describe("patchFetchCacheSetMissingWaitUntil", () => {
+    test("on minified code", () => {
+        const code = `
+{
+  let [o4, a2] = (0, d2.cloneResponse)(e3);
+  return o4.arrayBuffer().then(async (e4) => {
+    var a3;
+    let i4 = Buffer.from(e4), s3 = { headers: Object.fromEntries(o4.headers.entries()), body: i4.toString("base64"), status: o4.status, url: o4.url };
+    null == $ || null == (a3 = $.serverComponentsHmrCache) || a3.set(n2, s3), F && await H.set(n2, { kind: c2.CachedRouteKind.FETCH, data: s3, revalidate: t5 }, { fetchCache: true, revalidate: r4, fetchUrl: _, fetchIdx: q, tags: A2 });
+  }).catch((e4) => console.warn("Failed to set fetch cache", u4, e4)).finally(X), a2;
+}`;
+        expect(patchCode(code, rule)).toMatchInlineSnapshot(`
+      "{
+        let [o4, a2] = (0, d2.cloneResponse)(e3);
+        return globalThis.__openNextAls?.getStore()?.waitUntil?.(o4.arrayBuffer().then(async (e4) => {
+          var a3;
+          let i4 = Buffer.from(e4), s3 = { headers: Object.fromEntries(o4.headers.entries()), body: i4.toString("base64"), status: o4.status, url: o4.url };
+          null == $ || null == (a3 = $.serverComponentsHmrCache) || a3.set(n2, s3), F && await H.set(n2, { kind: c2.CachedRouteKind.FETCH, data: s3, revalidate: t5 }, { fetchCache: true, revalidate: r4, fetchUrl: _, fetchIdx: q, tags: A2 });
+        }).catch((e4) => console.warn("Failed to set fetch cache", u4, e4)).finally(X))
+      , a2;
+      }"
+    `);
+    });
+    describe("on non-minified code", () => {
+        test("15.1.0", () => {
+            // source: https://github.com/vercel/next.js/blob/fe45b74fdac83d3/packages/next/src/server/lib/patch-fetch.ts#L627-L732
+            const code = `if (
+                res.status === 200 &&
+                incrementalCache &&
+                cacheKey &&
+                (isCacheableRevalidate ||
+                  useCacheOrRequestStore?.serverComponentsHmrCache)
+              ) {
+                const normalizedRevalidate =
+                  finalRevalidate >= INFINITE_CACHE
+                    ? CACHE_ONE_YEAR
+                    : finalRevalidate
+                const externalRevalidate =
+                  finalRevalidate >= INFINITE_CACHE ? false : finalRevalidate
+
+                if (workUnitStore && workUnitStore.type === 'prerender') {
+                  // We are prerendering at build time or revalidate time with dynamicIO so we need to
+                  // buffer the response so we can guarantee it can be read in a microtask
+                  const bodyBuffer = await res.arrayBuffer()
+
+                  const fetchedData = {
+                    headers: Object.fromEntries(res.headers.entries()),
+                    body: Buffer.from(bodyBuffer).toString('base64'),
+                    status: res.status,
+                    url: res.url,
+                  }
+
+                  // We can skip checking the serverComponentsHmrCache because we aren't in
+                  // dev mode.
+
+                  await incrementalCache.set(
+                    cacheKey,
+                    {
+                      kind: CachedRouteKind.FETCH,
+                      data: fetchedData,
+                      revalidate: normalizedRevalidate,
+                    },
+                    {
+                      fetchCache: true,
+                      revalidate: externalRevalidate,
+                      fetchUrl,
+                      fetchIdx,
+                      tags,
+                    }
+                  )
+                  await handleUnlock()
+
+                  // We return a new Response to the caller.
+                  return new Response(bodyBuffer, {
+                    headers: res.headers,
+                    status: res.status,
+                    statusText: res.statusText,
+                  })
+                } else {
+                  // We're cloning the response using this utility because there
+                  // exists a bug in the undici library around response cloning.
+                  // See the following pull request for more details:
+                  // https://github.com/vercel/next.js/pull/73274
+
+                  const [cloned1, cloned2] = cloneResponse(res)
+
+                  // We are dynamically rendering including dev mode. We want to return
+                  // the response to the caller as soon as possible because it might stream
+                  // over a very long time.
+                  cloned1
+                    .arrayBuffer()
+                    .then(async (arrayBuffer) => {
+                      const bodyBuffer = Buffer.from(arrayBuffer)
+
+                      const fetchedData = {
+                        headers: Object.fromEntries(cloned1.headers.entries()),
+                        body: bodyBuffer.toString('base64'),
+                        status: cloned1.status,
+                        url: cloned1.url,
+                      }
+
+                      useCacheOrRequestStore?.serverComponentsHmrCache?.set(
+                        cacheKey,
+                        fetchedData
+                      )
+
+                      if (isCacheableRevalidate) {
+                        await incrementalCache.set(
+                          cacheKey,
+                          {
+                            kind: CachedRouteKind.FETCH,
+                            data: fetchedData,
+                            revalidate: normalizedRevalidate,
+                          },
+                          {
+                            fetchCache: true,
+                            revalidate: externalRevalidate,
+                            fetchUrl,
+                            fetchIdx,
+                            tags,
+                          }
+                        )
+                      }
+                    })
+                    .catch((error) =>
+                      console.warn(\`Failed to set fetch cache\`, input, error)
+                    )
+                    .finally(handleUnlock)
+
+                  return cloned2
+                }
+              }
+      `;
+            expect(patchCode(code, rule)).toMatchInlineSnapshot(`
+        "if (
+                        res.status === 200 &&
+                        incrementalCache &&
+                        cacheKey &&
+                        (isCacheableRevalidate ||
+                          useCacheOrRequestStore?.serverComponentsHmrCache)
+                      ) {
+                        const normalizedRevalidate =
+                          finalRevalidate >= INFINITE_CACHE
+                            ? CACHE_ONE_YEAR
+                            : finalRevalidate
+                        const externalRevalidate =
+                          finalRevalidate >= INFINITE_CACHE ? false : finalRevalidate
+
+                        if (workUnitStore && workUnitStore.type === 'prerender') {
+                          // We are prerendering at build time or revalidate time with dynamicIO so we need to
+                          // buffer the response so we can guarantee it can be read in a microtask
+                          const bodyBuffer = await res.arrayBuffer()
+
+                          const fetchedData = {
+                            headers: Object.fromEntries(res.headers.entries()),
+                            body: Buffer.from(bodyBuffer).toString('base64'),
+                            status: res.status,
+                            url: res.url,
+                          }
+
+                          // We can skip checking the serverComponentsHmrCache because we aren't in
+                          // dev mode.
+
+                          await incrementalCache.set(
+                            cacheKey,
+                            {
+                              kind: CachedRouteKind.FETCH,
+                              data: fetchedData,
+                              revalidate: normalizedRevalidate,
+                            },
+                            {
+                              fetchCache: true,
+                              revalidate: externalRevalidate,
+                              fetchUrl,
+                              fetchIdx,
+                              tags,
+                            }
+                          )
+                          await handleUnlock()
+
+                          // We return a new Response to the caller.
+                          return new Response(bodyBuffer, {
+                            headers: res.headers,
+                            status: res.status,
+                            statusText: res.statusText,
+                          })
+                        } else {
+                          // We're cloning the response using this utility because there
+                          // exists a bug in the undici library around response cloning.
+                          // See the following pull request for more details:
+                          // https://github.com/vercel/next.js/pull/73274
+
+                          const [cloned1, cloned2] = cloneResponse(res)
+
+                          // We are dynamically rendering including dev mode. We want to return
+                          // the response to the caller as soon as possible because it might stream
+                          // over a very long time.
+                          globalThis.__openNextAls?.getStore()?.waitUntil?.(cloned1
+                            .arrayBuffer()
+                            .then(async (arrayBuffer) => {
+                              const bodyBuffer = Buffer.from(arrayBuffer)
+
+                              const fetchedData = {
+                                headers: Object.fromEntries(cloned1.headers.entries()),
+                                body: bodyBuffer.toString('base64'),
+                                status: cloned1.status,
+                                url: cloned1.url,
+                              }
+
+                              useCacheOrRequestStore?.serverComponentsHmrCache?.set(
+                                cacheKey,
+                                fetchedData
+                              )
+
+                              if (isCacheableRevalidate) {
+                                await incrementalCache.set(
+                                  cacheKey,
+                                  {
+                                    kind: CachedRouteKind.FETCH,
+                                    data: fetchedData,
+                                    revalidate: normalizedRevalidate,
+                                  },
+                                  {
+                                    fetchCache: true,
+                                    revalidate: externalRevalidate,
+                                    fetchUrl,
+                                    fetchIdx,
+                                    tags,
+                                  }
+                                )
+                              }
+                            })
+                            .catch((error) =>
+                              console.warn(\`Failed to set fetch cache\`, input, error)
+                            )
+                            .finally(handleUnlock))
+
+
+                          return cloned2
+                        }
+                      }
+              "
+      `);
+        });
+        test("Next.js 15.0.4", () => {
+            // source: https://github.com/vercel/next.js/blob/d6a6aa14069/packages/next/src/server/lib/patch-fetch.ts#L627-L725
+            const code = `if (
+      res.status === 200 &&
+      incrementalCache &&
+      cacheKey &&
+      (isCacheableRevalidate || requestStore?.serverComponentsHmrCache)
+    ) {
+      const normalizedRevalidate =
+        finalRevalidate >= INFINITE_CACHE
+          ? CACHE_ONE_YEAR
+          : finalRevalidate
+      const externalRevalidate =
+        finalRevalidate >= INFINITE_CACHE ? false : finalRevalidate
+
+      if (workUnitStore && workUnitStore.type === 'prerender') {
+        // We are prerendering at build time or revalidate time with dynamicIO so we need to
+        // buffer the response so we can guarantee it can be read in a microtask
+        const bodyBuffer = await res.arrayBuffer()
+
+        const fetchedData = {
+          headers: Object.fromEntries(res.headers.entries()),
+          body: Buffer.from(bodyBuffer).toString('base64'),
+          status: res.status,
+          url: res.url,
+        }
+
+        // We can skip checking the serverComponentsHmrCache because we aren't in
+        // dev mode.
+
+        await incrementalCache.set(
+          cacheKey,
+          {
+            kind: CachedRouteKind.FETCH,
+            data: fetchedData,
+            revalidate: normalizedRevalidate,
+          },
+          {
+            fetchCache: true,
+            revalidate: externalRevalidate,
+            fetchUrl,
+            fetchIdx,
+            tags,
+          }
+        )
+        await handleUnlock()
+
+        // We we return a new Response to the caller.
+        return new Response(bodyBuffer, {
+          headers: res.headers,
+          status: res.status,
+          statusText: res.statusText,
+        })
+      } else {
+        // We are dynamically rendering including dev mode. We want to return
+        // the response to the caller as soon as possible because it might stream
+        // over a very long time.
+        res
+          .clone()
+          .arrayBuffer()
+          .then(async (arrayBuffer) => {
+            const bodyBuffer = Buffer.from(arrayBuffer)
+
+            const fetchedData = {
+              headers: Object.fromEntries(res.headers.entries()),
+              body: bodyBuffer.toString('base64'),
+              status: res.status,
+              url: res.url,
+            }
+
+            requestStore?.serverComponentsHmrCache?.set(
+              cacheKey,
+              fetchedData
+            )
+
+            if (isCacheableRevalidate) {
+              await incrementalCache.set(
+                cacheKey,
+                {
+                  kind: CachedRouteKind.FETCH,
+                  data: fetchedData,
+                  revalidate: normalizedRevalidate,
+                },
+                {
+                  fetchCache: true,
+                  revalidate: externalRevalidate,
+                  fetchUrl,
+                  fetchIdx,
+                  tags,
+                }
+              )
+            }
+          })
+          .catch((error) =>
+            console.warn(\`Failed to set fetch cache\`, input, error)
+          )
+          .finally(handleUnlock)
+
+        return res
+      }
+    }`;
+            expect(patchCode(code, rule)).toMatchInlineSnapshot(`
+        "if (
+              res.status === 200 &&
+              incrementalCache &&
+              cacheKey &&
+              (isCacheableRevalidate || requestStore?.serverComponentsHmrCache)
+            ) {
+              const normalizedRevalidate =
+                finalRevalidate >= INFINITE_CACHE
+                  ? CACHE_ONE_YEAR
+                  : finalRevalidate
+              const externalRevalidate =
+                finalRevalidate >= INFINITE_CACHE ? false : finalRevalidate
+
+              if (workUnitStore && workUnitStore.type === 'prerender') {
+                // We are prerendering at build time or revalidate time with dynamicIO so we need to
+                // buffer the response so we can guarantee it can be read in a microtask
+                const bodyBuffer = await res.arrayBuffer()
+
+                const fetchedData = {
+                  headers: Object.fromEntries(res.headers.entries()),
+                  body: Buffer.from(bodyBuffer).toString('base64'),
+                  status: res.status,
+                  url: res.url,
+                }
+
+                // We can skip checking the serverComponentsHmrCache because we aren't in
+                // dev mode.
+
+                await incrementalCache.set(
+                  cacheKey,
+                  {
+                    kind: CachedRouteKind.FETCH,
+                    data: fetchedData,
+                    revalidate: normalizedRevalidate,
+                  },
+                  {
+                    fetchCache: true,
+                    revalidate: externalRevalidate,
+                    fetchUrl,
+                    fetchIdx,
+                    tags,
+                  }
+                )
+                await handleUnlock()
+
+                // We we return a new Response to the caller.
+                return new Response(bodyBuffer, {
+                  headers: res.headers,
+                  status: res.status,
+                  statusText: res.statusText,
+                })
+              } else {
+                // We are dynamically rendering including dev mode. We want to return
+                // the response to the caller as soon as possible because it might stream
+                // over a very long time.
+                globalThis.__openNextAls?.getStore()?.waitUntil?.(res
+                  .clone()
+                  .arrayBuffer()
+                  .then(async (arrayBuffer) => {
+                    const bodyBuffer = Buffer.from(arrayBuffer)
+
+                    const fetchedData = {
+                      headers: Object.fromEntries(res.headers.entries()),
+                      body: bodyBuffer.toString('base64'),
+                      status: res.status,
+                      url: res.url,
+                    }
+
+                    requestStore?.serverComponentsHmrCache?.set(
+                      cacheKey,
+                      fetchedData
+                    )
+
+                    if (isCacheableRevalidate) {
+                      await incrementalCache.set(
+                        cacheKey,
+                        {
+                          kind: CachedRouteKind.FETCH,
+                          data: fetchedData,
+                          revalidate: normalizedRevalidate,
+                        },
+                        {
+                          fetchCache: true,
+                          revalidate: externalRevalidate,
+                          fetchUrl,
+                          fetchIdx,
+                          tags,
+                        }
+                      )
+                    }
+                  })
+                  .catch((error) =>
+                    console.warn(\`Failed to set fetch cache\`, input, error)
+                  )
+                  .finally(handleUnlock))
+
+
+                return res
+              }
+            }"
+      `);
+        });
+    });
+});

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

@@ -12,9 +12,5 @@ rule:
 fix: async loadInstrumentationModule() { }
 `;
 export function patchLoadInstrumentation(updater) {
-    return updater.updateContent("patch-load-instrumentation", { filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/ }, ({ contents }) => {
-        if (/async loadInstrumentationModule\(/.test(contents)) {
-            return patchCode(contents, instrumentationRule);
-        }
-    });
+    return updater.updateContent("patch-load-instrumentation", { filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/, contentFilter: /async loadInstrumentationModule\(/ }, ({ contents }) => patchCode(contents, instrumentationRule));
 }

package/dist/cli/build/patches/plugins/require-page.js

@@ -6,11 +6,8 @@ import { patchCode } from "../ast/util.js";
 export function inlineRequirePagePlugin(updater, buildOpts) {
     return updater.updateContent("inline-require-page", {
         filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/require\.js$`, { escape: false }),
-    }, async ({ contents }) => {
-        if (/function requirePage\(/.test(contents)) {
-            return patchCode(contents, await getRule(buildOpts));
-        }
-    });
+        contentFilter: /function requirePage\(/,
+    }, async ({ contents }) => patchCode(contents, await getRule(buildOpts)));
 }
 async function getRule(buildOpts) {
     const { outputDir } = buildOpts;

package/dist/cli/build/patches/plugins/require.js

@@ -1,5 +1,5 @@
 export function fixRequire(updater) {
-    return updater.updateContent("fix-require", { filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/ }, ({ contents }) => {
+    return updater.updateContent("fix-require", { filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/, contentFilter: /.*/ }, ({ contents }) => {
         // `eval(...)` is not supported by workerd.
         contents = contents.replaceAll(`eval("require")`, "require");
         // `@opentelemetry` has a few issues.
@@ -14,7 +14,7 @@ export function fixRequire(updater) {
         //
         // The intent is to allow users to install their own version of `@opentelemetry/api`.
         //
-        // The problem is that even when users do not explicitely install `@opentelemetry/api`,
+        // The problem is that even when users do not explicitly install `@opentelemetry/api`,
         // `require('@opentelemetry/api')` resolves to the package which is a dependency
         // of Next.
         //

package/dist/cli/build/utils/ensure-cf-config.js

@@ -11,8 +11,9 @@ export function ensureCloudflareConfig(config) {
         dftMaybeUseCache: config.default?.override?.incrementalCache === "dummy" ||
             typeof config.default?.override?.incrementalCache === "function",
         dftUseDummyTagCache: config.default?.override?.tagCache === "dummy",
-        dftMaybeUseQueue: config.default?.override?.queue === "dummy" || config.default?.override?.queue === "direct",
-        disableCacheInterception: config.dangerous?.enableCacheInterception !== true,
+        dftMaybeUseQueue: config.default?.override?.queue === "dummy" ||
+            config.default?.override?.queue === "direct" ||
+            typeof config.default?.override?.queue === "function",
         mwIsMiddlewareExternal: config.middleware?.external == true,
         mwUseCloudflareWrapper: config.middleware?.override?.wrapper === "cloudflare-edge",
         mwUseEdgeConverter: config.middleware?.override?.converter === "edge",
@@ -30,7 +31,7 @@ export function ensureCloudflareConfig(config) {
               converter: "edge",
               incrementalCache: "dummy" | function,
               tagCache: "dummy",
-              queue: "dummy" | "direct",
+              queue: "dummy" | "direct" | function,
             },
           },
 
@@ -42,10 +43,6 @@ export function ensureCloudflareConfig(config) {
               proxyExternalRequest: "fetch",
             },
           },
-
-          "dangerous": {
-            "enableCacheInterception": false
-          },
         }\n\n`.replace(/^ {8}/gm, ""));
     }
 }

package/dist/utils/get-package-templates-dir-path.js

@@ -1,5 +1,8 @@
-import * as path from "node:path";
-const templatesDirPath = path.resolve(`${import.meta.dirname}/../../templates`);
+import path from "node:path";
+import url from "node:url";
+const __filename = url.fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const templatesDirPath = path.join(__dirname, "/../../templates");
 /**
  * Utility for getting the resolved path to the package's templates directory
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "0.4.8",
+  "version": "0.5.0",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"

package/templates/defaults/open-next.config.ts

@@ -21,10 +21,6 @@ const config = {
       proxyExternalRequest: "fetch",
     },
   },
-
-  dangerous: {
-    enableCacheInterception: false,
-  },
 };
 
 export default config;