Update D1 template to support production seeding via drizzle (#43)

brettimus · web-flow · commit 2d6b4dffd7a7 · 2025-02-07T13:43:04.000+01:00
* Fix ENVIROMENT typo and add production seeding logic for drizzle

* Remove dead code

* Clarify biome comment

* Print friendly error message when local wrangler d1 db not found
diff --git a/examples/uptime-monitor/drizzle.config.ts b/examples/uptime-monitor/drizzle.config.ts
@@ -4,7 +4,7 @@ import { config } from "dotenv";
 import { defineConfig } from "drizzle-kit";
 
 let dbConfig: ReturnType<typeof defineConfig>;
-if (process.env.ENVIROMENT === "production") {
+if (process.env.ENVIRONMENT === "production") {
   config({ path: "./.prod.vars" });
   dbConfig = defineConfig({
     schema: "./src/db/schema.ts",
diff --git a/examples/uptime-monitor/package.json b/examples/uptime-monitor/package.json
@@ -6,7 +6,7 @@
     "db:touch": "wrangler d1 execute uptime-d1-database --local --command='SELECT 1'",
     "db:generate": "drizzle-kit generate",
     "db:migrate": "wrangler d1 migrations apply uptime-d1-database --local",
-    "db:migrate:prod": "ENVIROMENT=production drizzle-kit migrate",
+    "db:migrate:prod": "ENVIRONMENT=production drizzle-kit migrate",
     "db:seed": "tsx seed.ts",
     "db:setup": "npm run db:touch && npm run db:generate && npm run db:migrate && npm run db:seed",
     "db:studio": "drizzle-kit studio",
diff --git a/templates/d1/drizzle.config.ts b/templates/d1/drizzle.config.ts
@@ -4,7 +4,7 @@ import { config } from "dotenv";
 import { defineConfig } from "drizzle-kit";
 
 let dbConfig: ReturnType<typeof defineConfig>;
-if (process.env.ENVIROMENT === "production") {
+if (process.env.ENVIRONMENT === "production") {
   config({ path: "./.prod.vars" });
   dbConfig = defineConfig({
     schema: "./src/db/schema.ts",
diff --git a/templates/d1/package.json b/templates/d1/package.json
@@ -6,8 +6,9 @@
     "db:touch": "wrangler d1 execute honc-d1-database --local --command='SELECT 1'",
     "db:generate": "drizzle-kit generate",
     "db:migrate": "wrangler d1 migrations apply honc-d1-database --local",
-    "db:migrate:prod": "ENVIROMENT=production drizzle-kit migrate",
+    "db:migrate:prod": "ENVIRONMENT=production drizzle-kit migrate",
     "db:seed": "tsx seed.ts",
+    "db:seed:prod": "ENVIRONMENT=production tsx seed.ts",
     "db:setup": "npm run db:touch && npm run db:generate && npm run db:migrate && npm run db:seed",
     "db:studio": "drizzle-kit studio",
     "fiberplane": "npx @fiberplane/studio@latest"
diff --git a/templates/d1/seed.ts b/templates/d1/seed.ts
@@ -1,22 +1,38 @@
 import { createClient } from "@libsql/client";
 import { drizzle } from "drizzle-orm/libsql";
+import {
+  type AsyncBatchRemoteCallback,
+  type AsyncRemoteCallback,
+  drizzle as drizzleSQLiteProxy,
+  type SqliteRemoteDatabase,
+} from "drizzle-orm/sqlite-proxy";
 import { seed } from "drizzle-seed";
+
 import * as schema from "./src/db/schema";
 import path from "node:path";
 import fs from "node:fs";
+import { config } from "dotenv";
+
+// biome-ignore lint/suspicious/noExplicitAny: Centralize usage of `any` type, since we use it in db results that are not worth the pain of typing
+type Any = any;
+
+seedDatabase();
+
+async function seedDatabase() {
+  const isProd = process.env.ENVIRONMENT === "production";
+  const db = isProd ? await getProductionDatabase() : getLocalD1Db();
+
+  if (isProd) {
+    console.warn("🚨 Seeding production database");
+  }
 
-const seedDatabase = async () => {
-  const pathToDb = getLocalD1DB();
-  const client = createClient({
-    url: `file:${pathToDb}`,
-  });
-  const db = drizzle(client);
-  
   try {
     // Read more about seeding here: https://orm.drizzle.team/docs/seed-overview#drizzle-seed
     await seed(db, schema);
     console.log("✅ Database seeded successfully!");
-    console.log("🪿 Run `npm run fiberplane` to explore data with your api.");
+    if (!isProd) {
+      console.log("🪿 Run `npm run fiberplane` to explore data with your api.");
+    }
   } catch (error) {
     console.error("❌ Error seeding database:", error);
     process.exit(1);
@@ -25,7 +41,31 @@ const seedDatabase = async () => {
   }
 };
 
-function getLocalD1DB() {
+/**
+ * Creates a connection to the local D1 database and returns a Drizzle ORM instance.
+ *
+ * Relies on `getLocalD1DBPath` to find the path to the local D1 database inside the `.wrangler` directory.
+ */
+function getLocalD1Db() {
+  const pathToDb = getLocalD1DBPath();
+  if (!pathToDb) {
+    console.error(
+      "⚠️ Local D1 database not found. Try running `npm run db:touch` to create one.",
+    );
+    process.exit(1);
+  }
+
+  const client = createClient({
+    url: `file:${pathToDb}`,
+  });
+  const db = drizzle(client);
+  return db;
+}
+
+/**
+ * Finds the path to the local D1 database inside the `.wrangler` directory.
+ */
+function getLocalD1DBPath() {
   try {
     const basePath = path.resolve(".wrangler");
     const files = fs
@@ -56,4 +96,135 @@ function getLocalD1DB() {
   }
 }
 
-seedDatabase();
+/**
+ * Creates a connection to the production Cloudflare D1 database and returns a Drizzle ORM instance.
+ * Loads production environment variables from .prod.vars file.
+ *
+ * @returns {Promise<SqliteRemoteDatabase>} Drizzle ORM instance connected to production database
+ * @throws {Error} If required environment variables are not set
+ */
+async function getProductionDatabase(): Promise<
+  SqliteRemoteDatabase<Record<string, never>>
+> {
+  config({ path: ".prod.vars" });
+
+  const apiToken = process.env.CLOUDFLARE_D1_TOKEN;
+  const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
+  const databaseId = process.env.CLOUDFLARE_DATABASE_ID;
+
+  if (!apiToken || !accountId || !databaseId) {
+    console.error(
+      "Database seed failed: production environment variables not set (make sure you have a .prod.vars file)",
+    );
+    process.exit(1);
+  }
+
+  return createProductionD1Connection(accountId, databaseId, apiToken);
+}
+
+/**
+ * Creates a connection to a remote Cloudflare D1 database using the sqlite-proxy driver.
+ * @param accountId - Cloudflare account ID
+ * @param databaseId - D1 database ID
+ * @param apiToken - Cloudflare API token with write access to D1
+ * @returns Drizzle ORM instance connected to remote database
+ */
+export function createProductionD1Connection(
+  accountId: string,
+  databaseId: string,
+  apiToken: string,
+) {
+  /**
+   * Executes a single query against the Cloudflare D1 HTTP API.
+   *
+   * @param accountId - Cloudflare account ID
+   * @param databaseId - D1 database ID
+   * @param apiToken - Cloudflare API token with write access to D1
+   * @param sql - The SQL statement to execute
+   * @param params - Parameters for the SQL statement
+   * @param method - The method type for the SQL operation
+   * @returns The result rows from the query
+   * @throws If the HTTP request fails or returns an error
+   */
+  async function executeCloudflareD1Query(
+    accountId: string,
+    databaseId: string,
+    apiToken: string,
+    sql: string,
+    params: Any[],
+    method: string,
+  ): Promise<{ rows: Any[][] }> {
+    const url = `https://api.cloudflare.com/client/v4/accounts/${accountId}/d1/database/${databaseId}/query`;
+
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ sql, params, method }),
+    });
+
+    const data: Any = await res.json();
+
+    if (res.status !== 200) {
+      throw new Error(
+        `Error from sqlite proxy server: ${res.status} ${res.statusText}\n${JSON.stringify(data)}`,
+      );
+    }
+
+    if (data.errors.length > 0 || !data.success) {
+      throw new Error(
+        `Error from sqlite proxy server: \n${JSON.stringify(data)}}`,
+      );
+    }
+
+    const qResult = data?.result?.[0];
+
+    if (!qResult?.success) {
+      throw new Error(
+        `Error from sqlite proxy server: \n${JSON.stringify(data)}`,
+      );
+    }
+
+    return { rows: qResult.results.map((r: Any) => Object.values(r)) };
+  }
+
+  /**
+   * Asynchronously executes a single query.
+   */
+  const queryClient: AsyncRemoteCallback = async (sql, params, method) => {
+    return executeCloudflareD1Query(
+      accountId,
+      databaseId,
+      apiToken,
+      sql,
+      params,
+      method,
+    );
+  };
+
+  /**
+   * Asynchronously executes a batch of queries.
+   */
+  const batchQueryClient: AsyncBatchRemoteCallback = async (queries) => {
+    const results: { rows: Any[][] }[] = [];
+
+    for (const query of queries) {
+      const { sql, params, method } = query;
+      const result = await executeCloudflareD1Query(
+        accountId,
+        databaseId,
+        apiToken,
+        sql,
+        params,
+        method,
+      );
+      results.push(result);
+    }
+
+    return results;
+  };
+
+  return drizzleSQLiteProxy(queryClient, batchQueryClient);
+}
