@opennextjs/cloudflare 1.0.0-beta.3 → 1.0.0

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

@@ -0,0 +1,32 @@
+/**
+ * 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 { compareSemver } from "@opennextjs/aws/build/helper.js";
+export function patchPagesRouterContext(buildOpts) {
+    const pathRegex = /^.*\/(?<CONTEXT>.*)\.shared-runtime$/;
+    const isAfter15 = compareSemver(buildOpts.nextVersion, ">=", "15.0.0");
+    const isAfter153 = compareSemver(buildOpts.nextVersion, ">=", "15.3.0");
+    const basePath = `next/dist/server/${isAfter15 ? "" : "future/"}route-modules/pages/vendored/contexts/`;
+    return {
+        name: "pages-router-context",
+        setup: (build) => {
+            // If we are after 15.3, we don't need to patch the context anymore
+            if (isAfter153) {
+                return;
+            }
+            // We need to modify some imports (i.e. https://github.com/vercel/next.js/blob/48540b836642525b38a2cba40a92b4532c553a52/packages/next/src/server/require-hook.ts#L59-L68)
+            build.onResolve({ filter: /.*shared-runtime/ }, async ({ path, resolveDir, ...options }) => {
+                const match = path.match(pathRegex);
+                if (match && match.groups?.CONTEXT) {
+                    const newPath = `${basePath}${match.groups.CONTEXT}.js`;
+                    return await build.resolve(newPath, {
+                        resolveDir,
+                        ...options,
+                    });
+                }
+            });
+        },
+    };
+}

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

@@ -19,7 +19,8 @@ export function setWranglerExternal() {
         name: "wrangler-externals",
         setup: async (build) => {
             const namespace = "wrangler-externals-plugin";
-            build.onResolve({ filter: /(\.bin|\.wasm\?module)$/ }, ({ path, importer }) => {
+            //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),
                     namespace,

package/dist/cli/build/utils/ensure-cf-config.d.ts

@@ -1,4 +1,4 @@
-import type { OpenNextConfig } from "@opennextjs/aws/types/open-next.js";
+import type { OpenNextConfig } from "../../../api/config.js";
 /**
  * Ensures open next is configured for cloudflare.
  *

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

@@ -0,0 +1,38 @@
+import type { BuildOptions } from "@opennextjs/aws/build/helper.js";
+/**
+ * This function transforms the exports (or imports) object from the package.json
+ * to only include the build condition if found (e.g. "workerd") and remove everything else.
+ * If no build condition is found, it keeps everything as is.
+ * It also returns a boolean indicating if the build condition was found.
+ * @param conditionMap The exports (or imports) object from the package.json
+ * @param condition The build condition to look for
+ * @returns An object with the transformed exports and a boolean indicating if the build condition was found
+ */
+export declare function transformBuildCondition(conditionMap: {
+    [key: string]: unknown;
+}, condition: string): {
+    transformedExports: {
+        [key: string]: unknown;
+    };
+    hasBuildCondition: boolean;
+};
+interface PackageJson {
+    name: string;
+    exports?: {
+        [key: string]: unknown;
+    };
+    imports?: {
+        [key: string]: unknown;
+    };
+}
+/**
+ *
+ * @param json The package.json object
+ * @returns An object with the transformed package.json and a boolean indicating if the build condition was found
+ */
+export declare function transformPackageJson(json: PackageJson): {
+    transformed: PackageJson;
+    hasBuildCondition: boolean;
+};
+export declare function copyWorkerdPackages(options: BuildOptions, nodePackages: Map<string, string>): Promise<void>;
+export {};

package/dist/cli/build/utils/workerd.js

