driftsql 1.0.15 → 1.0.17

package/.prettierrc

@@ -0,0 +1,5 @@
+{
+  "printWidth": 200,
+  "semi": false,
+  "singleQuote": true
+}

package/package.json

@@ -1,21 +1,7 @@
 {
   "name": "driftsql",
-  "version": "1.0.15",
-  "author": "lasse vestergaard",
+  "version": "1.0.17",
   "description": "A lightweight SQL client for TypeScript",
-  "repository": "lassejlv/driftsql",
-  "license": "MIT",
-  "sideEffects": false,
-  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.mts",
-      "default": "./dist/index.mjs"
-    }
-  },
-  "files": [
-    "dist"
-  ],
   "scripts": {
     "build": "unbuild",
     "dev": "vitest dev",
@@ -26,20 +12,8 @@
     "test": "pnpm lint && pnpm test:types && vitest run --coverage",
     "test:types": "tsc --noEmit --skipLibCheck"
   },
-  "devDependencies": {
-    "@types/better-sqlite3": "^7.6.13",
-    "@types/node": "^22.15.34",
-    "@vitest/coverage-v8": "^3.2.4",
-    "automd": "^0.4.0",
-    "changelogen": "^0.6.1",
-    "eslint": "^9.30.0",
-    "eslint-config-unjs": "^0.4.2",
-    "prettier": "^3.6.2",
-    "typescript": "^5.8.3",
-    "unbuild": "^3.5.0",
-    "vitest": "^3.2.4"
-  },
-  "packageManager": "pnpm@10.12.1",
+  "author": "lasse vestergaard",
+  "license": "MIT",
   "dependencies": {
     "@libsql/client": "^0.15.9",
     "@neondatabase/serverless": "^1.0.1",
@@ -54,5 +28,19 @@
     "mysql2": "^3.14.1",
     "pg": "^8.16.3",
     "postgres": "^3.4.7"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/bun": "^1.2.20",
+    "@types/node": "^22.15.34",
+    "@vitest/coverage-v8": "^3.2.4",
+    "automd": "^0.4.0",
+    "changelogen": "^0.6.1",
+    "eslint": "^9.30.0",
+    "eslint-config-unjs": "^0.4.2",
+    "prettier": "^3.6.2",
+    "typescript": "^5.8.3",
+    "unbuild": "^3.5.0",
+    "vitest": "^3.2.4"
   }
 }

package/src/drivers/libsql.ts

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,70 @@
+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)
+    }
+  }
+}

package/src/drivers/postgres.ts

