fixup! drop D1 custom table names

Author: vicb

packages/cloudflare/src/api/cloudflare-context.ts

@@ -25,12 +25,6 @@ declare global {
 
     // D1 db used for the tag cache
     NEXT_CACHE_D1?: D1Database;
-    // D1 table to use for the tag cache for the tag/path mapping
-    // Optional, default to "tags"
-    NEXT_CACHE_D1_TAGS_TABLE?: string;
-    // D1 table to use for the tag cache for storing the tag and their associated revalidation times
-    // Optional, default to "revalidations"
-    NEXT_CACHE_D1_REVALIDATIONS_TABLE?: string;
 
     // Durable Object namespace to use for the durable object queue handler
     NEXT_CACHE_DO_REVALIDATION?: DurableObjectNamespace<DurableObjectQueueHandler>;

packages/cloudflare/src/api/overrides/tag-cache/d1-next-tag-cache.ts

@@ -4,19 +4,18 @@ import type { NextModeTagCache } from "@opennextjs/aws/types/overrides.js";
 import { RecoverableError } from "@opennextjs/aws/utils/error.js";
 
 import { getCloudflareContext } from "../../cloudflare-context.js";
-import { DEFAULT_NEXT_CACHE_D1_REVALIDATIONS_TABLE } from "./internal.js";
 
 export class D1NextModeTagCache implements NextModeTagCache {
   readonly mode = "nextMode" as const;
   readonly name = "d1-next-mode-tag-cache";
 
   async hasBeenRevalidated(tags: string[], lastModified?: number): Promise<boolean> {
-    const { isDisabled, db, tables } = this.getConfig();
+    const { isDisabled, db } = this.getConfig();
     if (isDisabled) return false;
     try {
       const result = await db
         .prepare(
-          `SELECT COUNT(*) as cnt FROM ${JSON.stringify(tables.revalidations)} WHERE tag IN (${tags.map(() => "?").join(", ")}) AND revalidatedAt > ? LIMIT 1`
+          `SELECT COUNT(*) as cnt FROM revalidations WHERE tag IN (${tags.map(() => "?").join(", ")}) AND revalidatedAt > ? LIMIT 1`
         )
         .bind(...tags.map((tag) => this.getCacheKey(tag)), lastModified ?? Date.now())
         .first<{ cnt: number }>();
@@ -32,12 +31,12 @@ export class D1NextModeTagCache implements NextModeTagCache {
   }
 
   async writeTags(tags: string[]): Promise<void> {
-    const { isDisabled, db, tables } = this.getConfig();
+    const { isDisabled, db } = this.getConfig();
     if (isDisabled) return Promise.resolve();
     const result = await db.batch(
       tags.map((tag) =>
         db
-          .prepare(`INSERT INTO ${JSON.stringify(tables.revalidations)} (tag, revalidatedAt) VALUES (?, ?)`)
+          .prepare(`INSERT INTO revalidations (tag, revalidatedAt) VALUES (?, ?)`)
           .bind(this.getCacheKey(tag), Date.now())
       )
     );
@@ -53,17 +52,12 @@ export class D1NextModeTagCache implements NextModeTagCache {
     const isDisabled = !!(globalThis as unknown as { openNextConfig: OpenNextConfig }).openNextConfig
       .dangerous?.disableTagCache;
 
-    if (!db || isDisabled) {
-      return { isDisabled: true as const };
-    }
-
-    return {
-      isDisabled: false as const,
-      db,
-      tables: {
-        revalidations: cfEnv.NEXT_CACHE_D1_REVALIDATIONS_TABLE ?? DEFAULT_NEXT_CACHE_D1_REVALIDATIONS_TABLE,
-      },
-    };
+    return !db || isDisabled
+      ? { isDisabled: true as const }
+      : {
+          isDisabled: false as const,
+          db,
+        };
   }
 
   protected removeBuildId(key: string) {

packages/cloudflare/src/api/overrides/tag-cache/d1-tag-cache.ts

@@ -4,37 +4,34 @@ import type { OriginalTagCache } from "@opennextjs/aws/types/overrides.js";
 import { RecoverableError } from "@opennextjs/aws/utils/error.js";
 
 import { getCloudflareContext } from "../../cloudflare-context.js";
-import { DEFAULT_NEXT_CACHE_D1_REVALIDATIONS_TABLE, DEFAULT_NEXT_CACHE_D1_TAGS_TABLE } from "./internal.js";
 
 /**
  * An instance of the Tag Cache that uses a D1 binding (`NEXT_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`. The table name can be configured with `NEXT_CACHE_D1_TAGS_TABLE`
- * environment variable.
+ * 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`. The table name can be configured with `NEXT_CACHE_D1_REVALIDATIONS_TABLE`
- * environment variable.
+ * and `revalidatedAt`..
  */
 class D1TagCache implements OriginalTagCache {
   public readonly name = "d1-tag-cache";
 
   public async getByPath(rawPath: string): Promise<string[]> {
-    const { isDisabled, db, tables } = this.getConfig();
+    const { isDisabled, db } = this.getConfig();
     if (isDisabled) return [];
 
     const path = this.getCacheKey(rawPath);
 
     try {
       const { success, results } = await db
-        .prepare(`SELECT tag FROM ${JSON.stringify(tables.tags)} WHERE path = ?`)
+        .prepare(`SELECT tag FROM tags WHERE path = ?`)
         .bind(path)
         .all<{ tag: string }>();
 
@@ -51,14 +48,14 @@ class D1TagCache implements OriginalTagCache {
   }
 
   public async getByTag(rawTag: string): Promise<string[]> {
-    const { isDisabled, db, tables } = this.getConfig();
+    const { isDisabled, db } = this.getConfig();
     if (isDisabled) return [];
 
     const tag = this.getCacheKey(rawTag);
 
     try {
       const { success, results } = await db
-        .prepare(`SELECT path FROM ${JSON.stringify(tables.tags)} WHERE tag = ?`)
+        .prepare(`SELECT path FROM tags WHERE tag = ?`)
         .bind(tag)
         .all<{ path: string }>();
 
@@ -75,15 +72,15 @@ class D1TagCache implements OriginalTagCache {
   }
 
   public async getLastModified(path: string, lastModified?: number): Promise<number> {
-    const { isDisabled, db, tables } = this.getConfig();
+    const { isDisabled, db } = this.getConfig();
     if (isDisabled) return lastModified ?? Date.now();
 
     try {
       const { success, results } = await db
         .prepare(
-          `SELECT ${JSON.stringify(tables.revalidations)}.tag FROM ${JSON.stringify(tables.revalidations)}
-            INNER JOIN ${JSON.stringify(tables.tags)} ON ${JSON.stringify(tables.revalidations)}.tag = ${JSON.stringify(tables.tags)}.tag
-            WHERE ${JSON.stringify(tables.tags)}.path = ? AND ${JSON.stringify(tables.revalidations)}.revalidatedAt > ?;`
+          `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<{ tag: string }>();
@@ -99,7 +96,7 @@ class D1TagCache implements OriginalTagCache {
   }
 
   public async writeTags(tags: { tag: string; path: string; revalidatedAt?: number }[]): Promise<void> {
-    const { isDisabled, db, tables } = this.getConfig();
+    const { isDisabled, db } = this.getConfig();
     if (isDisabled || tags.length === 0) return;
 
     try {
@@ -110,17 +107,15 @@ class D1TagCache implements OriginalTagCache {
             if (revalidatedAt === 1) {
               // new tag/path mapping from set
               return db
-                .prepare(`INSERT INTO ${JSON.stringify(tables.tags)} (tag, path) VALUES (?, ?)`)
+                .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 ${JSON.stringify(tables.revalidations)} (tag, revalidatedAt) VALUES (?, ?)`
-                )
+                .prepare(`INSERT INTO revalidations (tag, revalidatedAt) VALUES (?, ?)`)
                 .bind(this.getCacheKey(tag), revalidatedAt ?? Date.now());
             }
           })
@@ -146,18 +141,12 @@ class D1TagCache implements OriginalTagCache {
     const isDisabled = !!(globalThis as unknown as { openNextConfig: OpenNextConfig }).openNextConfig
       .dangerous?.disableTagCache;
 
-    if (!db || isDisabled) {
-      return { isDisabled: true as const };
-    }
-
-    return {
-      isDisabled: false as const,
-      db,
-      tables: {
-        tags: cfEnv.NEXT_CACHE_D1_TAGS_TABLE ?? DEFAULT_NEXT_CACHE_D1_TAGS_TABLE,
-        revalidations: cfEnv.NEXT_CACHE_D1_REVALIDATIONS_TABLE ?? DEFAULT_NEXT_CACHE_D1_REVALIDATIONS_TABLE,
-      },
-    };
+    return !db || isDisabled
+      ? { isDisabled: true as const }
+      : {
+          isDisabled: false as const,
+          db,
+        };
   }
 
   protected removeBuildId(key: string) {

packages/cloudflare/src/api/overrides/tag-cache/do-sharded-tag-cache.ts

@@ -195,14 +195,12 @@ class ShardedDOTagCache implements NextModeTagCache {
     const isDisabled = !!(globalThis as unknown as { openNextConfig: OpenNextConfig }).openNextConfig
       .dangerous?.disableTagCache;
 
-    if (!db || isDisabled) {
-      return { isDisabled: true as const };
-    }
-
-    return {
-      isDisabled: false as const,
-      db,
-    };
+    return !db || isDisabled
+      ? { isDisabled: true as const }
+      : {
+          isDisabled: false as const,
+          db,
+        };
   }
 
   /**

packages/cloudflare/src/api/overrides/tag-cache/internal.ts

@@ -5,27 +5,21 @@ import type { BuildOptions } from "@opennextjs/aws/build/helper.js";
 import type { TagCacheMetaFile } from "@opennextjs/aws/types/cache.js";
 
 /**
- * Generates SQL statements that can be used to initialise the cache assets manifest in an SQL data store.
+ * Generates SQL statements that can be used to initialize the cache assets manifest in an SQL data store.
  */
 export function compileCacheAssetsManifestSqlFile(options: BuildOptions, metaFiles: TagCacheMetaFile[]) {
   const outputPath = path.join(options.outputDir, "cloudflare/cache-assets-manifest.sql");
 
-  const tagsTable = process.env.NEXT_CACHE_D1_TAGS_TABLE || "tags";
-  const revalidationsTable = process.env.NEXT_CACHE_D1_REVALIDATIONS_TABLE || "revalidations";
-
   mkdirSync(path.dirname(outputPath), { recursive: true });
   writeFileSync(
     outputPath,
-    `CREATE TABLE IF NOT EXISTS ${JSON.stringify(tagsTable)} (tag TEXT NOT NULL, path TEXT NOT NULL, UNIQUE(tag, path) ON CONFLICT REPLACE);
-     CREATE TABLE IF NOT EXISTS ${JSON.stringify(revalidationsTable)} (tag TEXT NOT NULL, revalidatedAt INTEGER NOT NULL, UNIQUE(tag) ON CONFLICT REPLACE);\n`
+    `CREATE TABLE IF NOT EXISTS tags (tag TEXT NOT NULL, path TEXT NOT NULL, UNIQUE(tag, path) ON CONFLICT REPLACE);
+     CREATE TABLE IF NOT EXISTS revalidations (tag TEXT NOT NULL, revalidatedAt INTEGER NOT NULL, UNIQUE(tag) ON CONFLICT REPLACE);\n`
   );
 
   const values = metaFiles.map(({ tag, path }) => `(${JSON.stringify(tag.S)}, ${JSON.stringify(path.S)})`);
 
   if (values.length) {
-    appendFileSync(
-      outputPath,
-      `INSERT INTO ${JSON.stringify(tagsTable)} (tag, path) VALUES ${values.join(", ")};`
-    );
+    appendFileSync(outputPath, `INSERT INTO tags (tag, path) VALUES ${values.join(", ")};`);
   }
 }

packages/cloudflare/src/cli/build/open-next/compile-cache-assets-manifest.ts

@@ -90,14 +90,13 @@ export async function populateCache(
     switch (name) {
       case "d1-next-mode-tag-cache": {
         logger.info("\nCreating D1 table if necessary...");
-        const revalidationsTable = process.env.NEXT_CACHE_D1_REVALIDATIONS_TABLE || "revalidations";
 
         runWrangler(
           options,
           [
             "d1 execute",
             "NEXT_CACHE_D1",
-            `--command "CREATE TABLE IF NOT EXISTS ${JSON.stringify(revalidationsTable)} (tag TEXT NOT NULL, revalidatedAt INTEGER NOT NULL, UNIQUE(tag) ON CONFLICT REPLACE);"`,
+            `--command "CREATE TABLE IF NOT EXISTS revalidations (tag TEXT NOT NULL, revalidatedAt INTEGER NOT NULL, UNIQUE(tag) ON CONFLICT REPLACE);"`,
           ],
           { ...populateCacheOptions, logging: "error" }
         );