driftsql 1.0.16 → 1.0.18

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'
+export { BobSQLDriver, type BobSQLConfig } from './drivers/bobsql'
+// 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

package/src/pull.ts

@@ -0,0 +1,318 @@
+import { PostgresDriver, LibSQLDriver, MySQLDriver, SqliteDriver, SQLClient } from '.'
+import type { DatabaseDriver } from './types'
+import fs from 'node:fs/promises'
+
+interface InspectOptions {
+  driver: DatabaseDriver
+  outputFile?: string
+}
+
+// Helper function to add timeout to promises
+const withTimeout = <T>(promise: Promise<T>, timeoutMs = 30_000): Promise<T> => {
+  return Promise.race([promise, new Promise<never>((_, reject) => setTimeout(() => reject(new Error(`Query timeout after ${timeoutMs}ms`)), timeoutMs))])
+}
+
+// Helper function to retry queries with exponential backoff
+const retryQuery = async <T>(queryFn: () => Promise<T>, maxRetries = 3, baseDelay = 1000): Promise<T> => {
+  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: string, isNullable: boolean = false, driverType: string = 'postgres'): string => {
+  const nullable = isNullable ? ' | null' : ''
+  const lowerType = dataType.toLowerCase()
+
+  // Common types that work for all databases
+  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: DatabaseDriver): string => {
+  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'
+}
+
+export const inspectDB = async (options: InspectOptions) => {
+  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 {
+    // Use different queries based on the driver type
+    let tablesQuery: string
+    let tableSchemaFilter: string | undefined
+
+    if (driverType === 'mysql') {
+      // For MySQL, get the current database name first
+      const dbResult = await withTimeout(
+        retryQuery(() => client.query<{ database: string }>('SELECT DATABASE() as `database`', [])),
+        10_000,
+      )
+      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') {
+      // PostgreSQL
+      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') {
+      // LibSQL/SQLite
+      tablesQuery = `SELECT name as table_name
+                   FROM sqlite_master
+                   WHERE type = 'table'
+                   ORDER BY name`
+      tableSchemaFilter = undefined
+    } else {
+      throw new Error(`Unsupported driver type: ${driverType}`)
+    }
+
+    const tables = await withTimeout(
+      retryQuery(() => client.query<{ table_name: string }>(tablesQuery, tableSchemaFilter ? [tableSchemaFilter] : [])),
+      30_000,
+    )
+
+    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 {
+        // Get columns with nullability information
+        let columnsQuery: string
+        let queryParams: (string | null)[]
+
+        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 {
+          // LibSQL/SQLite
+          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<{
+              column_name: string
+              data_type: string
+              is_nullable: string
+              column_default: string | null
+            }>(columnsQuery, queryParams),
+          ),
+          15_000,
+        )
+
+        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(', '))
+
+        // Deduplicate columns by name
+        const uniqueColumns = new Map<string, (typeof columns.rows)[0]>()
+        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)} {\n`
+        for (const col of uniqueColumns.values()) {
+          const tsType = mapDatabaseTypeToTypeScript(col.data_type, col.is_nullable === 'YES', driverType)
+          generatedTypes += `  ${col.column_name}: ${tsType};\n`
+        }
+        generatedTypes += '}\n\n'
+      } catch (error) {
+        console.error(`Failed to process table ${tableName}:`, error)
+        console.log(`Skipping table ${tableName} and continuing...`)
+        continue
+      }
+    }
+
+    // Generate the Database interface
+    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};\n`
+    }
+    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()
+  }
+}
+
+// Convenience functions for each driver type
+export const inspectPostgres = async (config: { connectionString?: string; experimental?: { http?: { url: string; apiKey?: string } } }, outputFile?: string) => {
+  const driver = new PostgresDriver(config)
+  return inspectDB({ driver, outputFile })
+}
+
+export const inspectLibSQL = async (config: { url: string; authToken?: string; useTursoServerlessDriver?: boolean }, outputFile?: string) => {
+  const driver = new LibSQLDriver(config)
+  return inspectDB({ driver, outputFile })
+}
+
+export const inspectMySQL = async (config: { connectionString: string }, outputFile?: string) => {
+  const driver = new MySQLDriver(config)
+  return inspectDB({ driver, outputFile })
+}
+
+export const inspectSQLite = async (config: { filename: string; readonly?: boolean }, outputFile?: string) => {
+  const driver = new SqliteDriver(config)
+  return inspectDB({ driver, outputFile })
+}
+
+export default inspectDB

package/src/types.ts

@@ -0,0 +1,78 @@
+// Core result type for all database operations
+export interface QueryResult<T = any> {
+  rows: T[]
+  rowCount: number
+  command?: string
+  fields?: QueryField[]
+}
+
+// Field information for query results
+export interface QueryField {
+  name: string
+  dataTypeID: number
+}
+
+// Base driver interface that all drivers must implement
+export interface DatabaseDriver {
+  query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>
+  // findMany?<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>
+  // findFirst?<T = any>(sql: string, params?: any[]): Promise<T | null>
+  // insert?<T = any>(table: string, data: Partial<T>): Promise<QueryResult<T>>
+  // update?<T = any>(table: string, data: Partial<T>, where: Partial<T>): Promise<QueryResult<T>>
+  // delete?<T = any>(table: string, where: Partial<T>): Promise<QueryResult<T>>
+  close(): Promise<void>
+}
+
+// Optional interfaces for advanced features
+export interface TransactionCapable {
+  transaction<T>(callback: (driver: DatabaseDriver) => Promise<T>): Promise<T>
+}
+
+export interface PreparedStatementCapable {
+  prepare(sql: string): Promise<PreparedStatement>
+}
+
+export interface PreparedStatement {
+  execute<T = any>(params?: any[]): Promise<QueryResult<T>>
+  finalize(): Promise<void>
+}
+
+// Type guards
+export function hasTransactionSupport(driver: DatabaseDriver): driver is DatabaseDriver & TransactionCapable {
+  return 'transaction' in driver && typeof (driver as any).transaction === 'function'
+}
+
+export function hasPreparedStatementSupport(driver: DatabaseDriver): driver is DatabaseDriver & PreparedStatementCapable {
+  return 'prepare' in driver && typeof (driver as any).prepare === 'function'
+}
+
+// Error classes
+export class DatabaseError extends Error {
+  constructor(
+    message: string,
+    public readonly driverType: string,
+    public readonly originalError?: Error,
+  ) {
+    super(message)
+    this.name = 'DatabaseError'
+  }
+}
+
+export class QueryError extends DatabaseError {
+  constructor(driverType: string, sql: string, originalError?: Error) {
+    super(`Query failed: ${sql}`, driverType, originalError)
+    this.name = 'QueryError'
+  }
+}
+
+export class ConnectionError extends DatabaseError {
+  constructor(driverType: string, originalError?: Error) {
+    super(`Failed to connect to ${driverType}`, driverType, originalError)
+    this.name = 'ConnectionError'
+  }
+}
+
+// Generic driver options
+export interface DriverOptions {
+  [key: string]: any
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "allowJs": true,
+    "resolveJsonModule": true,
+    "strict": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "noUncheckedIndexedAccess": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowImportingTsExtensions": true,
+    "noImplicitOverride": true,
+    "noEmit": true
+  }
+}