@@ -0,0 +1,112 @@
+import postgres from 'postgres'
+import ky from 'ky'
+import type { DatabaseDriver, QueryResult, TransactionCapable } from '../types'
+import { QueryError, ConnectionError } from '../types'
+
+export interface PostgresConfig {
+  connectionString?: string
+  experimental?: {
+    http?: {
+      url: string
+      apiKey?: string
+    }
+  }
+}
+
+export class PostgresDriver implements DatabaseDriver, TransactionCapable {
+  private client: postgres.Sql | PostgresHTTPDriver
+
+  constructor(config: PostgresConfig) {
+    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 as Error)
+    }
+  }
+
+  async query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>> {
+    try {
+      if (this.client instanceof PostgresHTTPDriver) {
+        return await this.client.query<T>(sql, params)
+      }
+
+      const result = await this.client.unsafe(sql, params || [])
+      return {
+        rows: result as unknown as T[],
+        rowCount: Array.isArray(result) ? result.length : 0,
+        command: undefined,
+      }
+    } catch (error) {
+      throw new QueryError('postgres', sql, error as Error)
+    }
+  }
+
+  async transaction<T>(callback: (driver: DatabaseDriver) => Promise<T>): Promise<T> {
+    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 as T
+  }
+
+  // Helper methods for findMany, findFirst, insert, update, delete
+  async findMany<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>> {
+    return this.query<T>(sql, params)
+  }
+
+  async close(): Promise<void> {
+    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 {
+  private httpClient: typeof ky
+
+  constructor(config: { url: string; apiKey?: string }) {
+    this.httpClient = ky.create({
+      prefixUrl: config.url,
+      headers: {
+        Authorization: `Bearer ${config.apiKey || ''}`,
+      },
+    })
+  }
+
+  async query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>> {
+    try {
+      const response = await this.httpClient
+        .post('query', {
+          json: { query: sql, args: params },
+        })
+        .json<{ rows: T[]; rowCount: number }>()
+
+      return {
+        rows: response.rows,
+        rowCount: response.rowCount,
+        command: undefined,
+      }
+    } catch (error) {
+      throw new QueryError('postgres-http', sql, error as Error)
+    }
+  }
+
+  async close(): Promise<void> {
+    // HTTP connections don't need explicit closing
+    return Promise.resolve()
+  }
+}

package/src/drivers/sqlite.ts

@@ -0,0 +1,122 @@
+import Database from 'better-sqlite3'
+import type { DatabaseDriver, QueryResult, TransactionCapable, PreparedStatementCapable, PreparedStatement } from '../types'
+import { QueryError, ConnectionError } from '../types'
+
+export interface SqliteConfig {
+  filename: string
+  readonly?: boolean
+}
+
+export class SqliteDriver implements DatabaseDriver, TransactionCapable, PreparedStatementCapable {
+  private client: Database.Database
+
+  constructor(config: SqliteConfig) {
+    try {
+      this.client = new Database(config.filename, {
+        readonly: config.readonly || false,
+        fileMustExist: config.readonly || false,
+      })
+    } catch (error) {
+      throw new ConnectionError('sqlite', error as Error)
+    }
+  }
+
+  async query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>> {
+    try {
+      const stmt = this.client.prepare(sql)
+      const rows = stmt.all(params || []) as T[]
+
+      // Get column names from the first row if available
+      const fields = rows.length > 0 && typeof rows[0] === 'object' && rows[0] !== null ? Object.keys(rows[0] as object).map((name) => ({ name, dataTypeID: 0 })) : []
+
+      return {
+        rows,
+        rowCount: rows.length,
+        command: undefined,
+        fields,
+      }
+    } catch (error) {
+      throw new QueryError('sqlite', sql, error as Error)
+    }
+  }
+
+  async transaction<T>(callback: (driver: DatabaseDriver) => Promise<T>): Promise<T> {
+    const transaction = this.client.transaction(() => {
+      const transactionDriver = new SqliteDriver({ filename: '' })
+      ;(transactionDriver as any).client = this.client
+      return callback(transactionDriver)
+    })
+
+    return await transaction()
+  }
+
+  async prepare(sql: string): Promise<PreparedStatement> {
+    return new SqlitePreparedStatement(this.client.prepare(sql))
+  }
+
+  async close(): Promise<void> {
+    try {
+      this.client.close()
+    } catch (error) {
+      console.error('Error closing SQLite client:', error)
+    }
+  }
+
+  // SQLite-specific methods
+  exec(sql: string): void {
+    this.client.exec(sql)
+  }
+
+  backup(filename: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        this.client.backup(filename)
+        resolve()
+      } catch (error) {
+        reject(error)
+      }
+    })
+  }
+
+  pragma(pragma: string): any {
+    return this.client.pragma(pragma)
+  }
+}
+
+class SqlitePreparedStatement implements PreparedStatement {
+  constructor(private stmt: Database.Statement) {}
+
+  async execute<T = any>(params?: any[]): Promise<QueryResult<T>> {
+    try {
+      const rows = this.stmt.all(params || []) as T[]
+      const fields = rows.length > 0 && typeof rows[0] === 'object' && rows[0] !== null ? Object.keys(rows[0] as object).map((name) => ({ name, dataTypeID: 0 })) : []
+
+      return {
+        rows,
+        rowCount: rows.length,
+        command: undefined,
+        fields,
+      }
+    } catch (error) {
+      throw new QueryError('sqlite', 'prepared statement', error as Error)
+    }
+  }
+
+  async finalize(): Promise<void> {
+    // better-sqlite3 doesn't have finalize method, we can just ignore this
+    return Promise.resolve()
+  }
+
+  // SQLite-specific methods for prepared statements
+  run(params?: any[]): Database.RunResult {
+    return this.stmt.run(params || [])
+  }
+
+  get(params?: any[]): any {
+    return this.stmt.get(params || [])
+  }
+
+  all(params?: any[]): any[] {
+    return this.stmt.all(params || [])
+  }
+}

package/src/index.ts

