driftsql 1.0.19 → 1.0.21

package/dist/drivers/libsql.d.ts

@@ -0,0 +1,23 @@
+import type { DatabaseDriver, QueryResult, TransactionCapable } from '../types';
+export interface LibSQLConfig {
+    url: string;
+    authToken?: string;
+    useTursoServerlessDriver?: boolean;
+}
+export declare class LibSQLDriver implements DatabaseDriver, TransactionCapable {
+    private client;
+    constructor(config: LibSQLConfig);
+    query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>;
+    transaction<T>(callback: (driver: DatabaseDriver) => Promise<T>): Promise<T>;
+    findFirst<T = any>(table: string, where?: Record<string, any>): Promise<QueryResult<T> | null>;
+    findMany<T = any>(table: string, options?: {
+        where?: Record<string, any>;
+        limit?: number;
+        offset?: number;
+    }): Promise<QueryResult<T>>;
+    insert<T = any>(table: string, data: Record<string, any>): Promise<QueryResult<T>>;
+    update<T = any>(table: string, data: Record<string, any>, where: Record<string, any>): Promise<QueryResult<T>>;
+    delete(table: string, where: Record<string, any>): Promise<number>;
+    close(): Promise<void>;
+    private convertLibsqlResult;
+}

package/dist/drivers/mysql.d.ts

@@ -0,0 +1,20 @@
+import type { DatabaseDriver, QueryResult, TransactionCapable } from '../types';
+export interface MySQLConfig {
+    connectionString: string;
+}
+export declare class MySQLDriver implements DatabaseDriver, TransactionCapable {
+    private client;
+    constructor(config: MySQLConfig);
+    query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>;
+    transaction<T>(callback: (driver: DatabaseDriver) => Promise<T>): Promise<T>;
+    findFirst<T = any>(table: string, where?: Record<string, any>): Promise<QueryResult<T> | null>;
+    findMany<T = any>(table: string, options?: {
+        where?: Record<string, any>;
+        limit?: number;
+        offset?: number;
+    }): Promise<QueryResult<T>>;
+    insert<T = any>(table: string, data: Record<string, any>): Promise<QueryResult<T>>;
+    update<T = any>(table: string, data: Record<string, any>, where: Record<string, any>): Promise<QueryResult<T>>;
+    delete(table: string, where: Record<string, any>): Promise<number>;
+    close(): Promise<void>;
+}

package/dist/drivers/postgres.d.ts

@@ -0,0 +1,26 @@
+import type { DatabaseDriver, QueryResult, TransactionCapable } from '../types';
+export interface PostgresConfig {
+    connectionString?: string;
+    experimental?: {
+        http?: {
+            url: string;
+            apiKey?: string;
+        };
+    };
+}
+export declare class PostgresDriver implements DatabaseDriver, TransactionCapable {
+    private client;
+    constructor(config: PostgresConfig);
+    query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>;
+    transaction<T>(callback: (driver: DatabaseDriver) => Promise<T>): Promise<T>;
+    findFirst<T = any>(table: string, where?: Record<string, any>): Promise<QueryResult<T> | null>;
+    findMany<T = any>(table: string, options?: {
+        where?: Record<string, any>;
+        limit?: number;
+        offset?: number;
+    }): Promise<QueryResult<T>>;
+    insert<T = any>(table: string, data: Record<string, any>): Promise<QueryResult<T>>;
+    update<T = any>(table: string, data: Record<string, any>, where: Record<string, any>): Promise<QueryResult<T>>;
+    delete<T = any>(table: string, where: Record<string, any>): Promise<number>;
+    close(): Promise<void>;
+}

package/dist/drivers/sqlite.d.ts

