@opennextjs/cloudflare 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/api/overrides/incremental-cache/kv-incremental-cache.d.ts

@@ -1,9 +1,8 @@
-import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides";
-export declare const CACHE_ASSET_DIR = "cdn-cgi/_next_cache";
-export declare const STATUS_DELETED = 1;
+import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides.js";
 export declare const NAME = "cf-kv-incremental-cache";
+export declare const BINDING_NAME = "NEXT_INC_CACHE_KV";
 /**
- * Open Next cache based on cloudflare KV and Assets.
+ * Open Next cache based on Cloudflare KV.
  *
  * Note: The class is instantiated outside of the request context.
  * The cloudflare context and process.env are not initialized yet
@@ -15,9 +14,6 @@ declare class KVIncrementalCache implements IncrementalCache {
     set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
     delete(key: string): Promise<void>;
     protected getKVKey(key: string, isFetch?: boolean): string;
-    protected getAssetUrl(key: string, isFetch?: boolean): string;
-    protected debug(...args: unknown[]): void;
-    protected getBuildId(): string;
 }
 declare const _default: KVIncrementalCache;
 export default _default;

package/dist/api/overrides/incremental-cache/kv-incremental-cache.js

@@ -1,10 +1,11 @@
-import { IgnorableError, RecoverableError } from "@opennextjs/aws/utils/error.js";
+import { error } from "@opennextjs/aws/adapters/logger.js";
+import { IgnorableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context.js";
-export const CACHE_ASSET_DIR = "cdn-cgi/_next_cache";
-export const STATUS_DELETED = 1;
+import { debugCache, FALLBACK_BUILD_ID } from "../internal.js";
 export const NAME = "cf-kv-incremental-cache";
+export const BINDING_NAME = "NEXT_INC_CACHE_KV";
 /**
- * Open Next cache based on cloudflare KV and Assets.
+ * Open Next cache based on Cloudflare KV.
  *
  * Note: The class is instantiated outside of the request context.
  * The cloudflare context and process.env are not initialized yet
@@ -13,112 +14,64 @@ export const NAME = "cf-kv-incremental-cache";
 class KVIncrementalCache {
     name = NAME;
     async get(key, isFetch) {
-        const cfEnv = getCloudflareContext().env;
-        const kv = cfEnv.NEXT_INC_CACHE_KV;
-        const assets = cfEnv.ASSETS;
-        if (!(kv || assets)) {
-            throw new IgnorableError(`No KVNamespace nor Fetcher`);
-        }
-        this.debug(`Get ${key}`);
+        const kv = getCloudflareContext().env[BINDING_NAME];
+        if (!kv)
+            throw new IgnorableError("No KV Namespace");
+        debugCache(`Get ${key}`);
         try {
-            let entry = null;
-            if (kv) {
-                this.debug(`- From KV`);
-                const kvKey = this.getKVKey(key, isFetch);
-                entry = await kv.get(kvKey, "json");
-                if (entry?.status === STATUS_DELETED) {
-                    return null;
-                }
-            }
-            if (!entry && assets) {
-                this.debug(`- From Assets`);
-                const url = this.getAssetUrl(key, isFetch);
-                const response = await assets.fetch(url);
-                if (response.ok) {
-                    // TODO: consider populating KV with the asset value if faster.
-                    // This could be optional as KV writes are $$.
-                    // See https://github.com/opennextjs/opennextjs-cloudflare/pull/194#discussion_r1893166026
-                    entry = {
-                        value: await response.json(),
-                        // __BUILD_TIMESTAMP_MS__ is injected by ESBuild.
-                        lastModified: globalThis.__BUILD_TIMESTAMP_MS__,
-                    };
-                }
-                if (!kv) {
-                    // The cache can not be updated when there is no KV
-                    // As we don't want to keep serving stale data for ever,
-                    // we pretend the entry is not in cache
-                    if (entry?.value &&
-                        "kind" in entry.value &&
-                        entry.value.kind === "FETCH" &&
-                        entry.value.data?.headers?.expires) {
-                        const expiresTime = new Date(entry.value.data.headers.expires).getTime();
-                        if (!isNaN(expiresTime) && expiresTime <= Date.now()) {
-                            this.debug(`found expired entry (expire time: ${entry.value.data.headers.expires})`);
-                            return null;
-                        }
-                    }
-                }
+            const entry = await kv.get(this.getKVKey(key, isFetch), "json");
+            if (!entry)
+                return null;
+            if ("lastModified" in entry) {
+                return entry;
             }
-            this.debug(entry ? `-> hit` : `-> miss`);
-            return { value: entry?.value, lastModified: entry?.lastModified };
+            // if there is no lastModified property, the file was stored during build-time cache population.
+            return {
+                value: entry,
+                // __BUILD_TIMESTAMP_MS__ is injected by ESBuild.
+                lastModified: globalThis.__BUILD_TIMESTAMP_MS__,
+            };
         }
-        catch {
-            throw new RecoverableError(`Failed to get cache [${key}]`);
+        catch (e) {
+            error("Failed to get from cache", e);
+            return null;
         }
     }
     async set(key, value, isFetch) {
-        const kv = getCloudflareContext().env.NEXT_INC_CACHE_KV;
-        if (!kv) {
-            throw new IgnorableError(`No KVNamespace`);
-        }
-        this.debug(`Set ${key}`);
+        const kv = getCloudflareContext().env[BINDING_NAME];
+        if (!kv)
+            throw new IgnorableError("No KV Namespace");
+        debugCache(`Set ${key}`);
         try {
-            const kvKey = this.getKVKey(key, isFetch);
-            // Note: We can not set a TTL as we might fallback to assets,
-            //       still removing old data (old BUILD_ID) could help avoiding
-            //       the cache growing too big.
-            await kv.put(kvKey, JSON.stringify({
+            await kv.put(this.getKVKey(key, isFetch), JSON.stringify({
                 value,
                 // Note: `Date.now()` returns the time of the last IO rather than the actual time.
                 //       See https://developers.cloudflare.com/workers/reference/security-model/
                 lastModified: Date.now(),
-            }));
+            })
+            // TODO: Figure out how to best leverage KV's TTL.
+            // NOTE: Ideally, the cache should operate in an SWR-like manner.
+            );
         }
-        catch {
-            throw new RecoverableError(`Failed to set cache [${key}]`);
+        catch (e) {
+            error("Failed to set to cache", e);
         }
     }
     async delete(key) {
-        const kv = getCloudflareContext().env.NEXT_INC_CACHE_KV;
-        if (!kv) {
-            throw new IgnorableError(`No KVNamespace`);
-        }
-        this.debug(`Delete ${key}`);
+        const kv = getCloudflareContext().env[BINDING_NAME];
+        if (!kv)
+            throw new IgnorableError("No KV Namespace");
+        debugCache(`Delete ${key}`);
         try {
-            const kvKey = this.getKVKey(key, /* isFetch= */ false);
-            // Do not delete the key as we would then fallback to the assets.
-            await kv.put(kvKey, JSON.stringify({ status: STATUS_DELETED }));
+            await kv.delete(this.getKVKey(key, /* isFetch= */ false));
         }
