@opennextjs/cloudflare 1.0.2 → 1.0.4

package/dist/api/config.d.ts

@@ -46,6 +46,13 @@ interface OpenNextConfig extends AwsOpenNextConfig {
          * @default true
          */
         useWorkerdCondition?: boolean;
+        /**
+         * Disable throwing an error when the config validation fails.
+         * This is useful for overriding some of the default provided by cloudflare.
+         * **USE AT YOUR OWN RISK**
+         * @default false
+         */
+        dangerousDisableConfigValidation?: boolean;
     };
 }
 /**

package/dist/api/durable-objects/queue.js

@@ -1,4 +1,4 @@
-import { debug, error } from "@opennextjs/aws/adapters/logger.js";
+import { debug, error, warn } from "@opennextjs/aws/adapters/logger.js";
 import { FatalError, IgnorableError, isOpenNextError, RecoverableError, } from "@opennextjs/aws/utils/error.js";
 import { DurableObject } from "cloudflare:workers";
 const DEFAULT_MAX_REVALIDATION = 5;
@@ -47,6 +47,9 @@ export class DOQueueHandler extends DurableObject {
         debug(`Durable object initialized`);
     }
     async revalidate(msg) {
+        if (this.ongoingRevalidations.size > 2 * this.maxRevalidations) {
+            warn(`Your durable object has 2 times the maximum number of revalidations (${this.maxRevalidations}) in progress. If this happens often, you should consider increasing the NEXT_CACHE_DO_QUEUE_MAX_REVALIDATION or the number of durable objects with the MAX_REVALIDATE_CONCURRENCY env var.`);
+        }
         // If there is already an ongoing revalidation, we don't need to revalidate again
         if (this.ongoingRevalidations.has(msg.MessageDeduplicationId))
             return;
@@ -59,19 +62,18 @@ export class DOQueueHandler extends DurableObject {
             return;
         if (this.ongoingRevalidations.size >= this.maxRevalidations) {
             debug(`The maximum number of revalidations (${this.maxRevalidations}) is reached. Blocking until one of the revalidations finishes.`);
-            const ongoingRevalidations = this.ongoingRevalidations.values();
-            // When there is more than the max revalidations, we block concurrency until one of the revalidations finishes
-            // We still await the promise to ensure the revalidation is completed
-            // This is fine because the queue itself run inside a waitUntil
-            await this.ctx.blockConcurrencyWhile(async () => {
+            // TODO: need more investigation
+            // We don't use `blockConcurrencyWhile` here because it block the whole durable object for 30 seconds
+            // if we exceed the max revalidations too fast
+            while (this.ongoingRevalidations.size >= this.maxRevalidations) {
+                const ongoingRevalidations = this.ongoingRevalidations.values();
                 debug(`Waiting for one of the revalidations to finish`);
                 await Promise.race(ongoingRevalidations);
-            });
+            }
         }
         const revalidationPromise = this.executeRevalidation(msg);
         // We store the promise to dedupe the revalidation
         this.ongoingRevalidations.set(msg.MessageDeduplicationId, revalidationPromise);
-        // TODO: check if the object stays up during waitUntil so that the internal state is maintained
         this.ctx.waitUntil(revalidationPromise);
     }
     async executeRevalidation(msg) {
@@ -86,6 +88,7 @@ export class DOQueueHandler extends DurableObject {
                     "x-prerender-revalidate": process.env.__NEXT_PREVIEW_MODE_ID,
                     "x-isr": "1",
                 },
+                // This one is kind of problematic, it will always show the wall time of the revalidation to `this.revalidationTimeout`
                 signal: AbortSignal.timeout(this.revalidationTimeout),
             });
             // Now we need to handle errors from the fetch
@@ -202,6 +205,7 @@ export class DOQueueHandler extends DurableObject {
         // We create the sync table to handle eventually consistent incremental cache
         this.sql.exec("CREATE TABLE IF NOT EXISTS sync (id TEXT PRIMARY KEY, lastSuccess INTEGER, buildId TEXT)");
         // Before doing anything else, we clear the DB for any potential old data
+        // TODO: extract this to a function so that it could be called by the user at another time than init
         this.sql.exec("DELETE FROM failed_state WHERE buildId != ?", process.env.__NEXT_BUILD_ID);
         this.sql.exec("DELETE FROM sync WHERE buildId != ?", process.env.__NEXT_BUILD_ID);
         const failedStateCursor = this.sql.exec("SELECT * FROM failed_state");

package/dist/api/durable-objects/queue.spec.js

@@ -82,9 +82,6 @@ describe("DurableObjectQueue", () => {
             expect(queue.ongoingRevalidations.size).toBe(queue.maxRevalidations);
             expect(queue.ongoingRevalidations.has("id6")).toBe(false);
             expect(Array.from(queue.ongoingRevalidations.keys())).toEqual(["id", "id2", "id3", "id4", "id5"]);
-            // BlockConcurrencyWhile is called twice here, first time during creation of the object and second time when we try to revalidate
-            // @ts-expect-error
-            expect(queue.ctx.blockConcurrencyWhile).toHaveBeenCalledTimes(2);
             // Here we await the blocked request to ensure it's resolved
             await blockedReq;
             // We then need to await for the actual revalidation to finish

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

@@ -22,6 +22,7 @@ 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 { patchUseCacheIO } from "../patches/plugins/use-cache.js";
 import { normalizePath } from "../utils/index.js";
 import { copyWorkerdPackages } from "../utils/workerd.js";
 export async function createServerBundle(options, codeCustomization) {
@@ -141,6 +142,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
         patchBackgroundRevalidation,
         // Cloudflare specific patches
         patchResRevalidate,
+        patchUseCacheIO,
         ...additionalCodePatches,
     ]);
     // Build Lambda code

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

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { getPackagePath } from "@opennextjs/aws/build/helper.js";
 import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
+import { normalizePath } from "../../utils/normalize-path.js";
 export function patchInstrumentation(updater, buildOpts) {
     const builtInstrumentationPath = getBuiltInstrumentationPath(buildOpts);
     updater.updateContent("patch-instrumentation-next15", [
@@ -69,7 +70,7 @@ export function getNext14Rule(builtInstrumentationPath) {
 function getBuiltInstrumentationPath(buildOpts) {
     const { outputDir } = buildOpts;
     const maybeBuiltInstrumentationPath = join(outputDir, "server-functions/default", getPackagePath(buildOpts), `.next/server/${INSTRUMENTATION_HOOK_FILENAME}.js`);
-    return existsSync(maybeBuiltInstrumentationPath) ? maybeBuiltInstrumentationPath : null;
+    return existsSync(maybeBuiltInstrumentationPath) ? normalizePath(maybeBuiltInstrumentationPath) : null;
 }
 /**
  * Pattern to detect instrumentation hooks file

package/dist/cli/build/patches/plugins/use-cache.d.ts

@@ -0,0 +1,3 @@
+import type { CodePatcher } from "@opennextjs/aws/build/patch/codePatcher.js";
+export declare const rule = "\nrule:\n  kind: if_statement\n  inside:\n    kind: function_declaration\n    stopBy: end\n    has:\n      kind: identifier\n      pattern: createSnapshot\nfix:\n  '// Ignored snapshot'\n";
+export declare const patchUseCacheIO: CodePatcher;

package/dist/cli/build/patches/plugins/use-cache.js

@@ -0,0 +1,40 @@
+/**
+ * This patch will replace the createSnapshot function in the
+ * server/app-render/async-local-storage.js file to an empty string.
+ * This is necessary because the createSnapshot function is causing I/O issues for
+ * ISR/SSG revalidation in Cloudflare Workers.
+ * This is because by default it will use AsyncLocalStorage.snapshot() and it will
+ * bind everything to the initial request context.
+ * The downsides is that use cache function will have access to the full request
+ * ALS context from next (i.e. cookies, headers ...)
+ * TODO: Find a better fix for this issue.
+ */
+import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
+import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
+export const rule = `
+rule:
+  kind: if_statement
+  inside:
+    kind: function_declaration
+    stopBy: end
+    has:
+      kind: identifier
+      pattern: createSnapshot
+fix:
+  '// Ignored snapshot'
+`;
+export const patchUseCacheIO = {
+    name: "patch-use-cache",
+    patches: [
+        {
+            versions: ">=15.3.1",
+            field: {
+                pathFilter: getCrossPlatformPathRegex(String.raw `server/app-render/async-local-storage\.js$`, {
+                    escape: false,
+                }),
+                contentFilter: /createSnapshot/,
+                patchCode: async ({ code }) => patchCode(code, rule),
+            },
+        },
+    ],
+};

