driftsql 1.0.12 → 1.0.13

package/dist/index.mjs

@@ -4,284 +4,74 @@ 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 fs from 'node:fs/promises';
+import Database from 'better-sqlite3';
 
-const supportedDrivers = ["postgres", "postgresHTTP", "mysql", "libsql"];
-const withTimeout = (promise, timeoutMs = 3e4) => {
-  return Promise.race([promise, new Promise((_, reject) => setTimeout(() => reject(new Error(`Query timeout after ${timeoutMs}ms`)), timeoutMs))]);
-};
-const retryQuery = async (queryFn, maxRetries = 3, baseDelay = 1e3) => {
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    try {
-      return await queryFn();
-    } catch (error) {
-      if (attempt === maxRetries) {
-        throw error;
-      }
-      const delay = baseDelay * Math.pow(2, attempt - 1);
-      console.warn(`Query attempt ${attempt} failed, retrying in ${delay}ms...`, error);
-      await new Promise((resolve) => setTimeout(resolve, delay));
-    }
+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";
   }
-  throw new Error("Max retries exceeded");
-};
-const mapDatabaseTypeToTypeScript = (dataType, isNullable = false, driverType = "postgres") => {
-  const nullable = isNullable ? " | null" : "";
-  const lowerType = dataType.toLowerCase();
-  switch (lowerType) {
-    case "uuid": {
-      return `string${nullable}`;
-    }
-    case "character varying":
-    case "varchar":
-    case "text":
-    case "char":
-    case "character":
-    case "longtext":
-    case "mediumtext":
-    case "tinytext": {
-      return `string${nullable}`;
-    }
-    case "integer":
-    case "int":
-    case "int4":
-    case "smallint":
-    case "int2":
-    case "bigint":
-    case "int8":
-    case "serial":
-    case "bigserial":
-    case "numeric":
-    case "decimal":
-    case "real":
-    case "float4":
-    case "double precision":
-    case "float8":
-    case "tinyint":
-    case "mediumint":
-    case "float":
-    case "double": {
-      return `number${nullable}`;
-    }
-    case "boolean":
-    case "bool":
-    case "bit": {
-      return `boolean${nullable}`;
-    }
-    case "timestamp":
-    case "timestamp with time zone":
-    case "timestamp without time zone":
-    case "timestamptz":
-    case "date":
-    case "time":
-    case "time with time zone":
-    case "time without time zone":
-    case "timetz":
-    case "interval":
-    case "datetime":
-    case "year": {
-      return `Date${nullable}`;
-    }
-    case "json":
-    case "jsonb": {
-      return `any${nullable}`;
-    }
-    case "array": {
-      return `any[]${nullable}`;
-    }
-    case "bytea":
-    case "binary":
-    case "varbinary":
-    case "blob":
-    case "longblob":
-    case "mediumblob":
-    case "tinyblob": {
-      return `Buffer${nullable}`;
-    }
-    case "enum":
-    case "set": {
-      return `string${nullable}`;
-    }
-    default: {
-      console.warn(`Unknown ${driverType} type: ${dataType}, defaulting to 'any'`);
-      return `any${nullable}`;
-    }
+}
+class QueryError extends DatabaseError {
+  constructor(driverType, sql, originalError) {
+    super(`Query failed: ${sql}`, driverType, originalError);
+    this.name = "QueryError";
   }
-};
-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];
-  let generatedTypes = "";
-  const client = new DriftSQLClient({ drivers });
-  try {
-    let tablesQuery;
-    let tableSchemaFilter;
-    if (activeDriver === "mysql") {
-      const dbResult = await withTimeout(
-        retryQuery(() => client.query("SELECT DATABASE() as `database`", [])),
-        1e4
-      );
-      const currentDatabase = dbResult.rows[0]?.database;
-      if (!currentDatabase) {
-        throw new Error("Could not determine current MySQL database name");
-      }
-      console.log(`Using MySQL database: ${currentDatabase}`);
-      tablesQuery = `SELECT TABLE_NAME as table_name
-                   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 
-                   AND table_type = 'BASE TABLE'
-                   ORDER BY table_name`;
-      tableSchemaFilter = "public";
-    } else {
-      tablesQuery = `SELECT name as table_name 
-                   FROM sqlite_master 
-                   WHERE type = 'table' 
-                   ORDER BY name`;
-      tableSchemaFilter = void 0;
-    }
-    const tables = await withTimeout(
-      retryQuery(() => client.query(tablesQuery, tableSchemaFilter ? [tableSchemaFilter] : [])),
-      3e4
-    );
-    console.log("Tables in the database:", tables.rows.map((t) => t.table_name).join(", "));
-    let processedTables = 0;
-    const totalTables = tables.rows.length;
-    for (const table of tables.rows) {
-      const tableName = table.table_name;
-      processedTables++;
-      console.log(`[${processedTables}/${totalTables}] Inspecting table: ${tableName}`);
-      try {
-        let columnsQuery;
-        let queryParams;
-        if (activeDriver === "mysql") {
-          columnsQuery = `
-          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 = ? 
-          AND TABLE_SCHEMA = ?
-          ORDER BY ORDINAL_POSITION
-        `;
-          queryParams = [tableName, tableSchemaFilter];
-        } else if (activeDriver === "postgres" || activeDriver === "postgresHTTP") {
-          columnsQuery = `
-          SELECT 
-            column_name, 
-            data_type, 
-            is_nullable,
-            column_default
-          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, 
-            CASE WHEN "notnull" = 0 THEN 'YES' ELSE 'NO' END as is_nullable,
-            dflt_value as column_default
-          FROM pragma_table_info(?)
-          ORDER BY cid
-        `;
-          queryParams = [tableName];
-        }
-        const columns = await withTimeout(
-          retryQuery(
-            () => client.query(columnsQuery, queryParams)
-          ),
-          15e3
-          // Shorter timeout for individual table queries
-        );
-        if (columns.rows.length === 0) {
-          console.log(`No columns found for table: ${tableName}`);
-          continue;
-        }
-        console.log(`Columns in ${tableName}:`, columns.rows.map((c) => `${c.column_name} (${c.data_type}${c.is_nullable === "YES" ? ", nullable" : ""})`).join(", "));
-        const uniqueColumns = /* @__PURE__ */ new Map();
-        columns.rows.forEach((col) => {
-          if (!uniqueColumns.has(col.column_name)) {
-            uniqueColumns.set(col.column_name, col);
-          }
-        });
-        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);
-          generatedTypes += `  ${col.column_name}: ${tsType};
-`;
-        }
-        generatedTypes += "}\n\n";
-      } catch (error) {
-        console.error(`Failed to process table ${tableName}:`, error);
-        console.log(`Skipping table ${tableName} and continuing...`);
-        continue;
-      }
-    }
-    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};
-`;
-    }
-    generatedTypes += "}\n\n";
-    await fs.writeFile("db-types.ts", generatedTypes, "utf8");
-    console.log("TypeScript types written to db-types.ts");
-    console.log(`Successfully processed ${processedTables} tables`);
-  } catch (error) {
-    console.error("Fatal error during database inspection:", error);
-    process.exit(1);
-  }
-  process.exit(0);
-};
+}
+class ConnectionError extends DatabaseError {
+  constructor(driverType, originalError) {
+    super(`Failed to connect to ${driverType}`, driverType, originalError);
+    this.name = "ConnectionError";
+  }
+}
 
 class PostgresDriver {
-  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 || "");
+  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);
     }
   }
-  client;
-  async query(query, params) {
+  async query(sql, params) {
     try {
       if (this.client instanceof PostgresHTTPDriver) {
-        return await this.client.query(query, params);
+        return await this.client.query(sql, params);
       }
-      const result = await this.client.unsafe(query, params);
+      const result = await this.client.unsafe(sql, params || []);
       return {
         rows: result,
-        rowCount: result.length,
+        rowCount: Array.isArray(result) ? result.length : 0,
         command: void 0
       };
     } catch (error) {
-      console.error("Postgres query error:", error);
-      throw 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) {
@@ -290,30 +80,23 @@ class PostgresDriver {
       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");
-    }
+  constructor(config) {
     this.httpClient = ky.create({
-      prefixUrl: options.http.url,
+      prefixUrl: config.url,
       headers: {
-        Authorization: `Bearer ${options.http.apiKey || ""}`
+        Authorization: `Bearer ${config.apiKey || ""}`
       }
     });
   }
-  async query(query, params) {
+  async query(sql, params) {
     try {
       const response = await this.httpClient.post("query", {
-        json: {
-          query,
-          params
-        }
+        json: { query: sql, params }
       }).json();
       return {
         rows: response.rows,
@@ -321,8 +104,7 @@ class PostgresHTTPDriver {
         command: void 0
       };
     } catch (error) {
-      console.error("Postgres HTTP query error:", error);
-      throw error;
+      throw new QueryError("postgres-http", sql, error);
     }
   }
   async close() {
@@ -331,17 +113,40 @@ class PostgresHTTPDriver {
 }
 
 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;
+  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 = {};
@@ -357,158 +162,241 @@ class LibSQLDriver {
       fields: result.columns.map((col) => ({ name: col, dataTypeID: 0 }))
     };
   }
-  async query(query, params) {
+}
+
+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 result = await this.client.execute(query, params);
-      return this.convertLibsqlResult(result);
+      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) {
-      console.error("LibSQL query error:", error);
+      await connection.rollback();
       throw error;
     }
   }
   async close() {
     try {
-      this.client.close();
+      await (await this.client).end();
     } catch (error) {
-      console.error("Error closing LibSQL client:", error);
+      consola.error("Error closing MySQL client:", error);
     }
   }
 }
 
-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);
-  }
+class SqliteDriver {
   client;
-  async query(query, params) {
+  constructor(config) {
     try {
-      const [rows, fields] = await (await this.client).execute(query, params || []);
-      const rowCount = Array.isArray(rows) ? rows.length : 0;
+      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,
+        rowCount: rows.length,
         command: void 0,
-        fields: fields.map((field) => ({ name: field.name, dataTypeID: field.columnType }))
+        fields
       };
     } catch (error) {
-      consola.error("MySQL query error:", error);
-      throw 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 {
-      await (await this.client).end();
+      this.client.close();
     } catch (error) {
-      consola.error("Error closing MySQL client:", error);
+      console.error("Error closing SQLite 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) {
+  // SQLite-specific methods
+  exec(sql) {
+    this.client.exec(sql);
+  }
+  backup(filename) {
+    return new Promise((resolve, reject) => {
       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;
+        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);
     }
-    if (this.mysql) {
+  }
+  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 || []);
+  }
+}
+
+class SQLClient {
+  primaryDriver;
+  fallbackDrivers;
+  constructor(options) {
+    this.primaryDriver = options.driver;
+    this.fallbackDrivers = options.fallbackDrivers || [];
+  }
+  async query(sql, params) {
+    const drivers = [this.primaryDriver, ...this.fallbackDrivers];
+    let lastError;
+    for (const driver of drivers) {
       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;
+        return await driver.query(sql, params);
+      } catch (error) {
+        lastError = error;
+        consola.warn(`Query failed with ${driver.constructor.name}:`, error);
+        continue;
       }
     }
-    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;
-      }
+    throw lastError || new DatabaseError("All drivers failed to execute query", "unknown");
+  }
+  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 await callback(transactionClient);
+    });
+  }
+  async prepare(sql) {
+    if (!hasPreparedStatementSupport(this.primaryDriver)) {
+      throw new DatabaseError("Primary driver does not support prepared statements", this.primaryDriver.constructor.name);
     }
-    const error = new Error("No database driver is configured or all drivers failed to execute the query");
-    consola.error(error);
-    throw error;
+    return await this.primaryDriver.prepare(sql);
   }
+  // 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 +412,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 +425,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 };