-        catch {
-            throw new RecoverableError(`Failed to delete cache [${key}]`);
+        catch (e) {
+            error("Failed to delete from cache", e);
         }
     }
     getKVKey(key, isFetch) {
-        return `${this.getBuildId()}/${key}.${isFetch ? "fetch" : "cache"}`;
-    }
-    getAssetUrl(key, isFetch) {
-        return isFetch
-            ? `http://assets.local/${CACHE_ASSET_DIR}/__fetch/${this.getBuildId()}/${key}`
-            : `http://assets.local/${CACHE_ASSET_DIR}/${this.getBuildId()}/${key}.cache`;
-    }
-    debug(...args) {
-        if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
-            console.log(`[Cache ${this.name}] `, ...args);
-        }
-    }
-    getBuildId() {
-        return process.env.NEXT_BUILD_ID ?? "no-build-id";
+        const buildId = process.env.NEXT_BUILD_ID ?? FALLBACK_BUILD_ID;
+        return `${buildId}/${key}.${isFetch ? "fetch" : "cache"}`.replace(/\/+/g, "/");
     }
 }
 export default new KVIncrementalCache();

package/dist/api/overrides/incremental-cache/r2-incremental-cache.d.ts

@@ -1,5 +1,8 @@
 import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides.js";
 export declare const NAME = "cf-r2-incremental-cache";