@@ -0,0 +1,80 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { loadConfig } from "@opennextjs/aws/adapters/config/util.js";
+import logger from "@opennextjs/aws/logger.js";
+import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
+/**
+ * This function transforms the exports (or imports) object from the package.json
+ * to only include the build condition if found (e.g. "workerd") and remove everything else.
+ * If no build condition is found, it keeps everything as is.
+ * It also returns a boolean indicating if the build condition was found.
+ * @param conditionMap The exports (or imports) object from the package.json
+ * @param condition The build condition to look for
+ * @returns An object with the transformed exports and a boolean indicating if the build condition was found
+ */
+export function transformBuildCondition(conditionMap, condition) {
+    const transformed = {};
+    const hasTopLevelBuildCondition = Object.keys(conditionMap).some((key) => key === condition && typeof conditionMap[key] === "string");
+    let hasBuildCondition = hasTopLevelBuildCondition;
+    for (const [key, value] of Object.entries(conditionMap)) {
+        if (typeof value === "object" && value != null) {
+            const { transformedExports, hasBuildCondition: innerBuildCondition } = transformBuildCondition(value, condition);
+            transformed[key] = transformedExports;
+            hasBuildCondition ||= innerBuildCondition;
+        }
+        else {
+            // If it doesn't have the build condition, we need to keep everything as is
+            // If it has the build condition, we need to keep only the build condition
+            // and remove everything else
+            if (!hasTopLevelBuildCondition) {
+                transformed[key] = value;
+            }
+            else if (key === condition) {
+                transformed[key] = value;
+            }
+        }
+    }
+    return { transformedExports: transformed, hasBuildCondition };
+}
+/**
+ *
+ * @param json The package.json object
+ * @returns An object with the transformed package.json and a boolean indicating if the build condition was found
+ */
+export function transformPackageJson(json) {
+    const transformed = structuredClone(json);
+    let hasBuildCondition = false;
+    if (json.exports) {
+        const exp = transformBuildCondition(json.exports, "workerd");
+        transformed.exports = exp.transformedExports;
+        hasBuildCondition ||= exp.hasBuildCondition;
+    }
+    if (json.imports) {
+        const imp = transformBuildCondition(json.imports, "workerd");
+        transformed.imports = imp.transformedExports;
+        hasBuildCondition ||= imp.hasBuildCondition;
+    }
+    return { transformed, hasBuildCondition };
+}
+export async function copyWorkerdPackages(options, nodePackages) {
+    const isNodeModuleRegex = getCrossPlatformPathRegex(`.*/node_modules/(?<pkg>.*)`, { escape: false });
+    // Copy full external packages when they use "workerd" build condition
+    const nextConfig = loadConfig(path.join(options.appBuildOutputPath, ".next"));
+    const externalPackages = nextConfig.serverExternalPackages ?? [];
+    for (const [src, dst] of nodePackages.entries()) {
+        try {
+            const pkgJson = JSON.parse(await fs.readFile(path.join(src, "package.json"), "utf8"));
+            const { transformed, hasBuildCondition } = transformPackageJson(pkgJson);
+            const match = src.match(isNodeModuleRegex);
+            if (match?.groups?.pkg && externalPackages.includes(match.groups.pkg) && hasBuildCondition) {
+                logger.debug(`Copying package using a workerd condition: ${path.relative(options.appPath, src)} -> ${path.relative(options.appPath, dst)}`);
+                await fs.cp(src, dst, { recursive: true, force: true });
+                // Overwrite with  the transformed package.json
+                await fs.writeFile(path.join(dst, "package.json"), JSON.stringify(transformed), "utf8");
+            }
+        }
+        catch {
+            logger.error(`Failed to copy ${src}`);
+        }
+    }
+}

package/dist/cli/build/utils/workerd.spec.d.ts

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

package/dist/cli/build/utils/workerd.spec.js

