feat: make Better Auth Drizzle-native

Author: yyx990803

packages/void/src/auth/drizzle.ts

@@ -1,11 +1,11 @@
 import { join } from "node:path";
 import { loadEnv } from "vite";
-import { getMigrations } from "better-auth/db/migration";
-import pg from "pg";
 import { readConfig } from "../config";
 import { getMiniflareDatabasePath } from "../migrations/runner";
+import { applyPgAuthMigrations, applySqliteAuthMigrations } from "../runtime/auth-migrations";
 import { findVoidAuthConfig, loadVoidAuthConfig } from "./config";
 import type { VoidAuthDialect, VoidAuthEnv } from "../runtime/better-auth-shared";
+import { resolveVoidAuthMigrationSchema } from "./drizzle";
 
 export async function runLocalVoidAuthMigrations(
   root: string,
@@ -20,19 +20,25 @@ export async function runLocalVoidAuthMigrations(
     providers: readConfig(root).auth?.providers ?? null,
     userConfig: authConfig,
   };
-
   const env = loadEnv("development", root, "") as unknown as VoidAuthEnv;
-  const request = new Request("http://localhost/api/auth");
+  const migrationSchema = resolveVoidAuthMigrationSchema(runtime, env);
 
   if (dialect === "sqlite") {
     const { DatabaseSync } = await import("node:sqlite");
-    const { resolveVoidAuthOptions } = await import("../runtime/better-auth");
     const dbPath = getMiniflareDatabasePath(persistRoot, databaseId);
     const db = new DatabaseSync(dbPath);
     try {
-      const { options } = await resolveVoidAuthOptions(request, env, runtime, db as any);
-      const { runMigrations } = await getMigrations(options);
-      await runMigrations();
+      await applySqliteAuthMigrations(
+        {
+          async all<T extends Record<string, unknown>>(sql: string) {
+            return db.prepare(sql).all() as T[];
+          },
+          async run(sql: string) {
+            db.prepare(sql).run();
+          },
+        },
+        migrationSchema,
+      );
     } finally {
       db.close();
     }
@@ -45,13 +51,23 @@ export async function runLocalVoidAuthMigrations(
       : undefined;
   if (!connectionString) return;
 
-  const { resolveVoidAuthOptions } = await import("../runtime/better-auth-pg");
-  const pool = new pg.Pool({ connectionString, max: 1 });
+  const { Client } = await import("pg");
+  const client = new Client({ connectionString });
+  await client.connect();
   try {
-    const { options } = await resolveVoidAuthOptions(request, env, runtime, pool as any);
-    const { runMigrations } = await getMigrations(options);
-    await runMigrations();
+    await applyPgAuthMigrations(
+      {
+        async all<T extends Record<string, unknown>>(sql: string, params?: unknown[]) {
+          const result = await client.query(sql, params);
+          return result.rows as T[];
+        },
+        async run(sql: string, params?: unknown[]) {
+          await client.query(sql, params);
+        },
+      },
+      migrationSchema,
+    );
   } finally {
-    await pool.end();
+    await client.end();
   }
 }

packages/void/src/auth/node.ts

@@ -502,7 +502,7 @@ async function runModel(root: string, name: string, columns: ColumnSpec[]): Prom
   }
 
   // 3. Regenerate .void/tsconfig.json and db.d.ts
-  ensureProjectTsconfig(root, undefined, true);
+  ensureProjectTsconfig(root, undefined, true, true);
 
   log.success(`Created ${relative(root, modelPath)}`);
   log.success(`Updated ${relative(root, barrelPath)}`);

packages/void/src/cli/gen.ts

@@ -790,7 +790,7 @@ export const GET = defineHandler(async () => {
 `,
   );
   log.success("Created routes/api/posts.ts");
-  ensureProjectTsconfig(root, undefined, true);
+  ensureProjectTsconfig(root, undefined, true, true);
 
   // Frontend demo
   mkdirSync(join(root, "src"), { recursive: true });
@@ -1045,7 +1045,8 @@ export async function runInitCommand(root: string, initArgs?: InitArgs): Promise
 
   // Generate .void/tsconfig.json so the root tsconfig can extend it
   if (state.typescriptWanted) {
-    ensureProjectTsconfig(root, undefined, hasDrizzleSchema(root));
+    const hasSchema = hasDrizzleSchema(root);
+    ensureProjectTsconfig(root, undefined, hasSchema, hasSchema);
   }
 
   // Step 2: Wrangler config (class B/C meta-frameworks)

packages/void/src/cli/init.ts

@@ -14,37 +14,41 @@ import { join } from "node:path";
 export function ensureProjectTsconfig(
   root: string,
   hasRouteTypes?: boolean,
-  hasDrizzle?: boolean,
+  hasDb?: boolean,
+  hasSchema?: boolean,
 ): void {
   const outDir = join(root, ".void");
   mkdirSync(outDir, { recursive: true });
   const includeRoutes = hasRouteTypes ?? existsSync(join(root, "routes"));
   const includeQueues = existsSync(join(root, "queues"));
   const files = [
     ...(includeRoutes ? ["routes.d.ts"] : []),
-    ...(hasDrizzle ? ["db.d.ts"] : []),
+    ...(hasDb ? ["db.d.ts"] : []),
     ...(includeQueues ? ["queues.d.ts"] : []),
   ];
 
   const tsconfig: Record<string, unknown> = { files };
 
-  if (hasDrizzle) {
-    // Determine whether schema is a file or directory
-    const isDir =
-      existsSync(join(root, "db", "schema")) && !existsSync(join(root, "db", "schema.ts"));
-
-    // Paths are relative to .void/ (where this tsconfig lives), so use ../
-    tsconfig.compilerOptions = {
-      paths: {
-        "@schema": isDir ? ["../db/schema/index.ts"] : ["../db/schema.ts"],
-        "@schema/*": ["../db/schema/*"],
-        // Redirect void/db to the generated db.d.ts so TypeScript uses
-        // schema-aware types instead of the generic base module.
-        // (moduleResolution: "bundler" ignores ambient `declare module`
-        // when the module resolves to a real file — paths is the fix.)
-        "void/db": ["./db.d.ts"],
-      },
+  if (hasDb) {
+    const paths: Record<string, string[]> = {
+      // Redirect void/db to the generated db.d.ts so TypeScript uses
+      // schema-aware types instead of the generic base module.
+      // (moduleResolution: "bundler" ignores ambient `declare module`
+      // when the module resolves to a real file — paths is the fix.)
+      "void/db": ["./db.d.ts"],
     };
+
+    if (hasSchema) {
+      // Determine whether schema is a file or directory
+      const isDir =
+        existsSync(join(root, "db", "schema")) && !existsSync(join(root, "db", "schema.ts"));
+
+      // Paths are relative to .void/ (where this tsconfig lives), so use ../
+      paths["@schema"] = [isDir ? "../db/schema/index.ts" : "../db/schema.ts"];
+      paths["@schema/*"] = ["../db/schema/*"];
+    }
+
+    tsconfig.compilerOptions = { paths };
   }
 
   writeFileSync(join(outDir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n");

packages/void/src/codegen/project-tsconfig.ts

@@ -398,7 +398,7 @@ export function voidPlugin(options?: {
       wranglerSyncPlugin,
       svelteKitHooksInjectPlugin,
       clientStubsPlugin,
-      drizzlePlugin(root, false, dialect),
+      drizzlePlugin(root, false, dialect, { forceVirtualDb: authEnabled }),
       migrationPlugin(root, dialect, "local", frameworkPersistRoot, {
         enabled: false,
       }),
@@ -752,7 +752,7 @@ export function voidPlugin(options?: {
       bindingWatchPlugin,
       envPlugin,
       clientStubsPlugin,
-      drizzlePlugin(root, false, getDatabaseDialect(config)),
+      drizzlePlugin(root, false, getDatabaseDialect(config), { forceVirtualDb: authEnabled }),
       migrationPlugin(root, getDatabaseDialect(config)),
       ...(vinextCompat ? [vinextCompat] : []),
       ...cloudflare({
@@ -855,7 +855,7 @@ export function voidPlugin(options?: {
       prerenderPaths: config.routing?.prerender,
       remoteMode,
     }),
-    drizzlePlugin(root, true, dialect),
+    drizzlePlugin(root, true, dialect, { forceVirtualDb: authEnabled }),
     migrationPlugin(root, dialect, "local", join(root, ".void"), {
       enabled: authEnabled,
       configPath: authConfigPath,

packages/void/src/index.ts

@@ -19,29 +19,36 @@ const VIRTUAL_SCHEMA_DB_ID = "\0virtual:void-db-schema";
 const DRIZZLE_OPERATORS =
   "sql, eq, ne, gt, gte, lt, lte, and, or, not, desc, asc, like, ilike, notLike, inArray, notInArray, isNull, isNotNull, between, notBetween, exists, notExists, count, sum, avg, min, max";
 
+interface DrizzlePluginOptions {
+  forceVirtualDb?: boolean;
+}
+
 /**
  * Vite plugin for Drizzle integration.
  *
  * - Intercepts `void/db` imports in SSR/worker environments and serves
- *   a virtual module that creates a Drizzle D1 instance with the user's schema.
+ *   a virtual module that creates a Drizzle DB instance, using the user's
+ *   schema when present.
  * - Generates `.void/db.d.ts` with proper Drizzle types.
- * - Sets up `@schema` Vite alias for convenient imports.
+ * - Sets up `@schema` Vite alias for convenient imports when a schema exists.
  * - Updates `.void/tsconfig.json` with TypeScript paths.
  */
 export function drizzlePlugin(
   root: string,
   hasRouteTypes: boolean,
   dialect: "sqlite" | "postgresql" = "sqlite",
+  options: DrizzlePluginOptions = {},
 ): Plugin {
   const outDir = join(root, ".void");
   const schema = discoverSchema(root);
+  const hasDbRuntime = schema != null || options.forceVirtualDb === true;
 
   // Always write tsconfig (for routes.d.ts, queues.d.ts, etc.)
-  ensureProjectTsconfig(root, hasRouteTypes, schema != null);
+  ensureProjectTsconfig(root, hasRouteTypes, hasDbRuntime, schema != null);
 
-  // Generate db.d.ts if schema exists
-  if (schema) {
-    generateDbDts(outDir, schema, dialect);
+  // Generate db.d.ts when void/db is available, even without a user schema.
+  if (hasDbRuntime) {
+    generateDbDts(outDir, schema ?? null, dialect);
   }
 
   let isBuild = false;
@@ -74,11 +81,11 @@ export function drizzlePlugin(
 
         // Only intercept void/db in server/worker environments (not client)
         if (id === "void/db" && this.environment?.name !== "client") {
-          if (!schema) return; // Fall through to the real module (stub)
+          if (!hasDbRuntime) return; // Fall through to the real module (stub)
           // Don't redirect schema files to avoid circular dependency
           // (virtual:void-db imports the schema, which imports void/db).
           // Schema files only need SQL helpers, not the runtime DB instance.
-          if (importer) {
+          if (schema && importer) {
             if (schema.type === "file" && importer === schema.path) return VIRTUAL_SCHEMA_DB_ID;
             if (schema.type === "directory" && importer.startsWith(schema.path)) {
               return VIRTUAL_SCHEMA_DB_ID;
@@ -112,14 +119,17 @@ export function createDb() {
         }
 
         // void/db virtual module
-        const schemaImport = JSON.stringify(schema!.path);
+        const schemaImport = schema
+          ? `import * as schema from ${JSON.stringify(schema.path)};`
+          : "";
+        const drizzleConfig = schema ? ", { schema }" : "";
 
         if (dialect === "postgresql") {
           return `
 import { drizzle } from ${JSON.stringify(drizzleNodePgResolved)};
 import pg from "pg";
 import { getRuntimeBinding } from ${JSON.stringify(envModuleResolved)};
-import * as schema from ${schemaImport};
+${schemaImport}
 export { ${DRIZZLE_OPERATORS} } from ${JSON.stringify(drizzleOrmResolved)};
 
 let _prodInstance;
@@ -137,10 +147,10 @@ function getInstance() {
   // workerd kills TCP sockets between requests, so pg.Pool's cached
   // connections go stale and hang. Fresh Pool = fresh connection every time.
   if (getRuntimeBinding("DATABASE_URL")) {
-    return drizzle(new pg.Pool({ connectionString: getRuntimeBinding("DATABASE_URL"), max: 1 }), { schema });
+    return drizzle(new pg.Pool({ connectionString: getRuntimeBinding("DATABASE_URL"), max: 1 })${drizzleConfig});
   }
   // Production (Hyperdrive): cache the instance — Hyperdrive handles pooling.
-  _prodInstance ??= drizzle(getConnectionString(), { schema });
+  _prodInstance ??= drizzle(getConnectionString()${drizzleConfig});
   return _prodInstance;
 }
 
@@ -151,7 +161,7 @@ export const db = new Proxy({}, {
 });
 
 export function createDb(connectionString) {
-  return drizzle(connectionString, { schema });
+  return drizzle(connectionString${drizzleConfig});
 }
 `;
         }
@@ -160,20 +170,20 @@ export function createDb(connectionString) {
         return `
 import { drizzle } from ${JSON.stringify(drizzleD1Resolved)};
 import { requireRuntimeBinding } from ${JSON.stringify(envModuleResolved)};
-import * as schema from ${schemaImport};
+${schemaImport}
 export { ${DRIZZLE_OPERATORS} } from ${JSON.stringify(drizzleOrmResolved)};
 
 let _instance;
 
 export const db = new Proxy({}, {
   get(_, prop) {
-    _instance ??= drizzle(requireRuntimeBinding("DB"), { schema });
+    _instance ??= drizzle(requireRuntimeBinding("DB")${drizzleConfig});
     return Reflect.get(_instance, prop);
   },
 });
 
 export function createDb(d1) {
-  return drizzle(d1, { schema });
+  return drizzle(d1${drizzleConfig});
 }
 `;
       },
@@ -221,36 +231,57 @@ export function createDb(d1) {
  */
 function generateDbDts(
   outDir: string,
-  _schema: SchemaLocation,
+  schema: SchemaLocation | null,
   dialect: "sqlite" | "postgresql",
 ): void {
   mkdirSync(outDir, { recursive: true });
 
   const lines =
     dialect === "postgresql"
-      ? [
-          "// Auto-generated by void — do not edit",
-          `import type { NodePgDatabase } from "void/_db-pg";`,
-          `import type * as schema from "@schema";`,
-          "type Schema = typeof schema;",
-          "export declare const db: NodePgDatabase<Schema>;",
-          "export declare function createDb(connectionString: string): NodePgDatabase<Schema>;",
-          `export { ${DRIZZLE_OPERATORS} } from "void/_db";`,
-          `export type { NodePgDatabase } from "void/_db-pg";`,
-          "",
-        ]
-      : [
-          "// Auto-generated by void — do not edit",
-          '/// <reference types="@cloudflare/workers-types" />',
-          `import type { DrizzleD1Database } from "void/_db";`,
-          `import type * as schema from "@schema";`,
-          "type Schema = typeof schema;",
-          "export declare const db: DrizzleD1Database<Schema>;",
-          "export declare function createDb(d1: D1Database): DrizzleD1Database<Schema>;",
-          `export { ${DRIZZLE_OPERATORS} } from "void/_db";`,
-          `export type { DrizzleD1Database } from "void/_db";`,
-          "",
-        ];
+      ? schema
+        ? [
+            "// Auto-generated by void — do not edit",
+            `import type { NodePgDatabase } from "void/_db-pg";`,
+            `import type * as schema from "@schema";`,
+            "type Schema = typeof schema;",
+            "export declare const db: NodePgDatabase<Schema>;",
+            "export declare function createDb(connectionString: string): NodePgDatabase<Schema>;",
+            `export { ${DRIZZLE_OPERATORS} } from "void/_db";`,
+            `export type { NodePgDatabase } from "void/_db-pg";`,
+            "",
+          ]
+        : [
+            "// Auto-generated by void — do not edit",
+            `import type { NodePgDatabase } from "void/_db-pg";`,
+            "export declare const db: NodePgDatabase<Record<string, never>>;",
+            "export declare function createDb(connectionString: string): NodePgDatabase<Record<string, never>>;",
+            `export { ${DRIZZLE_OPERATORS} } from "void/_db";`,
+            `export type { NodePgDatabase } from "void/_db-pg";`,
+            "",
+          ]
+      : schema
+        ? [
+            "// Auto-generated by void — do not edit",
+            '/// <reference types="@cloudflare/workers-types" />',
+            `import type { DrizzleD1Database } from "void/_db";`,
+            `import type * as schema from "@schema";`,
+            "type Schema = typeof schema;",
+            "export declare const db: DrizzleD1Database<Schema>;",
+            "export declare function createDb(d1: D1Database): DrizzleD1Database<Schema>;",
+            `export { ${DRIZZLE_OPERATORS} } from "void/_db";`,
+            `export type { DrizzleD1Database } from "void/_db";`,
+            "",
+          ]
+        : [
+            "// Auto-generated by void — do not edit",
+            '/// <reference types="@cloudflare/workers-types" />',
+            `import type { DrizzleD1Database } from "void/_db";`,
+            "export declare const db: DrizzleD1Database<Record<string, never>>;",
+            "export declare function createDb(d1: D1Database): DrizzleD1Database<Record<string, never>>;",
+            `export { ${DRIZZLE_OPERATORS} } from "void/_db";`,
+            `export type { DrizzleD1Database } from "void/_db";`,
+            "",
+          ];
 
   writeFileSync(join(outDir, "db.d.ts"), lines.join("\n"));
 }