+export declare const BINDING_NAME = "NEXT_INC_CACHE_R2_BUCKET";
+export declare const PREFIX_ENV_NAME = "NEXT_INC_CACHE_R2_PREFIX";
+export declare const DEFAULT_PREFIX = "incremental-cache";
 /**
  * An instance of the Incremental Cache that uses an R2 bucket (`NEXT_INC_CACHE_R2_BUCKET`) as it's
  * underlying data store.

package/dist/api/overrides/incremental-cache/r2-incremental-cache.js

@@ -1,7 +1,11 @@
-import { debug, error } from "@opennextjs/aws/adapters/logger.js";
+import { error } from "@opennextjs/aws/adapters/logger.js";
 import { IgnorableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context.js";
+import { debugCache, FALLBACK_BUILD_ID } from "../internal.js";
 export const NAME = "cf-r2-incremental-cache";
+export const BINDING_NAME = "NEXT_INC_CACHE_R2_BUCKET";
+export const PREFIX_ENV_NAME = "NEXT_INC_CACHE_R2_PREFIX";
+export const DEFAULT_PREFIX = "incremental-cache";
 /**
  * An instance of the Incremental Cache that uses an R2 bucket (`NEXT_INC_CACHE_R2_BUCKET`) as it's
  * underlying data store.
@@ -12,10 +16,10 @@ export const NAME = "cf-r2-incremental-cache";
 class R2IncrementalCache {
     name = NAME;
     async get(key, isFetch) {
-        const r2 = getCloudflareContext().env.NEXT_INC_CACHE_R2_BUCKET;
+        const r2 = getCloudflareContext().env[BINDING_NAME];
         if (!r2)
             throw new IgnorableError("No R2 bucket");
-        debug(`Get ${key}`);
+        debugCache(`Get ${key}`);
         try {
             const r2Object = await r2.get(this.getR2Key(key, isFetch));
             if (!r2Object)
@@ -31,10 +35,10 @@ class R2IncrementalCache {
         }
     }
     async set(key, value, isFetch) {
-        const r2 = getCloudflareContext().env.NEXT_INC_CACHE_R2_BUCKET;
+        const r2 = getCloudflareContext().env[BINDING_NAME];
         if (!r2)
             throw new IgnorableError("No R2 bucket");
-        debug(`Set ${key}`);
+        debugCache(`Set ${key}`);
         try {
             await r2.put(this.getR2Key(key, isFetch), JSON.stringify(value));
         }
@@ -43,10 +47,10 @@ class R2IncrementalCache {
         }
     }
     async delete(key) {
-        const r2 = getCloudflareContext().env.NEXT_INC_CACHE_R2_BUCKET;
+        const r2 = getCloudflareContext().env[BINDING_NAME];
         if (!r2)
             throw new IgnorableError("No R2 bucket");
-        debug(`Delete ${key}`);
+        debugCache(`Delete ${key}`);
         try {
             await r2.delete(this.getR2Key(key));
         }
@@ -55,8 +59,8 @@ class R2IncrementalCache {
         }
     }
     getR2Key(key, isFetch) {
-        const directory = getCloudflareContext().env.NEXT_INC_CACHE_R2_PREFIX ?? "incremental-cache";
-        return `${directory}/${process.env.NEXT_BUILD_ID ?? "no-build-id"}/${key}.${isFetch ? "fetch" : "cache"}`;
+        const directory = getCloudflareContext().env[PREFIX_ENV_NAME] ?? DEFAULT_PREFIX;
+        return `${directory}/${process.env.NEXT_BUILD_ID ?? FALLBACK_BUILD_ID}/${key}.${isFetch ? "fetch" : "cache"}`.replace(/\/+/g, "/");
     }
 }
 export default new R2IncrementalCache();

package/dist/api/overrides/incremental-cache/regional-cache.d.ts

@@ -1,5 +1,5 @@
 import { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides.js";
-import { IncrementalCacheEntry } from "./internal.js";
+import { IncrementalCacheEntry } from "../internal.js";
 type Options = {
     /**
      * The mode to use for the regional cache.

package/dist/api/overrides/incremental-cache/regional-cache.js

@@ -1,5 +1,6 @@
-import { debug, error } from "@opennextjs/aws/adapters/logger.js";
+import { error } from "@opennextjs/aws/adapters/logger.js";
 import { getCloudflareContext } from "../../cloudflare-context.js";
+import { debugCache, FALLBACK_BUILD_ID } from "../internal.js";
 import { NAME as KV_CACHE_NAME } from "./kv-incremental-cache.js";
 const ONE_MINUTE_IN_SECONDS = 60;
 const THIRTY_MINUTES_IN_SECONDS = ONE_MINUTE_IN_SECONDS * 30;
@@ -27,7 +28,7 @@ class RegionalCache {
             // Check for a cached entry as this will be faster than the store response.
             const cachedResponse = await cache.match(localCacheKey);
             if (cachedResponse) {
-                debug("Get - cached response");
+                debugCache("Get - cached response");
                 // Re-fetch from the store and update the regional cache in the background
                 if (this.opts.shouldLazilyUpdateOnCacheHit) {
                     getCloudflareContext().ctx.waitUntil(this.store.get(key, isFetch).then(async (rawEntry) => {
@@ -83,7 +84,7 @@ class RegionalCache {
         return this.localCache;
     }
     getCacheKey(key, isFetch) {
-        return new Request(new URL(`${process.env.NEXT_BUILD_ID ?? "no-build-id"}/${key}.${isFetch ? "fetch" : "cache"}`, "http://cache.local"));
+        return new Request(new URL(`${process.env.NEXT_BUILD_ID ?? FALLBACK_BUILD_ID}/${key}.${isFetch ? "fetch" : "cache"}`, "http://cache.local"));
     }
     async putToCache(key, entry) {
         const cache = await this.getCacheInstance();

package/dist/api/overrides/incremental-cache/static-assets-incremental-cache.d.ts

@@ -0,0 +1,17 @@
+import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides.js";
+export declare const CACHE_DIR = "cdn-cgi/_next_cache";
+export declare const NAME = "cf-static-assets-incremental-cache";
+/**
+ * This cache uses Workers static assets.
+ *
+ * It should only be used for applications that do NOT want revalidation and ONLY want to serve prerendered data.
+ */
+declare class StaticAssetsIncrementalCache implements IncrementalCache {
+    readonly name = "cf-static-assets-incremental-cache";
+    get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>> | null>;
+    set(): Promise<void>;
+    delete(): Promise<void>;
+    protected getAssetUrl(key: string, isFetch?: boolean): string;
+}
+declare const _default: StaticAssetsIncrementalCache;
+export default _default;

