bunql 1.0.1-dev.1 → 1.0.1-dev.2

package/README.md

@@ -194,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) => {
@@ -421,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
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunql",
-  "version": "1.0.1-dev.1",
+  "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

@@ -287,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);
     });
   }