@opennextjs/cloudflare 0.6.6 → 1.0.0-beta.0

package/dist/api/cloudflare-context.d.ts

@@ -1,5 +1,5 @@
 import type { GetPlatformProxyOptions } from "wrangler";
-import type { DurableObjectQueueHandler } from "./durable-objects/queue";
+import type { DOQueueHandler } from "./durable-objects/queue";
 import { DOShardedTagCache } from "./durable-objects/sharded-tag-cache";
 declare global {
     interface CloudflareEnv {
@@ -12,11 +12,11 @@ declare global {
         NEXT_TAG_CACHE_D1?: D1Database;
         NEXT_TAG_CACHE_DO_SHARDED?: DurableObjectNamespace<DOShardedTagCache>;
         NEXT_TAG_CACHE_DO_SHARDED_DLQ?: Queue;
-        NEXT_CACHE_DO_QUEUE?: DurableObjectNamespace<DurableObjectQueueHandler>;
+        NEXT_CACHE_DO_QUEUE?: DurableObjectNamespace<DOQueueHandler>;
         NEXT_CACHE_DO_QUEUE_MAX_REVALIDATION?: string;
         NEXT_CACHE_DO_QUEUE_REVALIDATION_TIMEOUT_MS?: string;
         NEXT_CACHE_DO_QUEUE_RETRY_INTERVAL_MS?: string;
-        NEXT_CACHE_DO_QUEUE_MAX_NUM_REVALIDATIONS?: string;
+        NEXT_CACHE_DO_QUEUE_MAX_RETRIES?: string;
         NEXT_CACHE_DO_QUEUE_DISABLE_SQLITE?: string;
     }
 }

package/dist/api/durable-objects/queue.d.ts

@@ -5,7 +5,7 @@ interface FailedState {
     retryCount: number;
     nextAlarmMs: number;
 }
-export declare class DurableObjectQueueHandler extends DurableObject<CloudflareEnv> {
+export declare class DOQueueHandler extends DurableObject<CloudflareEnv> {
     ongoingRevalidations: Map<string, Promise<void>>;
     sql: SqlStorage;
     routeInFailedState: Map<string, FailedState>;
@@ -13,7 +13,7 @@ export declare class DurableObjectQueueHandler extends DurableObject<CloudflareE
     readonly maxRevalidations: number;
     readonly revalidationTimeout: number;
     readonly revalidationRetryInterval: number;
-    readonly maxRevalidationAttempts: number;
+    readonly maxRetries: number;
     readonly disableSQLite: boolean;
     constructor(ctx: DurableObjectState, env: CloudflareEnv);
     revalidate(msg: QueueMessage): Promise<void>;

package/dist/api/durable-objects/queue.js

@@ -4,8 +4,8 @@ import { DurableObject } from "cloudflare:workers";
 const DEFAULT_MAX_REVALIDATION = 5;
 const DEFAULT_REVALIDATION_TIMEOUT_MS = 10_000;
 const DEFAULT_RETRY_INTERVAL_MS = 2_000;
-const DEFAULT_MAX_NUM_REVALIDATIONS = 6;
-export class DurableObjectQueueHandler extends DurableObject {
+const DEFAULT_MAX_RETRIES = 6;
+export class DOQueueHandler extends DurableObject {
     // Ongoing revalidations are deduped by the deduplication id
     // Since this is running in waitUntil, we expect the durable object state to persist this during the duration of the revalidation
     // TODO: handle incremental cache with only eventual consistency (i.e. KV or R2/D1 with the optional cache layer on top)
@@ -17,7 +17,7 @@ export class DurableObjectQueueHandler extends DurableObject {
     maxRevalidations;
     revalidationTimeout;
     revalidationRetryInterval;
-    maxRevalidationAttempts;
+    maxRetries;
     disableSQLite;
     constructor(ctx, env) {
         super(ctx, env);
@@ -35,9 +35,9 @@ export class DurableObjectQueueHandler extends DurableObject {
         this.revalidationRetryInterval = env.NEXT_CACHE_DO_QUEUE_RETRY_INTERVAL_MS
             ? parseInt(env.NEXT_CACHE_DO_QUEUE_RETRY_INTERVAL_MS)
             : DEFAULT_RETRY_INTERVAL_MS;
-        this.maxRevalidationAttempts = env.NEXT_CACHE_DO_QUEUE_MAX_NUM_REVALIDATIONS
-            ? parseInt(env.NEXT_CACHE_DO_QUEUE_MAX_NUM_REVALIDATIONS)
-            : DEFAULT_MAX_NUM_REVALIDATIONS;
+        this.maxRetries = env.NEXT_CACHE_DO_QUEUE_MAX_RETRIES
+            ? parseInt(env.NEXT_CACHE_DO_QUEUE_MAX_RETRIES)
+            : DEFAULT_MAX_RETRIES;
         this.disableSQLite = env.NEXT_CACHE_DO_QUEUE_DISABLE_SQLITE === "true";
         // We restore the state
         ctx.blockConcurrencyWhile(async () => {
@@ -152,9 +152,8 @@ export class DurableObjectQueueHandler extends DurableObject {
         const existingFailedState = this.routeInFailedState.get(msg.MessageDeduplicationId);
         let updatedFailedState;
         if (existingFailedState) {
-            if (existingFailedState.retryCount >= this.maxRevalidationAttempts) {
-                // We give up after 6 retries and log the error
-                error(`The revalidation for ${msg.MessageBody.host}${msg.MessageBody.url} has failed after 6 retries. It will not be tried again, but subsequent ISR requests will retry.`);
+            if (existingFailedState.retryCount >= this.maxRetries) {
+                error(`The revalidation for ${msg.MessageBody.host}${msg.MessageBody.url} has failed after ${this.maxRetries} retries. It will not be tried again, but subsequent ISR requests will retry.`);
                 this.routeInFailedState.delete(msg.MessageDeduplicationId);
                 return;
             }

package/dist/api/durable-objects/queue.spec.js

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
-import { DurableObjectQueueHandler } from "./queue";
+import { DOQueueHandler } from "./queue";
 vi.mock("cloudflare:workers", () => ({
     DurableObject: class {
         ctx;
@@ -25,7 +25,7 @@ const createDurableObjectQueue = ({ fetchDuration, statusCode, headers, disableS
         },
     };
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return new DurableObjectQueueHandler(mockState, {
+    return new DOQueueHandler(mockState, {
         WORKER_SELF_REFERENCE: {
             fetch: vi.fn().mockReturnValue(new Promise((res) => setTimeout(() => res(new Response(null, {
                 status: statusCode,

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

@@ -1,6 +1,7 @@
 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;
+export declare const NAME = "cf-kv-incremental-cache";
 /**
  * Open Next cache based on cloudflare KV and Assets.
  *
@@ -8,8 +9,8 @@ export declare const STATUS_DELETED = 1;
  * The cloudflare context and process.env are not initialized yet
  * when the constructor is called.
  */
-declare class Cache implements IncrementalCache {
-    readonly name = "cloudflare-kv";
+declare class KVIncrementalCache implements IncrementalCache {
+    readonly name = "cf-kv-incremental-cache";
     get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>> | null>;
     set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
     delete(key: string): Promise<void>;
@@ -18,5 +19,5 @@ declare class Cache implements IncrementalCache {
     protected debug(...args: unknown[]): void;
     protected getBuildId(): string;
 }
-declare const _default: Cache;
+declare const _default: KVIncrementalCache;
 export default _default;

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

@@ -2,6 +2,7 @@ import { IgnorableError, RecoverableError } 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;
+export const NAME = "cf-kv-incremental-cache";
 /**
  * Open Next cache based on cloudflare KV and Assets.
  *
@@ -9,8 +10,8 @@ export const STATUS_DELETED = 1;
  * The cloudflare context and process.env are not initialized yet
  * when the constructor is called.
  */
-class Cache {
-    name = "cloudflare-kv";
+class KVIncrementalCache {
+    name = NAME;
     async get(key, isFetch) {
         const cfEnv = getCloudflareContext().env;
         const kv = cfEnv.NEXT_INC_CACHE_KV;
@@ -120,4 +121,4 @@ class Cache {
         return process.env.NEXT_BUILD_ID ?? "no-build-id";
     }
 }
-export default new Cache();
+export default new KVIncrementalCache();

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

@@ -1,4 +1,5 @@
 import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides.js";
+export declare const NAME = "cf-r2-incremental-cache";
 /**
  * An instance of the Incremental Cache that uses an R2 bucket (`NEXT_INC_CACHE_R2_BUCKET`) as it's
  * underlying data store.
@@ -7,7 +8,7 @@ import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs
  * environment variable, and defaults to `incremental-cache`.
  */
 declare class R2IncrementalCache implements IncrementalCache {
-    readonly name = "r2-incremental-cache";
+    readonly name = "cf-r2-incremental-cache";
     get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>> | null>;
     set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
     delete(key: string): Promise<void>;

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

@@ -1,6 +1,7 @@
 import { debug, error } from "@opennextjs/aws/adapters/logger.js";
 import { IgnorableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context.js";
+export const NAME = "cf-r2-incremental-cache";
 /**
  * An instance of the Incremental Cache that uses an R2 bucket (`NEXT_INC_CACHE_R2_BUCKET`) as it's
  * underlying data store.
@@ -9,7 +10,7 @@ import { getCloudflareContext } from "../../cloudflare-context.js";
  * environment variable, and defaults to `incremental-cache`.
  */
 class R2IncrementalCache {
-    name = "r2-incremental-cache";
+    name = NAME;
     async get(key, isFetch) {
         const r2 = getCloudflareContext().env.NEXT_INC_CACHE_R2_BUCKET;
         if (!r2)

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

@@ -5,17 +5,21 @@ type Options = {
      * The mode to use for the regional cache.
      *
      * - `short-lived`: Re-use a cache entry for up to a minute after it has been retrieved.
-     * - `long-lived`: Re-use a fetch cache entry until it is revalidated (per-region), or an ISR/SSG entry for up to 30 minutes.
+     * - `long-lived`: Re-use a fetch cache entry until it is revalidated (per-region),
+     *                 or an ISR/SSG entry for up to 30 minutes.
      */
     mode: "short-lived" | "long-lived";
     /**
      * Whether the regional cache entry should be updated in the background or not when it experiences
      * a cache hit.
      *
-     * Defaults to `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
+     * @default `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
      */
     shouldLazilyUpdateOnCacheHit?: boolean;
 };
+/**
+ * Wrapper adding a regional cache on an `IncrementalCache` implementation
+ */
 declare class RegionalCache implements IncrementalCache {
     private store;
     private opts;
@@ -35,17 +39,19 @@ declare class RegionalCache implements IncrementalCache {
  *
  * The regional cache uses the Cache API.
  *
- * **WARNING:** If an entry is revalidated in one region, it will trigger an additional revalidation if
+ * **WARNING:**
+ * If an entry is revalidated on demand in one region (using either `revalidateTag`, `revalidatePath` or `res.revalidate` ), it will trigger an additional revalidation if
  * a request is made to another region that has an entry stored in its regional cache.
  *
- * @param cache - Incremental cache instance.
- * @param opts.mode - The mode to use for the regional cache.
- * - `short-lived`: Re-use a cache entry for up to a minute after it has been retrieved.
- * - `long-lived`: Re-use a fetch cache entry until it is revalidated (per-region), or an ISR/SSG entry for up to 30 minutes.
- * @param opts.shouldLazilyUpdateOnCacheHit - Whether the regional cache entry should be updated in
- * the background or not when it experiences a cache hit.
+ * @param cache Incremental cache instance.
+ * @param opts.mode The mode to use for the regional cache.
+ *                  - `short-lived`: Re-use a cache entry for up to a minute after it has been retrieved.
+ *                  - `long-lived`: Re-use a fetch cache entry until it is revalidated (per-region),
+ *                                  or an ISR/SSG entry for up to 30 minutes.
+ * @param opts.shouldLazilyUpdateOnCacheHit Whether the regional cache entry should be updated in
+ *                                          the background or not when it experiences a cache hit.
  *
- * Defaults to `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
+ * @default `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
  */
 export declare function withRegionalCache(cache: IncrementalCache, opts: Options): RegionalCache;
 export {};

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

@@ -1,7 +1,11 @@
 import { debug, error } from "@opennextjs/aws/adapters/logger.js";
 import { getCloudflareContext } from "../../cloudflare-context.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;
+/**
+ * Wrapper adding a regional cache on an `IncrementalCache` implementation
+ */
 class RegionalCache {
     store;
     opts;
@@ -10,6 +14,9 @@ class RegionalCache {
     constructor(store, opts) {
         this.store = store;
         this.opts = opts;
+        if (this.store.name === KV_CACHE_NAME) {
+            throw new Error("The KV incremental cache does not need a regional cache.");
+        }
         this.name = this.store.name;
         this.opts.shouldLazilyUpdateOnCacheHit ??= this.opts.mode === "long-lived";
     }
@@ -94,17 +101,19 @@ class RegionalCache {
  *
  * The regional cache uses the Cache API.
  *
- * **WARNING:** If an entry is revalidated in one region, it will trigger an additional revalidation if
+ * **WARNING:**
+ * If an entry is revalidated on demand in one region (using either `revalidateTag`, `revalidatePath` or `res.revalidate` ), it will trigger an additional revalidation if
  * a request is made to another region that has an entry stored in its regional cache.
  *
- * @param cache - Incremental cache instance.
- * @param opts.mode - The mode to use for the regional cache.
- * - `short-lived`: Re-use a cache entry for up to a minute after it has been retrieved.
- * - `long-lived`: Re-use a fetch cache entry until it is revalidated (per-region), or an ISR/SSG entry for up to 30 minutes.
- * @param opts.shouldLazilyUpdateOnCacheHit - Whether the regional cache entry should be updated in
- * the background or not when it experiences a cache hit.
+ * @param cache Incremental cache instance.
+ * @param opts.mode The mode to use for the regional cache.
+ *                  - `short-lived`: Re-use a cache entry for up to a minute after it has been retrieved.
+ *                  - `long-lived`: Re-use a fetch cache entry until it is revalidated (per-region),
+ *                                  or an ISR/SSG entry for up to 30 minutes.
+ * @param opts.shouldLazilyUpdateOnCacheHit Whether the regional cache entry should be updated in
+ *                                          the background or not when it experiences a cache hit.
  *
- * Defaults to `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
+ * @default `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
  */
 export function withRegionalCache(cache, opts) {
     return new RegionalCache(cache, opts);

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

@@ -1,4 +1,5 @@
 import type { NextModeTagCache } from "@opennextjs/aws/types/overrides.js";
+export declare const NAME = "d1-next-mode-tag-cache";
 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,9 +1,10 @@
 import { debug, error } from "@opennextjs/aws/adapters/logger.js";
 import { RecoverableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context.js";
+export const NAME = "d1-next-mode-tag-cache";
 export class D1NextModeTagCache {
     mode = "nextMode";
-    name = "d1-next-mode-tag-cache";
+    name = NAME;
     async hasBeenRevalidated(tags, lastModified) {
         const { isDisabled, db } = this.getConfig();
         if (isDisabled)

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

@@ -1,67 +1,73 @@
 import type { NextModeTagCache } from "@opennextjs/aws/types/overrides.js";
-export declare const DEFAULT_SOFT_REPLICAS = 4;
-export declare const DEFAULT_HARD_REPLICAS = 2;
 export declare const DEFAULT_WRITE_RETRIES = 3;
 export declare const DEFAULT_NUM_SHARDS = 4;
+export declare const NAME = "do-sharded-tag-cache";
 interface ShardedDOTagCacheOptions {
     /**
      * The number of shards that will be used.
+     *
      * 1 shards means 1 durable object instance.
-     * Soft (internal next tags used for `revalidatePath`) and hard tags (the one you define in your app) will be split in different shards.
+     * Soft (internal next tags used for `revalidatePath`) and hard tags (the one you define in your app)
+     * will be split in different shards.
+     *
      * The number of requests made to Durable Objects will scale linearly with the number of shards.
-     * For example, a request involving 5 tags may access between 1 and 5 shards, with the upper limit being the lesser of the number of tags or the number of shards
+     * For example, a request involving 5 tags may access between 1 and 5 shards, with the upper limit being
+     * the lesser of the number of tags or the number of shards
+     *
      * @default 4
      */
     baseShardSize: number;
     /**
      * Whether to enable a regional cache on a per-shard basis
      * Because of the way tags are implemented in Next.js, some shards will have more requests than others. For these cases, it is recommended to enable the regional cache.
+     *
      * @default false
      */
     regionalCache?: boolean;
     /**
      * The TTL for the regional cache in seconds
      * Increasing this value will reduce the number of requests to the Durable Object, but it could make `revalidateTags`/`revalidatePath` call being longer to take effect
+     *
      * @default 5
      */
     regionalCacheTtlSec?: number;
     /**
-     * Whether to enable shard replication
-     * Shard replication will duplicate each shards into N replicas to spread the load even more
-     * All replicas of the a shard contain the same value - write are sent to all of the replicas.
-     * This allows most frequent read operations to be sent to only one replica to spread the load.
-     * For example with N being 2, tag `tag1` could be read from 2 different durable object instance
-     * On read you only need to read from one of the shards, but on write you need to write to all shards
-     * @default false
-     */
-    enableShardReplication?: boolean;
-    /**
-     * The number of replicas that will be used for shard replication
-     * Soft shard replicas are more often accessed than hard shard replicas, so it is recommended to have more soft replicas than hard replicas
-     * Soft replicas are for internal next tags used for `revalidatePath` (i.e. `_N_T_/layout`, `_N_T_/page1`), hard replicas are the tags defined in your app
-     * @default { numberOfSoftReplicas: 4, numberOfHardReplicas: 2 }
+     * Enable shard replication to handle higher load.
+     *
+     * By default shards are not replicated (`numberOfSoftReplicas = 1` or `numberOfHardReplicas = 1`).
+     *
+     * Setting the number of replicas to a number greater than 1 will replicate the shards.
+     * Write operations always apply to all of the shards.
+     * However read operations read from a single shard to spread the load.
+     *
+     * Soft replicas are for internal next tags used for `revalidatePath` (i.e. `_N_T_/layout`, `_N_T_/page1`).
+     * Hard replicas are the tags defined in your app.
+     *
+     * Soft replicas are accessed more often  than hard replicas, so it is recommended to have more soft replicas
+     * than hard replicas (2x is a good rule of thumb)
      */
-    shardReplicationOptions?: {
+    shardReplication?: {
         numberOfSoftReplicas: number;
         numberOfHardReplicas: number;
     };
     /**
      * The number of retries to perform when writing tags
+     *
      * @default 3
      */
     maxWriteRetries?: number;
 }
-interface TagCacheDOIdOptions {
+interface DOIdOptions {
     baseShardId: string;
     numberOfReplicas: number;
     shardType: "soft" | "hard";
     replicaId?: number;
 }
-export declare class TagCacheDOId {
-    options: TagCacheDOIdOptions;
+export declare class DOId {
+    options: DOIdOptions;
     shardId: string;
     replicaId: number;
-    constructor(options: TagCacheDOIdOptions);
+    constructor(options: DOIdOptions);
     private generateRandomNumberBetween;
     get key(): string;
 }
@@ -92,7 +98,7 @@ declare class ShardedDOTagCache implements NextModeTagCache {
         tags: string[];
         generateAllReplicas?: boolean;
     }): {
-        doId: TagCacheDOId;
+        doId: DOId;
         tags: string[];
     }[];
     private getConfig;
@@ -111,12 +117,12 @@ declare class ShardedDOTagCache implements NextModeTagCache {
      * @returns
      */
     writeTags(tags: string[]): Promise<void>;
-    performWriteTagsWithRetry(doId: TagCacheDOId, tags: string[], lastModified: number, retryNumber?: number): Promise<void>;
+    performWriteTagsWithRetry(doId: DOId, tags: string[], lastModified: number, retryNumber?: number): Promise<void>;
     getCacheInstance(): Promise<Cache | undefined>;
-    getCacheKey(doId: TagCacheDOId, tags: string[]): Promise<Request<unknown, CfProperties<unknown>>>;
-    getFromRegionalCache(doId: TagCacheDOId, tags: string[]): Promise<Response | undefined>;
-    putToRegionalCache(doId: TagCacheDOId, tags: string[], hasBeenRevalidated: boolean): Promise<void>;
-    deleteRegionalCache(doId: TagCacheDOId, tags: string[]): Promise<void>;
+    getCacheKey(doId: DOId, tags: string[]): Promise<Request<unknown, CfProperties<unknown>>>;
+    getFromRegionalCache(doId: DOId, tags: string[]): Promise<Response | undefined>;
+    putToRegionalCache(doId: DOId, tags: string[], hasBeenRevalidated: boolean): Promise<void>;
+    deleteRegionalCache(doId: DOId, tags: string[]): Promise<void>;
 }
 declare const _default: (opts?: ShardedDOTagCacheOptions) => ShardedDOTagCache;
 export default _default;

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

@@ -2,12 +2,11 @@ import { debug, 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";
-const SOFT_TAG_PREFIX = "_N_T_/";
-export const DEFAULT_SOFT_REPLICAS = 4;
-export const DEFAULT_HARD_REPLICAS = 2;
 export const DEFAULT_WRITE_RETRIES = 3;
 export const DEFAULT_NUM_SHARDS = 4;
-export class TagCacheDOId {
+export const NAME = "do-sharded-tag-cache";
+const SOFT_TAG_PREFIX = "_N_T_/";
+export class DOId {
     options;
     shardId;
     replicaId;
@@ -27,15 +26,15 @@ export class TagCacheDOId {
 class ShardedDOTagCache {
     opts;
     mode = "nextMode";
-    name = "do-sharded-tag-cache";
+    name = NAME;
     numSoftReplicas;
     numHardReplicas;
     maxWriteRetries;
     localCache;
     constructor(opts = { baseShardSize: DEFAULT_NUM_SHARDS }) {
         this.opts = opts;
-        this.numSoftReplicas = opts.shardReplicationOptions?.numberOfSoftReplicas ?? DEFAULT_SOFT_REPLICAS;
-        this.numHardReplicas = opts.shardReplicationOptions?.numberOfHardReplicas ?? DEFAULT_HARD_REPLICAS;
+        this.numSoftReplicas = opts.shardReplication?.numberOfSoftReplicas ?? 1;
+        this.numHardReplicas = opts.shardReplication?.numberOfHardReplicas ?? 1;
         this.maxWriteRetries = opts.maxWriteRetries ?? DEFAULT_WRITE_RETRIES;
     }
     getDurableObjectStub(doId) {
@@ -55,19 +54,14 @@ class ShardedDOTagCache {
     generateDOIdArray({ tags, shardType, generateAllReplicas = false, }) {
         let replicaIndexes = [1];
         const isSoft = shardType === "soft";
-        let numReplicas = 1;
-        if (this.opts.enableShardReplication) {
-            numReplicas = isSoft ? this.numSoftReplicas : this.numHardReplicas;
-            replicaIndexes = generateAllReplicas
-                ? Array.from({ length: numReplicas }, (_, i) => i + 1)
-                : [undefined];
-        }
+        const numReplicas = isSoft ? this.numSoftReplicas : this.numHardReplicas;
+        replicaIndexes = generateAllReplicas ? Array.from({ length: numReplicas }, (_, i) => i + 1) : [undefined];
         return replicaIndexes.flatMap((replicaId) => {
             return tags
                 .filter((tag) => (isSoft ? tag.startsWith(SOFT_TAG_PREFIX) : !tag.startsWith(SOFT_TAG_PREFIX)))
                 .map((tag) => {
                 return {
-                    doId: new TagCacheDOId({
+                    doId: new DOId({
                         baseShardId: generateShardId(tag, this.opts.baseShardSize, "shard"),
                         numberOfReplicas: numReplicas,
                         shardType,

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

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import doShardedTagCache, { DEFAULT_HARD_REPLICAS, DEFAULT_SOFT_REPLICAS, TagCacheDOId, } from "./do-sharded-tag-cache";
+import shardedDOTagCache, { DOId } from "./do-sharded-tag-cache";
 const hasBeenRevalidatedMock = vi.fn();
 const writeTagsMock = vi.fn();
 const idFromNameMock = vi.fn();
@@ -23,7 +23,7 @@ describe("DOShardedTagCache", () => {
     afterEach(() => vi.clearAllMocks());
     describe("generateShardId", () => {
         it("should generate a shardId", () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             const expectedResult = [
                 { doId: expect.objectContaining({ shardId: "tag-hard;shard-1" }), tags: ["tag1"] },
                 { doId: expect.objectContaining({ shardId: "tag-hard;shard-2" }), tags: ["tag2"] },
@@ -34,7 +34,7 @@ describe("DOShardedTagCache", () => {
             expect(result[1]?.doId.key).toBe("tag-hard;shard-2;replica-1");
         });
         it("should group tags by shard", () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             const expectedResult = [
                 { doId: expect.objectContaining({ shardId: "tag-hard;shard-1" }), tags: ["tag1", "tag6"] },
             ];
@@ -43,13 +43,13 @@ describe("DOShardedTagCache", () => {
             expect(result[0]?.doId.key).toBe("tag-hard;shard-1;replica-1");
         });
         it("should generate the same shardId for the same tag", () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             const firstResult = cache.groupTagsByDO({ tags: ["tag1"] });
             const secondResult = cache.groupTagsByDO({ tags: ["tag1", "tag3", "tag4"] });
             expect(firstResult[0]).toEqual(secondResult[0]);
         });
         it("should split hard and soft tags", () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             const expectedResult = [
                 { doId: expect.objectContaining({ shardId: "tag-soft;shard-3" }), tags: ["_N_T_/tag1"] },
                 { doId: expect.objectContaining({ shardId: "tag-hard;shard-1", replicaId: 1 }), tags: ["tag1"] },
@@ -61,7 +61,10 @@ describe("DOShardedTagCache", () => {
         });
         describe("with shard replication", () => {
             it("should generate all doIds if generateAllReplicas is true", () => {
-                const cache = doShardedTagCache({ baseShardSize: 4, enableShardReplication: true });
+                const cache = shardedDOTagCache({
+                    baseShardSize: 4,
+                    shardReplication: { numberOfSoftReplicas: 4, numberOfHardReplicas: 2 },
+                });
                 const expectedResult = [
                     { doId: expect.objectContaining({ shardId: "tag-soft;shard-3" }), tags: ["_N_T_/tag1"] },
                     { doId: expect.objectContaining({ shardId: "tag-soft;shard-3" }), tags: ["_N_T_/tag1"] },
@@ -74,7 +77,10 @@ describe("DOShardedTagCache", () => {
                 expect(result).toEqual(expectedResult);
             });
             it("should generate only one doIds by tag type if generateAllReplicas is false", () => {
-                const cache = doShardedTagCache({ baseShardSize: 4, enableShardReplication: true });
+                const cache = shardedDOTagCache({
+                    baseShardSize: 4,
+                    shardReplication: { numberOfSoftReplicas: 4, numberOfHardReplicas: 2 },
+                });
                 const shardedTagCollection = cache.groupTagsByDO({
                     tags: ["tag1", "_N_T_/tag1"],
                     generateAllReplicas: false,
@@ -86,9 +92,9 @@ describe("DOShardedTagCache", () => {
                 expect(secondDOId?.shardId).toBe("tag-hard;shard-1");
                 // We still need to check if the last part is between the correct boundaries
                 expect(firstDOId?.replicaId).toBeGreaterThanOrEqual(1);
-                expect(firstDOId?.replicaId).toBeLessThanOrEqual(DEFAULT_SOFT_REPLICAS);
+                expect(firstDOId?.replicaId).toBeLessThanOrEqual(4);
                 expect(secondDOId?.replicaId).toBeGreaterThanOrEqual(1);
-                expect(secondDOId?.replicaId).toBeLessThanOrEqual(DEFAULT_HARD_REPLICAS);
+                expect(secondDOId?.replicaId).toBeLessThanOrEqual(2);
             });
         });
     });
@@ -102,13 +108,13 @@ describe("DOShardedTagCache", () => {
             globalThis.openNextConfig = {
                 dangerous: { disableTagCache: true },
             };
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             const result = await cache.hasBeenRevalidated(["tag1"]);
             expect(result).toBe(false);
             expect(idFromNameMock).not.toHaveBeenCalled();
         });
         it("should return false if stub return false", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             cache.getFromRegionalCache = vi.fn();
             hasBeenRevalidatedMock.mockImplementationOnce(() => false);
             const result = await cache.hasBeenRevalidated(["tag1"], 123456);
@@ -118,7 +124,7 @@ describe("DOShardedTagCache", () => {
             expect(result).toBe(false);
         });
         it("should return true if stub return true", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             cache.getFromRegionalCache = vi.fn();
             hasBeenRevalidatedMock.mockImplementationOnce(() => true);
             const result = await cache.hasBeenRevalidated(["tag1"], 123456);
@@ -128,7 +134,7 @@ describe("DOShardedTagCache", () => {
             expect(result).toBe(true);
         });
         it("should return false if it throws", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             cache.getFromRegionalCache = vi.fn();
             hasBeenRevalidatedMock.mockImplementationOnce(() => {
                 throw new Error("error");
@@ -140,7 +146,7 @@ describe("DOShardedTagCache", () => {
             expect(result).toBe(false);
         });
         it("Should return from the cache if it was found there", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             cache.getFromRegionalCache = vi.fn().mockReturnValueOnce(new Response("true"));
             const result = await cache.hasBeenRevalidated(["tag1"], 123456);
             expect(result).toBe(true);
@@ -148,7 +154,7 @@ describe("DOShardedTagCache", () => {
             expect(hasBeenRevalidatedMock).not.toHaveBeenCalled();
         });
         it("should try to put the result in the cache if it was not revalidated", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             cache.getFromRegionalCache = vi.fn();
             cache.putToRegionalCache = vi.fn();
             hasBeenRevalidatedMock.mockImplementationOnce(() => false);
@@ -158,7 +164,7 @@ describe("DOShardedTagCache", () => {
             expect(cache.putToRegionalCache).toHaveBeenCalled();
         });
         it("should call all the durable object instance", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             cache.getFromRegionalCache = vi.fn();
             const result = await cache.hasBeenRevalidated(["tag1", "tag2"], 123456);
             expect(result).toBe(false);
@@ -181,20 +187,20 @@ describe("DOShardedTagCache", () => {
             globalThis.openNextConfig = {
                 dangerous: { disableTagCache: true },
             };
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             await cache.writeTags(["tag1"]);
             expect(idFromNameMock).not.toHaveBeenCalled();
             expect(writeTagsMock).not.toHaveBeenCalled();
         });
         it("should write the tags to the cache", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             await cache.writeTags(["tag1"]);
             expect(idFromNameMock).toHaveBeenCalled();
             expect(writeTagsMock).toHaveBeenCalled();
             expect(writeTagsMock).toHaveBeenCalledWith(["tag1"], 1000);
         });
         it("should write the tags to the cache for multiple shards", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             await cache.writeTags(["tag1", "tag2"]);
             expect(idFromNameMock).toHaveBeenCalledTimes(2);
             expect(writeTagsMock).toHaveBeenCalledTimes(2);
@@ -202,7 +208,10 @@ describe("DOShardedTagCache", () => {
             expect(writeTagsMock).toHaveBeenCalledWith(["tag2"], 1000);
         });
         it('should write to all the replicated shards if "generateAllReplicas" is true', async () => {
-            const cache = doShardedTagCache({ baseShardSize: 4, enableShardReplication: true });
+            const cache = shardedDOTagCache({
+                baseShardSize: 4,
+                shardReplication: { numberOfSoftReplicas: 4, numberOfHardReplicas: 2 },
+            });
             await cache.writeTags(["tag1", "_N_T_/tag1"]);
             expect(idFromNameMock).toHaveBeenCalledTimes(6);
             expect(writeTagsMock).toHaveBeenCalledTimes(6);
@@ -210,7 +219,7 @@ describe("DOShardedTagCache", () => {
             expect(writeTagsMock).toHaveBeenCalledWith(["_N_T_/tag1"], 1000);
         });
         it("should call deleteRegionalCache", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             cache.deleteRegionalCache = vi.fn();
             await cache.writeTags(["tag1"]);
             expect(cache.deleteRegionalCache).toHaveBeenCalled();
@@ -220,7 +229,7 @@ describe("DOShardedTagCache", () => {
     });
     describe("getCacheInstance", () => {
         it("should return undefined by default", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             expect(await cache.getCacheInstance()).toBeUndefined();
         });
         it("should try to return the cache instance if regional cache is enabled", async () => {
@@ -228,7 +237,7 @@ describe("DOShardedTagCache", () => {
             globalThis.caches = {
                 open: vi.fn().mockResolvedValue("cache"),
             };
-            const cache = doShardedTagCache({ baseShardSize: 4, regionalCache: true });
+            const cache = shardedDOTagCache({ baseShardSize: 4, regionalCache: true });
             expect(cache.localCache).toBeUndefined();
             expect(await cache.getCacheInstance()).toBe("cache");
             expect(cache.localCache).toBe("cache");
@@ -238,8 +247,8 @@ describe("DOShardedTagCache", () => {
     });
     describe("getFromRegionalCache", () => {
         it("should return undefined if regional cache is disabled", async () => {
-            const cache = doShardedTagCache();
-            const doId = new TagCacheDOId({
+            const cache = shardedDOTagCache();
+            const doId = new DOId({
                 baseShardId: "shard-1",
                 numberOfReplicas: 1,
                 shardType: "hard",
@@ -253,8 +262,8 @@ describe("DOShardedTagCache", () => {
                     match: vi.fn().mockResolvedValue("response"),
                 }),
             };
-            const cache = doShardedTagCache({ baseShardSize: 4, regionalCache: true });
-            const doId = new TagCacheDOId({
+            const cache = shardedDOTagCache({ baseShardSize: 4, regionalCache: true });
+            const doId = new DOId({
                 baseShardId: "shard-1",
                 numberOfReplicas: 1,
                 shardType: "hard",
@@ -266,11 +275,11 @@ describe("DOShardedTagCache", () => {
     });
     describe("getCacheKey", () => {
         it("should return the cache key without the random part", async () => {
-            const cache = doShardedTagCache();
-            const doId1 = new TagCacheDOId({ baseShardId: "shard-0", numberOfReplicas: 1, shardType: "hard" });
+            const cache = shardedDOTagCache();
+            const doId1 = new DOId({ baseShardId: "shard-0", numberOfReplicas: 1, shardType: "hard" });
             const reqKey = await cache.getCacheKey(doId1, ["_N_T_/tag1"]);
             expect(reqKey.url).toBe("http://local.cache/shard/tag-hard;shard-0?tags=_N_T_%2Ftag1");
-            const doId2 = new TagCacheDOId({
+            const doId2 = new DOId({
                 baseShardId: "shard-1",
                 numberOfReplicas: 1,
                 shardType: "hard",
@@ -283,12 +292,12 @@ describe("DOShardedTagCache", () => {
         it("should retry if it fails", async () => {
             vi.useFakeTimers();
             vi.setSystemTime(1000);
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             writeTagsMock.mockImplementationOnce(() => {
                 throw new Error("error");
             });
             const spiedFn = vi.spyOn(cache, "performWriteTagsWithRetry");
-            const doId = new TagCacheDOId({
+            const doId = new DOId({
                 baseShardId: "shard-1",
                 numberOfReplicas: 1,
                 shardType: "hard",
@@ -303,12 +312,12 @@ describe("DOShardedTagCache", () => {
         it("should stop retrying after 3 times", async () => {
             vi.useFakeTimers();
             vi.setSystemTime(1000);
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             writeTagsMock.mockImplementationOnce(() => {
                 throw new Error("error");
             });
             const spiedFn = vi.spyOn(cache, "performWriteTagsWithRetry");
-            await cache.performWriteTagsWithRetry(new TagCacheDOId({ baseShardId: "shard-1", numberOfReplicas: 1, shardType: "hard" }), ["tag1"], Date.now(), 3);
+            await cache.performWriteTagsWithRetry(new DOId({ baseShardId: "shard-1", numberOfReplicas: 1, shardType: "hard" }), ["tag1"], Date.now(), 3);
             expect(writeTagsMock).toHaveBeenCalledTimes(1);
             expect(spiedFn).toHaveBeenCalledTimes(1);
             expect(sendDLQMock).toHaveBeenCalledWith({

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

@@ -2,6 +2,8 @@ import { 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 { runWrangler } from "../utils/run-wrangler.js";
 async function resolveCacheName(value) {
     return typeof value === "function" ? (await value()).name : value;
@@ -31,7 +33,7 @@ export async function populateCache(options, config, populateCacheOptions) {
     if (!config.dangerous?.disableIncrementalCache && incrementalCache) {
         const name = await resolveCacheName(incrementalCache);
         switch (name) {
-            case "r2-incremental-cache": {
+            case R2_CACHE_NAME: {
                 logger.info("\nPopulating R2 incremental cache...");
                 const assets = getCacheAssetPaths(options);
                 assets.forEach(({ fsPath, destPath }) => {
@@ -51,7 +53,7 @@ export async function populateCache(options, config, populateCacheOptions) {
     if (!config.dangerous?.disableTagCache && !config.dangerous?.disableIncrementalCache && tagCache) {
         const name = await resolveCacheName(tagCache);
         switch (name) {
-            case "d1-next-mode-tag-cache": {
+            case D1_TAG_NAME: {
                 logger.info("\nCreating D1 table if necessary...");
                 runWrangler(options, [
                     "d1 execute",
@@ -61,16 +63,6 @@ export async function populateCache(options, config, populateCacheOptions) {
                 logger.info("\nSuccessfully created D1 table");
                 break;
             }
-            case "d1-tag-cache": {
-                logger.info("\nPopulating D1 tag cache...");
-                runWrangler(options, [
-                    "d1 execute",
-                    "NEXT_TAG_CACHE_D1",
-                    `--file ${JSON.stringify(path.join(options.outputDir, "cloudflare/cache-assets-manifest.sql"))}`,
-                ], { ...populateCacheOptions, logging: "error" });
-                logger.info("Successfully populated cache");
-                break;
-            }
             default:
                 logger.info("Tag cache does not need populating");
         }

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

@@ -1,4 +1,4 @@
-export { DurableObjectQueueHandler } from "./.build/durable-objects/queue.js";
+export { DOQueueHandler } from "./.build/durable-objects/queue.js";
 export { DOShardedTagCache } from "./.build/durable-objects/sharded-tag-cache.js";
 declare const _default: ExportedHandler<CloudflareEnv>;
 export default _default;

package/dist/cli/templates/worker.js

@@ -10,7 +10,7 @@ Object.defineProperty(globalThis, Symbol.for("__cloudflare-context__"), {
     },
 });
 //@ts-expect-error: Will be resolved by wrangler build
-export { DurableObjectQueueHandler } from "./.build/durable-objects/queue.js";
+export { DOQueueHandler } from "./.build/durable-objects/queue.js";
 //@ts-expect-error: Will be resolved by wrangler build
 export { DOShardedTagCache } from "./.build/durable-objects/sharded-tag-cache.js";
 // Populate process.env on the first request

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "0.6.6",
+  "version": "1.0.0-beta.0",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"
@@ -27,7 +27,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/opennextjs/opennextjs-cloudflare.git",
+    "url": "git+https://github.com/opennextjs/opennextjs-cloudflare.git",
     "directory": "packages/cloudflare"
   },
   "keywords": [
@@ -43,7 +43,7 @@
   "homepage": "https://github.com/opennextjs/opennextjs-cloudflare",
   "dependencies": {
     "@dotenvx/dotenvx": "1.31.0",
-    "@opennextjs/aws": "https://pkg.pr.new/@opennextjs/aws@802",
+    "@opennextjs/aws": "3.5.4",
     "enquirer": "^2.4.1",
     "glob": "^11.0.0"
   },
@@ -67,7 +67,7 @@
     "vitest": "^2.1.1"
   },
   "peerDependencies": {
-    "wrangler": "^3.114.1 || ^4.6.0"
+    "wrangler": "^3.114.3 || ^4.7.0"
   },
   "scripts": {
     "clean": "rimraf dist",

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

@@ -1,33 +0,0 @@
-import type { OriginalTagCache } from "@opennextjs/aws/types/overrides.js";
-/**
- * An instance of the Tag Cache that uses a D1 binding (`NEXT_TAG_CACHE_D1`) as it's underlying data store.
- *
- * **Tag/path mappings table**
- *
- * Information about the relation between tags and paths is stored in a `tags` table that contains
- * two columns; `tag`, and `path`.
- *
- * This table should be populated using an SQL file that is generated during the build process.
- *
- * **Tag revalidations table**
- *
- * Revalidation times for tags are stored in a `revalidations` table that contains two columns; `tags`,
- * and `revalidatedAt`.
- */
-declare class D1TagCache implements OriginalTagCache {
-    readonly name = "d1-tag-cache";
-    getByPath(rawPath: string): Promise<string[]>;
-    getByTag(rawTag: string): Promise<string[]>;
-    getLastModified(path: string, lastModified?: number): Promise<number>;
-    writeTags(tags: {
-        tag: string;
-        path: string;
-        revalidatedAt?: number;
-    }[]): Promise<void>;
-    private getConfig;
-    protected removeBuildId(key: string): string;
-    protected getCacheKey(key: string): string;
-    protected getBuildId(): string;
-}
-declare const _default: D1TagCache;
-export default _default;

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

@@ -1,140 +0,0 @@
-import { debug, error } from "@opennextjs/aws/adapters/logger.js";
-import { RecoverableError } from "@opennextjs/aws/utils/error.js";
-import { getCloudflareContext } from "../../cloudflare-context.js";
-/**
- * An instance of the Tag Cache that uses a D1 binding (`NEXT_TAG_CACHE_D1`) as it's underlying data store.
- *
- * **Tag/path mappings table**
- *
- * Information about the relation between tags and paths is stored in a `tags` table that contains
- * two columns; `tag`, and `path`.
- *
- * This table should be populated using an SQL file that is generated during the build process.
- *
- * **Tag revalidations table**
- *
- * Revalidation times for tags are stored in a `revalidations` table that contains two columns; `tags`,
- * and `revalidatedAt`.
- */
-class D1TagCache {
-    name = "d1-tag-cache";
-    async getByPath(rawPath) {
-        const { isDisabled, db } = this.getConfig();
-        if (isDisabled)
-            return [];
-        const path = this.getCacheKey(rawPath);
-        try {
-            const { success, results } = await db
-                .prepare(`SELECT tag FROM tags WHERE path = ?`)
-                .bind(path)
-                .all();
-            if (!success)
-                throw new RecoverableError(`D1 select failed for ${path}`);
-            const tags = results?.map((item) => this.removeBuildId(item.tag));
-            debug("tags for path", path, tags);
-            return tags;
-        }
-        catch (e) {
-            error("Failed to get tags by path", e);
-            return [];
-        }
-    }
-    async getByTag(rawTag) {
-        const { isDisabled, db } = this.getConfig();
-        if (isDisabled)
-            return [];
-        const tag = this.getCacheKey(rawTag);
-        try {
-            const { success, results } = await db
-                .prepare(`SELECT path FROM tags WHERE tag = ?`)
-                .bind(tag)
-                .all();
-            if (!success)
-                throw new RecoverableError(`D1 select failed for ${tag}`);
-            const paths = results?.map((item) => this.removeBuildId(item.path));
-            debug("paths for tag", tag, paths);
-            return paths;
-        }
-        catch (e) {
-            error("Failed to get by tag", e);
-            return [];
-        }
-    }
-    async getLastModified(path, lastModified) {
-        const { isDisabled, db } = this.getConfig();
-        if (isDisabled)
-            return lastModified ?? Date.now();
-        try {
-            const { success, results } = await db
-                .prepare(`SELECT revalidations.tag FROM revalidations
-            INNER JOIN tags ON revalidations.tag = tags.tag
-            WHERE tags.path = ? AND revalidations.revalidatedAt > ?;`)
-                .bind(this.getCacheKey(path), lastModified ?? 0)
-                .all();
-            if (!success)
-                throw new RecoverableError(`D1 select failed for ${path} - ${lastModified ?? 0}`);
-            debug("revalidatedTags", results);
-            return results?.length > 0 ? -1 : (lastModified ?? Date.now());
-        }
-        catch (e) {
-            error("Failed to get revalidated tags", e);
-            return lastModified ?? Date.now();
-        }
-    }
-    async writeTags(tags) {
-        const { isDisabled, db } = this.getConfig();
-        if (isDisabled || tags.length === 0)
-            return;
-        try {
-            const uniqueTags = new Set();
-            const results = await db.batch(tags
-                .map(({ tag, path, revalidatedAt }) => {
-                if (revalidatedAt === 1) {
-                    // new tag/path mapping from set
-                    return db
-                        .prepare(`INSERT INTO tags (tag, path) VALUES (?, ?)`)
-                        .bind(this.getCacheKey(tag), this.getCacheKey(path));
-                }
-                if (!uniqueTags.has(tag) && revalidatedAt !== -1) {
-                    // tag was revalidated
-                    uniqueTags.add(tag);
-                    return db
-                        .prepare(`INSERT INTO revalidations (tag, revalidatedAt) VALUES (?, ?)`)
-                        .bind(this.getCacheKey(tag), revalidatedAt ?? Date.now());
-                }
-            })
-                .filter((stmt) => !!stmt));
-            const failedResults = results.filter((res) => !res.success);
-            if (failedResults.length > 0) {
-                throw new RecoverableError(`${failedResults.length} tags failed to write`);
-            }
-        }
-        catch (e) {
-            error("Failed to batch write tags", e);
-        }
-    }
-    getConfig() {
-        const cfEnv = getCloudflareContext().env;
-        const db = cfEnv.NEXT_TAG_CACHE_D1;
-        if (!db)
-            debug("No D1 database found");
-        const isDisabled = !!globalThis.openNextConfig
-            .dangerous?.disableTagCache;
-        return !db || isDisabled
-            ? { isDisabled: true }
-            : {
-                isDisabled: false,
-                db,
-            };
-    }
-    removeBuildId(key) {
-        return key.replace(`${this.getBuildId()}/`, "");
-    }
-    getCacheKey(key) {
-        return `${this.getBuildId()}/${key}`.replaceAll("//", "/");
-    }
-    getBuildId() {
-        return process.env.NEXT_BUILD_ID ?? "no-build-id";
-    }
-}
-export default new D1TagCache();