@@ -0,0 +1,225 @@
+import consola from 'consola'
+import type { DatabaseDriver, QueryResult } from './types'
+import { hasTransactionSupport, hasPreparedStatementSupport, DatabaseError } from './types'
+import { PostgresDriver } from './drivers/postgres'
+import { LibSQLDriver } from './drivers/libsql'
+import { MySQLDriver } from './drivers/mysql'
+import { SqliteDriver } from './drivers/sqlite'
+
+// Re-export types and drivers for convenience
+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'
+
+// Re-export inspection utilities
+export { inspectDB, inspectPostgres, inspectLibSQL, inspectMySQL, inspectSQLite } from './pull'
+
+export interface ClientOptions<T extends DatabaseDriver = DatabaseDriver> {
+  driver: T
+  fallbackDrivers?: DatabaseDriver[]
+}
+
+export class SQLClient<DT = any> {
+  private primaryDriver: DatabaseDriver
+  private fallbackDrivers: DatabaseDriver[]
+
+  constructor(options: ClientOptions) {
+    this.primaryDriver = options.driver
+    this.fallbackDrivers = options.fallbackDrivers || []
+  }
+
+  async query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>> {
+    const drivers = [this.primaryDriver, ...this.fallbackDrivers]
+    let lastError: Error | undefined
+
+    for (const driver of drivers) {
+      try {
+        return await driver.query<T>(sql, params)
+      } catch (error) {
+        lastError = error as Error
+        consola.warn(`Query failed with ${driver.constructor.name}:`, error)
+        continue
+      }
+    }
+
+    throw lastError || new DatabaseError('All drivers failed to execute query', 'unknown')
+  }
+
+  async transaction<T>(callback: (client: SQLClient<DT>) => Promise<T>): Promise<T> {
+    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<DT>({
+        driver: transactionDriver,
+        fallbackDrivers: [],
+      })
+      return await callback(transactionClient)
+    })
+  }
+
+  async prepare(sql: string) {
+    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<K extends keyof DT>(table: K, where?: Partial<DT[K]>): Promise<DT[K] | null> {
+    const tableName = String(table)
+    const whereEntries = Object.entries(where || {})
+
+    let sql = `SELECT * FROM ${tableName}`
+    let params: any[] = []
+
+    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<DT[K]>(sql, params)
+    return result.rows[0] || null
+  }
+
+  async findMany<K extends keyof DT>(
+    table: K,
+    options?: {
+      where?: Partial<DT[K]>
+      limit?: number
+      offset?: number
+    },
+  ): Promise<DT[K][]> {
+    const tableName = String(table)
+    const { where, limit, offset } = options || {}
+    const whereEntries = Object.entries(where || {})
+
+    let sql = `SELECT * FROM ${tableName}`
+    let params: any[] = []
+
+    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<DT[K]>(sql, params)
+    return result.rows
+  }
+
+  async insert<K extends keyof DT>(table: K, data: Partial<DT[K]>): Promise<DT[K]> {
+    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<DT[K]>(sql, values)
+
+    if (!result.rows[0]) {
+      throw new Error('Insert failed: No data returned')
+    }
+
+    return result.rows[0]
+  }
+
+  async update<K extends keyof DT>(table: K, data: Partial<DT[K]>, where: Partial<DT[K]>): Promise<DT[K] | null> {
+    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<DT[K]>(sql, params)
+    return result.rows[0] || null
+  }
+
+  async delete<K extends keyof DT>(table: K, where: Partial<DT[K]>): Promise<number> {
+    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<DT[K]>(sql, params)
+    return result.rowCount || 0
+  }
+
+  // Get the primary driver (useful for driver-specific operations)
+  getDriver(): DatabaseDriver {
+    return this.primaryDriver
+  }
+
+  // Check driver capabilities
+  supportsTransactions(): boolean {
+    return hasTransactionSupport(this.primaryDriver)
+  }
+
+  supportsPreparedStatements(): boolean {
+    return hasPreparedStatementSupport(this.primaryDriver)
+  }
+
+  async close(): Promise<void> {
+    const drivers = [this.primaryDriver, ...this.fallbackDrivers]
+    await Promise.all(drivers.map((driver) => driver.close().catch((err) => consola.warn(`Error closing ${driver.constructor.name}:`, err))))
+  }
+}
+
+// Factory functions for common use cases
+export function createPostgresClient<DT = any>(config: { connectionString?: string; experimental?: { http?: { url: string; apiKey?: string } } }) {
+  return new SQLClient<DT>({ driver: new PostgresDriver(config) })
+}
+
+export function createLibSQLClient<DT = any>(config: { url: string; authToken?: string; useTursoServerlessDriver?: boolean }) {
+  return new SQLClient<DT>({ driver: new LibSQLDriver(config) })
+}
+
+export function createMySQLClient<DT = any>(config: { connectionString: string }) {
+  return new SQLClient<DT>({ driver: new MySQLDriver(config) })
+}
+
+export function createSqliteClient<DT = any>(config: { filename: string; readonly?: boolean }) {
+  return new SQLClient<DT>({ driver: new SqliteDriver(config) })
+}
+
+// Legacy export for backward compatibility
+export const DriftSQLClient = SQLClient