@@ -0,0 +1,188 @@
+import { describe, expect, test } from "vitest";
+import { transformBuildCondition, transformPackageJson } from "./workerd";
+describe("transformBuildCondition", () => {
+    test("top level", () => {
+        const exports = {
+            workerd: "./path/to/workerd.js",
+            default: "./path/to/default.js",
+        };
+        const workerd = transformBuildCondition(exports, "workerd");
+        const defaultExport = transformBuildCondition(exports, "default");
+        const moduleExport = transformBuildCondition(exports, "module");
+        expect(workerd.hasBuildCondition).toBe(true);
+        expect(workerd.transformedExports).toEqual({
+            workerd: "./path/to/workerd.js",
+        });
+        expect(defaultExport.hasBuildCondition).toBe(true);
+        expect(defaultExport.transformedExports).toEqual({
+            default: "./path/to/default.js",
+        });
+        expect(moduleExport.hasBuildCondition).toBe(false);
+        expect(moduleExport.transformedExports).toEqual({
+            workerd: "./path/to/workerd.js",
+            default: "./path/to/default.js",
+        });
+    });
+    test("nested", () => {
+        const exports = {
+            ".": "/path/to/index.js",
+            "./server": {
+                "react-server": {
+                    workerd: "./server.edge.js",
+                    other: "./server.js",
+                },
+                default: "./server.js",
+            },
+        };
+        const workerd = transformBuildCondition(exports, "workerd");
+        const defaultExport = transformBuildCondition(exports, "default");
+        const moduleExport = transformBuildCondition(exports, "module");
+        expect(workerd.hasBuildCondition).toBe(true);
+        expect(workerd.transformedExports).toEqual({
+            ".": "/path/to/index.js",
+            "./server": {
+                "react-server": {
+                    workerd: "./server.edge.js",
+                },
+                default: "./server.js",
+            },
+        });
+        expect(defaultExport.hasBuildCondition).toBe(true);
+        expect(defaultExport.transformedExports).toEqual({
+            ".": "/path/to/index.js",
+            "./server": {
+                "react-server": {
+                    workerd: "./server.edge.js",
+                    other: "./server.js",
+                },
+                default: "./server.js",
+            },
+        });
+        expect(moduleExport.hasBuildCondition).toBe(false);
+        expect(moduleExport.transformedExports).toEqual({
+            ".": "/path/to/index.js",
+            "./server": {
+                "react-server": {
+                    workerd: "./server.edge.js",
+                    other: "./server.js",
+                },
+                default: "./server.js",
+            },
+        });
+    });
+    test("only consider leaves", () => {
+        const exports = {
+            ".": "/path/to/index.js",
+            "./server": {
+                workerd: {
+                    default: "./server.edge.js",
+                },
+            },
+        };
+        const workerd = transformBuildCondition(exports, "workerd");
+        expect(workerd.hasBuildCondition).toBe(false);
+        expect(workerd.transformedExports).toEqual({
+            ".": "/path/to/index.js",
+            "./server": {
+                workerd: {
+                    default: "./server.edge.js",
+                },
+            },
+        });
+    });
+});
+describe("transformPackageJson", () => {
+    test("no exports nor imports", () => {
+        const json = {
+            name: "test",
+            main: "index.js",
+            version: "1.0.0",
+            description: "test package",
+        };
+        const { transformed, hasBuildCondition } = transformPackageJson(json);
+        expect(transformed).toEqual(json);
+        expect(hasBuildCondition).toBe(false);
+    });
+    test("exports only with no workerd condition", () => {
+        const json = {
+            name: "test",
+            exports: {
+                ".": "./index.js",
+                "./server": "./server.js",
+            },
+        };
+        const { transformed, hasBuildCondition } = transformPackageJson(json);
+        expect(transformed).toEqual(json);
+        expect(hasBuildCondition).toBe(false);
+    });
+    test("exports only with nested workerd condition", () => {
+        const json = {
+            name: "test",
+            exports: {
+                ".": "./index.js",
+                "./server": {
+                    workerd: "./server.edge.js",
+                    other: "./server.js",
+                },
+            },
+        };
+        const { transformed, hasBuildCondition } = transformPackageJson(json);
+        expect(transformed).toEqual({
+            name: "test",
+            exports: {
+                ".": "./index.js",
+                "./server": {
+                    workerd: "./server.edge.js",
+                },
+            },
+        });
+        expect(hasBuildCondition).toBe(true);
+    });
+    test("imports only with top level workerd condition", () => {
+        const json = {
+            name: "test",
+            imports: {
+                workerd: "./server.edge.js",
+                default: "./server.js",
+            },
+        };
+        const { transformed, hasBuildCondition } = transformPackageJson(json);
+        expect(transformed).toEqual({
+            name: "test",
+            imports: {
+                workerd: "./server.edge.js",
+            },
+        });
+        expect(hasBuildCondition).toBe(true);
+    });
+    test("exports and imports with workerd condition both nested and top level", () => {
+        const json = {
+            name: "test",
+            exports: {
+                ".": "./index.js",
+                "./server": {
+                    workerd: "./server.edge.js",
+                    other: "./server.js",
+                },
+            },
+            imports: {
+                workerd: "./server.edge.js",
+                default: "./server.js",
+            },
+        };
+        const { transformed, hasBuildCondition } = transformPackageJson(json);
+        expect(transformed).toEqual({
+            name: "test",
+            exports: {
+                ".": "./index.js",
+                "./server": {
+                    workerd: "./server.edge.js",
+                },
+            },
+            imports: {
+                workerd: "./server.edge.js",
+            },
+        });
+        expect(hasBuildCondition).toBe(true);
+    });
+});