@@ -0,0 +1,25 @@
+import type { DatabaseDriver, QueryResult, TransactionCapable, PreparedStatementCapable, PreparedStatement } from '../types';
+export interface SqliteConfig {
+    filename: string;
+    readonly?: boolean;
+}
+export declare class SqliteDriver implements DatabaseDriver, TransactionCapable, PreparedStatementCapable {
+    private client;
+    constructor(config: SqliteConfig);
+    query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>;
+    transaction<T>(callback: (driver: DatabaseDriver) => Promise<T>): Promise<T>;
+    prepare(sql: string): Promise<PreparedStatement>;
+    findFirst<T = any>(table: string, where?: Record<string, any>): Promise<QueryResult<T> | null>;
+    findMany<T = any>(table: string, options?: {
+        where?: Record<string, any>;
+        limit?: number;
+        offset?: number;
+    }): Promise<QueryResult<T>>;
+    insert<T = any>(table: string, data: Record<string, any>): Promise<QueryResult<T>>;
+    update<T = any>(table: string, data: Record<string, any>, where: Record<string, any>): Promise<QueryResult<T>>;
+    delete(table: string, where: Record<string, any>): Promise<number>;
+    close(): Promise<void>;
+    exec(sql: string): void;
+    backup(filename: string): Promise<void>;
+    pragma(pragma: string): any;
+}

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import type { DatabaseDriver, QueryResult } from './types';
+export type { DatabaseDriver, QueryResult, QueryError, QueryField, ConnectionError } from './types';
+export { PostgresDriver } from './drivers/postgres';
+export { LibSQLDriver } from './drivers/libsql';
+export { MySQLDriver } from './drivers/mysql';
+export { SqliteDriver } from './drivers/sqlite';
+export { inspectDB, inspectPostgres, inspectLibSQL, inspectMySQL, inspectSQLite } from './pull';
+export interface ClientOptions<T extends DatabaseDriver = DatabaseDriver> {
+    driver: T;
+    fallbackDrivers?: DatabaseDriver[];
+}
+export declare class SQLClient<DT = any> {
+    private primaryDriver;
+    private fallbackDrivers;
+    constructor(options: ClientOptions);
+    query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>;
+    transaction<T>(callback: (client: SQLClient<DT>) => Promise<T>): Promise<T>;
+    prepare(sql: string): Promise<import("./types").PreparedStatement>;
+    findFirst<K extends keyof DT>(table: K, where?: Partial<DT[K]>): Promise<DT[K] | null>;
+    findMany<K extends keyof DT>(table: K, options?: {
+        where?: Partial<DT[K]>;
+        limit?: number;
+        offset?: number;
+    }): Promise<DT[K][]>;
+    insert<K extends keyof DT>(table: K, data: Partial<DT[K]>): Promise<DT[K]>;
+    update<K extends keyof DT>(table: K, data: Partial<DT[K]>, where: Partial<DT[K]>): Promise<DT[K] | null>;
+    delete<K extends keyof DT>(table: K, where: Partial<DT[K]>): Promise<number>;
+    getDriver(): DatabaseDriver;
+    supportsTransactions(): boolean;
+    supportsPreparedStatements(): boolean;
+    close(): Promise<void>;
+}
+export declare function createPostgresClient<DT = any>(config: {
+    connectionString?: string;
+    experimental?: {
+        http?: {
+            url: string;
+            apiKey?: string;
+        };
+    };
+}): SQLClient<DT>;
+export declare function createLibSQLClient<DT = any>(config: {
+    url: string;
+    authToken?: string;
+    useTursoServerlessDriver?: boolean;
+}): SQLClient<DT>;
+export declare function createMySQLClient<DT = any>(config: {
+    connectionString: string;
+}): SQLClient<DT>;
+export declare function createSqliteClient<DT = any>(config: {
+    filename: string;
+    readonly?: boolean;
+}): SQLClient<DT>;
+export declare const DriftSQLClient: typeof SQLClient;

package/dist/index.js