package/dist/api/overrides/incremental-cache/static-assets-incremental-cache.js

@@ -0,0 +1,47 @@
+import { error } from "@opennextjs/aws/adapters/logger.js";
+import { IgnorableError } from "@opennextjs/aws/utils/error.js";
+import { getCloudflareContext } from "../../cloudflare-context.js";
+import { debugCache, FALLBACK_BUILD_ID } from "../internal.js";
+//  Assets inside `cdn-cgi/...` are only accessible by the worker.
+export const CACHE_DIR = "cdn-cgi/_next_cache";
+export const NAME = "cf-static-assets-incremental-cache";
+/**
+ * This cache uses Workers static assets.
+ *
+ * It should only be used for applications that do NOT want revalidation and ONLY want to serve prerendered data.
+ */
+class StaticAssetsIncrementalCache {
+    name = NAME;
+    async get(key, isFetch) {
+        const assets = getCloudflareContext().env.ASSETS;
+        if (!assets)
+            throw new IgnorableError("No Static Assets");
+        debugCache(`Get ${key}`);
+        try {
+            const response = await assets.fetch(this.getAssetUrl(key, isFetch));
+            if (!response.ok)
+                return null;
+            return {
+                value: await response.json(),
+                // __BUILD_TIMESTAMP_MS__ is injected by ESBuild.
+                lastModified: globalThis.__BUILD_TIMESTAMP_MS__,
+            };
+        }
+        catch (e) {
+            error("Failed to get from cache", e);
+            return null;
+        }
+    }
+    async set() {
+        error("Failed to set to read-only cache");
+    }
+    async delete() {
+        error("Failed to delete from read-only cache");
+    }
+    getAssetUrl(key, isFetch) {
+        const buildId = process.env.NEXT_BUILD_ID ?? FALLBACK_BUILD_ID;
+        const name = (isFetch ? `${CACHE_DIR}/__fetch/${buildId}/${key}` : `${CACHE_DIR}/${buildId}/${key}.cache`).replace(/\/+/g, "/");
+        return `http://assets.local/${name}`;
+    }
+}
+export default new StaticAssetsIncrementalCache();

