driftsql 1.0.16 → 1.0.18

package/.prettierrc

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

package/package.json

@@ -1,21 +1,7 @@
 {
   "name": "driftsql",
-  "version": "1.0.16",
-  "author": "lasse vestergaard",
+  "version": "1.0.18",
   "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/bobsql.ts

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

package/src/drivers/libsql.ts

@@ -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 || [])
+  }
+}