@@ -0,0 +1,48 @@
+import consola2 from"consola";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{driverType;originalError;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"}}import postgres from"postgres";import ky from"ky";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:undefined}}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 findFirst(table,where){const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;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.length>0?result:null}async findMany(table,options){if(this.client instanceof PostgresHTTPDriver){return await this.client.findMany(table,options)}const{where,limit,offset}=options||{};const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;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)}return this.query(sql,params)}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}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.length>0?result:result}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}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:undefined}}catch(error){throw new QueryError("postgres-http",sql,error)}}async findFirst(table,where){const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;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.length>0?result:null}async findMany(table,options){const{where,limit,offset}=options||{};const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;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)}return this.query(sql,params)}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}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.length>0?result:result}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}async close(){return Promise.resolve()}}import{createClient}from"@libsql/client";import{createClient as tursoServerLessClient}from"@tursodatabase/serverless/compat";class LibSQLDriver{client;constructor(config){try{this.client=config.useTursoServerlessDriver?tursoServerLessClient({url:config.url,...config.authToken?{authToken:config.authToken}:{}}):createClient({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 findFirst(table,where){const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;let params=[];if(whereEntries.length>0){const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = ?`).join(" AND ");sql+=` WHERE ${whereClause}`;params=whereEntries.map(([,value])=>value)}sql+=" LIMIT 1";const result=await this.query(sql,params);return result.rows.length>0?result:null}async findMany(table,options){const{where,limit,offset}=options||{};const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;let params=[];if(whereEntries.length>0){const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = ?`).join(" AND ");sql+=` WHERE ${whereClause}`;params=whereEntries.map(([,value])=>value)}if(typeof limit==="number"&&limit>0){sql+=` LIMIT ?`;params.push(limit)}if(typeof offset==="number"&&offset>0){sql+=` OFFSET ?`;params.push(offset)}return this.query(sql,params)}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(()=>"?").join(", ");const sql=`INSERT INTO ${tableName} (${keys.join(", ")}) VALUES (${placeholders})`;try{const result=await this.client.execute(sql,values);if(result.lastInsertRowid){try{const selectSql=`SELECT * FROM ${tableName} WHERE rowid = ?`;const insertedRow=await this.query(selectSql,[result.lastInsertRowid]);return{rows:insertedRow.rows,rowCount:result.rowsAffected||0,command:undefined,fields:insertedRow.fields}}catch{return{rows:[],rowCount:result.rowsAffected||0,command:undefined,fields:[]}}}return{rows:[],rowCount:result.rowsAffected||0,command:undefined,fields:[]}}catch(error){throw new QueryError("libsql",sql,error)}}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(([key])=>`${key} = ?`).join(", ");const whereClause=whereEntries.map(([key])=>`${key} = ?`).join(" AND ");const sql=`UPDATE ${tableName} SET ${setClause} WHERE ${whereClause}`;const params=[...setEntries.map(([,value])=>value),...whereEntries.map(([,value])=>value)];try{const result=await this.client.execute(sql,params);const selectSql=`SELECT * FROM ${tableName} WHERE ${whereClause}`;const selectParams=whereEntries.map(([,value])=>value);const updatedRows=await this.query(selectSql,selectParams);return{rows:updatedRows.rows,rowCount:result.rowsAffected||0,command:undefined,fields:updatedRows.fields}}catch(error){throw new QueryError("libsql",sql,error)}}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(([key])=>`${key} = ?`).join(" AND ");const sql=`DELETE FROM ${tableName} WHERE ${whereClause}`;const params=whereEntries.map(([,value])=>value);try{const result=await this.client.execute(sql,params);return result.rowsAffected||0}catch(error){throw new QueryError("libsql",sql,error)}}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:undefined,fields:result.columns.map((col)=>({name:col,dataTypeID:0}))}}}import consola from"consola";import*as mysql from"mysql2/promise";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:undefined,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 findFirst(table,where){const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;let params=[];if(whereEntries.length>0){const whereClause=whereEntries.map(([key])=>`${key} = ?`).join(" AND ");sql+=` WHERE ${whereClause}`;params=whereEntries.map(([,value])=>value)}sql+=" LIMIT 1";const result=await this.query(sql,params);return result.rows.length>0?result:null}async findMany(table,options){const{where,limit,offset}=options||{};const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;let params=[];if(whereEntries.length>0){const whereClause=whereEntries.map(([key])=>`${key} = ?`).join(" AND ");sql+=` WHERE ${whereClause}`;params=whereEntries.map(([,value])=>value)}if(typeof limit==="number"&&limit>0){sql+=` LIMIT ?`;params.push(limit)}if(typeof offset==="number"&&offset>0){sql+=` OFFSET ?`;params.push(offset)}return this.query(sql,params)}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(()=>"?").join(", ");const sql=`INSERT INTO ${tableName} (${keys.join(", ")}) VALUES (${placeholders})`;try{const connection=await this.client;const[result]=await connection.execute(sql,values);const insertResult=result;if(insertResult.insertId){try{const selectSql=`SELECT * FROM ${tableName} WHERE id = ?`;const insertedRow=await this.query(selectSql,[insertResult.insertId]);return{rows:insertedRow.rows,rowCount:insertResult.affectedRows||0,command:undefined,fields:insertedRow.fields}}catch{return{rows:[],rowCount:insertResult.affectedRows||0,command:undefined,fields:[]}}}return{rows:[],rowCount:insertResult.affectedRows||0,command:undefined,fields:[]}}catch(error){throw new QueryError("mysql",sql,error)}}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(([key])=>`${key} = ?`).join(", ");const whereClause=whereEntries.map(([key])=>`${key} = ?`).join(" AND ");const sql=`UPDATE ${tableName} SET ${setClause} WHERE ${whereClause}`;const params=[...setEntries.map(([,value])=>value),...whereEntries.map(([,value])=>value)];try{const connection=await this.client;const[result]=await connection.execute(sql,params);const selectSql=`SELECT * FROM ${tableName} WHERE ${whereClause}`;const selectParams=whereEntries.map(([,value])=>value);const updatedRows=await this.query(selectSql,selectParams);const updateResult=result;return{rows:updatedRows.rows,rowCount:updateResult.affectedRows||0,command:undefined,fields:updatedRows.fields}}catch(error){throw new QueryError("mysql",sql,error)}}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(([key])=>`${key} = ?`).join(" AND ");const sql=`DELETE FROM ${tableName} WHERE ${whereClause}`;const params=whereEntries.map(([,value])=>value);try{const connection=await this.client;const[result]=await connection.execute(sql,params);const deleteResult=result;return deleteResult.affectedRows||0}catch(error){throw new QueryError("mysql",sql,error)}}async close(){try{await(await this.client).end()}catch(error){consola.error("Error closing MySQL client:",error)}}}import Database from"better-sqlite3";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:undefined,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 findFirst(table,where){const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;let params=[];if(whereEntries.length>0){const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = ?`).join(" AND ");sql+=` WHERE ${whereClause}`;params=whereEntries.map(([,value])=>value)}sql+=" LIMIT 1";const result=await this.query(sql,params);return result.rows.length>0?result:null}async findMany(table,options){const{where,limit,offset}=options||{};const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;let params=[];if(whereEntries.length>0){const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = ?`).join(" AND ");sql+=` WHERE ${whereClause}`;params=whereEntries.map(([,value])=>value)}if(typeof limit==="number"&&limit>0){sql+=` LIMIT ?`;params.push(limit)}if(typeof offset==="number"&&offset>0){sql+=` OFFSET ?`;params.push(offset)}return this.query(sql,params)}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(()=>"?").join(", ");const sql=`INSERT INTO ${tableName} (${keys.join(", ")}) VALUES (${placeholders})`;try{const stmt=this.client.prepare(sql);const result=stmt.run(values);if(result.lastInsertRowid){const selectSql=`SELECT * FROM ${tableName} WHERE rowid = ?`;const insertedRow=await this.query(selectSql,[result.lastInsertRowid]);return{rows:insertedRow.rows,rowCount:result.changes,command:undefined,fields:insertedRow.fields}}return{rows:[],rowCount:result.changes,command:undefined,fields:[]}}catch(error){throw new QueryError("sqlite",sql,error)}}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(([key])=>`${key} = ?`).join(", ");const whereClause=whereEntries.map(([key])=>`${key} = ?`).join(" AND ");const sql=`UPDATE ${tableName} SET ${setClause} WHERE ${whereClause}`;const params=[...setEntries.map(([,value])=>value),...whereEntries.map(([,value])=>value)];try{const stmt=this.client.prepare(sql);const result=stmt.run(params);const selectSql=`SELECT * FROM ${tableName} WHERE ${whereClause}`;const selectParams=whereEntries.map(([,value])=>value);const updatedRows=await this.query(selectSql,selectParams);return{rows:updatedRows.rows,rowCount:result.changes,command:undefined,fields:updatedRows.fields}}catch(error){throw new QueryError("sqlite",sql,error)}}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(([key])=>`${key} = ?`).join(" AND ");const sql=`DELETE FROM ${tableName} WHERE ${whereClause}`;const params=whereEntries.map(([,value])=>value);try{const stmt=this.client.prepare(sql);const result=stmt.run(params);return result.changes}catch(error){throw new QueryError("sqlite",sql,error)}}async close(){try{this.client.close()}catch(error){console.error("Error closing SQLite client:",error)}}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{stmt;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:undefined,fields}}catch(error){throw new QueryError("sqlite","prepared statement",error)}}async finalize(){return Promise.resolve()}run(params){return this.stmt.run(params||[])}get(params){return this.stmt.get(params||[])}all(params){return this.stmt.all(params||[])}}import fs from"node:fs/promises";var withTimeout=(promise,timeoutMs=30000)=>{return Promise.race([promise,new Promise((_,reject)=>setTimeout(()=>reject(new Error(`Query timeout after ${timeoutMs}ms`)),timeoutMs))])};var retryQuery=async(queryFn,maxRetries=3,baseDelay=1000)=>{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")};var 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}`}}};var 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"};var 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=undefined}else{throw new Error(`Unsupported driver type: ${driverType}`)}const tables=await withTimeout(retryQuery(()=>client.query(tablesQuery,tableSchemaFilter?[tableSchemaFilter]:[])),30000);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)),15000);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=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+=`}
+
+`}catch(error){console.error(`Failed to process table ${tableName}:`,error);console.log(`Skipping table ${tableName} and continuing...`);continue}}generatedTypes+=`export interface Database {
+`;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+=`}
+
+`;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()}};var inspectPostgres=async(config,outputFile)=>{const driver=new PostgresDriver(config);return inspectDB({driver,outputFile})};var inspectLibSQL=async(config,outputFile)=>{const driver=new LibSQLDriver(config);return inspectDB({driver,outputFile})};var inspectMySQL=async(config,outputFile)=>{const driver=new MySQLDriver(config);return inspectDB({driver,outputFile})};var 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;consola2.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)}async findFirst(table,where){if(!this.primaryDriver.findFirst)throw new DatabaseError("Primary driver does not support findFirst",this.primaryDriver.constructor.name);try{const response=await this.primaryDriver.findFirst(table,where);return response.rows[0]||null}catch(error){throw new QueryError("findFirst",`Error finding first in ${String(table)}`,error)}}async findMany(table,options){if(!this.primaryDriver.findMany)throw new DatabaseError("Primary driver does not support findMany",this.primaryDriver.constructor.name);try{const response=await this.primaryDriver.findMany(table,options);return response.rows}catch(error){throw new QueryError("findMany",`Error finding many in ${String(table)}`,error)}}async insert(table,data){if(!this.primaryDriver.insert)throw new DatabaseError("Primary driver does not support insert",this.primaryDriver.constructor.name);try{const response=await this.primaryDriver.insert(table,data);return response.rows[0]}catch(error){throw new QueryError("insert",`Error inserting into ${String(table)}`,error)}}async update(table,data,where){if(!this.primaryDriver.update)throw new DatabaseError("Primary driver does not support update",this.primaryDriver.constructor.name);try{const response=await this.primaryDriver.update(table,data,where);return response.rows[0]||null}catch(error){throw new QueryError("update",`Error updating ${String(table)}`,error)}}async delete(table,where){if(!this.primaryDriver.delete)throw new DatabaseError("Primary driver does not support delete",this.primaryDriver.constructor.name);try{const affectedRows=await this.primaryDriver.delete(table,where);return affectedRows}catch(error){throw new QueryError("delete",`Error deleting from ${String(table)}`,error)}}getDriver(){return this.primaryDriver}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)=>consola2.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)})}var DriftSQLClient=SQLClient;export{inspectSQLite,inspectPostgres,inspectMySQL,inspectLibSQL,inspectDB,createSqliteClient,createPostgresClient,createMySQLClient,createLibSQLClient,SqliteDriver,SQLClient,PostgresDriver,MySQLDriver,LibSQLDriver,DriftSQLClient};

package/dist/pull.d.ts

@@ -0,0 +1,28 @@
+import type { DatabaseDriver } from './types';
+interface InspectOptions {
+    driver: DatabaseDriver;
+    outputFile?: string;
+}
+export declare const inspectDB: (options: InspectOptions) => Promise<void>;
+export declare const inspectPostgres: (config: {
+    connectionString?: string;
+    experimental?: {
+        http?: {
+            url: string;
+            apiKey?: string;
+        };
+    };
+}, outputFile?: string) => Promise<void>;
+export declare const inspectLibSQL: (config: {
+    url: string;
+    authToken?: string;
+    useTursoServerlessDriver?: boolean;
+}, outputFile?: string) => Promise<void>;
+export declare const inspectMySQL: (config: {
+    connectionString: string;
+}, outputFile?: string) => Promise<void>;
+export declare const inspectSQLite: (config: {
+    filename: string;
+    readonly?: boolean;
+}, outputFile?: string) => Promise<void>;
+export default inspectDB;

package/dist/types.d.ts

@@ -0,0 +1,49 @@
+export interface QueryResult<T = any> {
+    rows: T[];
+    rowCount: number;
+    command?: string;
+    fields?: QueryField[];
+}
+export interface QueryField {
+    name: string;
+    dataTypeID: number;
+}
+export interface DatabaseDriver {
+    query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>;
+    findFirst?(table: string, where?: Record<string, any>): Promise<QueryResult<any> | null>;
+    findMany?(table: string, options?: {
+        where?: Record<string, any>;
+        limit?: number;
+        offset?: number;
+    }): Promise<QueryResult<any>>;
+    insert?(table: string, data: Record<string, any>): Promise<QueryResult<any>>;
+    update?(table: string, data: Record<string, any>, where: Record<string, any>): Promise<QueryResult<any>>;
+    delete?(table: string, where: Record<string, any>): Promise<number>;
+    close(): Promise<void>;
+}
+export interface TransactionCapable {
+    transaction<T>(callback: (driver: DatabaseDriver) => Promise<T>): Promise<T>;
+}
+export interface PreparedStatementCapable {
+    prepare(sql: string): Promise<PreparedStatement>;
+}
+export interface PreparedStatement {
+    execute<T = any>(params?: any[]): Promise<QueryResult<T>>;
+    finalize(): Promise<void>;
+}
+export declare function hasTransactionSupport(driver: DatabaseDriver): driver is DatabaseDriver & TransactionCapable;
+export declare function hasPreparedStatementSupport(driver: DatabaseDriver): driver is DatabaseDriver & PreparedStatementCapable;
+export declare class DatabaseError extends Error {
+    readonly driverType: string;
+    readonly originalError?: Error | undefined;
+    constructor(message: string, driverType: string, originalError?: Error | undefined);
+}
+export declare class QueryError extends DatabaseError {
+    constructor(driverType: string, sql: string, originalError?: Error);
+}
+export declare class ConnectionError extends DatabaseError {
+    constructor(driverType: string, originalError?: Error);
+}
+export interface DriverOptions {
+    [key: string]: any;
+}

package/package.json

@@ -1,16 +1,10 @@
 {
   "name": "driftsql",
-  "version": "1.0.19",
+  "version": "1.0.21",
+  "main": "dist/index.js",
   "description": "A lightweight SQL client for TypeScript",
   "scripts": {
-    "build": "unbuild",
-    "dev": "vitest dev",
-    "lint": "eslint . && prettier -c .",
-    "lint:fix": "automd && eslint . --fix && prettier -w .",
-    "prepack": "pnpm build",
-    "release": "pnpm test && changelogen --release && npm publish && git push --follow-tags",
-    "test": "pnpm lint && pnpm test:types && vitest run --coverage",
-    "test:types": "tsc --noEmit --skipLibCheck"
+    "build": "bun build.ts"
   },
   "author": "lasse vestergaard",
   "license": "MIT",
@@ -22,7 +16,7 @@
     "@types/pg": "^8.15.4",
     "better-sqlite3": "^12.2.0",
     "consola": "^3.4.2",
-    "driftsql": "^0.0.1",
+    "driftsql": "^1.0.19",
     "drizzle-orm": "^0.44.2",
     "ky": "^1.8.1",
     "mysql2": "^3.14.1",
@@ -42,11 +36,5 @@
     "typescript": "^5.8.3",
     "unbuild": "^3.5.0",
     "vitest": "^3.2.4"
-  },
-  "unbuild": {
-    "entries": [
-      "./src/index"
-    ],
-    "outDir": "dist"
   }
 }

package/tsconfig.json

@@ -1,20 +1,34 @@
 {
   "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
     "target": "ESNext",
     "module": "Preserve",
-    "moduleResolution": "bundler",
     "moduleDetection": "force",
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "allowJs": true,
     "resolveJsonModule": true,
-    "strict": true,
     "isolatedModules": true,
-    "verbatimModuleSyntax": true,
-    "noUncheckedIndexedAccess": true,
-    "forceConsistentCasingInFileNames": true,
+    "jsx": "react-jsx",
+    "allowJs": true,
+    // Bundler mode
+    "moduleResolution": "bundler",
     "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noImplicitAny": true,
     "noImplicitOverride": true,
-    "noEmit": true
-  }
+    "noImplicitThis": true,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false,
+    // Output declarations
+    "declaration": true,
+    "declarationDir": "dist",
+    "emitDeclarationOnly": true,
+    "stripInternal": true
+  },
+  "include": ["src"]
 }

package/src/drivers/bobsql.ts

@@ -1,43 +0,0 @@
-import type { DatabaseDriver, QueryResult } from '../types'
-import ky from 'ky'
-
-export interface BobSQLConfig {
-  url: string
-  authToken?: string
-}
-
-export class BobSQLDriver implements DatabaseDriver {
-  private httpClient: typeof ky
-
-  constructor(config: BobSQLConfig) {
-    this.httpClient = ky.create({
-      prefixUrl: config.url,
-      ...(config.authToken ? { headers: { Authorization: `Bearer ${config.authToken}` } } : {}),
-    })
-  }
-
-  async query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>> {
-    try {
-      if (params) {
-        throw new Error('BobSQL does not support args at this moment.')
-      }
-
-      const response = await this.httpClient
-        .post('query', {
-          json: { sql },
-        })
-        .json<{ rows: T[] }>()
-
-      return {
-        rows: response.rows,
-        rowCount: response.rows.length,
-      }
-    } catch (error) {
-      throw new Error(`Query failed: ${error}`)
-    }
-  }
-
-  async close(): Promise<void> {
-    return Promise.resolve()
-  }
-}

package/src/drivers/libsql.ts

@@ -1,70 +0,0 @@
-import { createClient, type ResultSet } from '@libsql/client'
-import { createClient as tursoServerLessClient, type ResultSet as tursoServerLessResultSet } from '@tursodatabase/serverless/compat'
-import type { DatabaseDriver, QueryResult, TransactionCapable } from '../types'
-import { QueryError, ConnectionError } from '../types'
-
-export interface LibSQLConfig {
-  url: string
-  authToken?: string
-  useTursoServerlessDriver?: boolean
-}
-
-export class LibSQLDriver implements DatabaseDriver, TransactionCapable {
-  private client: ReturnType<typeof createClient> | ReturnType<typeof tursoServerLessClient>
-
-  constructor(config: LibSQLConfig) {
-    try {
-      this.client = config.useTursoServerlessDriver
-        ? tursoServerLessClient({
-            url: config.url,
-            ...(config.authToken ? { authToken: config.authToken } : {}),
-          })
-        : createClient({
-            url: config.url,
-            ...(config.authToken ? { authToken: config.authToken } : {}),
-          })
-    } catch (error) {
-      throw new ConnectionError('libsql', error as Error)
-    }
-  }
-
-  async query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>> {
-    try {
-      const result = await this.client.execute(sql, params)
-      return this.convertLibsqlResult<T>(result)
-    } catch (error) {
-      throw new QueryError('libsql', sql, error as Error)
-    }
-  }
-
-  async transaction<T>(callback: (driver: DatabaseDriver) => Promise<T>): Promise<T> {
-    const transactionDriver = new LibSQLDriver({ url: '', authToken: '' })
-    ;(transactionDriver as any).client = this.client
-    return await callback(transactionDriver)
-  }
-
-  async close(): Promise<void> {
-    try {
-      this.client.close()
-    } catch (error) {
-      console.error('Error closing LibSQL client:', error)
-    }
-  }
-
-  private convertLibsqlResult<T = any>(result: ResultSet | tursoServerLessResultSet): QueryResult<T> {
-    const rows = result.rows.map((row) => {
-      const obj: Record<string, any> = {}
-      result.columns.forEach((col, index) => {
-        obj[col] = row[index]
-      })
-      return obj as T
-    })
-
-    return {
-      rows,
-      rowCount: result.rowsAffected || rows.length,
-      command: undefined,
-      fields: result.columns.map((col) => ({ name: col, dataTypeID: 0 })),
-    }
-  }
-}

package/src/drivers/mysql.ts

@@ -1,70 +0,0 @@
-import consola from 'consola'
-import * as mysql from 'mysql2/promise'
-import type { DatabaseDriver, QueryResult, TransactionCapable } from '../types'
-import { QueryError, ConnectionError } from '../types'
-
-export interface MySQLConfig {
-  connectionString: string
-}
-
-export class MySQLDriver implements DatabaseDriver, TransactionCapable {
-  private client: ReturnType<typeof mysql.createConnection>
-
-  constructor(config: MySQLConfig) {
-    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 as Error)
-    }
-  }
-
-  async query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>> {
-    try {
-      const [rows, fields] = await (await this.client).execute(sql, params || [])
-      const rowCount = Array.isArray(rows) ? rows.length : 0
-
-      const normalizedFields = fields.map((field: any) => ({
-        name: field.name,
-        dataTypeID: field.columnType,
-      }))
-
-      return {
-        rows: rows as T[],
-        rowCount,
-        command: undefined,
-        fields: normalizedFields,
-      }
-    } catch (error) {
-      throw new QueryError('mysql', sql, error as Error)
-    }
-  }
-
-  async transaction<T>(callback: (driver: DatabaseDriver) => Promise<T>): Promise<T> {
-    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(): Promise<void> {
-    try {
-      await (await this.client).end()
-    } catch (error) {
-      consola.error('Error closing MySQL client:', error)
-    }
-  }
-}