@opennextjs/cloudflare 1.8.2 → 1.8.3

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

@@ -96,7 +96,7 @@ class RegionalCache {
             });
         }
         catch (e) {
-            error(`Failed to get from regional cache`, e);
+            error(`Failed to set the regional cache`, e);
         }
     }
     async delete(key) {

package/dist/api/overrides/tag-cache/do-sharded-tag-cache.d.ts

@@ -87,19 +87,6 @@ interface DOIdOptions {
     replicaId?: number;
     region?: DurableObjectLocationHint;
 }
-export declare class DOId {
-    options: DOIdOptions;
-    shardId: string;
-    replicaId: number;
-    region?: DurableObjectLocationHint;
-    constructor(options: DOIdOptions);
-    private generateRandomNumberBetween;
-    get key(): string;
-}
-interface CacheTagKeyOptions {
-    doId: DOId;
-    tags: string[];
-}
 declare class ShardedDOTagCache implements NextModeTagCache {
     private opts;
     readonly mode: "nextMode";
@@ -111,29 +98,9 @@ declare class ShardedDOTagCache implements NextModeTagCache {
     readonly defaultRegion: AllowedDurableObjectRegion;
     localCache?: Cache;
     constructor(opts?: ShardedDOTagCacheOptions);
-    private getDurableObjectStub;
     /**
-     * Generates a list of DO ids for the shards and replicas
-     * @param tags The tags to generate shards for
-     * @param shardType Whether to generate shards for soft or hard tags
-     * @param generateAllShards Whether to generate all shards or only one
-     * @returns An array of TagCacheDOId and tag
+     * Public API
      */
-    private generateDOIdArray;
-    getClosestRegion(): "enam" | "sam" | "weur" | "apac" | "oc" | "afr";
-    /**
-     * Same tags are guaranteed to be in the same shard
-     * @param tags
-     * @returns An array of DO ids and tags
-     */
-    groupTagsByDO({ tags, generateAllReplicas }: {
-        tags: string[];
-        generateAllReplicas?: boolean;
-    }): {
-        doId: DOId;
-        tags: string[];
-    }[];
-    private getConfig;
     getLastRevalidated(tags: string[]): Promise<number>;
     /**
      * This function checks if the tags have been revalidated
@@ -150,9 +117,12 @@ declare class ShardedDOTagCache implements NextModeTagCache {
      * @returns
      */
     writeTags(tags: string[]): Promise<void>;
+    /**
+     * The following methods are public only because they are accessed from the tests
+     */
     performWriteTagsWithRetry(doId: DOId, tags: string[], lastModified: number, retryNumber?: number): Promise<void>;
-    getCacheInstance(): Promise<Cache | undefined>;
     getCacheUrlKey(doId: DOId, tag: string): string;
+    getCacheInstance(): Promise<Cache | undefined>;
     /**
      * Get the last revalidation time for the tags from the regional cache
      * If the cache is not enabled, it will return an empty array
@@ -168,6 +138,42 @@ declare class ShardedDOTagCache implements NextModeTagCache {
      * This is used to ensure that the cache is cleared when the tags are revalidated
      */
     deleteRegionalCache(optsKey: CacheTagKeyOptions): Promise<void>;
+    /**
+     * Same tags are guaranteed to be in the same shard
+     * @param tags
+     * @returns An array of DO ids and tags
+     */
+    groupTagsByDO({ tags, generateAllReplicas, }: {
+        tags: string[];
+        generateAllReplicas?: boolean;
+    }): {
+        doId: DOId;
+        tags: string[];
+    }[];
+    private getDurableObjectStub;
+    /**
+     * Generates a list of DO ids for the shards and replicas
+     * @param tags The tags to generate shards for
+     * @param shardType Whether to generate shards for soft or hard tags
+     * @param generateAllShards Whether to generate all shards or only one
+     * @returns An array of TagCacheDOId and tag
+     */
+    private generateDOIdArray;
+    private getClosestRegion;
+    private getConfig;
+}
+export declare class DOId {
+    options: DOIdOptions;
+    shardId: string;
+    replicaId: number;
+    region?: DurableObjectLocationHint;
+    constructor(options: DOIdOptions);
+    private generateRandomNumberBetween;
+    get key(): string;
+}
+interface CacheTagKeyOptions {
+    doId: DOId;
+    tags: string[];
 }
 declare const _default: (opts?: ShardedDOTagCacheOptions) => ShardedDOTagCache;
 export default _default;

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

@@ -9,25 +9,6 @@ export const NAME = "do-sharded-tag-cache";
 const SOFT_TAG_PREFIX = "_N_T_/";
 export const DEFAULT_REGION = "enam";
 export const AVAILABLE_REGIONS = ["enam", "weur", "apac", "sam", "afr", "oc"];
-export class DOId {
-    options;
-    shardId;
-    replicaId;
-    region;
-    constructor(options) {
-        this.options = options;
-        const { baseShardId, shardType, numberOfReplicas, replicaId, region } = options;
-        this.shardId = `tag-${shardType};${baseShardId}`;
-        this.replicaId = replicaId ?? this.generateRandomNumberBetween(1, numberOfReplicas);
-        this.region = region;
-    }
-    generateRandomNumberBetween(min, max) {
-        return Math.floor(Math.random() * (max - min + 1) + min);
-    }
-    get key() {
-        return `${this.shardId};replica-${this.replicaId}${this.region ? `;region-${this.region}` : ""}`;
-    }
-}
 class ShardedDOTagCache {
     opts;
     mode = "nextMode";
@@ -46,137 +27,11 @@ class ShardedDOTagCache {
         this.enableRegionalReplication = Boolean(opts.shardReplication?.regionalReplication);
         this.defaultRegion = opts.shardReplication?.regionalReplication?.defaultRegion ?? DEFAULT_REGION;
     }
-    getDurableObjectStub(doId) {
-        const durableObject = getCloudflareContext().env.NEXT_TAG_CACHE_DO_SHARDED;
-        if (!durableObject)
-            throw new IgnorableError("No durable object binding for cache revalidation");
-        const id = durableObject.idFromName(doId.key);
-        debug("[shardedTagCache] - Accessing Durable Object : ", {
-            key: doId.key,
-            region: doId.region,
-        });
-        return durableObject.get(id, { locationHint: doId.region });
-    }
     /**
-     * Generates a list of DO ids for the shards and replicas
-     * @param tags The tags to generate shards for
-     * @param shardType Whether to generate shards for soft or hard tags
-     * @param generateAllShards Whether to generate all shards or only one
-     * @returns An array of TagCacheDOId and tag
+     * Public API
      */
-    generateDOIdArray({ tags, shardType, generateAllReplicas = false, }) {
-        let replicaIndexes = [1];
-        const isSoft = shardType === "soft";
-        let numReplicas = 1;
-        if (this.opts.shardReplication) {
-            numReplicas = isSoft ? this.numSoftReplicas : this.numHardReplicas;
-            replicaIndexes = generateAllReplicas
-                ? Array.from({ length: numReplicas }, (_, i) => i + 1)
-                : [undefined];
-        }
-        const regionalReplicas = replicaIndexes.flatMap((replicaId) => {
-            return tags
-                .filter((tag) => (isSoft ? tag.startsWith(SOFT_TAG_PREFIX) : !tag.startsWith(SOFT_TAG_PREFIX)))
-                .map((tag) => {
-                return {
-                    doId: new DOId({
-                        baseShardId: generateShardId(tag, this.opts.baseShardSize, "shard"),
-                        numberOfReplicas: numReplicas,
-                        shardType,
-                        replicaId,
-                    }),
-                    tag,
-                };
-            });
-        });
-        if (!this.enableRegionalReplication)
-            return regionalReplicas;
-        // If we have regional replication enabled, we need to further duplicate the shards in all the regions
-        const regionalReplicasInAllRegions = generateAllReplicas
-            ? regionalReplicas.flatMap(({ doId, tag }) => {
-                return AVAILABLE_REGIONS.map((region) => {
-                    return {
-                        doId: new DOId({
-                            baseShardId: doId.options.baseShardId,
-                            numberOfReplicas: numReplicas,
-                            shardType,
-                            replicaId: doId.replicaId,
-                            region,
-                        }),
-                        tag,
-                    };
-                });
-            })
-            : regionalReplicas.map(({ doId, tag }) => {
-                doId.region = this.getClosestRegion();
-                return { doId, tag };
-            });
-        return regionalReplicasInAllRegions;
-    }
-    getClosestRegion() {
-        const continent = getCloudflareContext().cf?.continent;
-        if (!continent)
-            return this.defaultRegion;
-        debug("[shardedTagCache] - Continent : ", continent);
-        switch (continent) {
-            case "AF":
-                return "afr";
-            case "AS":
-                return "apac";
-            case "EU":
-                return "weur";
-            case "NA":
-                return "enam";
-            case "OC":
-                return "oc";
-            case "SA":
-                return "sam";
-            default:
-                return this.defaultRegion;
-        }
-    }
-    /**
-     * Same tags are guaranteed to be in the same shard
-     * @param tags
-     * @returns An array of DO ids and tags
-     */
-    groupTagsByDO({ tags, generateAllReplicas = false }) {
-        // Here we'll start by splitting soft tags from hard tags
-        // This will greatly increase the cache hit rate for the soft tag (which are the most likely to cause issue because of load)
-        const softTags = this.generateDOIdArray({ tags, shardType: "soft", generateAllReplicas });
-        const hardTags = this.generateDOIdArray({ tags, shardType: "hard", generateAllReplicas });
-        const tagIdCollection = [...softTags, ...hardTags];
-        // We then group the tags by DO id
-        const tagsByDOId = new Map();
-        for (const { doId, tag } of tagIdCollection) {
-            const doIdString = doId.key;
-            const tagsArray = tagsByDOId.get(doIdString)?.tags ?? [];
-            tagsArray.push(tag);
-            tagsByDOId.set(doIdString, {
-                // We override the doId here, but it should be the same for all tags
-                doId,
-                tags: tagsArray,
-            });
-        }
-        const result = Array.from(tagsByDOId.values());
-        return result;
-    }
-    async getConfig() {
-        const cfEnv = getCloudflareContext().env;
-        const db = cfEnv.NEXT_TAG_CACHE_DO_SHARDED;
-        if (!db)
-            debugCache("No Durable object found");
-        const isDisabled = !!globalThis.openNextConfig
-            .dangerous?.disableTagCache;
-        return !db || isDisabled
-            ? { isDisabled: true }
-            : {
-                isDisabled: false,
-                db,
-            };
-    }
     async getLastRevalidated(tags) {
-        const { isDisabled } = await this.getConfig();
+        const { isDisabled } = this.getConfig();
         if (isDisabled)
             return 0;
         if (tags.length === 0)
@@ -214,7 +69,7 @@ class ShardedDOTagCache {
      * @returns
      */
     async hasBeenRevalidated(tags, lastModified) {
-        const { isDisabled } = await this.getConfig();
+        const { isDisabled } = this.getConfig();
         if (isDisabled)
             return false;
         try {
@@ -251,7 +106,7 @@ class ShardedDOTagCache {
      * @returns
      */
     async writeTags(tags) {
-        const { isDisabled } = await this.getConfig();
+        const { isDisabled } = this.getConfig();
         if (isDisabled)
             return;
         const shardedTagGroups = this.groupTagsByDO({ tags, generateAllReplicas: true });
@@ -262,6 +117,9 @@ class ShardedDOTagCache {
         }));
         await purgeCacheByTags(tags);
     }
+    /**
+     * The following methods are public only because they are accessed from the tests
+     */
     async performWriteTagsWithRetry(doId, tags, lastModified, retryNumber = 0) {
         try {
             const stub = this.getDurableObjectStub(doId);
@@ -285,16 +143,15 @@ class ShardedDOTagCache {
             await this.performWriteTagsWithRetry(doId, tags, lastModified, retryNumber + 1);
         }
     }
-    // Cache API
+    getCacheUrlKey(doId, tag) {
+        return `http://local.cache/shard/${doId.shardId}?tag=${encodeURIComponent(tag)}`;
+    }
     async getCacheInstance() {
         if (!this.localCache && this.opts.regionalCache) {
             this.localCache = await caches.open("sharded-do-tag-cache");
         }
         return this.localCache;
     }
-    getCacheUrlKey(doId, tag) {
-        return `http://local.cache/shard/${doId.shardId}?tag=${encodeURIComponent(tag)}`;
-    }
     /**
      * Get the last revalidation time for the tags from the regional cache
      * If the cache is not enabled, it will return an empty array
@@ -383,5 +240,154 @@ class ShardedDOTagCache {
             debugCache("Error while deleting from regional cache", e);
         }
     }
+    /**
+     * Same tags are guaranteed to be in the same shard
+     * @param tags
+     * @returns An array of DO ids and tags
+     */
+    groupTagsByDO({ tags, generateAllReplicas = false, }) {
+        // Here we'll start by splitting soft tags from hard tags
+        // This will greatly increase the cache hit rate for the soft tag (which are the most likely to cause issue because of load)
+        const softTags = this.generateDOIdArray({ tags, shardType: "soft", generateAllReplicas });
+        const hardTags = this.generateDOIdArray({ tags, shardType: "hard", generateAllReplicas });
+        const tagIdCollection = [...softTags, ...hardTags];
+        // We then group the tags by DO id
+        const tagsByDOId = new Map();
+        for (const { doId, tag } of tagIdCollection) {
+            const doIdString = doId.key;
+            const tagsArray = tagsByDOId.get(doIdString)?.tags ?? [];
+            tagsArray.push(tag);
+            tagsByDOId.set(doIdString, {
+                // We override the doId here, but it should be the same for all tags
+                doId,
+                tags: tagsArray,
+            });
+        }
+        const result = Array.from(tagsByDOId.values());
+        return result;
+    }
+    // Private methods
+    getDurableObjectStub(doId) {
+        const durableObject = getCloudflareContext().env.NEXT_TAG_CACHE_DO_SHARDED;
+        if (!durableObject)
+            throw new IgnorableError("No durable object binding for cache revalidation");
+        const id = durableObject.idFromName(doId.key);
+        debug("[shardedTagCache] - Accessing Durable Object : ", {
+            key: doId.key,
+            region: doId.region,
+        });
+        return durableObject.get(id, { locationHint: doId.region });
+    }
+    /**
+     * Generates a list of DO ids for the shards and replicas
+     * @param tags The tags to generate shards for
+     * @param shardType Whether to generate shards for soft or hard tags
+     * @param generateAllShards Whether to generate all shards or only one
+     * @returns An array of TagCacheDOId and tag
+     */
+    generateDOIdArray({ tags, shardType, generateAllReplicas = false, }) {
+        let replicaIndexes = [1];
+        const isSoft = shardType === "soft";
+        let numReplicas = 1;
+        if (this.opts.shardReplication) {
+            numReplicas = isSoft ? this.numSoftReplicas : this.numHardReplicas;
+            replicaIndexes = generateAllReplicas
+                ? Array.from({ length: numReplicas }, (_, i) => i + 1)
+                : [undefined];
+        }
+        const regionalReplicas = replicaIndexes.flatMap((replicaId) => {
+            return tags
+                .filter((tag) => (isSoft ? tag.startsWith(SOFT_TAG_PREFIX) : !tag.startsWith(SOFT_TAG_PREFIX)))
+                .map((tag) => {
+                return {
+                    doId: new DOId({
+                        baseShardId: generateShardId(tag, this.opts.baseShardSize, "shard"),
+                        numberOfReplicas: numReplicas,
+                        shardType,
+                        replicaId,
+                    }),
+                    tag,
+                };
+            });
+        });
+        if (!this.enableRegionalReplication)
+            return regionalReplicas;
+        // If we have regional replication enabled, we need to further duplicate the shards in all the regions
+        const regionalReplicasInAllRegions = generateAllReplicas
+            ? regionalReplicas.flatMap(({ doId, tag }) => {
+                return AVAILABLE_REGIONS.map((region) => {
+                    return {
+                        doId: new DOId({
+                            baseShardId: doId.options.baseShardId,
+                            numberOfReplicas: numReplicas,
+                            shardType,
+                            replicaId: doId.replicaId,
+                            region,
+                        }),
+                        tag,
+                    };
+                });
+            })
+            : regionalReplicas.map(({ doId, tag }) => {
+                doId.region = this.getClosestRegion();
+                return { doId, tag };
+            });
+        return regionalReplicasInAllRegions;
+    }
+    getClosestRegion() {
+        const continent = getCloudflareContext().cf?.continent;
+        if (!continent)
+            return this.defaultRegion;
+        debug("[shardedTagCache] - Continent : ", continent);
+        switch (continent) {
+            case "AF":
+                return "afr";
+            case "AS":
+                return "apac";
+            case "EU":
+                return "weur";
+            case "NA":
+                return "enam";
+            case "OC":
+                return "oc";
+            case "SA":
+                return "sam";
+            default:
+                return this.defaultRegion;
+        }
+    }
+    getConfig() {
+        const cfEnv = getCloudflareContext().env;
+        const db = cfEnv.NEXT_TAG_CACHE_DO_SHARDED;
+        if (!db)
+            debugCache("No Durable object found");
+        const isDisabled = !!globalThis.openNextConfig
+            .dangerous?.disableTagCache;
+        return !db || isDisabled
+            ? { isDisabled: true }
+            : {
+                isDisabled: false,
+                db,
+            };
+    }
+}
+export class DOId {
+    options;
+    shardId;
+    replicaId;
+    region;
+    constructor(options) {
+        this.options = options;
+        const { baseShardId, shardType, numberOfReplicas, replicaId, region } = options;
+        this.shardId = `tag-${shardType};${baseShardId}`;
+        this.replicaId = replicaId ?? this.generateRandomNumberBetween(1, numberOfReplicas);
+        this.region = region;
+    }
+    generateRandomNumberBetween(min, max) {
+        return Math.floor(Math.random() * (max - min + 1) + min);
+    }
+    get key() {
+        return `${this.shardId};replica-${this.replicaId}${this.region ? `;region-${this.region}` : ""}`;
+    }
 }
 export default (opts) => new ShardedDOTagCache(opts);

package/dist/cli/commands/utils.js

@@ -35,8 +35,7 @@ export async function compileConfig(configPath) {
     if (!configPath) {
         configPath = await createOpenNextConfigIfNotExistent(nextAppDir);
     }
-    // TODO: remove the hack passing the `configPath` as the `baseDir` when https://github.com/opennextjs/opennextjs-aws/pull/972 is merged
-    const { config, buildDir } = await compileOpenNextConfig(configPath, "", { compileEdge: true });
+    const { config, buildDir } = await compileOpenNextConfig(configPath, { compileEdge: true });
     ensureCloudflareConfig(config);
     return { config, buildDir };
 }

package/package.json

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