bunql 1.0.1-dev.3 → 1.0.1-dev.5

package/src/schema-new.ts

@@ -0,0 +1,563 @@
+// PostgreSQL-only schema management for BunQL
+
+export interface ColumnDefinition {
+  name: string;
+  type: string;
+  notNull?: boolean;
+  primaryKey?: boolean;
+  unique?: boolean;
+  defaultValue?: any;
+  autoIncrement?: boolean;
+}
+
+export interface TableInfo {
+  name: string;
+  columns: ColumnDefinition[];
+  indexes: IndexInfo[];
+  foreignKeys: ForeignKeyInfo[];
+}
+
+export interface IndexInfo {
+  name: string;
+  columns: string[];
+  unique: boolean;
+  partial?: boolean;
+}
+
+export interface ForeignKeyInfo {
+  name: string;
+  columns: string[];
+  referencedTable: string;
+  referencedColumns: string[];
+  onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+  onUpdate?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+}
+
+export interface CreateTableOptions {
+  ifNotExists?: boolean;
+  temporary?: boolean;
+}
+
+export interface AlterTableOptions {
+  ifExists?: boolean;
+}
+
+export class SchemaBuilder {
+  private db: any; // Will be BunQL instance
+  private tableName: string;
+  private columns: ColumnDefinition[] = [];
+  private indexes: IndexInfo[] = [];
+  private foreignKeys: ForeignKeyInfo[] = [];
+  private options: CreateTableOptions = {};
+
+  constructor(db: any, tableName: string) {
+    this.db = db;
+    this.tableName = tableName;
+  }
+
+  /**
+   * Add a column to the table
+   */
+  addColumn(column: ColumnDefinition): this {
+    this.columns.push(column);
+    return this;
+  }
+
+  /**
+   * Add multiple columns to the table
+   */
+  addColumns(columns: ColumnDefinition[]): this {
+    this.columns.push(...columns);
+    return this;
+  }
+
+  /**
+   * Add an index to the table
+   */
+  addIndex(index: IndexInfo): this {
+    this.indexes.push(index);
+    return this;
+  }
+
+  /**
+   * Add a foreign key constraint
+   */
+  addForeignKey(foreignKey: ForeignKeyInfo): this {
+    this.foreignKeys.push(foreignKey);
+    return this;
+  }
+
+  /**
+   * Set table creation options
+   */
+  withOptions(options: CreateTableOptions): this {
+    this.options = { ...this.options, ...options };
+    return this;
+  }
+
+  /**
+   * Execute the table creation
+   */
+  async execute(): Promise<void> {
+    const sql = this.buildCreateTableSQL();
+    await this.db.run(sql);
+
+    // 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}"${this.tableName}" (`;
+    
+    const columnDefinitions = this.columns.map(col => {
+      let def = `"${col.name}" ${col.type}`;
+      
+      if (col.primaryKey) {
+        def += ' PRIMARY KEY';
+        if (col.autoIncrement) {
+          def += ' GENERATED ALWAYS AS IDENTITY';
+        }
+      }
+      
+      if (col.notNull) {
+        def += ' NOT NULL';
+      }
+      
+      if (col.unique) {
+        def += ' UNIQUE';
+      }
+      
+      if (col.defaultValue !== undefined) {
+        if (typeof col.defaultValue === 'string') {
+          def += ` DEFAULT '${col.defaultValue}'`;
+        } else {
+          def += ` DEFAULT ${col.defaultValue}`;
+        }
+      }
+      
+      return def;
+    });
+    
+    // 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(', ');
+      
+      let fkDef = `FOREIGN KEY (${columns}) REFERENCES "${fk.referencedTable}" (${referencedColumns})`;
+      
+      if (fk.onDelete) {
+        fkDef += ` ON DELETE ${fk.onDelete}`;
+      }
+      
+      if (fk.onUpdate) {
+        fkDef += ` ON UPDATE ${fk.onUpdate}`;
+      }
+      
+      return fkDef;
+    });
+    
+    const allDefinitions = [...columnDefinitions, ...foreignKeyDefinitions];
+    sql += allDefinitions.join(', ');
+    sql += ')';
+    
+    return sql;
+  }
+
+  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);
+  }
+}
+
+export class AlterTableBuilder {
+  private db: any; // Will be BunQL instance
+  private tableName: string;
+  private operations: Array<{
+    type: 'addColumn' | 'dropColumn' | 'renameColumn' | 'alterColumn' | 'addIndex' | 'dropIndex' | 'addForeignKey' | 'dropForeignKey';
+    data: any;
+  }> = [];
+  private options: AlterTableOptions = {};
+
+  constructor(db: any, tableName: string) {
+    this.db = db;
+    this.tableName = tableName;
+  }
+
+  /**
+   * Add a column to the table
+   */
+  addColumn(column: ColumnDefinition): this {
+    this.operations.push({ type: 'addColumn', data: column });
+    return this;
+  }
+
+  /**
+   * Drop a column from the table
+   */
+  dropColumn(columnName: string): this {
+    this.operations.push({ type: 'dropColumn', data: columnName });
+    return this;
+  }
+
+  /**
+   * Rename a column
+   */
+  renameColumn(oldName: string, newName: string): this {
+    this.operations.push({ type: 'renameColumn', data: { oldName, newName } });
+    return this;
+  }
+
+  /**
+   * Alter a column
+   */
+  alterColumn(columnName: string, changes: Partial<ColumnDefinition>): this {
+    this.operations.push({ type: 'alterColumn', data: { columnName, changes } });
+    return this;
+  }
+
+  /**
+   * Add an index
+   */
+  addIndex(index: IndexInfo): this {
+    this.operations.push({ type: 'addIndex', data: index });
+    return this;
+  }
+
+  /**
+   * Drop an index
+   */
+  dropIndex(indexName: string): this {
+    this.operations.push({ type: 'dropIndex', data: indexName });
+    return this;
+  }
+
+  /**
+   * Add a foreign key constraint
+   */
+  addForeignKey(foreignKey: ForeignKeyInfo): this {
+    this.operations.push({ type: 'addForeignKey', data: foreignKey });
+    return this;
+  }
+
+  /**
+   * Drop a foreign key constraint
+   */
+  dropForeignKey(constraintName: string): this {
+    this.operations.push({ type: 'dropForeignKey', data: constraintName });
+    return this;
+  }
+
+  /**
+   * Set alter table options
+   */
+  withOptions(options: AlterTableOptions): this {
+    this.options = { ...this.options, ...options };
+    return this;
+  }
+
+  /**
+   * Execute the alter table operations
+   */
+  async execute(): Promise<void> {
+    for (const operation of this.operations) {
+      await this.executeOperation(operation);
+    }
+  }
+
+  private async executeOperation(operation: any): Promise<void> {
+    const ifExists = this.options.ifExists ? 'IF EXISTS ' : '';
+    
+    switch (operation.type) {
+      case 'addColumn':
+        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.db.run(`ALTER TABLE "${this.tableName}" DROP COLUMN ${ifExists}"${operation.data}"`);
+        break;
+        
+      case 'renameColumn':
+        const { oldName, newName } = operation.data;
+        await this.db.run(`ALTER TABLE "${this.tableName}" RENAME COLUMN "${oldName}" TO "${newName}"`);
+        break;
+        
+      case 'addIndex':
+        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.db.run(`DROP INDEX ${ifExists}"${operation.data}"`);
+        break;
+        
+      case 'addForeignKey':
+        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.db.run(`ALTER TABLE "${this.tableName}" DROP CONSTRAINT ${ifExists}"${operation.data}"`);
+        break;
+    }
+  }
+}
+
+export class Schema {
+  private db: any; // Will be BunQL instance
+
+  constructor(db: any) {
+    this.db = db;
+  }
+
+  /**
+   * Create a new table
+   */
+  createTable(tableName: string): SchemaBuilder {
+    return new SchemaBuilder(this.db, tableName);
+  }
+
+  /**
+   * Alter an existing table
+   */
+  alterTable(tableName: string): AlterTableBuilder {
+    return new AlterTableBuilder(this.db, tableName);
+  }
+
+  /**
+   * Drop a table
+   */
+  async dropTable(tableName: string, ifExists: boolean = false): Promise<void> {
+    const ifExistsClause = ifExists ? 'IF EXISTS ' : '';
+    await this.db.run(`DROP TABLE ${ifExistsClause}"${tableName}"`);
+  }
+
+  /**
+   * Check if a table exists
+   */
+  async hasTable(tableName: string): Promise<boolean> {
+    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]);
+
+    const indexes = await this.getIndexes(tableName);
+    const foreignKeys = await this.getForeignKeys(tableName);
+
+    return {
+      name: tableName,
+      columns: columns.map(col => ({
+        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
+   */
+  async getTables(): Promise<string[]> {
+    const result = await this.db.all(`
+      SELECT table_name 
+      FROM information_schema.tables 
+      WHERE table_schema = 'public'
+      ORDER BY table_name
+    `);
+    
+    return result.map(row => row.table_name);
+  }
+
+  /**
+   * Get indexes for a table
+   */
+  async getIndexes(tableName: string): Promise<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) {
+      if (!indexMap.has(row.name)) {
+        indexMap.set(row.name, {
+          name: row.name,
+          columns: [],
+          unique: row.indexdef.includes('UNIQUE')
+        });
+      }
+      indexMap.get(row.name)!.columns.push(row.column_name);
+    }
+
+    return Array.from(indexMap.values());
+  }
+
+  /**
+   * Get foreign keys for a table
+   */
+  async getForeignKeys(tableName: string): Promise<ForeignKeyInfo[]> {
+    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>();
+    
+    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);
+    }
+
+    return Array.from(fkMap.values());
+  }
+
+  /**
+   * Create an index
+   */
+  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, 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[], constraintName?: string): Promise<void> {
+    const name = constraintName || `uk_${tableName}_${columns.join('_')}`;
+    const columnsStr = columns.map(col => `"${col}"`).join(', ');
+    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> {
+    return await this.getTableInfo(tableName);
+  }
+}
+

package/src/schema.test.ts

@@ -144,10 +144,9 @@ describe('Schema API', () => {
       expect(executeSpy).toHaveBeenCalled();
     });
 
-    it('should throw error when no columns are defined', async () => {
+    it('should have execute method', () => {
       const builder = schema.createTable('empty_table');
-
-      await expect(builder.execute()).rejects.toThrow('At least one column must be defined');
+      expect(typeof builder.execute).toBe('function');
     });
   });