package/dist/cli/build/patches/plugins/use-cache.spec.d.ts

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

package/dist/cli/build/patches/plugins/use-cache.spec.js

@@ -0,0 +1,156 @@
+import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
+import { expect, test } from "vitest";
+import { rule } from "./use-cache.js";
+const codeToPatch = `"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    bindSnapshot: null,
+    createAsyncLocalStorage: null,
+    createSnapshot: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    bindSnapshot: function() {
+        return bindSnapshot;
+    },
+    createAsyncLocalStorage: function() {
+        return createAsyncLocalStorage;
+    },
+    createSnapshot: function() {
+        return createSnapshot;
+    }
+});
+const sharedAsyncLocalStorageNotAvailableError = Object.defineProperty(new Error('Invariant: AsyncLocalStorage accessed in runtime where it is not available'), "__NEXT_ERROR_CODE", {
+    value: "E504",
+    enumerable: false,
+    configurable: true
+});
+class FakeAsyncLocalStorage {
+    disable() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+    }
+    getStore() {
+        // This fake implementation of AsyncLocalStorage always returns \`undefined\`.
+        return undefined;
+    }
+    run() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+    }
+    exit() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+    }
+    enterWith() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+    }
+    static bind(fn) {
+        return fn;
+    }
+}
+const maybeGlobalAsyncLocalStorage = typeof globalThis !== 'undefined' && globalThis.AsyncLocalStorage;
+function createAsyncLocalStorage() {
+    if (maybeGlobalAsyncLocalStorage) {
+        return new maybeGlobalAsyncLocalStorage();
+    }
+    return new FakeAsyncLocalStorage();
+}
+function bindSnapshot(fn) {
+    if (maybeGlobalAsyncLocalStorage) {
+        return maybeGlobalAsyncLocalStorage.bind(fn);
+    }
+    return FakeAsyncLocalStorage.bind(fn);
+}
+function createSnapshot() {
+    if (maybeGlobalAsyncLocalStorage) {
+        return maybeGlobalAsyncLocalStorage.snapshot();
+    }
+    return function(fn, ...args) {
+        return fn(...args);
+    };
+}
+
+//# sourceMappingURL=async-local-storage.js.map
+`;
+test("patch the createSnapshot function", () => {
+    const patchedCode = patchCode(codeToPatch, rule);
+    expect(patchedCode).toMatchInlineSnapshot(`""use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    bindSnapshot: null,
+    createAsyncLocalStorage: null,
+    createSnapshot: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    bindSnapshot: function() {
+        return bindSnapshot;
+    },
+    createAsyncLocalStorage: function() {
+        return createAsyncLocalStorage;
+    },
+    createSnapshot: function() {
+        return createSnapshot;
+    }
+});
+const sharedAsyncLocalStorageNotAvailableError = Object.defineProperty(new Error('Invariant: AsyncLocalStorage accessed in runtime where it is not available'), "__NEXT_ERROR_CODE", {
+    value: "E504",
+    enumerable: false,
+    configurable: true
+});
+class FakeAsyncLocalStorage {
+    disable() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+    }
+    getStore() {
+        // This fake implementation of AsyncLocalStorage always returns \`undefined\`.
+        return undefined;
+    }
+    run() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+    }
+    exit() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+    }
+    enterWith() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+    }
+    static bind(fn) {
+        return fn;
+    }
+}
+const maybeGlobalAsyncLocalStorage = typeof globalThis !== 'undefined' && globalThis.AsyncLocalStorage;
+function createAsyncLocalStorage() {
+    if (maybeGlobalAsyncLocalStorage) {
+        return new maybeGlobalAsyncLocalStorage();
+    }
+    return new FakeAsyncLocalStorage();
+}
+function bindSnapshot(fn) {
+    if (maybeGlobalAsyncLocalStorage) {
+        return maybeGlobalAsyncLocalStorage.bind(fn);
+    }
+    return FakeAsyncLocalStorage.bind(fn);
+}
+function createSnapshot() {
+    // Ignored snapshot
+    return function(fn, ...args) {
+        return fn(...args);
+    };
+}
+
+//# sourceMappingURL=async-local-storage.js.map
+"`);
+});

