bunql 1.0.1-dev.4 → 1.0.1-dev.5

package/src/schema.ts

@@ -1,9 +1,4 @@
-// Import will be handled by the main index file to avoid circular dependency
-
-export interface DatabaseInfo {
-  type: 'sqlite' | 'postgresql' | 'mysql';
-  version?: string;
-}
+// PostgreSQL-only schema management for BunQL
 
 export interface ColumnDefinition {
   name: string;
@@ -54,31 +49,10 @@ 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';
-    }
   }
 
   /**
@@ -125,48 +99,28 @@ export class SchemaBuilder {
    * Execute the table creation
    */
   async execute(): Promise<void> {
-    if (this.columns.length === 0) {
-      throw new Error('At least one column must be defined');
-    }
-
-    await this.detectDatabaseType();
     const sql = this.buildCreateTableSQL();
     await this.db.run(sql);
-    
-    // Create indexes after table creation
+
+    // Create indexes separately
     for (const index of this.indexes) {
       await this.createIndex(index);
     }
   }
 
   private buildCreateTableSQL(): string {
-    
     const ifNotExists = this.options.ifNotExists ? 'IF NOT EXISTS ' : '';
     const temporary = this.options.temporary ? 'TEMPORARY ' : '';
     
-    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;
-    }
+    let sql = `CREATE ${temporary}TABLE ${ifNotExists}"${this.tableName}" (`;
     
     const columnDefinitions = this.columns.map(col => {
-      let def = this.quoteColumn(col.name) + ' ' + this.mapColumnType(col.type);
+      let def = `"${col.name}" ${col.type}`;
       
       if (col.primaryKey) {
         def += ' PRIMARY KEY';
-        if (col.autoIncrement && this.databaseType !== 'postgresql') {
-          def += this.getAutoIncrementKeyword();
+        if (col.autoIncrement) {
+          def += ' GENERATED ALWAYS AS IDENTITY';
         }
       }
       
@@ -179,7 +133,11 @@ export class SchemaBuilder {
       }
       
       if (col.defaultValue !== undefined) {
-        def += this.formatDefaultValue(col.defaultValue);
+        if (typeof col.defaultValue === 'string') {
+          def += ` DEFAULT '${col.defaultValue}'`;
+        } else {
+          def += ` DEFAULT ${col.defaultValue}`;
+        }
       }
       
       return def;
@@ -187,10 +145,10 @@ export class SchemaBuilder {
     
     // Add foreign key constraints
     const foreignKeyDefinitions = this.foreignKeys.map(fk => {
-      const columns = fk.columns.map(col => this.quoteColumn(col)).join(', ');
-      const referencedColumns = fk.referencedColumns.map(col => this.quoteColumn(col)).join(', ');
+      const columns = fk.columns.map(col => `"${col}"`).join(', ');
+      const referencedColumns = fk.referencedColumns.map(col => `"${col}"`).join(', ');
       
-      let fkDef = `FOREIGN KEY (${columns}) REFERENCES ${this.quoteTable(fk.referencedTable)} (${referencedColumns})`;
+      let fkDef = `FOREIGN KEY (${columns}) REFERENCES "${fk.referencedTable}" (${referencedColumns})`;
       
       if (fk.onDelete) {
         fkDef += ` ON DELETE ${fk.onDelete}`;
@@ -210,120 +168,10 @@ 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('_')}`;
     const columns = index.columns.map(col => `"${col}"`).join(', ');
-    
     const sql = `CREATE ${unique}INDEX "${indexName}" ON "${this.tableName}" (${columns})`;
     await this.db.run(sql);
   }
@@ -347,10 +195,7 @@ export class AlterTableBuilder {
    * Add a column to the table
    */
   addColumn(column: ColumnDefinition): this {
-    this.operations.push({
-      type: 'addColumn',
-      data: column
-    });
+    this.operations.push({ type: 'addColumn', data: column });
     return this;
   }
 
@@ -358,10 +203,7 @@ export class AlterTableBuilder {
    * Drop a column from the table
    */
   dropColumn(columnName: string): this {
-    this.operations.push({
-      type: 'dropColumn',
-      data: { columnName }
-    });
+    this.operations.push({ type: 'dropColumn', data: columnName });
     return this;
   }
 
@@ -369,21 +211,15 @@ export class AlterTableBuilder {
    * Rename a column
    */
   renameColumn(oldName: string, newName: string): this {
-    this.operations.push({
-      type: 'renameColumn',
-      data: { oldName, newName }
-    });
+    this.operations.push({ type: 'renameColumn', data: { oldName, newName } });
     return this;
   }
 
   /**
-   * Alter a column definition
+   * Alter a column
    */
-  alterColumn(columnName: string, newDefinition: Partial<ColumnDefinition>): this {
-    this.operations.push({
-      type: 'alterColumn',
-      data: { columnName, newDefinition }
-    });
+  alterColumn(columnName: string, changes: Partial<ColumnDefinition>): this {
+    this.operations.push({ type: 'alterColumn', data: { columnName, changes } });
     return this;
   }
 
@@ -391,10 +227,7 @@ export class AlterTableBuilder {
    * Add an index
    */
   addIndex(index: IndexInfo): this {
-    this.operations.push({
-      type: 'addIndex',
-      data: index
-    });
+    this.operations.push({ type: 'addIndex', data: index });
     return this;
   }
 
@@ -402,10 +235,7 @@ export class AlterTableBuilder {
    * Drop an index
    */
   dropIndex(indexName: string): this {
-    this.operations.push({
-      type: 'dropIndex',
-      data: { indexName }
-    });
+    this.operations.push({ type: 'dropIndex', data: indexName });
     return this;
   }
 
@@ -413,10 +243,7 @@ export class AlterTableBuilder {
    * Add a foreign key constraint
    */
   addForeignKey(foreignKey: ForeignKeyInfo): this {
-    this.operations.push({
-      type: 'addForeignKey',
-      data: foreignKey
-    });
+    this.operations.push({ type: 'addForeignKey', data: foreignKey });
     return this;
   }
 
@@ -424,10 +251,7 @@ export class AlterTableBuilder {
    * Drop a foreign key constraint
    */
   dropForeignKey(constraintName: string): this {
-    this.operations.push({
-      type: 'dropForeignKey',
-      data: { constraintName }
-    });
+    this.operations.push({ type: 'dropForeignKey', data: constraintName });
     return this;
   }
 
@@ -449,173 +273,78 @@ export class AlterTableBuilder {
   }
 
   private async executeOperation(operation: any): Promise<void> {
+    const ifExists = this.options.ifExists ? 'IF EXISTS ' : '';
+    
     switch (operation.type) {
       case 'addColumn':
-        await this.addColumnOperation(operation.data);
+        const column = operation.data as ColumnDefinition;
+        let columnDef = `"${column.name}" ${column.type}`;
+        
+        if (column.notNull) {
+          columnDef += ' NOT NULL';
+        }
+        
+        if (column.defaultValue !== undefined) {
+          if (typeof column.defaultValue === 'string') {
+            columnDef += ` DEFAULT '${column.defaultValue}'`;
+          } else {
+            columnDef += ` DEFAULT ${column.defaultValue}`;
+          }
+        }
+        
+        await this.db.run(`ALTER TABLE "${this.tableName}" ADD COLUMN ${columnDef}`);
         break;
+        
       case 'dropColumn':
-        await this.dropColumnOperation(operation.data);
+        await this.db.run(`ALTER TABLE "${this.tableName}" DROP COLUMN ${ifExists}"${operation.data}"`);
         break;
+        
       case 'renameColumn':
-        await this.renameColumnOperation(operation.data);
-        break;
-      case 'alterColumn':
-        await this.alterColumnOperation(operation.data);
+        const { oldName, newName } = operation.data;
+        await this.db.run(`ALTER TABLE "${this.tableName}" RENAME COLUMN "${oldName}" TO "${newName}"`);
         break;
+        
       case 'addIndex':
-        await this.addIndexOperation(operation.data);
+        const index = operation.data as IndexInfo;
+        const unique = index.unique ? 'UNIQUE ' : '';
+        const indexName = index.name || `idx_${this.tableName}_${index.columns.join('_')}`;
+        const columns = index.columns.map(col => `"${col}"`).join(', ');
+        await this.db.run(`CREATE ${unique}INDEX "${indexName}" ON "${this.tableName}" (${columns})`);
         break;
+        
       case 'dropIndex':
-        await this.dropIndexOperation(operation.data);
+        await this.db.run(`DROP INDEX ${ifExists}"${operation.data}"`);
         break;
+        
       case 'addForeignKey':
-        await this.addForeignKeyOperation(operation.data);
+        const fk = operation.data as ForeignKeyInfo;
+        const fkColumns = fk.columns.map(col => `"${col}"`).join(', ');
+        const refColumns = fk.referencedColumns.map(col => `"${col}"`).join(', ');
+        let fkDef = `FOREIGN KEY (${fkColumns}) REFERENCES "${fk.referencedTable}" (${refColumns})`;
+        
+        if (fk.onDelete) {
+          fkDef += ` ON DELETE ${fk.onDelete}`;
+        }
+        
+        if (fk.onUpdate) {
+          fkDef += ` ON UPDATE ${fk.onUpdate}`;
+        }
+        
+        await this.db.run(`ALTER TABLE "${this.tableName}" ADD CONSTRAINT "${fk.name}" ${fkDef}`);
         break;
+        
       case 'dropForeignKey':
-        await this.dropForeignKeyOperation(operation.data);
+        await this.db.run(`ALTER TABLE "${this.tableName}" DROP CONSTRAINT ${ifExists}"${operation.data}"`);
         break;
     }
   }
-
-  private async addColumnOperation(column: ColumnDefinition): Promise<void> {
-    let sql = `ALTER TABLE "${this.tableName}" ADD COLUMN `;
-    sql += `"${column.name}" ${column.type}`;
-    
-    if (column.notNull) {
-      sql += ' NOT NULL';
-    }
-    
-    if (column.defaultValue !== undefined) {
-      if (typeof column.defaultValue === 'string') {
-        sql += ` DEFAULT '${column.defaultValue}'`;
-      } else {
-        sql += ` DEFAULT ${column.defaultValue}`;
-      }
-    }
-    
-    await this.db.run(sql);
-  }
-
-  private async dropColumnOperation(data: { columnName: string }): Promise<void> {
-    // SQLite doesn't support DROP COLUMN directly, so we need to recreate the table
-    // This is a simplified implementation
-    const sql = `ALTER TABLE "${this.tableName}" DROP COLUMN "${data.columnName}"`;
-    await this.db.run(sql);
-  }
-
-  private async renameColumnOperation(data: { oldName: string; newName: string }): Promise<void> {
-    const sql = `ALTER TABLE "${this.tableName}" RENAME COLUMN "${data.oldName}" TO "${data.newName}"`;
-    await this.db.run(sql);
-  }
-
-  private async alterColumnOperation(data: { columnName: string; newDefinition: Partial<ColumnDefinition> }): Promise<void> {
-    // SQLite has limited ALTER COLUMN support, so we'll use a basic approach
-    // In practice, you might need to recreate the table for complex changes
-    const sql = `ALTER TABLE "${this.tableName}" ALTER COLUMN "${data.columnName}" SET DATA TYPE ${data.newDefinition.type}`;
-    await this.db.run(sql);
-  }
-
-  private async addIndexOperation(index: IndexInfo): Promise<void> {
-    const unique = index.unique ? 'UNIQUE ' : '';
-    const indexName = index.name || `idx_${this.tableName}_${index.columns.join('_')}`;
-    const columns = index.columns.map(col => `"${col}"`).join(', ');
-    
-    const sql = `CREATE ${unique}INDEX "${indexName}" ON "${this.tableName}" (${columns})`;
-    await this.db.run(sql);
-  }
-
-  private async dropIndexOperation(data: { indexName: string }): Promise<void> {
-    const sql = `DROP INDEX "${data.indexName}"`;
-    await this.db.run(sql);
-  }
-
-  private async addForeignKeyOperation(foreignKey: ForeignKeyInfo): Promise<void> {
-    const columns = foreignKey.columns.map(col => `"${col}"`).join(', ');
-    const referencedColumns = foreignKey.referencedColumns.map(col => `"${col}"`).join(', ');
-    
-    let sql = `ALTER TABLE "${this.tableName}" ADD `;
-    sql += `FOREIGN KEY (${columns}) REFERENCES "${foreignKey.referencedTable}" (${referencedColumns})`;
-    
-    if (foreignKey.onDelete) {
-      sql += ` ON DELETE ${foreignKey.onDelete}`;
-    }
-    
-    if (foreignKey.onUpdate) {
-      sql += ` ON UPDATE ${foreignKey.onUpdate}`;
-    }
-    
-    await this.db.run(sql);
-  }
-
-  private async dropForeignKeyOperation(data: { constraintName: string }): Promise<void> {
-    // SQLite doesn't support dropping foreign key constraints directly
-    // This would require recreating the table in practice
-    const sql = `ALTER TABLE "${this.tableName}" DROP CONSTRAINT "${data.constraintName}"`;
-    await this.db.run(sql);
-  }
 }
 
 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
-    };
   }
 
   /**
@@ -635,332 +364,199 @@ export class Schema {
   /**
    * Drop a table
    */
-  async dropTable(tableName: string, ifExists: boolean = true): Promise<void> {
+  async dropTable(tableName: string, ifExists: boolean = false): Promise<void> {
     const ifExistsClause = ifExists ? 'IF EXISTS ' : '';
-    const sql = `DROP TABLE ${ifExistsClause}"${tableName}"`;
-    await this.db.run(sql);
+    await this.db.run(`DROP TABLE ${ifExistsClause}"${tableName}"`);
   }
 
   /**
    * Check if a table exists
    */
   async hasTable(tableName: string): Promise<boolean> {
-    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;
-  }
+    const result = await this.db.all(`
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables 
+        WHERE table_schema = 'public' 
+        AND table_name = ?
+      ) as exists
+    `, [tableName]);
+    
+    return result[0]?.exists || false;
+  }
+
+  /**
+   * Get table information
+   */
+  async getTableInfo(tableName: string): Promise<TableInfo> {
+    const columns = await this.db.all(`
+      SELECT 
+        c.column_name,
+        c.data_type,
+        c.is_nullable,
+        c.column_default,
+        CASE WHEN pk.column_name IS NOT NULL THEN true ELSE false END as is_primary_key,
+        CASE WHEN u.column_name IS NOT NULL THEN true ELSE false END as is_unique
+      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.table_name = ? AND tc.constraint_type = 'PRIMARY KEY'
+      ) pk ON c.column_name = pk.column_name
+      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.table_name = ? AND tc.constraint_type = 'UNIQUE'
+      ) u ON c.column_name = u.column_name
+      WHERE c.table_name = ?
+      ORDER BY c.ordinal_position
+    `, [tableName, tableName, tableName]);
 
-  /**
-   * Get information about a table
-   */
-  async getTableInfo(tableName: string): Promise<ColumnDefinition[]> {
-    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 || 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
-    }));
+    const indexes = await this.getIndexes(tableName);
+    const foreignKeys = await this.getForeignKeys(tableName);
+
+    return {
+      name: tableName,
+      columns: columns.map((col: any) => ({
+        name: col.column_name,
+        type: col.data_type,
+        notNull: col.is_nullable === 'NO',
+        primaryKey: col.is_primary_key,
+        unique: col.is_unique,
+        defaultValue: col.column_default
+      })),
+      indexes,
+      foreignKeys
+    };
   }
 
   /**
-   * Get all tables in the database
+   * Get all tables
    */
   async getTables(): Promise<string[]> {
-    await this.detectDatabaseType();
-    
-    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(`
+      SELECT table_name 
+      FROM information_schema.tables 
+      WHERE table_schema = 'public'
+      ORDER BY table_name
+    `);
     
-    const result = await this.db.all(query, params);
-    return result.map((row: any) => row.table_name || row.name);
+    return result.map((row: any) => row.table_name);
   }
 
   /**
-   * Get all indexes for a table
+   * Get indexes for a table
    */
   async getIndexes(tableName: string): Promise<IndexInfo[]> {
-    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[] = [];
+    const result = await this.db.all(`
+      SELECT 
+        i.indexname as name,
+        a.attname as column_name,
+        i.indexdef
+      FROM pg_indexes i
+      JOIN pg_class c ON c.relname = i.indexname
+      JOIN pg_index idx ON idx.indexrelid = c.oid
+      JOIN pg_attribute a ON a.attrelid = idx.indrelid AND a.attnum = ANY(idx.indkey)
+      WHERE i.tablename = ?
+      ORDER BY i.indexname, a.attnum
+    `, [tableName]);
+
+    const indexMap = new Map<string, IndexInfo>();
     
     for (const row of result) {
-      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());
+      if (!indexMap.has(row.name)) {
+        indexMap.set(row.name, {
+          name: row.name,
+          columns: [],
+          unique: row.indexdef.includes('UNIQUE')
+        });
       }
-      
-      indexes.push({
-        name: row.name,
-        columns: columns,
-        unique: row.unique === 1 || row.unique === true,
-        partial: row.partial === 1 || row.partial === true
-      });
+      indexMap.get(row.name)!.columns.push(row.column_name);
     }
-    
-    return indexes;
+
+    return Array.from(indexMap.values());
   }
 
   /**
-   * Get all foreign keys for a table
+   * Get foreign keys for a table
    */
   async getForeignKeys(tableName: string): Promise<ForeignKeyInfo[]> {
-    await this.detectDatabaseType();
+    const result = await this.db.all(`
+      SELECT 
+        tc.constraint_name as name,
+        kcu.column_name,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name,
+        rc.delete_rule,
+        rc.update_rule
+      FROM information_schema.table_constraints AS tc 
+      JOIN information_schema.key_column_usage AS kcu
+        ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+      JOIN information_schema.constraint_column_usage AS ccu
+        ON ccu.constraint_name = tc.constraint_name
+        AND ccu.table_schema = tc.table_schema
+      JOIN information_schema.referential_constraints AS rc
+        ON tc.constraint_name = rc.constraint_name
+        AND tc.table_schema = rc.constraint_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY' 
+        AND tc.table_name = ?
+      ORDER BY tc.constraint_name, kcu.ordinal_position
+    `, [tableName]);
+
+    const fkMap = new Map<string, ForeignKeyInfo>();
     
-    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;
+    for (const row of result) {
+      if (!fkMap.has(row.name)) {
+        fkMap.set(row.name, {
+          name: row.name,
+          columns: [],
+          referencedTable: row.foreign_table_name,
+          referencedColumns: [],
+          onDelete: row.delete_rule !== 'NO ACTION' ? row.delete_rule : undefined,
+          onUpdate: row.update_rule !== 'NO ACTION' ? row.update_rule : undefined
+        });
+      }
+      fkMap.get(row.name)!.columns.push(row.column_name);
+      fkMap.get(row.name)!.referencedColumns.push(row.foreign_column_name);
     }
-    
-    const result = await this.db.all(query, params);
-    
-    return result.map((row: any) => ({
-      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
-    }));
+
+    return Array.from(fkMap.values());
   }
 
   /**
    * Create an index
    */
-  async createIndex(tableName: string, index: IndexInfo): Promise<void> {
-    const unique = index.unique ? 'UNIQUE ' : '';
-    const indexName = index.name || `idx_${tableName}_${index.columns.join('_')}`;
-    const columns = index.columns.map(col => `"${col}"`).join(', ');
-    
-    const sql = `CREATE ${unique}INDEX "${indexName}" ON "${tableName}" (${columns})`;
+  async createIndex(tableName: string, columns: string[], options: { unique?: boolean; name?: string } = {}): Promise<void> {
+    const unique = options.unique ? 'UNIQUE ' : '';
+    const indexName = options.name || `idx_${tableName}_${columns.join('_')}`;
+    const columnsStr = columns.map(col => `"${col}"`).join(', ');
+    const sql = `CREATE ${unique}INDEX "${indexName}" ON "${tableName}" (${columnsStr})`;
     await this.db.run(sql);
   }
 
   /**
    * Drop an index
    */
-  async dropIndex(indexName: string): Promise<void> {
-    const sql = `DROP INDEX "${indexName}"`;
-    await this.db.run(sql);
+  async dropIndex(indexName: string, ifExists: boolean = false): Promise<void> {
+    const ifExistsClause = ifExists ? 'IF EXISTS ' : '';
+    await this.db.run(`DROP INDEX ${ifExistsClause}"${indexName}"`);
   }
 
   /**
    * Make columns unique
    */
-  async makeColumnsUnique(tableName: string, columns: string[]): Promise<void> {
-    const indexName = `idx_${tableName}_${columns.join('_')}_unique`;
+  async makeColumnsUnique(tableName: string, columns: string[], constraintName?: string): Promise<void> {
+    const name = constraintName || `uk_${tableName}_${columns.join('_')}`;
     const columnsStr = columns.map(col => `"${col}"`).join(', ');
-    
-    const sql = `CREATE UNIQUE INDEX "${indexName}" ON "${tableName}" (${columnsStr})`;
-    await this.db.run(sql);
+    await this.db.run(`ALTER TABLE "${tableName}" ADD CONSTRAINT "${name}" UNIQUE (${columnsStr})`);
   }
 
   /**
    * Get complete table information including indexes and foreign keys
    */
   async getCompleteTableInfo(tableName: string): Promise<TableInfo> {
-    const columns = await this.getTableInfo(tableName);
-    const indexes = await this.getIndexes(tableName);
-    const foreignKeys = await this.getForeignKeys(tableName);
-    
-    return {
-      name: tableName,
-      columns,
-      indexes,
-      foreignKeys
-    };
+    return await this.getTableInfo(tableName);
   }
 }
-
-// Schema functionality will be added to BunQL in the main index file
-