driftsql 1.0.18 → 1.0.20

package/src/index.ts

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

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

@@ -1,78 +0,0 @@
-// 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
-}