bunql 1.0.0 → 1.0.1-dev.2

package/README.md

@@ -49,6 +49,35 @@ const users = await db.select('*').from('users').execute();
 
 This makes the API more concise and intuitive while maintaining backward compatibility.
 
+## Count Functionality
+
+BunQL provides `.count()` methods on all query types to get the number of records:
+
+```typescript
+// Count all records in a table
+const totalUsers = await db.select('*').from('users').count();
+
+// Count with WHERE conditions
+const activeUsers = await db.select('*')
+  .from('users')
+  .where('active', '=', true)
+  .count();
+
+// Count records that would be affected by an update
+const usersToUpdate = await db.update('users')
+  .set({ active: false })
+  .where('last_login', '<', new Date('2023-01-01'))
+  .count();
+
+// Count records that would be deleted
+const usersToDelete = await db.delete('users')
+  .where('active', '=', false)
+  .count();
+
+// Count total records in table (for insert queries)
+const totalRecords = await db.insert('users').values({ name: 'Test' }).count();
+```
+
 ## Usage Examples
 
 ### Select Queries
@@ -165,6 +194,37 @@ const user = await db.get('SELECT * FROM users WHERE id = ?', [1]);
 
 ### Transactions
 
+BunQL provides two ways to handle transactions:
+
+#### Method 1: Using `db.transaction()` (Recommended)
+
+```typescript
+// Clean transaction API with automatic rollback on error
+const result = await db.transaction(async (trx) => {
+  // Insert user
+  const userResult = await trx.insert('users')
+    .values({ name: 'John', email: 'john@example.com' });
+  
+  // Insert user profile
+  await trx.insert('user_profiles')
+    .values({ 
+      user_id: userResult.lastInsertRowid,
+      bio: 'Software developer'
+    });
+  
+  // Update user status
+  await trx.update('users')
+    .set({ active: true })
+    .where('id', '=', userResult.lastInsertRowid);
+  
+  return userResult.lastInsertRowid;
+});
+
+console.log('Transaction completed, user ID:', result);
+```
+
+#### Method 2: Using `db.begin()` (Legacy)
+
 ```typescript
 // Transaction with automatic rollback on error
 const result = await db.begin(async (tx) => {
@@ -392,7 +452,8 @@ Main class for building and executing queries.
 - `run(query, params?)`: Execute raw SQL
 - `all(query, params?)`: Execute raw SQL and return all results
 - `get(query, params?)`: Execute raw SQL and return first result
-- `begin(callback)`: Execute queries in a transaction
+- `begin(callback)`: Execute queries in a transaction (legacy)
+- `transaction(callback)`: Execute queries in a transaction (recommended)
 
 ### SelectQuery
 
@@ -410,6 +471,7 @@ Methods for building SELECT queries.
 - `execute()`: Execute the query and return results
 - `first()`: Execute the query and return first result
 - `all()`: Alias for `execute()`
+- `count()`: Execute and return count of matching records
 
 ### InsertQuery
 
@@ -419,6 +481,7 @@ Methods for building INSERT queries.
 
 - `values(data)`: Specify values to insert (object or array)
 - `execute()`: Execute the insert query
+- `count()`: Return count of total records in table
 
 ### UpdateQuery
 
@@ -429,6 +492,7 @@ Methods for building UPDATE queries.
 - `set(data)`: Specify values to update
 - `where(column, operator, value)`: Add WHERE condition
 - `execute()`: Execute the update query
+- `count()`: Return count of records that would be affected
 
 ### DeleteQuery
 
@@ -438,6 +502,7 @@ Methods for building DELETE queries.
 
 - `where(column, operator, value)`: Add WHERE condition
 - `execute()`: Execute the delete query
+- `count()`: Return count of records that would be deleted
 
 ## Error Handling
 

package/package.json

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

package/src/index.test.ts

@@ -243,6 +243,33 @@ describe('BunQL', () => {
     });
   });
 
+  describe('Count Functionality', () => {
+    it('should have count method on select queries', () => {
+      const query = db.select('*').from('users');
+      expect(typeof query.count).toBe('function');
+    });
+
+    it('should have count method on update queries', () => {
+      const query = db.update('users').set({ name: 'Test' });
+      expect(typeof query.count).toBe('function');
+    });
+
+    it('should have count method on insert queries', () => {
+      const query = db.insert('users').values({ name: 'Test' });
+      expect(typeof query.count).toBe('function');
+    });
+
+    it('should have count method on delete queries', () => {
+      const query = db.delete('users').where('id', '=', 1);
+      expect(typeof query.count).toBe('function');
+    });
+
+    it('should throw error when calling count on select without table', async () => {
+      const query = db.select('*');
+      await expect(query.count()).rejects.toThrow('Table name is required. Use .from() method.');
+    });
+  });
+
   describe('Method Availability', () => {
     it('should have run method', () => {
       expect(typeof db.run).toBe('function');
@@ -260,6 +287,10 @@ describe('BunQL', () => {
       expect(typeof db.begin).toBe('function');
     });
 
+    it('should have transaction method', () => {
+      expect(typeof db.transaction).toBe('function');
+    });
+
     it('should have commit method', () => {
       expect(typeof db.commit).toBe('function');
     });

package/src/index.ts

@@ -42,35 +42,35 @@ async function executeSql(executor: any, query: string, params?: any[]): Promise
 
 export class BunQL {
   private sql: SQL;
-  private transaction?: any;
+  private _transaction?: any;
 
   constructor(connectionString?: string) {
     this.sql = connectionString ? new SQL(connectionString) : sql;
   }
 
   select<T = any>(columns?: string | string[]): SelectQuery<T> {
-    return new SelectQuery<T>(this.sql, this.transaction, columns);
+    return new SelectQuery<T>(this.sql, this._transaction, columns);
   }
 
   update(table: string): UpdateQuery {
-    return new UpdateQuery(this.sql, table, this.transaction);
+    return new UpdateQuery(this.sql, table, this._transaction);
   }
 
   insert(table: string): InsertQuery {
-    return new InsertQuery(this.sql, table, this.transaction);
+    return new InsertQuery(this.sql, table, this._transaction);
   }
 
   delete(table: string): DeleteQuery {
-    return new DeleteQuery(this.sql, table, this.transaction);
+    return new DeleteQuery(this.sql, table, this._transaction);
   }
 
   async run(query: string, params?: any[]): Promise<any> {
-    const executor = this.transaction || this.sql;
+    const executor = this._transaction || this.sql;
     return await executeSql(executor, query, params);
   }
 
   async all<T = any>(query: string, params?: any[]): Promise<T[]> {
-    const executor = this.transaction || this.sql;
+    const executor = this._transaction || this.sql;
     const result = await executeSql(executor, query, params);
     return Array.isArray(result) ? result : [];
   }
@@ -84,7 +84,16 @@ export class BunQL {
     return await this.sql.begin(async (tx) => {
       const transactionBuilder = new BunQL();
       transactionBuilder.sql = this.sql;
-      transactionBuilder.transaction = tx;
+      transactionBuilder._transaction = tx;
+      return await callback(transactionBuilder);
+    });
+  }
+
+  async transaction<T>(callback: (trx: BunQL) => Promise<T>): Promise<T> {
+    return await this.sql.begin(async (tx) => {
+      const transactionBuilder = new BunQL();
+      transactionBuilder.sql = this.sql;
+      transactionBuilder._transaction = tx;
       return await callback(transactionBuilder);
     });
   }
@@ -198,6 +207,26 @@ export class SelectQuery<T = any> {
     return this.execute();
   }
 
+  async count(): Promise<number> {
+    if (!this.table) {
+      throw new Error('Table name is required. Use .from() method.');
+    }
+
+    let query = `SELECT COUNT(*) as count FROM "${this.table}"`;
+    
+    if (this.whereClauses.length > 0) {
+      query += ` WHERE ${this.whereClauses.join(' AND ')}`;
+    }
+
+    const executor = this.transaction || this.sql;
+    const result = await executeSql(executor, query, this.whereParams);
+    // Handle different result formats
+    if (Array.isArray(result)) {
+      return result[0]?.count || 0;
+    }
+    return result.count || 0;
+  }
+
   // Make the query awaitable by implementing then method
   then<TResult1 = T[], TResult2 = never>(
     onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | undefined | null,
@@ -252,6 +281,22 @@ export class UpdateQuery {
     return await executeSql(executor, query, allParams);
   }
 
+  async count(): Promise<number> {
+    let query = `SELECT COUNT(*) as count FROM "${this.table}"`;
+    
+    if (this.whereClauses.length > 0) {
+      query += ` WHERE ${this.whereClauses.join(' AND ')}`;
+    }
+
+    const executor = this.transaction || this.sql;
+    const result = await executeSql(executor, query, this.whereParams);
+    // Handle different result formats
+    if (Array.isArray(result)) {
+      return result[0]?.count || 0;
+    }
+    return result.count || 0;
+  }
+
   // Make the query awaitable by implementing then method
   then<TResult1 = any, TResult2 = never>(
     onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | undefined | null,
@@ -315,6 +360,17 @@ export class InsertQuery {
     return await executeSql(executor, query, this.valuesArray);
   }
 
+  async count(): Promise<number> {
+    let query = `SELECT COUNT(*) as count FROM "${this.table}"`;
+    const executor = this.transaction || this.sql;
+    const result = await executeSql(executor, query, []);
+    // Handle different result formats
+    if (Array.isArray(result)) {
+      return result[0]?.count || 0;
+    }
+    return result.count || 0;
+  }
+
   // Make the query awaitable by implementing then method
   then<TResult1 = any, TResult2 = never>(
     onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | undefined | null,
@@ -354,6 +410,22 @@ export class DeleteQuery {
     return await executeSql(executor, query, this.whereParams);
   }
 
+  async count(): Promise<number> {
+    let query = `SELECT COUNT(*) as count FROM "${this.table}"`;
+    
+    if (this.whereClauses.length > 0) {
+      query += ` WHERE ${this.whereClauses.join(' AND ')}`;
+    }
+
+    const executor = this.transaction || this.sql;
+    const result = await executeSql(executor, query, this.whereParams);
+    // Handle different result formats
+    if (Array.isArray(result)) {
+      return result[0]?.count || 0;
+    }
+    return result.count || 0;
+  }
+
   // Make the query awaitable by implementing then method
   then<TResult1 = any, TResult2 = never>(
     onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | undefined | null,