@opennextjs/cloudflare 1.0.0-beta.4 → 1.0.0

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/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.4",
+  "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": "^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"