driftsql 1.0.12 → 1.0.14

package/dist/index.mjs

@@ -4,9 +4,314 @@ import ky from 'ky';
 import { createClient as createClient$1 } from '@libsql/client';
 import { createClient } from '@tursodatabase/serverless/compat';
 import * as mysql from 'mysql2/promise';
+import Database from 'better-sqlite3';
 import fs from 'node:fs/promises';
 
-const supportedDrivers = ["postgres", "postgresHTTP", "mysql", "libsql"];
+function hasTransactionSupport(driver) {
+  return "transaction" in driver && typeof driver.transaction === "function";
+}
+function hasPreparedStatementSupport(driver) {
+  return "prepare" in driver && typeof driver.prepare === "function";
+}
+class DatabaseError extends Error {
+  constructor(message, driverType, originalError) {
+    super(message);
+    this.driverType = driverType;
+    this.originalError = originalError;
+    this.name = "DatabaseError";
+  }
+}
+class QueryError extends DatabaseError {
+  constructor(driverType, sql, originalError) {
+    super(`Query failed: ${sql}`, driverType, originalError);
+    this.name = "QueryError";
+  }
+}
+class ConnectionError extends DatabaseError {
+  constructor(driverType, originalError) {
+    super(`Failed to connect to ${driverType}`, driverType, originalError);
+    this.name = "ConnectionError";
+  }
+}
+
+class PostgresDriver {
+  client;
+  constructor(config) {
+    try {
+      if (config.experimental?.http) {
+        this.client = new PostgresHTTPDriver(config.experimental.http);
+      } else {
+        this.client = postgres(config.connectionString || "");
+      }
+    } catch (error) {
+      throw new ConnectionError("postgres", error);
+    }
+  }
+  async query(sql, params) {
+    try {
+      if (this.client instanceof PostgresHTTPDriver) {
+        return await this.client.query(sql, params);
+      }
+      const result = await this.client.unsafe(sql, params || []);
+      return {
+        rows: result,
+        rowCount: Array.isArray(result) ? result.length : 0,
+        command: void 0
+      };
+    } catch (error) {
+      throw new QueryError("postgres", sql, error);
+    }
+  }
+  async transaction(callback) {
+    if (this.client instanceof PostgresHTTPDriver) {
+      throw new Error("Transactions not supported with HTTP driver");
+    }
+    const result = await this.client.begin(async (sql) => {
+      const transactionDriver = new PostgresDriver({ connectionString: "" });
+      transactionDriver.client = sql;
+      return await callback(transactionDriver);
+    });
+    return result;
+  }
+  async close() {
+    try {
+      if (this.client instanceof PostgresHTTPDriver) {
+        return await this.client.close();
+      }
+      await this.client.end();
+    } catch (error) {
+      console.error("Error closing Postgres client:", error);
+    }
+  }
+}
+class PostgresHTTPDriver {
+  httpClient;
+  constructor(config) {
+    this.httpClient = ky.create({
+      prefixUrl: config.url,
+      headers: {
+        Authorization: `Bearer ${config.apiKey || ""}`
+      }
+    });
+  }
+  async query(sql, params) {
+    try {
+      const response = await this.httpClient.post("query", {
+        json: { query: sql, params }
+      }).json();
+      return {
+        rows: response.rows,
+        rowCount: response.rowCount,
+        command: void 0
+      };
+    } catch (error) {
+      throw new QueryError("postgres-http", sql, error);
+    }
+  }
+  async close() {
+    return Promise.resolve();
+  }
+}
+
+class LibSQLDriver {
+  client;
+  constructor(config) {
+    try {
+      this.client = config.useTursoServerlessDriver ? createClient({
+        url: config.url,
+        ...config.authToken ? { authToken: config.authToken } : {}
+      }) : createClient$1({
+        url: config.url,
+        ...config.authToken ? { authToken: config.authToken } : {}
+      });
+    } catch (error) {
+      throw new ConnectionError("libsql", error);
+    }
+  }
+  async query(sql, params) {
+    try {
+      const result = await this.client.execute(sql, params);
+      return this.convertLibsqlResult(result);
+    } catch (error) {
+      throw new QueryError("libsql", sql, error);
+    }
+  }
+  async transaction(callback) {
+    const transactionDriver = new LibSQLDriver({ url: "", authToken: "" });
+    transactionDriver.client = this.client;
+    return await callback(transactionDriver);
+  }
+  async close() {
+    try {
+      this.client.close();
+    } catch (error) {
+      console.error("Error closing LibSQL client:", error);
+    }
+  }
+  convertLibsqlResult(result) {
+    const rows = result.rows.map((row) => {
+      const obj = {};
+      result.columns.forEach((col, index) => {
+        obj[col] = row[index];
+      });
+      return obj;
+    });
+    return {
+      rows,
+      rowCount: result.rowsAffected || rows.length,
+      command: void 0,
+      fields: result.columns.map((col) => ({ name: col, dataTypeID: 0 }))
+    };
+  }
+}
+
+class MySQLDriver {
+  client;
+  constructor(config) {
+    consola.warn("MySQL client is experimental and may not be compatible with the helper functions, since they originally designed for PostgreSQL and libsql. But .query() method should work.");
+    try {
+      this.client = mysql.createConnection(config.connectionString);
+    } catch (error) {
+      throw new ConnectionError("mysql", error);
+    }
+  }
+  async query(sql, params) {
+    try {
+      const [rows, fields] = await (await this.client).execute(sql, params || []);
+      const rowCount = Array.isArray(rows) ? rows.length : 0;
+      const normalizedFields = fields.map((field) => ({
+        name: field.name,
+        dataTypeID: field.columnType
+      }));
+      return {
+        rows,
+        rowCount,
+        command: void 0,
+        fields: normalizedFields
+      };
+    } catch (error) {
+      throw new QueryError("mysql", sql, error);
+    }
+  }
+  async transaction(callback) {
+    const connection = await this.client;
+    try {
+      await connection.beginTransaction();
+      const transactionDriver = new MySQLDriver({ connectionString: "" });
+      transactionDriver.client = Promise.resolve(connection);
+      const result = await callback(transactionDriver);
+      await connection.commit();
+      return result;
+    } catch (error) {
+      await connection.rollback();
+      throw error;
+    }
+  }
+  async close() {
+    try {
+      await (await this.client).end();
+    } catch (error) {
+      consola.error("Error closing MySQL client:", error);
+    }
+  }
+}
+
+class SqliteDriver {
+  client;
+  constructor(config) {
+    try {
+      this.client = new Database(config.filename, {
+        readonly: config.readonly || false,
+        fileMustExist: config.readonly || false
+      });
+    } catch (error) {
+      throw new ConnectionError("sqlite", error);
+    }
+  }
+  async query(sql, params) {
+    try {
+      const stmt = this.client.prepare(sql);
+      const rows = stmt.all(params || []);
+      const fields = rows.length > 0 && typeof rows[0] === "object" && rows[0] !== null ? Object.keys(rows[0]).map((name) => ({ name, dataTypeID: 0 })) : [];
+      return {
+        rows,
+        rowCount: rows.length,
+        command: void 0,
+        fields
+      };
+    } catch (error) {
+      throw new QueryError("sqlite", sql, error);
+    }
+  }
+  async transaction(callback) {
+    const transaction = this.client.transaction(() => {
+      const transactionDriver = new SqliteDriver({ filename: "" });
+      transactionDriver.client = this.client;
+      return callback(transactionDriver);
+    });
+    return await transaction();
+  }
+  async prepare(sql) {
+    return new SqlitePreparedStatement(this.client.prepare(sql));
+  }
+  async close() {
+    try {
+      this.client.close();
+    } catch (error) {
+      console.error("Error closing SQLite client:", error);
+    }
+  }
+  // SQLite-specific methods
+  exec(sql) {
+    this.client.exec(sql);
+  }
+  backup(filename) {
+    return new Promise((resolve, reject) => {
+      try {
+        this.client.backup(filename);
+        resolve();
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  pragma(pragma) {
+    return this.client.pragma(pragma);
+  }
+}
+class SqlitePreparedStatement {
+  constructor(stmt) {
+    this.stmt = stmt;
+  }
+  async execute(params) {
+    try {
+      const rows = this.stmt.all(params || []);
+      const fields = rows.length > 0 && typeof rows[0] === "object" && rows[0] !== null ? Object.keys(rows[0]).map((name) => ({ name, dataTypeID: 0 })) : [];
+      return {
+        rows,
+        rowCount: rows.length,
+        command: void 0,
+        fields
+      };
+    } catch (error) {
+      throw new QueryError("sqlite", "prepared statement", error);
+    }
+  }
+  async finalize() {
+    return Promise.resolve();
+  }
+  // SQLite-specific methods for prepared statements
+  run(params) {
+    return this.stmt.run(params || []);
+  }
+  get(params) {
+    return this.stmt.get(params || []);
+  }
+  all(params) {
+    return this.stmt.all(params || []);
+  }
+}
+
 const withTimeout = (promise, timeoutMs = 3e4) => {
   return Promise.race([promise, new Promise((_, reject) => setTimeout(() => reject(new Error(`Query timeout after ${timeoutMs}ms`)), timeoutMs))]);
 };
@@ -108,24 +413,23 @@ const mapDatabaseTypeToTypeScript = (dataType, isNullable = false, driverType =
     }
   }
 };
-const inspectDB = async (drivers) => {
-  if (!drivers) throw new Error("No drivers provided for inspection");
-  const configuredDrivers = Object.keys(drivers).filter((key) => drivers[key] !== void 0);
-  if (configuredDrivers.length === 0) {
-    throw new Error("No drivers are configured");
-  }
-  const supportedConfiguredDrivers = configuredDrivers.filter((driver) => supportedDrivers.includes(driver));
-  if (supportedConfiguredDrivers.length === 0) {
-    throw new Error(`No supported drivers found. Configured: ${configuredDrivers.join(", ")}. Supported: ${supportedDrivers.join(", ")}`);
-  }
-  console.log(`Found supported drivers: ${supportedConfiguredDrivers.join(", ")}`);
-  const activeDriver = supportedConfiguredDrivers[0];
+const getDriverType = (driver) => {
+  if (driver instanceof PostgresDriver) return "postgres";
+  if (driver instanceof LibSQLDriver) return "libsql";
+  if (driver instanceof MySQLDriver) return "mysql";
+  if (driver instanceof SqliteDriver) return "sqlite";
+  return "unknown";
+};
+const inspectDB = async (options) => {
+  const { driver, outputFile = "db-types.ts" } = options;
+  const driverType = getDriverType(driver);
+  console.log(`Inspecting database using ${driverType} driver`);
+  const client = new SQLClient({ driver });
   let generatedTypes = "";
-  const client = new DriftSQLClient({ drivers });
   try {
     let tablesQuery;
     let tableSchemaFilter;
-    if (activeDriver === "mysql") {
+    if (driverType === "mysql") {
       const dbResult = await withTimeout(
         retryQuery(() => client.query("SELECT DATABASE() as `database`", [])),
         1e4
@@ -136,24 +440,26 @@ const inspectDB = async (drivers) => {
       }
       console.log(`Using MySQL database: ${currentDatabase}`);
       tablesQuery = `SELECT TABLE_NAME as table_name
-                   FROM information_schema.tables 
-                   WHERE TABLE_SCHEMA = ? 
+                   FROM information_schema.tables
+                   WHERE TABLE_SCHEMA = ?
                    AND TABLE_TYPE = 'BASE TABLE'
                    ORDER BY TABLE_NAME`;
       tableSchemaFilter = currentDatabase;
-    } else if (activeDriver === "postgres" || activeDriver === "postgresHTTP") {
-      tablesQuery = `SELECT table_name 
-                   FROM information_schema.tables 
-                   WHERE table_schema = $1 
+    } else if (driverType === "postgres") {
+      tablesQuery = `SELECT table_name
+                   FROM information_schema.tables
+                   WHERE table_schema = $1
                    AND table_type = 'BASE TABLE'
                    ORDER BY table_name`;
       tableSchemaFilter = "public";
-    } else {
-      tablesQuery = `SELECT name as table_name 
-                   FROM sqlite_master 
-                   WHERE type = 'table' 
+    } else if (driverType === "libsql" || driverType === "sqlite") {
+      tablesQuery = `SELECT name as table_name
+                   FROM sqlite_master
+                   WHERE type = 'table'
                    ORDER BY name`;
       tableSchemaFilter = void 0;
+    } else {
+      throw new Error(`Unsupported driver type: ${driverType}`);
     }
     const tables = await withTimeout(
       retryQuery(() => client.query(tablesQuery, tableSchemaFilter ? [tableSchemaFilter] : [])),
@@ -169,37 +475,37 @@ const inspectDB = async (drivers) => {
       try {
         let columnsQuery;
         let queryParams;
-        if (activeDriver === "mysql") {
+        if (driverType === "mysql") {
           columnsQuery = `
-          SELECT 
-            COLUMN_NAME as column_name, 
-            DATA_TYPE as data_type, 
+          SELECT
+            COLUMN_NAME as column_name,
+            DATA_TYPE as data_type,
             IS_NULLABLE as is_nullable,
             COLUMN_DEFAULT as column_default
-          FROM information_schema.columns 
-          WHERE TABLE_NAME = ? 
+          FROM information_schema.columns
+          WHERE TABLE_NAME = ?
           AND TABLE_SCHEMA = ?
           ORDER BY ORDINAL_POSITION
         `;
           queryParams = [tableName, tableSchemaFilter];
-        } else if (activeDriver === "postgres" || activeDriver === "postgresHTTP") {
+        } else if (driverType === "postgres") {
           columnsQuery = `
-          SELECT 
-            column_name, 
-            data_type, 
+          SELECT
+            column_name,
+            data_type,
             is_nullable,
             column_default
-          FROM information_schema.columns 
-          WHERE table_name = $1 
+          FROM information_schema.columns
+          WHERE table_name = $1
           AND table_schema = $2
           ORDER BY ordinal_position
         `;
           queryParams = [tableName, tableSchemaFilter];
         } else {
           columnsQuery = `
-          SELECT 
-            name as column_name, 
-            type as data_type, 
+          SELECT
+            name as column_name,
+            type as data_type,
             CASE WHEN "notnull" = 0 THEN 'YES' ELSE 'NO' END as is_nullable,
             dflt_value as column_default
           FROM pragma_table_info(?)
@@ -212,7 +518,6 @@ const inspectDB = async (drivers) => {
             () => client.query(columnsQuery, queryParams)
           ),
           15e3
-          // Shorter timeout for individual table queries
         );
         if (columns.rows.length === 0) {
           console.log(`No columns found for table: ${tableName}`);
@@ -228,7 +533,7 @@ const inspectDB = async (drivers) => {
         generatedTypes += `export interface ${tableName.charAt(0).toUpperCase() + tableName.slice(1)} {
 `;
         for (const col of uniqueColumns.values()) {
-          const tsType = mapDatabaseTypeToTypeScript(col.data_type, col.is_nullable === "YES", activeDriver);
+          const tsType = mapDatabaseTypeToTypeScript(col.data_type, col.is_nullable === "YES", driverType);
           generatedTypes += `  ${col.column_name}: ${tsType};
 `;
         }
@@ -241,274 +546,124 @@ const inspectDB = async (drivers) => {
     }
     generatedTypes += "export interface Database {\n";
     for (const table of tables.rows) {
-      const tableName = table.table_name.charAt(0).toUpperCase() + table.table_name.slice(1);
-      generatedTypes += `  ${tableName}: ${tableName};
+      const interfaceName = table.table_name.charAt(0).toUpperCase() + table.table_name.slice(1);
+      generatedTypes += `  ${table.table_name}: ${interfaceName};
 `;
     }
     generatedTypes += "}\n\n";
-    await fs.writeFile("db-types.ts", generatedTypes, "utf8");
-    console.log("TypeScript types written to db-types.ts");
+    await fs.writeFile(outputFile, generatedTypes, "utf8");
+    console.log(`TypeScript types written to ${outputFile}`);
     console.log(`Successfully processed ${processedTables} tables`);
   } catch (error) {
     console.error("Fatal error during database inspection:", error);
-    process.exit(1);
+    throw error;
+  } finally {
+    await client.close();
   }
-  process.exit(0);
+};
+const inspectPostgres = async (config, outputFile) => {
+  const driver = new PostgresDriver(config);
+  return inspectDB({ driver, outputFile });
+};
+const inspectLibSQL = async (config, outputFile) => {
+  const driver = new LibSQLDriver(config);
+  return inspectDB({ driver, outputFile });
+};
+const inspectMySQL = async (config, outputFile) => {
+  const driver = new MySQLDriver(config);
+  return inspectDB({ driver, outputFile });
+};
+const inspectSQLite = async (config, outputFile) => {
+  const driver = new SqliteDriver(config);
+  return inspectDB({ driver, outputFile });
 };
 
-class PostgresDriver {
+class SQLClient {
+  primaryDriver;
+  fallbackDrivers;
   constructor(options) {
-    this.options = options;
-    if (this.options.options?.experimental?.http) {
-      this.client = new PostgresHTTPDriver(this.options.options.experimental);
-    } else {
-      this.client = postgres(this.options.connectionString || "");
-    }
+    this.primaryDriver = options.driver;
+    this.fallbackDrivers = options.fallbackDrivers || [];
   }
-  client;
-  async query(query, params) {
-    try {
-      if (this.client instanceof PostgresHTTPDriver) {
-        return await this.client.query(query, params);
-      }
-      const result = await this.client.unsafe(query, params);
-      return {
-        rows: result,
-        rowCount: result.length,
-        command: void 0
-      };
-    } catch (error) {
-      console.error("Postgres query error:", error);
-      throw error;
-    }
-  }
-  async close() {
-    try {
-      if (this.client instanceof PostgresHTTPDriver) {
-        return await this.client.close();
-      }
-      await this.client.end();
-    } catch (error) {
-      console.error("Error closing Postgres client:", error);
-      throw error;
-    }
-  }
-}
-class PostgresHTTPDriver {
-  httpClient;
-  constructor(options) {
-    if (!options || !options.http || !options.http.url) {
-      throw new Error("Postgres HTTP driver requires a valid URL in options.http");
-    }
-    this.httpClient = ky.create({
-      prefixUrl: options.http.url,
-      headers: {
-        Authorization: `Bearer ${options.http.apiKey || ""}`
+  async query(sql, params) {
+    const drivers = [this.primaryDriver, ...this.fallbackDrivers];
+    let lastError;
+    for (const driver of drivers) {
+      try {
+        return await driver.query(sql, params);
+      } catch (error) {
+        lastError = error;
+        consola.warn(`Query failed with ${driver.constructor.name}:`, error);
+        continue;
       }
-    });
-  }
-  async query(query, params) {
-    try {
-      const response = await this.httpClient.post("query", {
-        json: {
-          query,
-          params
-        }
-      }).json();
-      return {
-        rows: response.rows,
-        rowCount: response.rowCount,
-        command: void 0
-      };
-    } catch (error) {
-      console.error("Postgres HTTP query error:", error);
-      throw error;
     }
+    throw lastError || new DatabaseError("All drivers failed to execute query", "unknown");
   }
-  async close() {
-    return Promise.resolve();
-  }
-}
-
-class LibSQLDriver {
-  constructor(options) {
-    this.options = options;
-    this.client = this.options?.options?.experimental?.useTursoServerlessDriver ? createClient({
-      url: this.options.url,
-      ...this.options.authToken ? { authToken: this.options.authToken } : {}
-    }) : createClient$1({
-      url: this.options.url,
-      ...this.options.authToken ? { authToken: this.options.authToken } : {}
-    });
-  }
-  client;
-  convertLibsqlResult(result) {
-    const rows = result.rows.map((row) => {
-      const obj = {};
-      result.columns.forEach((col, index) => {
-        obj[col] = row[index];
+  async transaction(callback) {
+    if (!hasTransactionSupport(this.primaryDriver)) {
+      throw new DatabaseError("Primary driver does not support transactions", this.primaryDriver.constructor.name);
+    }
+    return await this.primaryDriver.transaction(async (transactionDriver) => {
+      const transactionClient = new SQLClient({
+        driver: transactionDriver,
+        fallbackDrivers: []
       });
-      return obj;
+      return await callback(transactionClient);
     });
-    return {
-      rows,
-      rowCount: result.rowsAffected || rows.length,
-      command: void 0,
-      fields: result.columns.map((col) => ({ name: col, dataTypeID: 0 }))
-    };
-  }
-  async query(query, params) {
-    try {
-      const result = await this.client.execute(query, params);
-      return this.convertLibsqlResult(result);
-    } catch (error) {
-      console.error("LibSQL query error:", error);
-      throw error;
-    }
   }
-  async close() {
-    try {
-      this.client.close();
-    } catch (error) {
-      console.error("Error closing LibSQL client:", error);
+  async prepare(sql) {
+    if (!hasPreparedStatementSupport(this.primaryDriver)) {
+      throw new DatabaseError("Primary driver does not support prepared statements", this.primaryDriver.constructor.name);
     }
+    return await this.primaryDriver.prepare(sql);
   }
-}
-
-class MySQLDriver {
-  constructor(options) {
-    this.options = options;
-    consola.warn("MySQL client is experimental and may not be compatible with the helper functions, since they originally designed for PostgreSQL and libsql. But .query() method should work.");
-    this.client = mysql.createConnection(this.options.connectionString);
-  }
-  client;
-  async query(query, params) {
-    try {
-      const [rows, fields] = await (await this.client).execute(query, params || []);
-      const rowCount = Array.isArray(rows) ? rows.length : 0;
-      return {
-        rows,
-        rowCount,
-        command: void 0,
-        fields: fields.map((field) => ({ name: field.name, dataTypeID: field.columnType }))
-      };
-    } catch (error) {
-      consola.error("MySQL query error:", error);
-      throw error;
-    }
-  }
-  async close() {
-    try {
-      await (await this.client).end();
-    } catch (error) {
-      consola.error("Error closing MySQL client:", error);
-    }
-  }
-}
-
-class DriftSQLClient {
-  postgres;
-  libsql;
-  mysql;
-  drivers;
-  constructor(options) {
-    this.postgres = options.drivers?.postgres ? new PostgresDriver({ connectionString: options.drivers.postgres.connectionString }) : void 0;
-    this.libsql = options.drivers?.libsql ? new LibSQLDriver(options.drivers.libsql) : void 0;
-    this.mysql = options.drivers?.mysql ? new MySQLDriver(options.drivers.mysql) : void 0;
-    this.drivers = options.drivers || {};
-  }
-  inspect = async () => {
-    return inspectDB(this.drivers);
-  };
-  async query(query, args) {
-    if (this.postgres) {
-      try {
-        const result = await this.postgres.query(query, args || []);
-        return {
-          rows: result.rows,
-          rowCount: result.rowCount || 0,
-          command: result.command,
-          fields: result.fields?.map((field) => ({ name: field.name, dataTypeID: field.dataTypeID })) || []
-        };
-      } catch (error2) {
-        consola.error("Failed to execute query with PostgreSQL:", error2);
-        throw error2;
-      }
-    }
-    if (this.mysql) {
-      try {
-        const result = await this.mysql.query(query, args || []);
-        return {
-          rows: result.rows,
-          rowCount: result.rowCount || 0,
-          command: result.command,
-          fields: result.fields?.map((field) => ({ name: field.name, dataTypeID: field.dataTypeID })) || []
-        };
-      } catch (error2) {
-        consola.error("Failed to execute query with MySQL:", error2);
-        throw error2;
-      }
-    }
-    if (this.libsql) {
-      try {
-        const result = await this.libsql.query(query, args || []);
-        return {
-          rows: result.rows,
-          rowCount: result.rowCount || 0,
-          command: result.command,
-          fields: void 0
-        };
-      } catch (error2) {
-        consola.error("Failed to execute query with LibSQL:", error2);
-        throw error2;
-      }
-    }
-    const error = new Error("No database driver is configured or all drivers failed to execute the query");
-    consola.error(error);
-    throw error;
-  }
+  // Helper methods for common database operations
   async findFirst(table, where) {
     const tableName = String(table);
     const whereEntries = Object.entries(where || {});
-    let query = `SELECT * FROM ${tableName}`;
-    let args = [];
+    let sql = `SELECT * FROM ${tableName}`;
+    let params = [];
     if (whereEntries.length > 0) {
-      const whereClause = whereEntries.map(([key], index) => `${key} = $${index + 1}`).join(" AND ");
-      query += ` WHERE ${whereClause}`;
-      args = whereEntries.map(([, value]) => value);
+      const whereClause = whereEntries.map((_, index) => `${whereEntries[index]?.[0]} = $${index + 1}`).join(" AND ");
+      sql += ` WHERE ${whereClause}`;
+      params = whereEntries.map(([, value]) => value);
     }
-    query += " LIMIT 1";
-    const result = await this.query(query, args);
+    sql += " LIMIT 1";
+    const result = await this.query(sql, params);
     return result.rows[0] || null;
   }
   async findMany(table, options) {
     const tableName = String(table);
-    const { where, limit } = options || {};
+    const { where, limit, offset } = options || {};
     const whereEntries = Object.entries(where || {});
-    let query = `SELECT * FROM ${tableName}`;
-    let args = [];
+    let sql = `SELECT * FROM ${tableName}`;
+    let params = [];
     if (whereEntries.length > 0) {
-      const whereClause = whereEntries.map(([key], index) => `${key} = $${index + 1}`).join(" AND ");
-      query += ` WHERE ${whereClause}`;
-      args = whereEntries.map(([, value]) => value);
+      const whereClause = whereEntries.map((_, index) => `${whereEntries[index]?.[0]} = $${index + 1}`).join(" AND ");
+      sql += ` WHERE ${whereClause}`;
+      params = whereEntries.map(([, value]) => value);
     }
     if (typeof limit === "number" && limit > 0) {
-      query += ` LIMIT $${args.length + 1}`;
-      args.push(limit);
+      sql += ` LIMIT $${params.length + 1}`;
+      params.push(limit);
+    }
+    if (typeof offset === "number" && offset > 0) {
+      sql += ` OFFSET $${params.length + 1}`;
+      params.push(offset);
     }
-    const result = await this.query(query, args);
+    const result = await this.query(sql, params);
     return result.rows;
   }
   async insert(table, data) {
     const tableName = String(table);
     const keys = Object.keys(data);
-    const values = Object.values(data).map((value) => value);
+    const values = Object.values(data);
     if (keys.length === 0) {
       throw new Error("No data provided for insert");
     }
     const placeholders = keys.map((_, index) => `$${index + 1}`).join(", ");
-    const query = `INSERT INTO ${tableName} (${keys.join(", ")}) VALUES (${placeholders}) RETURNING *`;
-    const result = await this.query(query, values);
+    const sql = `INSERT INTO ${tableName} (${keys.join(", ")}) VALUES (${placeholders}) RETURNING *`;
+    const result = await this.query(sql, values);
     if (!result.rows[0]) {
       throw new Error("Insert failed: No data returned");
     }
@@ -524,11 +679,11 @@ class DriftSQLClient {
     if (whereEntries.length === 0) {
       throw new Error("No conditions provided for update");
     }
-    const setClause = setEntries.map(([key], index) => `${key} = $${index + 1}`).join(", ");
-    const whereClause = whereEntries.map(([key], index) => `${key} = $${setEntries.length + index + 1}`).join(" AND ");
-    const query = `UPDATE ${tableName} SET ${setClause} WHERE ${whereClause} RETURNING *`;
-    const args = [...setEntries.map(([, value]) => value), ...whereEntries.map(([, value]) => value)];
-    const result = await this.query(query, args);
+    const setClause = setEntries.map((_, index) => `${setEntries[index]?.[0]} = $${index + 1}`).join(", ");
+    const whereClause = whereEntries.map((_, index) => `${whereEntries[index]?.[0]} = $${setEntries.length + index + 1}`).join(" AND ");
+    const sql = `UPDATE ${tableName} SET ${setClause} WHERE ${whereClause} RETURNING *`;
+    const params = [...setEntries.map(([, value]) => value), ...whereEntries.map(([, value]) => value)];
+    const result = await this.query(sql, params);
     return result.rows[0] || null;
   }
   async delete(table, where) {
@@ -537,26 +692,44 @@ class DriftSQLClient {
     if (whereEntries.length === 0) {
       throw new Error("No conditions provided for delete");
     }
-    const whereClause = whereEntries.map(([key], index) => `${key} = $${index + 1}`).join(" AND ");
-    const query = `DELETE FROM ${tableName} WHERE ${whereClause}`;
-    const args = whereEntries.map(([, value]) => value);
-    const result = await this.query(query, args);
-    return (result.rowCount || 0) > 0;
+    const whereClause = whereEntries.map((_, index) => `${whereEntries[index]?.[0]} = $${index + 1}`).join(" AND ");
+    const sql = `DELETE FROM ${tableName} WHERE ${whereClause}`;
+    const params = whereEntries.map(([, value]) => value);
+    const result = await this.query(sql, params);
+    return result.rowCount || 0;
   }
-  deleteFirst(table, where) {
-    return this.delete(table, where);
+  // Get the primary driver (useful for driver-specific operations)
+  getDriver() {
+    return this.primaryDriver;
+  }
+  // Check driver capabilities
+  supportsTransactions() {
+    return hasTransactionSupport(this.primaryDriver);
+  }
+  supportsPreparedStatements() {
+    return hasPreparedStatementSupport(this.primaryDriver);
   }
   async close() {
-    if (this.postgres) {
-      await this.postgres.close();
-    }
-    if (this.libsql) {
-      this.libsql.close();
-    }
-    if (this.mysql) {
-      await this.mysql.close();
-    }
+    const drivers = [this.primaryDriver, ...this.fallbackDrivers];
+    await Promise.all(drivers.map((driver) => driver.close().catch((err) => consola.warn(`Error closing ${driver.constructor.name}:`, err))));
   }
 }
+function createPostgresClient(config) {
+  const { PostgresDriver: PostgresDriver2 } = require("./drivers/postgres");
+  return new SQLClient({ driver: new PostgresDriver2(config) });
+}
+function createLibSQLClient(config) {
+  const { LibSQLDriver: LibSQLDriver2 } = require("./drivers/libsql");
+  return new SQLClient({ driver: new LibSQLDriver2(config) });
+}
+function createMySQLClient(config) {
+  const { MySQLDriver: MySQLDriver2 } = require("./drivers/mysql");
+  return new SQLClient({ driver: new MySQLDriver2(config) });
+}
+function createSqliteClient(config) {
+  const { SqliteDriver: SqliteDriver2 } = require("./drivers/sqlite");
+  return new SQLClient({ driver: new SqliteDriver2(config) });
+}
+const DriftSQLClient = SQLClient;
 
-export { DriftSQLClient, inspectDB };
+export { DriftSQLClient, LibSQLDriver, MySQLDriver, PostgresDriver, SQLClient, SqliteDriver, createLibSQLClient, createMySQLClient, createPostgresClient, createSqliteClient, inspectDB, inspectLibSQL, inspectMySQL, inspectPostgres, inspectSQLite };