bunql 1.0.1-dev.2 → 1.0.1-dev.4

package/README.md

@@ -255,7 +255,45 @@ console.log('Transaction completed, user ID:', result);
 
 ## Schema Management
 
-BunQL provides a comprehensive schema management API that can replace Bunely for database schema operations.
+BunQL provides a comprehensive schema management API that can replace Bunely for database schema operations. The schema API is **database-agnostic** and supports SQLite, PostgreSQL, and MySQL.
+
+### Database Support
+
+BunQL automatically detects your database type and adapts the schema operations accordingly:
+
+- **SQLite**: Uses `PRAGMA` statements and `sqlite_master` table
+- **PostgreSQL**: Uses `information_schema` views and `pg_*` system tables  
+- **MySQL**: Uses `information_schema` views and `SHOW` statements
+
+### Database Detection
+
+```typescript
+// Get database information
+const dbInfo = await db.schema.getDatabaseInfo();
+console.log(`Database: ${dbInfo.type} ${dbInfo.version}`);
+
+### Database-Specific Features
+
+BunQL handles database differences automatically:
+
+**Column Types:**
+- `INTEGER` → `INTEGER` (SQLite), `INTEGER` (PostgreSQL), `INT` (MySQL)
+- `BOOLEAN` → `INTEGER` (SQLite), `BOOLEAN` (PostgreSQL/MySQL)
+- `BLOB` → `BLOB` (SQLite/MySQL), `BYTEA` (PostgreSQL)
+
+**Auto-increment:**
+- SQLite: `AUTOINCREMENT`
+- MySQL: `AUTO_INCREMENT`  
+- PostgreSQL: Uses `SERIAL` or `IDENTITY` (handled automatically)
+
+**Quoting:**
+- SQLite/PostgreSQL: `"table_name"`
+- MySQL: `` `table_name` ``
+
+**Schema Introspection:**
+- SQLite: `PRAGMA table_info()`, `sqlite_master`
+- PostgreSQL: `information_schema.columns`, `pg_indexes`
+- MySQL: `information_schema.tables`, `information_schema.statistics`
 
 ### Creating Tables
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunql",
-  "version": "1.0.1-dev.2",
+  "version": "1.0.1-dev.4",
   "description": "A fluent SQL query builder for Bun with transaction support",
   "module": "src/index.ts",
   "type": "module",

package/src/schema.ts

@@ -1,5 +1,10 @@
 // Import will be handled by the main index file to avoid circular dependency
 
+export interface DatabaseInfo {
+  type: 'sqlite' | 'postgresql' | 'mysql';
+  version?: string;
+}
+
 export interface ColumnDefinition {
   name: string;
   type: string;
@@ -49,10 +54,31 @@ export class SchemaBuilder {
   private indexes: IndexInfo[] = [];
   private foreignKeys: ForeignKeyInfo[] = [];
   private options: CreateTableOptions = {};
+  private databaseType: 'sqlite' | 'postgresql' | 'mysql' = 'sqlite';
 
   constructor(db: any, tableName: string) {
     this.db = db;
     this.tableName = tableName;
+    this.detectDatabaseType();
+  }
+
+  /**
+   * Detect the database type
+   */
+  private async detectDatabaseType(): Promise<void> {
+    try {
+      const connectionString = process.env.DATABASE_URL || '';
+      
+      if (connectionString.includes('postgresql://') || connectionString.includes('postgres://')) {
+        this.databaseType = 'postgresql';
+      } else if (connectionString.includes('mysql://') || connectionString.includes('mariadb://')) {
+        this.databaseType = 'mysql';
+      } else {
+        this.databaseType = 'sqlite';
+      }
+    } catch (error) {
+      this.databaseType = 'sqlite';
+    }
   }
 
   /**
@@ -103,6 +129,7 @@ export class SchemaBuilder {
       throw new Error('At least one column must be defined');
     }
 
+    await this.detectDatabaseType();
     const sql = this.buildCreateTableSQL();
     await this.db.run(sql);
     
@@ -113,18 +140,33 @@ export class SchemaBuilder {
   }
 
   private buildCreateTableSQL(): string {
+    
     const ifNotExists = this.options.ifNotExists ? 'IF NOT EXISTS ' : '';
     const temporary = this.options.temporary ? 'TEMPORARY ' : '';
     
-    let sql = `CREATE ${temporary}TABLE ${ifNotExists}"${this.tableName}" (`;
+    let sql = `CREATE ${temporary}TABLE ${ifNotExists}`;
+    
+    // Handle different quoting for different databases
+    switch (this.databaseType) {
+      case 'postgresql':
+        sql += `"${this.tableName}" (`;
+        break;
+      case 'mysql':
+        sql += `\`${this.tableName}\` (`;
+        break;
+      case 'sqlite':
+      default:
+        sql += `"${this.tableName}" (`;
+        break;
+    }
     
     const columnDefinitions = this.columns.map(col => {
-      let def = `"${col.name}" ${col.type}`;
+      let def = this.quoteColumn(col.name) + ' ' + this.mapColumnType(col.type);
       
       if (col.primaryKey) {
         def += ' PRIMARY KEY';
-        if (col.autoIncrement) {
-          def += ' AUTOINCREMENT';
+        if (col.autoIncrement && this.databaseType !== 'postgresql') {
+          def += this.getAutoIncrementKeyword();
         }
       }
       
@@ -137,11 +179,7 @@ export class SchemaBuilder {
       }
       
       if (col.defaultValue !== undefined) {
-        if (typeof col.defaultValue === 'string') {
-          def += ` DEFAULT '${col.defaultValue}'`;
-        } else {
-          def += ` DEFAULT ${col.defaultValue}`;
-        }
+        def += this.formatDefaultValue(col.defaultValue);
       }
       
       return def;
@@ -149,10 +187,10 @@ export class SchemaBuilder {
     
     // Add foreign key constraints
     const foreignKeyDefinitions = this.foreignKeys.map(fk => {
-      const columns = fk.columns.map(col => `"${col}"`).join(', ');
-      const referencedColumns = fk.referencedColumns.map(col => `"${col}"`).join(', ');
+      const columns = fk.columns.map(col => this.quoteColumn(col)).join(', ');
+      const referencedColumns = fk.referencedColumns.map(col => this.quoteColumn(col)).join(', ');
       
-      let fkDef = `FOREIGN KEY (${columns}) REFERENCES "${fk.referencedTable}" (${referencedColumns})`;
+      let fkDef = `FOREIGN KEY (${columns}) REFERENCES ${this.quoteTable(fk.referencedTable)} (${referencedColumns})`;
       
       if (fk.onDelete) {
         fkDef += ` ON DELETE ${fk.onDelete}`;
@@ -172,6 +210,115 @@ export class SchemaBuilder {
     return sql;
   }
 
+  /**
+   * Quote column names based on database type
+   */
+  private quoteColumn(columnName: string): string {
+    switch (this.databaseType) {
+      case 'postgresql':
+        return `"${columnName}"`;
+      case 'mysql':
+        return `\`${columnName}\``;
+      case 'sqlite':
+      default:
+        return `"${columnName}"`;
+    }
+  }
+
+  /**
+   * Quote table names based on database type
+   */
+  private quoteTable(tableName: string): string {
+    switch (this.databaseType) {
+      case 'postgresql':
+        return `"${tableName}"`;
+      case 'mysql':
+        return `\`${tableName}\``;
+      case 'sqlite':
+      default:
+        return `"${tableName}"`;
+    }
+  }
+
+  /**
+   * Map generic types to database-specific types
+   */
+  private mapColumnType(type: string): string {
+    const typeMap: Record<string, Record<string, string>> = {
+      sqlite: {
+        'INTEGER': 'INTEGER',
+        'TEXT': 'TEXT',
+        'REAL': 'REAL',
+        'BLOB': 'BLOB',
+        'BOOLEAN': 'INTEGER',
+        'DATE': 'TEXT',
+        'DATETIME': 'TEXT',
+        'TIMESTAMP': 'TEXT'
+      },
+      postgresql: {
+        'INTEGER': 'INTEGER',
+        'TEXT': 'TEXT',
+        'REAL': 'REAL',
+        'BLOB': 'BYTEA',
+        'BOOLEAN': 'BOOLEAN',
+        'DATE': 'DATE',
+        'DATETIME': 'TIMESTAMP',
+        'TIMESTAMP': 'TIMESTAMP'
+      },
+      mysql: {
+        'INTEGER': 'INT',
+        'TEXT': 'TEXT',
+        'REAL': 'DOUBLE',
+        'BLOB': 'BLOB',
+        'BOOLEAN': 'BOOLEAN',
+        'DATE': 'DATE',
+        'DATETIME': 'DATETIME',
+        'TIMESTAMP': 'TIMESTAMP'
+      }
+    };
+
+    return typeMap[this.databaseType]?.[type.toUpperCase()] || type;
+  }
+
+  /**
+   * Get auto-increment keyword based on database type
+   */
+  private getAutoIncrementKeyword(): string {
+    switch (this.databaseType) {
+      case 'mysql':
+        return ' AUTO_INCREMENT';
+      case 'sqlite':
+        return ' AUTOINCREMENT';
+      case 'postgresql':
+        return ''; // PostgreSQL uses SERIAL or IDENTITY
+      default:
+        return ' AUTOINCREMENT';
+    }
+  }
+
+  /**
+   * Format default values based on database type
+   */
+  private formatDefaultValue(value: any): string {
+    if (typeof value === 'string') {
+      return ` DEFAULT '${value}'`;
+    } else if (value === null) {
+      return ' DEFAULT NULL';
+    } else if (typeof value === 'boolean') {
+      switch (this.databaseType) {
+        case 'postgresql':
+          return ` DEFAULT ${value}`;
+        case 'mysql':
+          return ` DEFAULT ${value ? 1 : 0}`;
+        case 'sqlite':
+        default:
+          return ` DEFAULT ${value ? 1 : 0}`;
+      }
+    } else {
+      return ` DEFAULT ${value}`;
+    }
+  }
+
   private async createIndex(index: IndexInfo): Promise<void> {
     const unique = index.unique ? 'UNIQUE ' : '';
     const indexName = index.name || `idx_${this.tableName}_${index.columns.join('_')}`;
@@ -410,9 +557,65 @@ export class AlterTableBuilder {
 
 export class Schema {
   private db: any; // Will be BunQL instance
+  private databaseType: 'sqlite' | 'postgresql' | 'mysql' = 'sqlite';
 
   constructor(db: any) {
     this.db = db;
+    this.detectDatabaseType();
+  }
+
+  /**
+   * Detect the database type from connection string or environment
+   */
+  private async detectDatabaseType(): Promise<void> {
+    try {
+      // Try to detect from connection string or environment
+      const connectionString = process.env.DATABASE_URL || '';
+      
+      if (connectionString.includes('postgresql://') || connectionString.includes('postgres://')) {
+        this.databaseType = 'postgresql';
+      } else if (connectionString.includes('mysql://') || connectionString.includes('mariadb://')) {
+        this.databaseType = 'mysql';
+      } else {
+        // Default to SQLite for local development
+        this.databaseType = 'sqlite';
+      }
+    } catch (error) {
+      // Fallback to SQLite
+      this.databaseType = 'sqlite';
+    }
+  }
+
+  /**
+   * Get database information
+   */
+  async getDatabaseInfo(): Promise<DatabaseInfo> {
+    await this.detectDatabaseType();
+    
+    let version = '';
+    try {
+      switch (this.databaseType) {
+        case 'postgresql':
+          const pgResult = await this.db.get('SELECT version() as version');
+          version = pgResult?.version || '';
+          break;
+        case 'mysql':
+          const mysqlResult = await this.db.get('SELECT VERSION() as version');
+          version = mysqlResult?.version || '';
+          break;
+        case 'sqlite':
+          const sqliteResult = await this.db.get('SELECT sqlite_version() as version');
+          version = sqliteResult?.version || '';
+          break;
+      }
+    } catch (error) {
+      // Ignore version detection errors
+    }
+
+    return {
+      type: this.databaseType,
+      version
+    };
   }
 
   /**
@@ -442,10 +645,36 @@ export class Schema {
    * Check if a table exists
    */
   async hasTable(tableName: string): Promise<boolean> {
-    const result = await this.db.get(`
-      SELECT name FROM sqlite_master 
-      WHERE type='table' AND name = ?
-    `, [tableName]);
+    await this.detectDatabaseType();
+    
+    let query: string;
+    let params: any[] = [tableName];
+    
+    switch (this.databaseType) {
+      case 'postgresql':
+        query = `
+          SELECT table_name 
+          FROM information_schema.tables 
+          WHERE table_schema = 'public' AND table_name = ?
+        `;
+        break;
+      case 'mysql':
+        query = `
+          SELECT table_name 
+          FROM information_schema.tables 
+          WHERE table_schema = DATABASE() AND table_name = ?
+        `;
+        break;
+      case 'sqlite':
+      default:
+        query = `
+          SELECT name FROM sqlite_master 
+          WHERE type='table' AND name = ?
+        `;
+        break;
+    }
+    
+    const result = await this.db.get(query, params);
     return result !== null;
   }
 
@@ -453,16 +682,62 @@ export class Schema {
    * Get information about a table
    */
   async getTableInfo(tableName: string): Promise<ColumnDefinition[]> {
-    const result = await this.db.all(`
-      PRAGMA table_info("${tableName}")
-    `);
+    await this.detectDatabaseType();
+    
+    let query: string;
+    let params: any[] = [tableName];
+    
+    switch (this.databaseType) {
+      case 'postgresql':
+        query = `
+          SELECT 
+            column_name as name,
+            data_type as type,
+            is_nullable = 'NO' as notnull,
+            column_default as dflt_value,
+            CASE WHEN pk.column_name IS NOT NULL THEN 1 ELSE 0 END as pk
+          FROM information_schema.columns c
+          LEFT JOIN (
+            SELECT ku.column_name
+            FROM information_schema.table_constraints tc
+            JOIN information_schema.key_column_usage ku
+              ON tc.constraint_name = ku.constraint_name
+            WHERE tc.constraint_type = 'PRIMARY KEY'
+              AND tc.table_name = ?
+          ) pk ON c.column_name = pk.column_name
+          WHERE c.table_name = ?
+          ORDER BY c.ordinal_position
+        `;
+        params = [tableName, tableName];
+        break;
+      case 'mysql':
+        query = `
+          SELECT 
+            COLUMN_NAME as name,
+            DATA_TYPE as type,
+            IS_NULLABLE = 'NO' as notnull,
+            COLUMN_DEFAULT as dflt_value,
+            CASE WHEN COLUMN_KEY = 'PRI' THEN 1 ELSE 0 END as pk
+          FROM information_schema.columns
+          WHERE table_schema = DATABASE() AND table_name = ?
+          ORDER BY ordinal_position
+        `;
+        break;
+      case 'sqlite':
+      default:
+        query = `PRAGMA table_info("${tableName}")`;
+        params = [];
+        break;
+    }
+    
+    const result = await this.db.all(query, params);
     
     return result.map((row: any) => ({
       name: row.name,
       type: row.type,
-      notNull: row.notnull === 1,
-      primaryKey: row.pk === 1,
-      unique: false, // SQLite doesn't expose this in table_info
+      notNull: row.notnull === 1 || row.notnull === true,
+      primaryKey: row.pk === 1 || row.pk === true,
+      unique: false, // Would need additional queries to detect this
       defaultValue: row.dflt_value,
       autoIncrement: false // Would need additional logic to detect this
     }));
@@ -472,34 +747,103 @@ export class Schema {
    * Get all tables in the database
    */
   async getTables(): Promise<string[]> {
-    const result = await this.db.all(`
-      SELECT name FROM sqlite_master 
-      WHERE type='table' AND name NOT LIKE 'sqlite_%'
-    `);
+    await this.detectDatabaseType();
     
-    return result.map((row: any) => row.name);
+    let query: string;
+    let params: any[] = [];
+    
+    switch (this.databaseType) {
+      case 'postgresql':
+        query = `
+          SELECT table_name 
+          FROM information_schema.tables 
+          WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
+        `;
+        break;
+      case 'mysql':
+        query = `
+          SELECT table_name 
+          FROM information_schema.tables 
+          WHERE table_schema = DATABASE() AND table_type = 'BASE TABLE'
+        `;
+        break;
+      case 'sqlite':
+      default:
+        query = `
+          SELECT name FROM sqlite_master 
+          WHERE type='table' AND name NOT LIKE 'sqlite_%'
+        `;
+        break;
+    }
+    
+    const result = await this.db.all(query, params);
+    return result.map((row: any) => row.table_name || row.name);
   }
 
   /**
    * Get all indexes for a table
    */
   async getIndexes(tableName: string): Promise<IndexInfo[]> {
-    const result = await this.db.all(`
-      PRAGMA index_list("${tableName}")
-    `);
+    await this.detectDatabaseType();
+    
+    let query: string;
+    let params: any[] = [tableName];
+    
+    switch (this.databaseType) {
+      case 'postgresql':
+        query = `
+          SELECT 
+            i.indexname as name,
+            array_agg(a.attname ORDER BY a.attnum) as columns,
+            i.indexdef LIKE '%UNIQUE%' as unique,
+            false as partial
+          FROM pg_indexes i
+          JOIN pg_class c ON c.relname = i.tablename
+          JOIN pg_index ix ON ix.indexrelid = (i.schemaname||'.'||i.indexname)::regclass
+          JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = ANY(ix.indkey)
+          WHERE i.tablename = $1 AND i.schemaname = 'public'
+          GROUP BY i.indexname, i.indexdef
+        `;
+        break;
+      case 'mysql':
+        query = `
+          SELECT 
+            INDEX_NAME as name,
+            GROUP_CONCAT(COLUMN_NAME ORDER BY SEQ_IN_INDEX) as columns,
+            NON_UNIQUE = 0 as unique,
+            false as partial
+          FROM information_schema.statistics
+          WHERE table_schema = DATABASE() AND table_name = ?
+          GROUP BY INDEX_NAME, NON_UNIQUE
+        `;
+        break;
+      case 'sqlite':
+      default:
+        query = `PRAGMA index_list("${tableName}")`;
+        params = [];
+        break;
+    }
+    
+    const result = await this.db.all(query, params);
     
     const indexes: IndexInfo[] = [];
     
     for (const row of result) {
-      const indexInfo = await this.db.all(`
-        PRAGMA index_info("${row.name}")
-      `);
+      let columns: string[];
+      
+      if (this.databaseType === 'sqlite') {
+        const indexInfo = await this.db.all(`PRAGMA index_info("${row.name}")`);
+        columns = indexInfo.map((col: any) => col.name);
+      } else {
+        // PostgreSQL and MySQL return columns as comma-separated string
+        columns = row.columns.split(',').map((col: string) => col.trim());
+      }
       
       indexes.push({
         name: row.name,
-        columns: indexInfo.map((col: any) => col.name),
-        unique: row.unique === 1,
-        partial: row.partial === 1
+        columns: columns,
+        unique: row.unique === 1 || row.unique === true,
+        partial: row.partial === 1 || row.partial === true
       });
     }
     
@@ -510,17 +854,63 @@ export class Schema {
    * Get all foreign keys for a table
    */
   async getForeignKeys(tableName: string): Promise<ForeignKeyInfo[]> {
-    const result = await this.db.all(`
-      PRAGMA foreign_key_list("${tableName}")
-    `);
+    await this.detectDatabaseType();
+    
+    let query: string;
+    let params: any[] = [tableName];
+    
+    switch (this.databaseType) {
+      case 'postgresql':
+        query = `
+          SELECT 
+            tc.constraint_name as name,
+            kcu.column_name as from_column,
+            ccu.table_name as referenced_table,
+            ccu.column_name as referenced_column,
+            rc.delete_rule as on_delete,
+            rc.update_rule as on_update
+          FROM information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu
+            ON tc.constraint_name = kcu.constraint_name
+          JOIN information_schema.constraint_column_usage ccu
+            ON ccu.constraint_name = tc.constraint_name
+          JOIN information_schema.referential_constraints rc
+            ON tc.constraint_name = rc.constraint_name
+          WHERE tc.constraint_type = 'FOREIGN KEY'
+            AND tc.table_name = ?
+        `;
+        break;
+      case 'mysql':
+        query = `
+          SELECT 
+            CONSTRAINT_NAME as name,
+            COLUMN_NAME as from_column,
+            REFERENCED_TABLE_NAME as referenced_table,
+            REFERENCED_COLUMN_NAME as referenced_column,
+            DELETE_RULE as on_delete,
+            UPDATE_RULE as on_update
+          FROM information_schema.key_column_usage
+          WHERE table_schema = DATABASE() 
+            AND table_name = ?
+            AND REFERENCED_TABLE_NAME IS NOT NULL
+        `;
+        break;
+      case 'sqlite':
+      default:
+        query = `PRAGMA foreign_key_list("${tableName}")`;
+        params = [];
+        break;
+    }
+    
+    const result = await this.db.all(query, params);
     
     return result.map((row: any) => ({
-      name: row.id.toString(), // SQLite doesn't provide constraint names
-      columns: [row.from],
-      referencedTable: row.table,
-      referencedColumns: [row.to],
-      onDelete: row.on_delete,
-      onUpdate: row.on_update
+      name: row.name || row.id?.toString() || '',
+      columns: [row.from_column || row.from],
+      referencedTable: row.referenced_table || row.table,
+      referencedColumns: [row.referenced_column || row.to],
+      onDelete: row.on_delete || row.on_delete,
+      onUpdate: row.on_update || row.on_update
     }));
   }