package/dist/api/overrides/{incremental-cache/internal.d.ts → internal.d.ts}

@@ -3,3 +3,5 @@ export type IncrementalCacheEntry<IsFetch extends boolean> = {
     value: CacheValue<IsFetch>;
     lastModified: number;
 };
+export declare const debugCache: (name: string, ...args: unknown[]) => void;
+export declare const FALLBACK_BUILD_ID = "no-build-id";

package/dist/api/overrides/internal.js

@@ -0,0 +1,6 @@
+export const debugCache = (name, ...args) => {
+    if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
+        console.log(`[${name}] `, ...args);
+    }
+};
+export const FALLBACK_BUILD_ID = "no-build-id";

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

@@ -1,6 +1,7 @@
-import { debug, error } from "@opennextjs/aws/adapters/logger.js";
+import { error } from "@opennextjs/aws/adapters/logger.js";
 import { IgnorableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context";
+import { debugCache } from "../internal";
 export const DEFAULT_REVALIDATION_TIMEOUT_MS = 10_000;
 /**
  * The Memory Queue offers basic ISR revalidation by directly requesting a revalidation of a route.
@@ -41,7 +42,7 @@ export class MemoryQueue {
             if (response.status !== 200 || response.headers.get("x-nextjs-cache") !== "REVALIDATED") {
                 error(`Revalidation failed for ${url} with status ${response.status}`);
             }
-            debug(`Revalidation successful for ${url}`);
+            debugCache(`Revalidation successful for ${url}`);
         }
         catch (e) {
             error(e);

package/dist/api/overrides/tag-cache/d1-next-tag-cache.d.ts

@@ -1,5 +1,6 @@
 import type { NextModeTagCache } from "@opennextjs/aws/types/overrides.js";
 export declare const NAME = "d1-next-mode-tag-cache";
+export declare const BINDING_NAME = "NEXT_TAG_CACHE_D1";
 export declare class D1NextModeTagCache implements NextModeTagCache {
     readonly mode: "nextMode";
     readonly name = "d1-next-mode-tag-cache";

package/dist/api/overrides/tag-cache/d1-next-tag-cache.js

@@ -1,7 +1,9 @@
-import { debug, error } from "@opennextjs/aws/adapters/logger.js";
+import { error } from "@opennextjs/aws/adapters/logger.js";
 import { RecoverableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context.js";
+import { debugCache, FALLBACK_BUILD_ID } from "../internal.js";
 export const NAME = "d1-next-mode-tag-cache";
+export const BINDING_NAME = "NEXT_TAG_CACHE_D1";
 export class D1NextModeTagCache {
     mode = "nextMode";
     name = NAME;
@@ -34,10 +36,9 @@ export class D1NextModeTagCache {
             throw new RecoverableError(`D1 insert failed for ${tags}`);
     }
     getConfig() {
-        const cfEnv = getCloudflareContext().env;
-        const db = cfEnv.NEXT_TAG_CACHE_D1;
+        const db = getCloudflareContext().env[BINDING_NAME];
         if (!db)
-            debug("No D1 database found");
+            debugCache("No D1 database found");
         const isDisabled = !!globalThis.openNextConfig
             .dangerous?.disableTagCache;
         return !db || isDisabled
@@ -54,7 +55,7 @@ export class D1NextModeTagCache {
         return `${this.getBuildId()}/${key}`.replaceAll("//", "/");
     }
     getBuildId() {
-        return process.env.NEXT_BUILD_ID ?? "no-build-id";
+        return process.env.NEXT_BUILD_ID ?? FALLBACK_BUILD_ID;
     }
 }
 export default new D1NextModeTagCache();

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

@@ -1,7 +1,8 @@
-import { debug, error } from "@opennextjs/aws/adapters/logger.js";
+import { error } from "@opennextjs/aws/adapters/logger.js";
 import { generateShardId } from "@opennextjs/aws/core/routing/queue.js";
 import { IgnorableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context";
+import { debugCache } from "../internal";
 export const DEFAULT_WRITE_RETRIES = 3;
 export const DEFAULT_NUM_SHARDS = 4;
 export const NAME = "do-sharded-tag-cache";
@@ -102,7 +103,7 @@ class ShardedDOTagCache {
         const cfEnv = getCloudflareContext().env;
         const db = cfEnv.NEXT_TAG_CACHE_DO_SHARDED;
         if (!db)
-            debug("No Durable object found");
+            debugCache("No Durable object found");
         const isDisabled = !!globalThis.openNextConfig
             .dangerous?.disableTagCache;
         return !db || isDisabled
@@ -234,7 +235,7 @@ class ShardedDOTagCache {
             await cache.delete(key);
         }
         catch (e) {
-            debug("Error while deleting from regional cache", e);
+            debugCache("Error while deleting from regional cache", e);
         }
     }
 }

package/dist/cli/build/build.js

@@ -9,7 +9,6 @@ import { bundleServer } from "./bundle-server.js";
 import { compileCacheAssetsManifestSqlFile } from "./open-next/compile-cache-assets-manifest.js";
 import { compileEnvFiles } from "./open-next/compile-env-files.js";
 import { compileDurableObjects } from "./open-next/compileDurableObjects.js";
-import { copyCacheAssets } from "./open-next/copyCacheAssets.js";
 import { createServerBundle } from "./open-next/createServerBundle.js";
 import { createWranglerConfigIfNotExistent } from "./utils/index.js";
 import { getVersion } from "./utils/version.js";
@@ -55,7 +54,6 @@ export async function build(options, config, projectOpts) {
     createStaticAssets(options);
     if (config.dangerous?.disableIncrementalCache !== true) {
         const { useTagCache, metaFiles } = createCacheAssets(options);
-        copyCacheAssets(options);
         if (useTagCache) {
             compileCacheAssetsManifestSqlFile(options, metaFiles);
         }

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

@@ -1,9 +1,13 @@
-import { existsSync } from "node:fs";
+import { cpSync, existsSync } from "node:fs";
 import path from "node:path";
 import logger from "@opennextjs/aws/logger.js";
 import { globSync } from "glob";
-import { NAME as R2_CACHE_NAME } from "../../api/overrides/incremental-cache/r2-incremental-cache.js";
-import { NAME as D1_TAG_NAME } from "../../api/overrides/tag-cache/d1-next-tag-cache.js";
+import { tqdm } from "ts-tqdm";
+import { unstable_readConfig } from "wrangler";
+import { BINDING_NAME as KV_CACHE_BINDING_NAME, NAME as KV_CACHE_NAME, } from "../../api/overrides/incremental-cache/kv-incremental-cache.js";
+import { BINDING_NAME as R2_CACHE_BINDING_NAME, DEFAULT_PREFIX as R2_CACHE_DEFAULT_PREFIX, 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 { 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) {
     return typeof value === "function" ? (await value()).name : value;
@@ -24,6 +28,64 @@ function getCacheAssetPaths(opts) {
         };
     });
 }
+function populateR2IncrementalCache(options, populateCacheOptions) {
+    logger.info("\nPopulating R2 incremental cache...");
+    const config = unstable_readConfig({ env: populateCacheOptions.environment });
+    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!`);
+    }
+    const bucket = binding.bucket_name;
+    if (!bucket) {
+        throw new Error(`R2 binding ${JSON.stringify(R2_CACHE_BINDING_NAME)} should have a 'bucket_name'`);
+    }
+    const assets = getCacheAssetPaths(options);
+    for (const { fsPath, destPath } of tqdm(assets)) {
+        const fullDestPath = path.join(bucket, process.env[R2_CACHE_PREFIX_ENV_NAME] ?? R2_CACHE_DEFAULT_PREFIX, destPath);
+        runWrangler(options, ["r2 object put", JSON.stringify(fullDestPath), `--file ${JSON.stringify(fsPath)}`], 
+        // 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" });
+    }
+    logger.info(`Successfully populated cache with ${assets.length} assets`);
+}
+function populateKVIncrementalCache(options, populateCacheOptions) {
+    logger.info("\nPopulating KV incremental cache...");
+    const config = unstable_readConfig({ env: populateCacheOptions.environment });
+    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 = getCacheAssetPaths(options);
+    for (const { fsPath, destPath } of tqdm(assets)) {
+        runWrangler(options, [
+            "kv key put",
+            JSON.stringify(destPath),
+            `--binding ${JSON.stringify(KV_CACHE_BINDING_NAME)}`,
+            `--path ${JSON.stringify(fsPath)}`,
+        ], { ...populateCacheOptions, logging: "error" });
+    }
+    logger.info(`Successfully populated cache with ${assets.length} assets`);
+}
+function populateD1TagCache(options, populateCacheOptions) {
+    logger.info("\nCreating D1 table if necessary...");
+    const config = unstable_readConfig({ env: populateCacheOptions.environment });
+    const binding = config.d1_databases.find(({ binding }) => binding === D1_TAG_BINDING_NAME);
+    if (!binding) {
+        throw new Error(`No D1 binding ${JSON.stringify(D1_TAG_BINDING_NAME)} found!`);
+    }
+    runWrangler(options, [
+        "d1 execute",
+        JSON.stringify(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");
+}
+function populateStaticAssetsIncrementalCache(options) {
+    logger.info("\nPopulating Workers static assets...");
+    cpSync(path.join(options.outputDir, "cache"), path.join(options.outputDir, "assets", STATIC_ASSETS_CACHE_DIR), { recursive: true });
+    logger.info(`Successfully populated static assets cache`);
+}
 export async function populateCache(options, config, populateCacheOptions) {
     const { incrementalCache, tagCache } = config.default.override ?? {};
     if (!existsSync(options.outputDir)) {
@@ -33,19 +95,15 @@ export async function populateCache(options, config, populateCacheOptions) {
     if (!config.dangerous?.disableIncrementalCache && incrementalCache) {
         const name = await resolveCacheName(incrementalCache);
         switch (name) {
-            case R2_CACHE_NAME: {
-                logger.info("\nPopulating R2 incremental cache...");
-                const assets = getCacheAssetPaths(options);
-                assets.forEach(({ fsPath, destPath }) => {
-                    const fullDestPath = path.join("NEXT_INC_CACHE_R2_BUCKET", process.env.NEXT_INC_CACHE_R2_PREFIX ?? "incremental-cache", destPath);
-                    runWrangler(options, ["r2 object put", JSON.stringify(fullDestPath), `--file ${JSON.stringify(fsPath)}`], 
-                    // 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" });
-                });
-                logger.info(`Successfully populated cache with ${assets.length} assets`);
+            case R2_CACHE_NAME:
+                populateR2IncrementalCache(options, populateCacheOptions);
+                break;
+            case KV_CACHE_NAME:
+                populateKVIncrementalCache(options, populateCacheOptions);
+                break;
+            case STATIC_ASSETS_CACHE_NAME:
+                populateStaticAssetsIncrementalCache(options);
                 break;
-            }
             default:
                 logger.info("Incremental cache does not need populating");
         }
@@ -53,16 +111,9 @@ export async function populateCache(options, config, populateCacheOptions) {
     if (!config.dangerous?.disableTagCache && !config.dangerous?.disableIncrementalCache && tagCache) {
         const name = await resolveCacheName(tagCache);
         switch (name) {
-            case D1_TAG_NAME: {
-                logger.info("\nCreating D1 table if necessary...");
-                runWrangler(options, [
-                    "d1 execute",
-                    "NEXT_TAG_CACHE_D1",
-                    `--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");
+            case D1_TAG_NAME:
+                populateD1TagCache(options, populateCacheOptions);
                 break;
-            }
             default:
                 logger.info("Tag cache does not need populating");
         }

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

@@ -49,6 +49,10 @@ export function runWrangler(options, args, wranglerOpts = {}) {
     ], {
         shell: true,
         stdio: wranglerOpts.logging === "error" ? ["ignore", "ignore", "inherit"] : "inherit",
+        env: {
+            ...process.env,
+            ...(wranglerOpts.logging === "error" ? { WRANGLER_LOG: "error" } : undefined),
+        },
     });
     if (result.status !== 0) {
         logger.error("Wrangler command failed");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.0.0-beta.0",
+  "version": "1.0.0-beta.2",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"
@@ -43,9 +43,10 @@
   "homepage": "https://github.com/opennextjs/opennextjs-cloudflare",
   "dependencies": {
     "@dotenvx/dotenvx": "1.31.0",
-    "@opennextjs/aws": "3.5.4",
+    "@opennextjs/aws": "3.5.5",
     "enquirer": "^2.4.1",
-    "glob": "^11.0.0"
+    "glob": "^11.0.0",
+    "ts-tqdm": "^0.8.6"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20250224.0",

package/dist/api/overrides/incremental-cache/internal.js

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

package/dist/cli/build/open-next/copyCacheAssets.d.ts

@@ -1,2 +0,0 @@
-import * as buildHelper from "@opennextjs/aws/build/helper.js";
-export declare function copyCacheAssets(options: buildHelper.BuildOptions): void;

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

@@ -1,10 +0,0 @@
-import { cpSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-import { CACHE_ASSET_DIR } from "../../../api/overrides/incremental-cache/kv-incremental-cache.js";
-export function copyCacheAssets(options) {
-    const { outputDir } = options;
-    const srcPath = join(outputDir, "cache");
-    const dstPath = join(outputDir, "assets", CACHE_ASSET_DIR);
-    mkdirSync(dstPath, { recursive: true });
-    cpSync(srcPath, dstPath, { recursive: true });
-}