bunql 1.0.0 → 1.0.1-dev.1

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
@@ -410,6 +439,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 +449,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 +460,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 +470,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.1",
   "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');

package/src/index.ts

@@ -198,6 +198,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 +272,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 +351,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 +401,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,