package/dist/cli/commands/deploy.d.ts

@@ -1,5 +1,6 @@
 import { BuildOptions } from "@opennextjs/aws/build/helper.js";
-import { OpenNextConfig } from "@opennextjs/aws/types/open-next.js";
+import type { OpenNextConfig } from "../../api/config.js";
 export declare function deploy(options: BuildOptions, config: OpenNextConfig, deployOptions: {
     passthroughArgs: string[];
+    cacheChunkSize?: number;
 }): Promise<void>;

package/dist/cli/commands/deploy.js

@@ -4,6 +4,7 @@ export async function deploy(options, config, deployOptions) {
     await populateCache(options, config, {
         target: "remote",
         environment: getWranglerEnvironmentFlag(deployOptions.passthroughArgs),
+        cacheChunkSize: deployOptions.cacheChunkSize,
     });
     runWrangler(options, ["deploy", ...deployOptions.passthroughArgs], { logging: "all" });
 }

package/dist/cli/commands/populate-cache.d.ts

@@ -11,4 +11,5 @@ export declare function getCacheAssets(opts: BuildOptions): CacheAsset[];
 export declare function populateCache(options: BuildOptions, config: OpenNextConfig, populateCacheOptions: {
     target: WranglerTarget;
     environment?: string;
+    cacheChunkSize?: number;
 }): Promise<void>;

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

