driftsql 1.0.18 → 1.0.19

package/dist/index.mjs

@@ -0,0 +1,764 @@
+import consola from 'consola';
+import postgres from 'postgres';
+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';
+
+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;
+  }
+  // Helper methods for findMany, findFirst, insert, update, delete
+  async findMany(sql, params) {
+    return this.query(sql, params);
+  }
+  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, args: 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 || []);
+  }
+}
+
+class BobSQLDriver {
+  httpClient;
+  constructor(config) {
+    this.httpClient = ky.create({
+      prefixUrl: config.url,
+      ...config.authToken ? { headers: { Authorization: `Bearer ${config.authToken}` } } : {}
+    });
+  }
+  async query(sql, params) {
+    try {
+      if (params) {
+        throw new Error("BobSQL does not support args at this moment.");
+      }
+      const response = await this.httpClient.post("query", {
+        json: { sql }
+      }).json();
+      return {
+        rows: response.rows,
+        rowCount: response.rows.length
+      };
+    } catch (error) {
+      throw new Error(`Query failed: ${error}`);
+    }
+  }
+  async close() {
+    return Promise.resolve();
+  }
+}
+
+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));
+    }
+  }
+  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}`;
+    }
+  }
+};
+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 = "";
+  try {
+    let tablesQuery;
+    let tableSchemaFilter;
+    if (driverType === "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 (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 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] : [])),
+      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 (driverType === "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 (driverType === "postgres") {
+          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
+        );
+        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", driverType);
+          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 interfaceName = table.table_name.charAt(0).toUpperCase() + table.table_name.slice(1);
+      generatedTypes += `  ${table.table_name}: ${interfaceName};
+`;
+    }
+    generatedTypes += "}\n\n";
+    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);
+    throw error;
+  } finally {
+    await client.close();
+  }
+};
+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 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 {
+        return await driver.query(sql, params);
+      } catch (error) {
+        lastError = error;
+        consola.warn(`Query failed with ${driver.constructor.name}:`, error);
+        continue;
+      }
+    }
+    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);
+    }
+    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 sql = `SELECT * FROM ${tableName}`;
+    let params = [];
+    if (whereEntries.length > 0) {
+      const whereClause = whereEntries.map((_, index) => `${whereEntries[index]?.[0]} = $${index + 1}`).join(" AND ");
+      sql += ` WHERE ${whereClause}`;
+      params = whereEntries.map(([, value]) => value);
+    }
+    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, offset } = options || {};
+    const whereEntries = Object.entries(where || {});
+    let sql = `SELECT * FROM ${tableName}`;
+    let params = [];
+    if (whereEntries.length > 0) {
+      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) {
+      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(sql, params);
+    return result.rows;
+  }
+  async insert(table, data) {
+    const tableName = String(table);
+    const keys = Object.keys(data);
+    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 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");
+    }
+    return result.rows[0];
+  }
+  async update(table, data, where) {
+    const tableName = String(table);
+    const setEntries = Object.entries(data);
+    const whereEntries = Object.entries(where);
+    if (setEntries.length === 0) {
+      throw new Error("No data provided for update");
+    }
+    if (whereEntries.length === 0) {
+      throw new Error("No conditions provided for update");
+    }
+    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) {
+    const tableName = String(table);
+    const whereEntries = Object.entries(where);
+    if (whereEntries.length === 0) {
+      throw new Error("No conditions provided for delete");
+    }
+    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;
+  }
+  // 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() {
+    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) {
+  return new SQLClient({ driver: new PostgresDriver(config) });
+}
+function createLibSQLClient(config) {
+  return new SQLClient({ driver: new LibSQLDriver(config) });
+}
+function createMySQLClient(config) {
+  return new SQLClient({ driver: new MySQLDriver(config) });
+}
+function createSqliteClient(config) {
+  return new SQLClient({ driver: new SqliteDriver(config) });
+}
+const DriftSQLClient = SQLClient;
+
+export { BobSQLDriver, DriftSQLClient, LibSQLDriver, MySQLDriver, PostgresDriver, SQLClient, SqliteDriver, createLibSQLClient, createMySQLClient, createPostgresClient, createSqliteClient, inspectDB, inspectLibSQL, inspectMySQL, inspectPostgres, inspectSQLite };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driftsql",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "description": "A lightweight SQL client for TypeScript",
   "scripts": {
     "build": "unbuild",
@@ -42,5 +42,11 @@
     "typescript": "^5.8.3",
     "unbuild": "^3.5.0",
     "vitest": "^3.2.4"
+  },
+  "unbuild": {
+    "entries": [
+      "./src/index"
+    ],
+    "outDir": "dist"
   }
 }

package/src/index.ts

@@ -12,7 +12,7 @@ export { PostgresDriver } from './drivers/postgres'
 export { LibSQLDriver } from './drivers/libsql'
 export { MySQLDriver } from './drivers/mysql'
 export { SqliteDriver } from './drivers/sqlite'
-export { BobSQLDriver, type BobSQLConfig } from './drivers/bobsql'
+export { BobSQLDriver } from './drivers/bobsql'
 // Re-export inspection utilities
 export { inspectDB, inspectPostgres, inspectLibSQL, inspectMySQL, inspectSQLite } from './pull'
 

package/src/types.ts

@@ -15,11 +15,6 @@ export interface QueryField {
 // Base driver interface that all drivers must implement
 export interface DatabaseDriver {
   query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>
-  // findMany?<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>
-  // findFirst?<T = any>(sql: string, params?: any[]): Promise<T | null>
-  // insert?<T = any>(table: string, data: Partial<T>): Promise<QueryResult<T>>
-  // update?<T = any>(table: string, data: Partial<T>, where: Partial<T>): Promise<QueryResult<T>>
-  // delete?<T = any>(table: string, where: Partial<T>): Promise<QueryResult<T>>
   close(): Promise<void>
 }