@ereo/db-drizzle 0.1.6

package/dist/index.js

@@ -0,0 +1,653 @@
+// @bun
+var __require = import.meta.require;
+
+// src/adapter.ts
+import {
+  dedupQuery,
+  clearDedupCache,
+  invalidateTables,
+  getRequestDedupStats,
+  ConnectionError,
+  QueryError,
+  TransactionError
+} from "@ereo/db";
+
+// src/types.ts
+var EDGE_COMPATIBLE_DRIVERS = {
+  "postgres-js": false,
+  "neon-http": true,
+  "neon-websocket": true,
+  planetscale: true,
+  libsql: true,
+  "bun-sqlite": false,
+  "better-sqlite3": false,
+  d1: true
+};
+
+// src/adapter.ts
+class DrizzleAdapter {
+  name;
+  edgeCompatible;
+  client = null;
+  rawConnection = null;
+  config;
+  isConnected = false;
+  constructor(config) {
+    this.config = config;
+    this.name = `drizzle-${config.driver}`;
+    this.edgeCompatible = config.edgeCompatible ?? EDGE_COMPATIBLE_DRIVERS[config.driver];
+  }
+  async connect() {
+    if (this.isConnected && this.client) {
+      return;
+    }
+    try {
+      const result = await createDrizzleClient(this.config);
+      this.client = result.client;
+      this.rawConnection = result.connection;
+      this.isConnected = true;
+      if (this.config.debug) {
+        console.log(`[${this.name}] Connected to database`);
+      }
+    } catch (error) {
+      throw new ConnectionError(`Failed to connect to database: ${error instanceof Error ? error.message : error}`, error instanceof Error ? error : undefined);
+    }
+  }
+  getClient() {
+    if (!this.client) {
+      throw new ConnectionError("Database not connected. Call connect() first or use the plugin which handles this automatically.");
+    }
+    return this.client;
+  }
+  getRequestClient(context) {
+    const client = this.getClient();
+    const adapter = this;
+    return {
+      get client() {
+        return client;
+      },
+      async query(sql, params) {
+        return dedupQuery(context, sql, params, async () => adapter.query(sql, params));
+      },
+      getDedupStats() {
+        return getRequestDedupStats(context);
+      },
+      clearDedup() {
+        clearDedupCache(context);
+      },
+      invalidate(tables) {
+        if (tables) {
+          invalidateTables(context, tables);
+        } else {
+          clearDedupCache(context);
+        }
+      }
+    };
+  }
+  async query(sql, params) {
+    await this.connect();
+    try {
+      const result = await executeRawQuery(this.rawConnection, this.config.driver, sql, params);
+      return {
+        rows: result,
+        rowCount: Array.isArray(result) ? result.length : 0
+      };
+    } catch (error) {
+      throw new QueryError(`Query failed: ${error instanceof Error ? error.message : error}`, sql, params, error instanceof Error ? error : undefined);
+    }
+  }
+  async execute(sql, params) {
+    await this.connect();
+    try {
+      const result = await executeRawMutation(this.rawConnection, this.config.driver, sql, params);
+      return result;
+    } catch (error) {
+      throw new QueryError(`Execute failed: ${error instanceof Error ? error.message : error}`, sql, params, error instanceof Error ? error : undefined);
+    }
+  }
+  async transaction(fn, _options) {
+    await this.connect();
+    try {
+      const result = await executeTransaction(this.client, this.config.driver, fn);
+      return result;
+    } catch (error) {
+      throw new TransactionError(`Transaction failed: ${error instanceof Error ? error.message : error}`, error instanceof Error ? error : undefined);
+    }
+  }
+  async beginTransaction(_options) {
+    await this.connect();
+    let isActive = true;
+    let resolveTransaction = null;
+    let rejectTransaction = null;
+    const transactionPromise = new Promise((resolve, reject) => {
+      resolveTransaction = resolve;
+      rejectTransaction = reject;
+    });
+    let transactionClient = null;
+    executeTransaction(this.client, this.config.driver, async (tx) => {
+      transactionClient = tx;
+      return transactionPromise;
+    }).catch(rejectTransaction);
+    return {
+      get client() {
+        if (!transactionClient) {
+          throw new TransactionError("Transaction not yet started");
+        }
+        return transactionClient;
+      },
+      async commit() {
+        if (!isActive) {
+          throw new TransactionError("Transaction is not active");
+        }
+        isActive = false;
+        resolveTransaction?.(undefined);
+      },
+      async rollback() {
+        if (!isActive) {
+          throw new TransactionError("Transaction is not active");
+        }
+        isActive = false;
+        rejectTransaction?.(new Error("Transaction rolled back"));
+      },
+      get isActive() {
+        return isActive;
+      }
+    };
+  }
+  async healthCheck() {
+    const start = Date.now();
+    try {
+      await this.connect();
+      const testQuery = getHealthCheckQuery(this.config.driver);
+      await this.query(testQuery);
+      return {
+        healthy: true,
+        latencyMs: Date.now() - start,
+        metadata: {
+          driver: this.config.driver,
+          edgeCompatible: this.edgeCompatible
+        }
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        latencyMs: Date.now() - start,
+        error: error instanceof Error ? error.message : String(error),
+        metadata: {
+          driver: this.config.driver
+        }
+      };
+    }
+  }
+  async disconnect() {
+    if (!this.isConnected) {
+      return;
+    }
+    try {
+      await closeConnection(this.rawConnection, this.config.driver);
+      this.client = null;
+      this.rawConnection = null;
+      this.isConnected = false;
+      if (this.config.debug) {
+        console.log(`[${this.name}] Disconnected from database`);
+      }
+    } catch (error) {
+      console.error(`[${this.name}] Error during disconnect:`, error);
+    }
+  }
+}
+function createDrizzleAdapter(config) {
+  return new DrizzleAdapter(config);
+}
+async function createDrizzleClient(config) {
+  switch (config.driver) {
+    case "postgres-js":
+      return createPostgresClient(config);
+    case "neon-http":
+      return createNeonHttpClient(config);
+    case "neon-websocket":
+      return createNeonWebSocketClient(config);
+    case "planetscale":
+      return createPlanetScaleClient(config);
+    case "libsql":
+      return createLibSQLClient(config);
+    case "bun-sqlite":
+      return createBunSQLiteClient(config);
+    case "better-sqlite3":
+      return createBetterSQLite3Client(config);
+    case "d1":
+      return createD1Client(config);
+    default:
+      throw new Error(`Unsupported driver: ${config.driver}`);
+  }
+}
+async function createPostgresClient(config) {
+  const postgres = await import("postgres");
+  const drizzleModule = await import("drizzle-orm/postgres-js");
+  const connection = postgres.default(config.url, {
+    ssl: config.connection?.ssl,
+    max: config.connection?.max ?? 10,
+    idle_timeout: config.connection?.idle_timeout ?? 20,
+    connect_timeout: config.connection?.connect_timeout ?? 10,
+    prepare: config.connection?.prepare ?? true
+  });
+  const client = drizzleModule.drizzle(connection, {
+    schema: config.schema,
+    logger: config.logger
+  });
+  return { client, connection };
+}
+async function createNeonHttpClient(config) {
+  const neonModule = await import("@neondatabase/serverless");
+  const drizzleModule = await import("drizzle-orm/neon-http");
+  const connection = neonModule.neon(config.url, config.neon);
+  const client = drizzleModule.drizzle(connection, {
+    schema: config.schema,
+    logger: config.logger
+  });
+  return { client, connection };
+}
+async function createNeonWebSocketClient(config) {
+  const neonModule = await import("@neondatabase/serverless");
+  const drizzleModule = await import("drizzle-orm/neon-serverless");
+  const connection = new neonModule.Pool({ connectionString: config.url });
+  const client = drizzleModule.drizzle(connection, {
+    schema: config.schema,
+    logger: config.logger
+  });
+  return { client, connection };
+}
+async function createPlanetScaleClient(config) {
+  const psModule = await import("@planetscale/database");
+  const drizzleModule = await import("drizzle-orm/planetscale-serverless");
+  const connection = new psModule.Client({
+    url: config.url,
+    fetch: config.planetscale?.fetch
+  });
+  const client = drizzleModule.drizzle(connection, {
+    schema: config.schema,
+    logger: config.logger
+  });
+  return { client, connection };
+}
+async function createLibSQLClient(config) {
+  const libsqlModule = await import("@libsql/client");
+  const drizzleModule = await import("drizzle-orm/libsql");
+  const connection = libsqlModule.createClient({
+    url: config.url,
+    authToken: config.authToken,
+    syncUrl: config.syncUrl
+  });
+  const client = drizzleModule.drizzle(connection, {
+    schema: config.schema,
+    logger: config.logger
+  });
+  return { client, connection };
+}
+async function createBunSQLiteClient(config) {
+  const sqliteModule = await import("bun:sqlite");
+  const drizzleModule = await import("drizzle-orm/bun-sqlite");
+  const connection = new sqliteModule.Database(config.url);
+  if (config.pragma) {
+    const { journal_mode, synchronous, foreign_keys, cache_size } = config.pragma;
+    if (journal_mode)
+      connection.exec(`PRAGMA journal_mode = ${journal_mode}`);
+    if (synchronous)
+      connection.exec(`PRAGMA synchronous = ${synchronous}`);
+    if (foreign_keys !== undefined)
+      connection.exec(`PRAGMA foreign_keys = ${foreign_keys ? "ON" : "OFF"}`);
+    if (cache_size)
+      connection.exec(`PRAGMA cache_size = ${cache_size}`);
+  }
+  const client = drizzleModule.drizzle(connection, {
+    schema: config.schema,
+    logger: config.logger
+  });
+  return { client, connection };
+}
+async function createBetterSQLite3Client(config) {
+  const Database = await import("better-sqlite3");
+  const drizzleModule = await import("drizzle-orm/better-sqlite3");
+  const connection = new Database.default(config.url, config.options);
+  const client = drizzleModule.drizzle(connection, {
+    schema: config.schema,
+    logger: config.logger
+  });
+  return { client, connection };
+}
+async function createD1Client(config) {
+  const drizzleModule = await import("drizzle-orm/d1");
+  if (!config.d1) {
+    throw new Error("D1 database binding is required for d1 driver");
+  }
+  const client = drizzleModule.drizzle(config.d1, {
+    schema: config.schema,
+    logger: config.logger
+  });
+  return { client, connection: config.d1 };
+}
+async function executeRawQuery(connection, driver, sql, params) {
+  const conn = connection;
+  switch (driver) {
+    case "postgres-js": {
+      return conn.unsafe(sql, params ?? []);
+    }
+    case "neon-http": {
+      return conn(sql, params ?? []);
+    }
+    case "neon-websocket": {
+      const result = await conn.query(sql, params ?? []);
+      return result.rows;
+    }
+    case "planetscale": {
+      const result = await conn.execute(sql, params ?? []);
+      return result.rows;
+    }
+    case "libsql": {
+      const result = await conn.execute({ sql, args: params ?? [] });
+      return result.rows;
+    }
+    case "bun-sqlite": {
+      const stmt = conn.prepare(sql);
+      return stmt.all(...params ?? []);
+    }
+    case "better-sqlite3": {
+      const stmt = conn.prepare(sql);
+      return stmt.all(...params ?? []);
+    }
+    case "d1": {
+      const stmt = conn.prepare(sql);
+      const bound = params ? stmt.bind(...params) : stmt;
+      const result = await bound.all();
+      return result.results ?? [];
+    }
+    default:
+      throw new Error(`Raw query not supported for driver: ${driver}`);
+  }
+}
+async function executeRawMutation(connection, driver, sql, params) {
+  const conn = connection;
+  switch (driver) {
+    case "postgres-js": {
+      const result = await conn.unsafe(sql, params ?? []);
+      return { rowsAffected: result.count ?? 0 };
+    }
+    case "neon-http": {
+      await conn(sql, params ?? []);
+      return { rowsAffected: 0 };
+    }
+    case "neon-websocket": {
+      const result = await conn.query(sql, params ?? []);
+      return { rowsAffected: result.rowCount ?? 0 };
+    }
+    case "planetscale": {
+      const result = await conn.execute(sql, params ?? []);
+      return {
+        rowsAffected: result.rowsAffected ?? 0,
+        lastInsertId: result.insertId ? BigInt(result.insertId) : undefined
+      };
+    }
+    case "libsql": {
+      const result = await conn.execute({ sql, args: params ?? [] });
+      return {
+        rowsAffected: result.rowsAffected,
+        lastInsertId: result.lastInsertRowid
+      };
+    }
+    case "bun-sqlite": {
+      const stmt = conn.prepare(sql);
+      const result = stmt.run(...params ?? []);
+      return {
+        rowsAffected: result.changes,
+        lastInsertId: result.lastInsertRowid
+      };
+    }
+    case "better-sqlite3": {
+      const stmt = conn.prepare(sql);
+      const result = stmt.run(...params ?? []);
+      return {
+        rowsAffected: result.changes,
+        lastInsertId: BigInt(result.lastInsertRowid)
+      };
+    }
+    case "d1": {
+      const stmt = conn.prepare(sql);
+      const bound = params ? stmt.bind(...params) : stmt;
+      const result = await bound.run();
+      return {
+        rowsAffected: result.meta.changes ?? 0,
+        lastInsertId: result.meta.last_row_id
+      };
+    }
+    default:
+      throw new Error(`Raw mutation not supported for driver: ${driver}`);
+  }
+}
+async function executeTransaction(client, driver, fn) {
+  const db = client;
+  if (typeof db.transaction === "function") {
+    return db.transaction(fn);
+  }
+  if (driver === "bun-sqlite" || driver === "better-sqlite3") {
+    throw new TransactionError(`Transaction support for ${driver} requires using the Drizzle client directly`);
+  }
+  throw new TransactionError(`Transaction not supported for driver: ${driver}`);
+}
+async function closeConnection(connection, driver) {
+  const conn = connection;
+  switch (driver) {
+    case "postgres-js": {
+      await conn.end();
+      break;
+    }
+    case "neon-websocket": {
+      await conn.end();
+      break;
+    }
+    case "libsql": {
+      conn.close();
+      break;
+    }
+    case "bun-sqlite": {
+      conn.close();
+      break;
+    }
+    case "better-sqlite3": {
+      conn.close();
+      break;
+    }
+    case "neon-http":
+    case "planetscale":
+    case "d1":
+      break;
+  }
+}
+function getHealthCheckQuery(driver) {
+  switch (driver) {
+    case "postgres-js":
+    case "neon-http":
+    case "neon-websocket":
+      return "SELECT 1";
+    case "planetscale":
+      return "SELECT 1";
+    case "libsql":
+    case "bun-sqlite":
+    case "better-sqlite3":
+    case "d1":
+      return "SELECT 1";
+    default:
+      return "SELECT 1";
+  }
+}
+// src/config.ts
+function defineDrizzleConfig(config) {
+  return config;
+}
+function definePostgresConfig(config) {
+  return {
+    driver: "postgres-js",
+    connection: {
+      ssl: "require",
+      max: 10,
+      idle_timeout: 20,
+      connect_timeout: 10,
+      prepare: true
+    },
+    ...config
+  };
+}
+function defineNeonHttpConfig(config) {
+  return {
+    driver: "neon-http",
+    edgeCompatible: true,
+    ...config
+  };
+}
+function defineNeonWebSocketConfig(config) {
+  return {
+    driver: "neon-websocket",
+    edgeCompatible: true,
+    pool: {
+      max: 5,
+      idleTimeoutMs: 1e4
+    },
+    ...config
+  };
+}
+function definePlanetScaleConfig(config) {
+  return {
+    driver: "planetscale",
+    edgeCompatible: true,
+    ...config
+  };
+}
+function defineLibSQLConfig(config) {
+  return {
+    driver: "libsql",
+    edgeCompatible: true,
+    ...config
+  };
+}
+function defineBunSQLiteConfig(config) {
+  return {
+    driver: "bun-sqlite",
+    edgeCompatible: false,
+    pragma: {
+      journal_mode: "WAL",
+      synchronous: "NORMAL",
+      foreign_keys: true,
+      cache_size: 1e4
+    },
+    ...config
+  };
+}
+function defineBetterSQLite3Config(config) {
+  return {
+    driver: "better-sqlite3",
+    edgeCompatible: false,
+    ...config
+  };
+}
+function defineD1Config(config) {
+  return {
+    driver: "d1",
+    edgeCompatible: true,
+    ...config
+  };
+}
+function defineEdgeConfig(options) {
+  const { driver, url, schema, authToken, debug } = options;
+  const baseConfig = {
+    url,
+    schema,
+    debug,
+    edgeCompatible: true
+  };
+  switch (driver) {
+    case "neon-http":
+      return defineNeonHttpConfig(baseConfig);
+    case "neon-websocket":
+      return defineNeonWebSocketConfig(baseConfig);
+    case "planetscale":
+      return definePlanetScaleConfig(baseConfig);
+    case "libsql":
+      return defineLibSQLConfig({
+        ...baseConfig,
+        authToken
+      });
+    case "d1":
+      return defineD1Config(baseConfig);
+    default:
+      throw new Error(`Unknown edge driver: ${driver}`);
+  }
+}
+function detectRuntime() {
+  if (typeof globalThis !== "undefined" && "Bun" in globalThis) {
+    return "bun";
+  }
+  if (typeof globalThis !== "undefined" && "Deno" in globalThis) {
+    return "deno";
+  }
+  if (typeof globalThis !== "undefined" && "caches" in globalThis && typeof globalThis.caches?.default !== "undefined") {
+    return "cloudflare-workers";
+  }
+  if (typeof process !== "undefined" && process.env?.VERCEL_EDGE === "1") {
+    return "vercel-edge";
+  }
+  if (typeof process !== "undefined" && process.versions?.node) {
+    return "node";
+  }
+  return "unknown";
+}
+function isEdgeRuntime() {
+  const runtime = detectRuntime();
+  return runtime === "cloudflare-workers" || runtime === "vercel-edge";
+}
+function suggestDrivers() {
+  const runtime = detectRuntime();
+  switch (runtime) {
+    case "bun":
+      return ["bun-sqlite", "postgres-js", "libsql"];
+    case "node":
+      return ["better-sqlite3", "postgres-js", "libsql"];
+    case "cloudflare-workers":
+      return ["d1", "neon-http", "planetscale"];
+    case "vercel-edge":
+      return ["neon-http", "planetscale", "libsql"];
+    case "deno":
+      return ["postgres-js", "libsql"];
+    default:
+      return ["neon-http", "postgres-js"];
+  }
+}
+
+// src/index.ts
+import {
+  createDatabasePlugin,
+  useDb,
+  useAdapter,
+  getDb,
+  withTransaction
+} from "@ereo/db";
+export {
+  withTransaction,
+  useDb,
+  useAdapter,
+  suggestDrivers,
+  isEdgeRuntime,
+  getDb,
+  detectRuntime,
+  definePostgresConfig,
+  definePlanetScaleConfig,
+  defineNeonWebSocketConfig,
+  defineNeonHttpConfig,
+  defineLibSQLConfig,
+  defineEdgeConfig,
+  defineDrizzleConfig,
+  defineD1Config,
+  defineBunSQLiteConfig,
+  defineBetterSQLite3Config,
+  createDrizzleAdapter,
+  createDatabasePlugin,
+  EDGE_COMPATIBLE_DRIVERS
+};