@opennextjs/cloudflare 1.9.0 → 1.9.1

package/dist/api/durable-objects/sharded-tag-cache.js

@@ -1,4 +1,5 @@
 import { DurableObject } from "cloudflare:workers";
+import { debugCache } from "../overrides/internal.js";
 export class DOShardedTagCache extends DurableObject {
     sql;
     constructor(state, env) {
@@ -13,10 +14,9 @@ export class DOShardedTagCache extends DurableObject {
             const result = this.sql
                 .exec(`SELECT MAX(revalidatedAt) AS time FROM revalidations WHERE tag IN (${tags.map(() => "?").join(", ")})`, ...tags)
                 .toArray();
-            if (result.length === 0)
-                return 0;
-            // We only care about the most recent revalidation
-            return result[0]?.time;
+            const timeMs = (result[0]?.time ?? 0);
+            debugCache("DOShardedTagCache", `getLastRevalidated tags=${tags} -> time=${timeMs}`);
+            return timeMs;
         }
         catch (e) {
             console.error(e);
@@ -25,11 +25,14 @@ export class DOShardedTagCache extends DurableObject {
         }
     }
     async hasBeenRevalidated(tags, lastModified) {
-        return (this.sql
+        const revalidated = this.sql
             .exec(`SELECT 1 FROM revalidations WHERE tag IN (${tags.map(() => "?").join(", ")}) AND revalidatedAt > ? LIMIT 1`, ...tags, lastModified ?? Date.now())
-            .toArray().length > 0);
+            .toArray().length > 0;
+        debugCache("DOShardedTagCache", `hasBeenRevalidated tags=${tags} -> revalidated=${revalidated}`);
+        return revalidated;
     }
     async writeTags(tags, lastModified) {
+        debugCache("DOShardedTagCache", `writeTags tags=${tags} time=${lastModified}`);
         tags.forEach((tag) => {
             this.sql.exec(`INSERT OR REPLACE INTO revalidations (tag, revalidatedAt) VALUES (?, ?)`, tag, lastModified);
         });

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

@@ -21,7 +21,7 @@ class KVIncrementalCache {
         const kv = getCloudflareContext().env[BINDING_NAME];
         if (!kv)
             throw new IgnorableError("No KV Namespace");
-        debugCache(`Get ${key}`);
+        debugCache("KVIncrementalCache", `get ${key}`);
         try {
             const entry = await kv.get(this.getKVKey(key, cacheType), "json");
             if (!entry)
@@ -44,7 +44,7 @@ class KVIncrementalCache {
         const kv = getCloudflareContext().env[BINDING_NAME];
         if (!kv)
             throw new IgnorableError("No KV Namespace");
-        debugCache(`Set ${key}`);
+        debugCache("KVIncrementalCache", `set ${key}`);
         try {
             await kv.put(this.getKVKey(key, cacheType), JSON.stringify({
                 value,
@@ -64,7 +64,7 @@ class KVIncrementalCache {
         const kv = getCloudflareContext().env[BINDING_NAME];
         if (!kv)
             throw new IgnorableError("No KV Namespace");
-        debugCache(`Delete ${key}`);
+        debugCache("KVIncrementalCache", `delete ${key}`);
         try {
             // Only cache that gets deleted is the ISR/SSG cache.
             await kv.delete(this.getKVKey(key, "cache"));

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

@@ -18,7 +18,7 @@ class R2IncrementalCache {
         const r2 = getCloudflareContext().env[BINDING_NAME];
         if (!r2)
             throw new IgnorableError("No R2 bucket");
-        debugCache(`Get ${key}`);
+        debugCache("R2IncrementalCache", `get ${key}`);
         try {
             const r2Object = await r2.get(this.getR2Key(key, cacheType));
             if (!r2Object)
@@ -37,7 +37,7 @@ class R2IncrementalCache {
         const r2 = getCloudflareContext().env[BINDING_NAME];
         if (!r2)
             throw new IgnorableError("No R2 bucket");
-        debugCache(`Set ${key}`);
+        debugCache("R2IncrementalCache", `set ${key}`);
         try {
             await r2.put(this.getR2Key(key, cacheType), JSON.stringify(value));
         }
@@ -49,7 +49,7 @@ class R2IncrementalCache {
         const r2 = getCloudflareContext().env[BINDING_NAME];
         if (!r2)
             throw new IgnorableError("No R2 bucket");
-        debugCache(`Delete ${key}`);
+        debugCache("R2IncrementalCache", `delete ${key}`);
         try {
             await r2.delete(this.getR2Key(key));
         }

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

@@ -45,7 +45,7 @@ class RegionalCache {
             // Check for a cached entry as this will be faster than the store response.
             const cachedResponse = await cache.match(urlKey);
             if (cachedResponse) {
-                debugCache("Get - cached response");
+                debugCache("RegionalCache", `get ${key} -> cached response`);
                 // Re-fetch from the store and update the regional cache in the background.
                 // Note: this is only useful when the Cache API is not purged automatically.
                 if (this.opts.shouldLazilyUpdateOnCacheHit) {
@@ -66,6 +66,7 @@ class RegionalCache {
             const { value, lastModified } = rawEntry ?? {};
             if (!value || typeof lastModified !== "number")
                 return null;
+            debugCache("RegionalCache", `get ${key} -> put to cache`);
             // Update the locale cache after retrieving from the store.
             getCloudflareContext().ctx.waitUntil(this.putToCache({ key, cacheType, entry: { value, lastModified } }));
             return { value, lastModified };
@@ -77,6 +78,7 @@ class RegionalCache {
     }
     async set(key, value, cacheType) {
         try {
+            debugCache("RegionalCache", `set ${key}`);
             await this.store.set(key, value, cacheType);
             await this.putToCache({
                 key,
@@ -94,6 +96,7 @@ class RegionalCache {
         }
     }
     async delete(key) {
+        debugCache("RegionalCache", `delete ${key}`);
         try {
             await this.store.delete(key);
             const cache = await this.getCacheInstance();

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

@@ -9,7 +9,7 @@ export declare const NAME = "cf-static-assets-incremental-cache";
 declare class StaticAssetsIncrementalCache implements IncrementalCache {
     readonly name = "cf-static-assets-incremental-cache";
     get<CacheType extends CacheEntryType = "cache">(key: string, cacheType?: CacheType): Promise<WithLastModified<CacheValue<CacheType>> | null>;
-    set(): Promise<void>;
+    set<CacheType extends CacheEntryType = "cache">(key: string, _value: CacheValue<CacheType>, cacheType?: CacheType): Promise<void>;
     delete(): Promise<void>;
     protected getAssetUrl(key: string, cacheType?: CacheEntryType): string;
 }

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

@@ -16,7 +16,7 @@ class StaticAssetsIncrementalCache {
         const assets = getCloudflareContext().env.ASSETS;
         if (!assets)
             throw new IgnorableError("No Static Assets");
-        debugCache(`Get ${key}`);
+        debugCache("StaticAssetsIncrementalCache", `get ${key}`);
         try {
             const response = await assets.fetch(this.getAssetUrl(key, cacheType));
             if (!response.ok) {
@@ -33,11 +33,11 @@ class StaticAssetsIncrementalCache {
             return null;
         }
     }
-    async set() {
-        error("Failed to set to read-only cache");
+    async set(key, _value, cacheType) {
+        error(`StaticAssetsIncrementalCache: Failed to set to read-only cache key=${key} type=${cacheType}`);
     }
     async delete() {
-        error("Failed to delete from read-only cache");
+        error("StaticAssetsIncrementalCache: Failed to delete from read-only cache");
     }
     getAssetUrl(key, cacheType) {
         if (cacheType === "composable") {

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

@@ -8,17 +8,17 @@ export class D1NextModeTagCache {
     name = NAME;
     async getLastRevalidated(tags) {
         const { isDisabled, db } = this.getConfig();
-        if (isDisabled)
+        if (isDisabled || tags.length === 0) {
             return 0;
+        }
         try {
             const result = await db
                 .prepare(`SELECT MAX(revalidatedAt) AS time FROM revalidations WHERE tag IN (${tags.map(() => "?").join(", ")})`)
                 .bind(...tags.map((tag) => this.getCacheKey(tag)))
                 .run();
-            if (result.results.length === 0)
-                return 0;
-            // We only care about the most recent revalidation
-            return (result.results[0]?.time ?? 0);
+            const timeMs = (result.results[0]?.time ?? 0);
+            debugCache("D1NextModeTagCache", `getLastRevalidated tags=${tags} -> ${timeMs}`);
+            return timeMs;
         }
         catch (e) {
             // By default we don't want to crash here, so we return false
@@ -29,14 +29,17 @@ export class D1NextModeTagCache {
     }
     async hasBeenRevalidated(tags, lastModified) {
         const { isDisabled, db } = this.getConfig();
-        if (isDisabled)
+        if (isDisabled || tags.length === 0) {
             return false;
+        }
         try {
             const result = await db
                 .prepare(`SELECT 1 FROM revalidations WHERE tag IN (${tags.map(() => "?").join(", ")}) AND revalidatedAt > ? LIMIT 1`)
                 .bind(...tags.map((tag) => this.getCacheKey(tag)), lastModified ?? Date.now())
                 .raw();
-            return result.length > 0;
+            const revalidated = result.length > 0;
+            debugCache("D1NextModeTagCache", `hasBeenRevalidated tags=${tags} at=${lastModified} -> ${revalidated}`);
+            return revalidated;
         }
         catch (e) {
             error(e);
@@ -49,9 +52,11 @@ export class D1NextModeTagCache {
         const { isDisabled, db } = this.getConfig();
         if (isDisabled || tags.length === 0)
             return Promise.resolve();
+        const nowMs = Date.now();
         await db.batch(tags.map((tag) => db
             .prepare(`INSERT INTO revalidations (tag, revalidatedAt) VALUES (?, ?)`)
-            .bind(this.getCacheKey(tag), Date.now())));
+            .bind(this.getCacheKey(tag), nowMs)));
+        debugCache("D1NextModeTagCache", `writeTags tags=${tags} time=${nowMs}`);
         // TODO: See https://github.com/opennextjs/opennextjs-aws/issues/986
         if (isPurgeCacheEnabled()) {
             await purgeCacheByTags(tags);

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

@@ -32,10 +32,9 @@ class ShardedDOTagCache {
      */
     async getLastRevalidated(tags) {
         const { isDisabled } = this.getConfig();
-        if (isDisabled)
+        if (isDisabled || tags.length === 0) {
             return 0;
-        if (tags.length === 0)
-            return 0; // No tags to check
+        }
         const deduplicatedTags = Array.from(new Set(tags)); // We deduplicate the tags to avoid unnecessary requests
         try {
             const shardedTagGroups = this.groupTagsByDO({ tags: deduplicatedTags });
@@ -43,16 +42,19 @@ class ShardedDOTagCache {
                 const cachedValue = await this.getFromRegionalCache({ doId, tags });
                 // If all the value were found in the regional cache, we can just return the max value
                 if (cachedValue.length === tags.length) {
-                    return Math.max(...cachedValue.map((item) => item.time));
+                    const timeMs = Math.max(...cachedValue.map((item) => item.time));
+                    debugCache("ShardedDOTagCache", `getLastRevalidated tags=${tags} -> ${timeMs} (regional cache)`);
+                    return timeMs;
                 }
                 // Otherwise we need to check the durable object on the ones that were not found in the cache
                 const filteredTags = deduplicatedTags.filter((tag) => !cachedValue.some((item) => item.tag === tag));
                 const stub = this.getDurableObjectStub(doId);
                 const lastRevalidated = await stub.getLastRevalidated(filteredTags);
-                const result = Math.max(...cachedValue.map((item) => item.time), lastRevalidated);
+                const timeMs = Math.max(...cachedValue.map((item) => item.time), lastRevalidated);
                 // We then need to populate the regional cache with the missing tags
                 getCloudflareContext().ctx.waitUntil(this.putToRegionalCache({ doId, tags }, stub));
-                return result;
+                debugCache("ShardedDOTagCache", `getLastRevalidated tags=${tags} -> ${timeMs}`);
+                return timeMs;
             }));
             return Math.max(...shardedTagRevalidationOutcomes);
         }
@@ -70,8 +72,9 @@ class ShardedDOTagCache {
      */
     async hasBeenRevalidated(tags, lastModified) {
         const { isDisabled } = this.getConfig();
-        if (isDisabled)
+        if (isDisabled || tags.length === 0) {
             return false;
+        }
         try {
             const shardedTagGroups = this.groupTagsByDO({ tags });
             const shardedTagRevalidationOutcomes = await Promise.all(shardedTagGroups.map(async ({ doId, tags }) => {
@@ -81,6 +84,7 @@ class ShardedDOTagCache {
                     return (cachedValue.time ?? 0) > (lastModified ?? Date.now());
                 });
                 if (cacheHasBeenRevalidated) {
+                    debugCache("ShardedDOTagCache", `hasBeenRevalidated tags=${tags} at=${lastModified} -> true (regional cache)`);
                     return true;
                 }
                 const stub = this.getDurableObjectStub(doId);
@@ -90,6 +94,7 @@ class ShardedDOTagCache {
                     // We need to put the missing tags in the regional cache
                     getCloudflareContext().ctx.waitUntil(this.putToRegionalCache({ doId, tags: remainingTags }, stub));
                 }
+                debugCache("ShardedDOTagCache", `hasBeenRevalidated tags=${tags} at=${lastModified} -> ${_hasBeenRevalidated}`);
                 return _hasBeenRevalidated;
             }));
             return shardedTagRevalidationOutcomes.some((result) => result);
@@ -109,11 +114,12 @@ class ShardedDOTagCache {
         const { isDisabled } = this.getConfig();
         if (isDisabled)
             return;
-        const shardedTagGroups = this.groupTagsByDO({ tags, generateAllReplicas: true });
         // We want to use the same revalidation time for all tags
-        const currentTime = Date.now();
+        const nowMs = Date.now();
+        debugCache("ShardedDOTagCache", `writeTags tags=${tags} time=${nowMs}`);
+        const shardedTagGroups = this.groupTagsByDO({ tags, generateAllReplicas: true });
         await Promise.all(shardedTagGroups.map(async ({ doId, tags }) => {
-            await this.performWriteTagsWithRetry(doId, tags, currentTime);
+            await this.performWriteTagsWithRetry(doId, tags, nowMs);
         }));
         // TODO: See https://github.com/opennextjs/opennextjs-aws/issues/986
         if (isPurgeCacheEnabled()) {

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

@@ -14,6 +14,7 @@ export declare const BINDING_NAME = "NEXT_TAG_CACHE_KV";
  *   are revalidated resulting in the page being generated based on outdated data.
  */
 export declare class KVNextModeTagCache implements NextModeTagCache {
+    #private;
     readonly mode: "nextMode";
     readonly name = "kv-next-mode-tag-cache";
     getLastRevalidated(tags: string[]): Promise<number>;

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

@@ -1,6 +1,6 @@
 import { error } from "@opennextjs/aws/adapters/logger.js";
 import { getCloudflareContext } from "../../cloudflare-context.js";
-import { FALLBACK_BUILD_ID, isPurgeCacheEnabled, purgeCacheByTags } from "../internal.js";
+import { debugCache, FALLBACK_BUILD_ID, isPurgeCacheEnabled, purgeCacheByTags } from "../internal.js";
 export const NAME = "kv-next-mode-tag-cache";
 export const BINDING_NAME = "NEXT_TAG_CACHE_KV";
 /**
@@ -19,8 +19,18 @@ export class KVNextModeTagCache {
     mode = "nextMode";
     name = NAME;
     async getLastRevalidated(tags) {
+        const timeMs = await this.#getLastRevalidated(tags);
+        debugCache("KVNextModeTagCache", `getLastRevalidated tags=${tags} -> time=${timeMs}`);
+        return timeMs;
+    }
+    /**
+     * Implementation of `getLastRevalidated`.
+     *
+     * This implementation is separated so that `hasBeenRevalidated` do not include logs from `getLastRevalidated`.
+     */
+    async #getLastRevalidated(tags) {
         const kv = this.getKv();
-        if (!kv) {
+        if (!kv || tags.length === 0) {
             return 0;
         }
         try {
@@ -38,17 +48,20 @@ export class KVNextModeTagCache {
         }
     }
     async hasBeenRevalidated(tags, lastModified) {
-        return (await this.getLastRevalidated(tags)) > (lastModified ?? Date.now());
+        const revalidated = (await this.#getLastRevalidated(tags)) > (lastModified ?? Date.now());
+        debugCache("KVNextModeTagCache", `hasBeenRevalidated tags=${tags} lastModified=${lastModified} -> ${revalidated}`);
+        return revalidated;
     }
     async writeTags(tags) {
         const kv = this.getKv();
         if (!kv || tags.length === 0) {
             return Promise.resolve();
         }
-        const timeMs = String(Date.now());
+        const nowMs = Date.now();
         await Promise.all(tags.map(async (tag) => {
-            await kv.put(this.getCacheKey(tag), timeMs);
+            await kv.put(this.getCacheKey(tag), String(nowMs));
         }));
+        debugCache("KVNextModeTagCache", `writeTags tags=${tags} time=${nowMs}`);
         // TODO: See https://github.com/opennextjs/opennextjs-aws/issues/986
         if (isPurgeCacheEnabled()) {
             await purgeCacheByTags(tags);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "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.7.7",
+    "@opennextjs/aws": "3.8.0",
     "cloudflare": "^4.4.1",
     "enquirer": "^2.4.1",
     "glob": "^11.0.0",