driftsql 1.0.23 → 1.0.25

package/README.md

@@ -3,7 +3,7 @@
 [![npm version](https://img.shields.io/npm/v/driftsql?color=yellow)](https://npmjs.com/package/driftsql)
 [![npm downloads](https://img.shields.io/npm/dm/driftsql?color=yellow)](https://npm.chart.dev/driftsql)
 
-A lightweight, type-safe SQL client for TypeScript with support for PostgreSQL, MySQL, and LibSQL/SQLite.
+A lightweight, type-safe SQL client for TypeScript with support for PostgreSQL, MySQL, LibSQL/SQLite, and Neon.
 
 ## Installation
 
@@ -41,11 +41,14 @@ const newUser = await client.insert('users', { name: 'John', email: 'john@exampl
 ## Supported Databases
 
 ```typescript
-import { PostgresDriver, LibSQLDriver, MySQLDriver, SQLClient } from 'driftsql'
+import { PostgresDriver, LibSQLDriver, MySQLDriver, NeonDriver, SQLClient } from 'driftsql'
 
 // PostgreSQL
 const pg = new PostgresDriver({ connectionString: 'postgresql://...' })
 
+// Neon
+const neon = new NeonDriver({ connectionString: 'postgresql://...' })
+
 // LibSQL/Turso/SQLite
 const libsql = new LibSQLDriver({ url: 'libsql://...', authToken: '...' })
 // or for local SQLite: new LibSQLDriver({ url: 'file:./database.db' })
@@ -83,6 +86,63 @@ class MyCustomDriver implements DatabaseDriver {
 const client = new SQLClient({ driver: new MyCustomDriver() })
 ```
 
+## Database Inspection
+
+Generate TypeScript interfaces from your database schema:
+
+```typescript
+import { inspectDB, PostgresDriver } from 'driftsql'
+
+const driver = new PostgresDriver({
+  connectionString: 'postgresql://user:password@localhost:5432/mydb',
+})
+
+// Generate types for all tables
+await inspectDB({
+  driver,
+  outputFile: 'db-types.ts', // optional, defaults to 'db-types.ts'
+})
+```
+
+This will create a file with TypeScript interfaces for each table:
+
+```typescript
+// Generated db-types.ts
+export interface Users {
+  id: number
+  name: string
+  email: string
+  created_at: Date
+  active: boolean | null
+}
+
+export interface Posts {
+  id: number
+  title: string
+  content: string
+  user_id: number
+  published: boolean
+}
+
+export interface Database {
+  users: Users
+  posts: Posts
+}
+```
+
+Then use the generated types with your client:
+
+```typescript
+import type { Database } from './db-types'
+import { PostgresDriver, SQLClient } from 'driftsql'
+
+const client = new SQLClient<Database>({ driver })
+
+// Now you get full type safety
+const user = await client.findFirst('users', { email: 'test@example.com' }) // Returns Users | null
+const posts = await client.findMany('posts', { where: { published: true } }) // Returns Posts[]
+```
+
 ## License
 
 Published under the [MIT](https://github.com/lassejlv/driftsql/blob/main/LICENSE) license.

package/dist/drivers/sqlitecloud.d.ts

@@ -0,0 +1,12 @@
+import { type DatabaseDriver, type QueryResult } from '../types';
+export interface SqliteCloudDriverOptions {
+    connectionString: string;
+}
+export declare class SqliteCloudDriver implements DatabaseDriver {
+    private readonly options;
+    private client;
+    constructor(options: SqliteCloudDriverOptions);
+    query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>;
+    prepare(sql: string): Promise<import("@sqlitecloud/drivers/lib/drivers/statement").Statement<any>>;
+    close(): Promise<void>;
+}

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export { PostgresDriver } from './drivers/postgres';
 export { LibSQLDriver } from './drivers/libsql';
 export { MySQLDriver } from './drivers/mysql';
 export { NeonDriver } from './drivers/neon';
+export { SqliteCloudDriver } from './drivers/sqlitecloud';
 export { inspectDB } from './pull';
 export interface ClientOptions<T extends DatabaseDriver = DatabaseDriver> {
     driver: T;

package/dist/index.js

@@ -1,4 +1,4 @@
-import consola3 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){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{neon}from"@neondatabase/serverless";class NeonDriver{client;constructor(options){this.client=neon(options.connectionString)}async query(sql,params){try{const resp=await this.client.query(sql,params);return{rows:resp,rowCount:resp.length||0}}catch(error){throw new QueryError("neon",`Failed to query database: ${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}close(){return Promise.resolve()}}import consola2 from"consola";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);consola2.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:{consola2.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 NeonDriver)return"neon";return"unknown"};var inspectDB=async(options)=>{const{driver,outputFile="db-types.ts"}=options;const driverType=getDriverType(driver);consola2.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")}consola2.log(`Using MySQL database: ${currentDatabase}`);tablesQuery=`SELECT TABLE_NAME as table_name
+import consola3 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){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{neon}from"@neondatabase/serverless";class NeonDriver{client;constructor(options){this.client=neon(options.connectionString)}async query(sql,params){try{const resp=await this.client.query(sql,params);return{rows:resp,rowCount:resp.length||0}}catch(error){throw new QueryError("neon",`Failed to query database: ${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}close(){return Promise.resolve()}}import{Database}from"@sqlitecloud/drivers";class SqliteCloudDriver{options;client;constructor(options){this.options=options;this.client=new Database(this.options.connectionString)}async query(sql,params){try{const result=await this.client.sql(sql,params);const rows=Array.isArray(result)?result.map((row)=>{const data={};for(const key in row){if(typeof row[key]!=="function"){data[key]=row[key]}}return data}):[];return{rows,rowCount:rows.length,command:undefined}}catch(error){throw new QueryError("sqlitecloud",sql,error)}}async prepare(sql){return this.client.prepare(sql)}async close(){this.client.close()}}import consola2 from"consola";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);consola2.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:{consola2.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 NeonDriver)return"neon";return"unknown"};var inspectDB=async(options)=>{const{driver,outputFile="db-types.ts"}=options;const driverType=getDriverType(driver);consola2.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")}consola2.log(`Using MySQL database: ${currentDatabase}`);tablesQuery=`SELECT TABLE_NAME as table_name
                    FROM information_schema.tables
                    WHERE TABLE_SCHEMA = ?
                    AND TABLE_TYPE = 'BASE TABLE'
@@ -45,4 +45,4 @@ import consola3 from"consola";function hasTransactionSupport(driver){return"tran
 `;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");consola2.log(`TypeScript types written to ${outputFile}`);consola2.log(`Successfully processed ${processedTables} tables`)}catch(error){consola2.error("Fatal error during database inspection:",error);throw error}finally{await client.close()}};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;consola3.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)=>consola3.warn(`Error closing ${driver.constructor.name}:`,err))))}}var DriftSQLClient=SQLClient;export{inspectDB,SQLClient,PostgresDriver,NeonDriver,MySQLDriver,LibSQLDriver,DriftSQLClient};
+`;await fs.writeFile(outputFile,generatedTypes,"utf8");consola2.log(`TypeScript types written to ${outputFile}`);consola2.log(`Successfully processed ${processedTables} tables`)}catch(error){consola2.error("Fatal error during database inspection:",error);throw error}finally{await client.close()}};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;consola3.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)=>consola3.warn(`Error closing ${driver.constructor.name}:`,err))))}}var DriftSQLClient=SQLClient;export{inspectDB,SqliteCloudDriver,SQLClient,PostgresDriver,NeonDriver,MySQLDriver,LibSQLDriver,DriftSQLClient};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driftsql",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "main": "dist/index.js",
   "description": "A lightweight SQL client for TypeScript",
   "scripts": {
@@ -13,20 +13,20 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@libsql/client": "^0.15.9",
+    "@libsql/client": "^0.15.12",
     "@neondatabase/serverless": "^1.0.1",
     "@sqlitecloud/drivers": "^1.0.507",
-    "@tursodatabase/serverless": "^0.1.2",
+    "@tursodatabase/serverless": "^0.1.3",
     "consola": "^3.4.2",
-    "driftsql": "^1.0.19",
-    "ky": "^1.8.1",
-    "mysql2": "^3.14.1",
+    "ky": "^1.9.0",
+    "mysql2": "^3.14.3",
+    "ora": "^8.2.0",
     "postgres": "^3.4.7",
-    "zod": "^4.0.17"
+    "zod": "^4.1.3"
   },
   "devDependencies": {
-    "@types/bun": "^1.2.20",
+    "@types/bun": "^1.2.21",
     "prettier": "^3.6.2",
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.2"
   }
 }

package/dist/drivers/sqlite.d.ts

@@ -1,25 +0,0 @@
-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.mjs

@@ -1,764 +0,0 @@
-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 };