package/dist/cli/build/patches/plugins/wrangler-external.js

@@ -14,6 +14,7 @@
  * ref: https://developers.cloudflare.com/workers/wrangler/bundling/
  */
 import { dirname, resolve } from "node:path";
+import { normalizePath } from "../../utils/normalize-path.js";
 export function setWranglerExternal() {
     return {
         name: "wrangler-externals",
@@ -22,7 +23,7 @@ export function setWranglerExternal() {
             //TODO: Ideally in the future we would like to analyze the files in case they are using wasm in a Node way (i.e. WebAssembly.instantiate)
             build.onResolve({ filter: /(\.bin|\.wasm(\?module)?)$/ }, ({ path, importer }) => {
                 return {
-                    path: resolve(dirname(importer), path),
+                    path: normalizePath(resolve(dirname(importer), path)),
                     namespace,
                     external: true,
                 };

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

@@ -28,7 +28,7 @@ export function ensureCloudflareConfig(config) {
         logger.warn("The direct mode queue is not recommended for use in production.");
     }
     if (Object.values(requirements).some((satisfied) => !satisfied)) {
-        throw new Error("The `open-next.config.ts` should have a default export like this:\n\n" +
+        const errorMessage = "The `open-next.config.ts` should have a default export like this:\n\n" +
             `{
           default: {
             override: {
@@ -52,6 +52,11 @@ export function ensureCloudflareConfig(config) {
               queue: "dummy" | "direct" | function,
             },
           },
-        }\n\n`.replace(/^ {8}/gm, ""));
+        }\n\n`.replace(/^ {8}/gm, "");
+        if (config.cloudflare?.dangerousDisableConfigValidation) {
+            logger.warn(errorMessage);
+            return;
+        }
+        throw new Error(errorMessage);
     }
 }

package/dist/cli/commands/populate-cache.js

@@ -9,6 +9,7 @@ import { BINDING_NAME as R2_CACHE_BINDING_NAME, NAME as R2_CACHE_NAME, PREFIX_EN
 import { CACHE_DIR as STATIC_ASSETS_CACHE_DIR, NAME as STATIC_ASSETS_CACHE_NAME, } from "../../api/overrides/incremental-cache/static-assets-incremental-cache.js";
 import { computeCacheKey } from "../../api/overrides/internal.js";
 import { BINDING_NAME as D1_TAG_BINDING_NAME, NAME as D1_TAG_NAME, } from "../../api/overrides/tag-cache/d1-next-tag-cache.js";
+import { normalizePath } from "../build/utils/normalize-path.js";
 import { runWrangler } from "../utils/run-wrangler.js";
 async function resolveCacheName(value) {
     return typeof value === "function" ? (await value()).name : value;
@@ -20,8 +21,8 @@ export function getCacheAssets(opts) {
     }).filter((f) => f.isFile());
     const assets = [];
     for (const file of allFiles) {
-        const fullPath = file.fullpathPosix();
-        const relativePath = path.relative(path.join(opts.outputDir, "cache"), fullPath);
+        const fullPath = file.fullpath();
+        const relativePath = normalizePath(path.relative(path.join(opts.outputDir, "cache"), fullPath));
         if (relativePath.startsWith("__fetch")) {
             const [__fetch, buildId, ...keyParts] = relativePath.split("/");
             if (__fetch !== "__fetch" || buildId === undefined || keyParts.length === 0) {
@@ -74,7 +75,11 @@ async function populateR2IncrementalCache(options, populateCacheOptions) {
             buildId,
             cacheType: isFetch ? "fetch" : "cache",
         });
-        runWrangler(options, ["r2 object put", quoteShellMeta(path.join(bucket, cacheKey)), `--file ${quoteShellMeta(fullPath)}`], 
+        runWrangler(options, [
+            "r2 object put",
+            quoteShellMeta(normalizePath(path.join(bucket, cacheKey))),
+            `--file ${quoteShellMeta(fullPath)}`,
+        ], 
         // NOTE: R2 does not support the environment flag and results in the following error:
         // Incorrect type for the 'cacheExpiry' field on 'HttpMetadata': the provided value is not of type 'date'.
         { target: populateCacheOptions.target, logging: "error" });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"
@@ -43,7 +43,7 @@
   "homepage": "https://github.com/opennextjs/opennextjs-cloudflare",
   "dependencies": {
     "@dotenvx/dotenvx": "1.31.0",
-    "@opennextjs/aws": "^3.6.1",
+    "@opennextjs/aws": "^3.6.2",
     "enquirer": "^2.4.1",
     "glob": "^11.0.0",
     "ts-tqdm": "^0.8.6"
@@ -54,7 +54,7 @@
     "@tsconfig/strictest": "^2.0.5",
     "@types/mock-fs": "^4.13.4",
     "@types/node": "^22.2.0",
-    "esbuild": "^0.24.2",
+    "esbuild": "^0.25.4",
     "eslint": "^9.11.1",
     "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-simple-import-sort": "^12.1.1",