feat(db): URL-based driver detection in createDb (postgres vs SQLite)

packages/db/src/index.ts

···
-import { drizzle } from "drizzle-orm/postgres-js";
+import { drizzle as drizzlePg } from "drizzle-orm/postgres-js";
+import { drizzle as drizzleSqlite } from "drizzle-orm/libsql";
+import { createClient } from "@libsql/client";
 import postgres from "postgres";
-import * as schema from "./schema.js";
+import * as pgSchema from "./schema.js";
+import * as sqliteSchema from "./schema.sqlite.js";
 
-export function createDb(databaseUrl: string) {
-  const client = postgres(databaseUrl);
-  return drizzle(client, { schema });
+/**
+ * Create a Drizzle database instance from a connection URL.
+ *
+ * URL prefix determines the driver:
+ *   postgres:// or postgresql://  →  postgres.js (PostgreSQL)
+ *   file:                         →  @libsql/client (SQLite file)
+ *   file::memory:                 →  @libsql/client (SQLite in-memory, tests)
+ *   libsql://                     →  @libsql/client (Turso cloud)
+ */
+export function createDb(databaseUrl: string): Database {
+  if (databaseUrl.startsWith("postgres")) {
+    return drizzlePg(postgres(databaseUrl), { schema: pgSchema }) as Database;
+  }
+  return drizzleSqlite(
+    createClient({ url: databaseUrl }),
+    { schema: sqliteSchema }
+  ) as unknown as Database;
 }
 
-export type Database = ReturnType<typeof createDb>;
+// Database type uses the Postgres schema as the TypeScript source of truth.
+// Both dialects produce compatible column names and TypeScript types,
+// so the cast is safe at the app layer.
+export type Database = ReturnType<typeof drizzlePg<typeof pgSchema>>;
 
-/**
- * Transaction type extracted from Drizzle's database instance.
- * Use this when you need to work with a transaction object directly.
- */
-export type Transaction = Parameters<Parameters<Database['transaction']>[0]>[0];
+export type Transaction = Parameters<Parameters<Database["transaction"]>[0]>[0];
 
-/**
- * Union type for functions that need to work with either the database
- * instance or an active transaction. This is useful for helper functions
- * that can be called both standalone and within a transaction context.
- *
- * Example:
- * ```typescript
- * async function getUser(id: string, dbOrTx: DbOrTransaction = db) {
- *   return dbOrTx.select().from(users).where(eq(users.id, id));
- * }
- *
- * // Can be called standalone
- * await getUser('123', db);
- *
- * // Or within a transaction
- * await db.transaction(async (tx) => {
- *   await getUser('123', tx);
- * });
- * ```
- */
 export type DbOrTransaction = Database | Transaction;
 
 export * from "./schema.js";