@@ -1,12 +1,13 @@
-import { cpSync, existsSync } from "node:fs";
+import { cpSync, existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import logger from "@opennextjs/aws/logger.js";
 import { globSync } from "glob";
 import { tqdm } from "ts-tqdm";
-import { unstable_readConfig } from "wrangler";
-import { BINDING_NAME as KV_CACHE_BINDING_NAME, computeCacheKey as computeKVCacheKey, NAME as KV_CACHE_NAME, } from "../../api/overrides/incremental-cache/kv-incremental-cache.js";
-import { BINDING_NAME as R2_CACHE_BINDING_NAME, computeCacheKey as computeR2CacheKey, NAME as R2_CACHE_NAME, PREFIX_ENV_NAME as R2_CACHE_PREFIX_ENV_NAME, } from "../../api/overrides/incremental-cache/r2-incremental-cache.js";
+import { getPlatformProxy, unstable_readConfig } from "wrangler";
+import { BINDING_NAME as KV_CACHE_BINDING_NAME, NAME as KV_CACHE_NAME, PREFIX_ENV_NAME as KV_CACHE_PREFIX_ENV_NAME, } from "../../api/overrides/incremental-cache/kv-incremental-cache.js";
+import { BINDING_NAME as R2_CACHE_BINDING_NAME, NAME as R2_CACHE_NAME, PREFIX_ENV_NAME as R2_CACHE_PREFIX_ENV_NAME, } from "../../api/overrides/incremental-cache/r2-incremental-cache.js";
 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 { runWrangler } from "../utils/run-wrangler.js";
 async function resolveCacheName(value) {
@@ -48,9 +49,10 @@ export function getCacheAssets(opts) {
     }
     return assets;
 }
-function populateR2IncrementalCache(options, populateCacheOptions) {
+async function populateR2IncrementalCache(options, populateCacheOptions) {
     logger.info("\nPopulating R2 incremental cache...");
     const config = unstable_readConfig({ env: populateCacheOptions.environment });
+    const proxy = await getPlatformProxy(populateCacheOptions);
     const binding = config.r2_buckets.find(({ binding }) => binding === R2_CACHE_BINDING_NAME);
     if (!binding) {
         throw new Error(`No R2 binding ${JSON.stringify(R2_CACHE_BINDING_NAME)} found!`);
@@ -61,37 +63,48 @@ function populateR2IncrementalCache(options, populateCacheOptions) {
     }
     const assets = getCacheAssets(options);
     for (const { fullPath, key, buildId, isFetch } of tqdm(assets)) {
-        const cacheKey = computeR2CacheKey(key, {
-            directory: process.env[R2_CACHE_PREFIX_ENV_NAME],
+        const cacheKey = computeCacheKey(key, {
+            prefix: proxy.env[R2_CACHE_PREFIX_ENV_NAME],
             buildId,
-            isFetch,
+            cacheType: isFetch ? "fetch" : "cache",
         });
-        runWrangler(options, ["r2 object put", JSON.stringify(path.join(bucket, cacheKey)), `--file ${JSON.stringify(fullPath)}`], 
+        runWrangler(options, ["r2 object put", quoteShellMeta(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, excludeRemoteFlag: true, logging: "error" });
+        { target: populateCacheOptions.target, logging: "error" });
     }
     logger.info(`Successfully populated cache with ${assets.length} assets`);
 }
-function populateKVIncrementalCache(options, populateCacheOptions) {
+async function populateKVIncrementalCache(options, populateCacheOptions) {
     logger.info("\nPopulating KV incremental cache...");
     const config = unstable_readConfig({ env: populateCacheOptions.environment });
+    const proxy = await getPlatformProxy(populateCacheOptions);
     const binding = config.kv_namespaces.find(({ binding }) => binding === KV_CACHE_BINDING_NAME);
     if (!binding) {
         throw new Error(`No KV binding ${JSON.stringify(KV_CACHE_BINDING_NAME)} found!`);
     }
     const assets = getCacheAssets(options);
-    for (const { fullPath, key, buildId, isFetch } of tqdm(assets)) {
-        const cacheKey = computeKVCacheKey(key, {
-            buildId,
-            isFetch,
+    const chunkSize = Math.max(1, populateCacheOptions.cacheChunkSize ?? 25);
+    const totalChunks = Math.ceil(assets.length / chunkSize);
+    logger.info(`Inserting ${assets.length} assets to KV in chunks of ${chunkSize}`);
+    for (const i of tqdm(Array.from({ length: totalChunks }, (_, i) => i))) {
+        const chunkPath = path.join(options.outputDir, "cloudflare", `cache-chunk-${i}.json`);
+        const kvMapping = assets
+            .slice(i * chunkSize, (i + 1) * chunkSize)
+            .map(({ fullPath, key, buildId, isFetch }) => ({
+            key: computeCacheKey(key, {
+                prefix: proxy.env[KV_CACHE_PREFIX_ENV_NAME],
+                buildId,
+                cacheType: isFetch ? "fetch" : "cache",
+            }),
+            value: readFileSync(fullPath, "utf8"),
+        }));
+        writeFileSync(chunkPath, JSON.stringify(kvMapping));
+        runWrangler(options, ["kv bulk put", quoteShellMeta(chunkPath), `--binding ${KV_CACHE_BINDING_NAME}`], {
+            ...populateCacheOptions,
+            logging: "error",
         });
-        runWrangler(options, [
-            "kv key put",
-            JSON.stringify(cacheKey),
-            `--binding ${JSON.stringify(KV_CACHE_BINDING_NAME)}`,
-            `--path ${JSON.stringify(fullPath)}`,
-        ], { ...populateCacheOptions, logging: "error" });
+        rmSync(chunkPath);
     }
     logger.info(`Successfully populated cache with ${assets.length} assets`);
 }
@@ -104,7 +117,7 @@ function populateD1TagCache(options, populateCacheOptions) {
     }
     runWrangler(options, [
         "d1 execute",
-        JSON.stringify(D1_TAG_BINDING_NAME),
+        D1_TAG_BINDING_NAME,
         `--command "CREATE TABLE IF NOT EXISTS revalidations (tag TEXT NOT NULL, revalidatedAt INTEGER NOT NULL, UNIQUE(tag) ON CONFLICT REPLACE);"`,
     ], { ...populateCacheOptions, logging: "error" });
     logger.info("\nSuccessfully created D1 table");
@@ -124,10 +137,10 @@ export async function populateCache(options, config, populateCacheOptions) {
         const name = await resolveCacheName(incrementalCache);
         switch (name) {
             case R2_CACHE_NAME:
-                populateR2IncrementalCache(options, populateCacheOptions);
+                await populateR2IncrementalCache(options, populateCacheOptions);
                 break;
             case KV_CACHE_NAME:
-                populateKVIncrementalCache(options, populateCacheOptions);
+                await populateKVIncrementalCache(options, populateCacheOptions);
                 break;
             case STATIC_ASSETS_CACHE_NAME:
                 populateStaticAssetsIncrementalCache(options);
@@ -147,3 +160,22 @@ export async function populateCache(options, config, populateCacheOptions) {
         }
     }
 }
+/**
+ * Escape shell metacharacters.
+ *
+ * When `spawnSync` is invoked with `shell: true`, metacharacters need to be escaped.
+ *
+ * Based on https://github.com/ljharb/shell-quote/blob/main/quote.js
+ *
+ * @param arg
+ * @returns escaped arg
+ */
+function quoteShellMeta(arg) {
+    if (/["\s]/.test(arg) && !/'/.test(arg)) {
+        return `'${arg.replace(/(['\\])/g, "\\$1")}'`;
+    }
+    if (/["'\s]/.test(arg)) {
+        return `"${arg.replace(/(["\\$`!])/g, "\\$1")}"`;
+    }
+    return arg.replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@[\\\]^`{|}])/g, "$1\\$2");
+}

package/dist/cli/commands/preview.d.ts

@@ -1,5 +1,6 @@
 import { BuildOptions } from "@opennextjs/aws/build/helper.js";
-import { OpenNextConfig } from "@opennextjs/aws/types/open-next.js";
+import type { OpenNextConfig } from "../../api/config.js";
 export declare function preview(options: BuildOptions, config: OpenNextConfig, previewOptions: {
     passthroughArgs: string[];
+    cacheChunkSize?: number;
 }): Promise<void>;

package/dist/cli/commands/preview.js

@@ -4,6 +4,7 @@ export async function preview(options, config, previewOptions) {
     await populateCache(options, config, {
         target: "local",
         environment: getWranglerEnvironmentFlag(previewOptions.passthroughArgs),
+        cacheChunkSize: previewOptions.cacheChunkSize,
     });
     runWrangler(options, ["dev", ...previewOptions.passthroughArgs], { logging: "all" });
 }

package/dist/cli/commands/upload.d.ts

@@ -1,5 +1,6 @@
 import { BuildOptions } from "@opennextjs/aws/build/helper.js";
-import { OpenNextConfig } from "@opennextjs/aws/types/open-next.js";
+import type { OpenNextConfig } from "../../api/config.js";
 export declare function upload(options: BuildOptions, config: OpenNextConfig, uploadOptions: {
     passthroughArgs: string[];
+    cacheChunkSize?: number;
 }): Promise<void>;

package/dist/cli/commands/upload.js

@@ -4,6 +4,7 @@ export async function upload(options, config, uploadOptions) {
     await populateCache(options, config, {
         target: "remote",
         environment: getWranglerEnvironmentFlag(uploadOptions.passthroughArgs),
+        cacheChunkSize: uploadOptions.cacheChunkSize,
     });
     runWrangler(options, ["versions upload", ...uploadOptions.passthroughArgs], { logging: "all" });
 }

package/dist/cli/templates/init.js

@@ -44,6 +44,9 @@ function initRuntime() {
     Object.assign(process.versions, { node: "22.14.0", ...process.versions });
     globalThis.__dirname ??= "";
     globalThis.__filename ??= "";
+    // Some packages rely on `import.meta.url` but it is undefined in workerd
+    // For example it causes a bunch of issues, and will make even import crash with payload
+    import.meta.url ??= "file:///worker.js";
     // Do not crash on cache not supported
     // https://github.com/cloudflare/workerd/pull/2434
     // compatibility flag "cache_option_enabled" -> does not support "force-cache"

package/dist/cli/templates/worker.d.ts

@@ -1,4 +1,6 @@
 export { DOQueueHandler } from "./.build/durable-objects/queue.js";
 export { DOShardedTagCache } from "./.build/durable-objects/sharded-tag-cache.js";
-declare const _default: ExportedHandler<CloudflareEnv>;
+declare const _default: {
+    fetch(request: Request<unknown, IncomingRequestCfProperties<unknown>>, env: CloudflareEnv, ctx: ExecutionContext): Promise<any>;
+};
 export default _default;

package/dist/cli/utils/run-wrangler.d.ts

@@ -3,7 +3,6 @@ export type WranglerTarget = "local" | "remote";
 type WranglerOptions = {
     target?: WranglerTarget;
     environment?: string;
-    excludeRemoteFlag?: boolean;
     logging?: "all" | "error";
 };
 export declare function runWrangler(options: BuildOptions, args: string[], wranglerOpts?: WranglerOptions): void;

package/dist/cli/utils/run-wrangler.js

@@ -43,7 +43,7 @@ export function runWrangler(options, args, wranglerOpts = {}) {
         ...injectPassthroughFlagForArgs(options, [
             ...args,
             wranglerOpts.environment && `--env ${wranglerOpts.environment}`,
-            wranglerOpts.target === "remote" && !wranglerOpts.excludeRemoteFlag && "--remote",
+            wranglerOpts.target === "remote" && "--remote",
             wranglerOpts.target === "local" && "--local",
         ].filter((v) => !!v)),
     ], {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.0.0-beta.3",
+  "version": "1.0.0",
   "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.5.7",
+    "@opennextjs/aws": "~3.6.0",
     "enquirer": "^2.4.1",
     "glob": "^11.0.0",
     "ts-tqdm": "^0.8.6"
@@ -68,7 +68,7 @@
     "vitest": "^2.1.1"
   },
   "peerDependencies": {
-    "wrangler": "^3.114.3 || ^4.7.0"
+    "wrangler": "^4.14.0"
   },
   "scripts": {
     "clean": "rimraf dist",

package/templates/wrangler.jsonc

@@ -3,7 +3,7 @@
   "main": ".open-next/worker.js",
   "name": "app-name",
   "compatibility_date": "2024-12-30",
-  "compatibility_flags": ["nodejs_compat"],
+  "compatibility_flags": ["nodejs_compat", "global_fetch_strictly_public"],
   "assets": {
     "directory": ".open-next/assets",
     "binding": "ASSETS"