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

package/src/index.ts

@@ -26,75 +26,235 @@ async function executeSql(executor: any, query: string, params?: any[]): Promise
     return await executor(strings);
   }
   
-  // Build the template literal with parameters
-  const parts = query.split('?');
-  if (parts.length - 1 !== params.length) {
-    throw new Error(`Parameter count mismatch: query has ${parts.length - 1} placeholders but ${params.length} parameters provided`);
-  }
-  
-  // Create a proper template strings array
-  const strings: any = [...parts];
-  strings.raw = [...parts];
+  // Check if query uses PostgreSQL-style parameters ($1, $2, etc.)
+  const postgresPattern = /\$\d+/g;
+  const postgresMatches = query.match(postgresPattern);
   
-  // Call the executor as a tagged template
-  return await executor(strings, ...params);
+  if (postgresMatches && postgresMatches.length > 0) {
+    // Handle PostgreSQL-style parameters
+    if (postgresMatches.length !== params.length) {
+      throw new Error(`Parameter count mismatch: query has ${postgresMatches.length} placeholders but ${params.length} parameters provided`);
+    }
+    
+    // Replace PostgreSQL parameters with ? placeholders
+    let processedQuery = query;
+    for (let i = 0; i < postgresMatches.length; i++) {
+      processedQuery = processedQuery.replace(`$${i + 1}`, '?');
+    }
+    
+    // Build the template literal with parameters
+    const parts = processedQuery.split('?');
+    const strings: any = [...parts];
+    strings.raw = [...parts];
+    
+    // Call the executor as a tagged template
+    return await executor(strings, ...params);
+  } else {
+    // Handle SQLite-style parameters (?)
+    const parts = query.split('?');
+    if (parts.length - 1 !== params.length) {
+      throw new Error(`Parameter count mismatch: query has ${parts.length - 1} placeholders but ${params.length} parameters provided`);
+    }
+    
+    // Create a proper template strings array
+    const strings: any = [...parts];
+    strings.raw = [...parts];
+    
+    // Call the executor as a tagged template
+    return await executor(strings, ...params);
+  }
+}
+
+// Connection pool for managing database connections
+class ConnectionPool {
+  private static instance: ConnectionPool;
+  private connections: Map<string, SQL> = new Map();
+  private maxConnections = 10;
+
+  static getInstance(): ConnectionPool {
+    if (!ConnectionPool.instance) {
+      ConnectionPool.instance = new ConnectionPool();
+    }
+    return ConnectionPool.instance;
+  }
+
+  getConnection(connectionString: string): SQL {
+    if (!this.connections.has(connectionString)) {
+      if (this.connections.size >= this.maxConnections) {
+        // If pool is full, return a new connection (will be closed after use)
+        return new SQL(connectionString);
+      }
+      this.connections.set(connectionString, new SQL(connectionString));
+    }
+    return this.connections.get(connectionString)!;
+  }
+
+  releaseConnection(connectionString: string, sql: SQL): void {
+    // Keep the connection in the pool for reuse
+    if (this.connections.size < this.maxConnections) {
+      this.connections.set(connectionString, sql);
+    }
+  }
+
+  closeAll(): void {
+    for (const [key, sql] of this.connections) {
+      if (sql && typeof sql.close === 'function') {
+        sql.close();
+      }
+    }
+    this.connections.clear();
+  }
+}
+
+// Base class for query builders with auto-close support
+abstract class BaseQuery {
+  protected sql: SQL;
+  protected transaction?: any;
+  protected bunql?: BunQL; // Reference to parent BunQL instance
+
+  constructor(sql: SQL, transaction?: any, bunql?: BunQL) {
+    this.sql = sql;
+    this.transaction = transaction;
+    this.bunql = bunql;
+  }
+
+  protected async executeWithAutoClose<T>(operation: () => Promise<T>): Promise<T> {
+    if (this.bunql) {
+      await this.bunql['ensureConnection']();
+    }
+    
+    try {
+      const result = await operation();
+      
+      // Only auto-close if not in transaction AND not using connection pool
+      if (!this.transaction && this.bunql && !this.bunql['connectionString']) {
+        await this.bunql.close();
+      }
+      
+      return result;
+    } catch (error) {
+      // Only auto-close on error if not in transaction AND not using connection pool
+      if (!this.transaction && this.bunql && !this.bunql['connectionString']) {
+        await this.bunql.close();
+      }
+      throw error;
+    }
+  }
 }
 
 export class BunQL {
   private sql: SQL;
   private _transaction?: any;
+  private connectionString?: string;
+  private isClosed: boolean = false;
+  private pool: ConnectionPool;
 
   constructor(connectionString?: string) {
-    this.sql = connectionString ? new SQL(connectionString) : sql;
+    this.connectionString = connectionString;
+    this.pool = ConnectionPool.getInstance();
+    
+    if (connectionString) {
+      this.sql = this.pool.getConnection(connectionString);
+    } else {
+      this.sql = sql;
+    }
+  }
+
+  private async ensureConnection(): Promise<void> {
+    if (this.isClosed && this.connectionString) {
+      this.sql = this.pool.getConnection(this.connectionString);
+      this.isClosed = false;
+    }
+  }
+
+  private async executeWithAutoClose<T>(operation: () => Promise<T>): Promise<T> {
+    await this.ensureConnection();
+    
+    try {
+      const result = await operation();
+      
+      // Only auto-close if not in transaction AND not using connection pool
+      if (!this._transaction && !this.connectionString) {
+        await this.close();
+      }
+      
+      return result;
+    } catch (error) {
+      // Only auto-close on error if not in transaction AND not using connection pool
+      if (!this._transaction && !this.connectionString) {
+        await this.close();
+      }
+      throw error;
+    }
   }
 
   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, this);
   }
 
   update(table: string): UpdateQuery {
-    return new UpdateQuery(this.sql, table, this._transaction);
+    return new UpdateQuery(this.sql, table, this._transaction, this);
   }
 
   insert(table: string): InsertQuery {
-    return new InsertQuery(this.sql, table, this._transaction);
+    return new InsertQuery(this.sql, table, this._transaction, this);
   }
 
   delete(table: string): DeleteQuery {
-    return new DeleteQuery(this.sql, table, this._transaction);
+    return new DeleteQuery(this.sql, table, this._transaction, this);
   }
 
   async run(query: string, params?: any[]): Promise<any> {
-    const executor = this._transaction || this.sql;
-    return await executeSql(executor, query, params);
+    return await this.executeWithAutoClose(async () => {
+      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 result = await executeSql(executor, query, params);
-    return Array.isArray(result) ? result : [];
+    return await this.executeWithAutoClose(async () => {
+      const executor = this._transaction || this.sql;
+      const result = await executeSql(executor, query, params);
+      return Array.isArray(result) ? result : [];
+    });
   }
 
   async get<T = any>(query: string, params?: any[]): Promise<T | null> {
-    const results = await this.all<T>(query, params);
-    return results.length > 0 ? results[0]! : null;
+    return await this.executeWithAutoClose(async () => {
+      const results = await this.all<T>(query, params);
+      return results.length > 0 ? results[0]! : null;
+    });
   }
 
-  async begin<T>(callback: (tx: Transaction) => Promise<T>): Promise<T> {
+  async begin<T>(callback: (tx: 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);
+      // Create a transaction builder that reuses the existing connection
+      // Don't create a new BunQL instance, just modify the current one temporarily
+      const originalTransaction = this._transaction;
+      this._transaction = tx;
+      
+      try {
+        return await callback(this);
+      } finally {
+        // Restore original transaction state
+        this._transaction = originalTransaction;
+      }
     });
   }
 
   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);
+      // Create a transaction builder that reuses the existing connection
+      // Don't create a new BunQL instance, just modify the current one temporarily
+      const originalTransaction = this._transaction;
+      this._transaction = tx;
+      
+      try {
+        return await callback(this);
+      } finally {
+        // Restore original transaction state
+        this._transaction = originalTransaction;
+      }
     });
   }
 
@@ -105,11 +265,19 @@ export class BunQL {
   async rollback(): Promise<void> {
     // Transactions are handled by Bun's SQL implementation
   }
+
+  async close(): Promise<void> {
+    if (this.connectionString) {
+      // Release connection back to pool instead of closing it
+      this.pool.releaseConnection(this.connectionString, this.sql);
+    } else if (this.sql && typeof this.sql.close === 'function') {
+      await this.sql.close();
+    }
+    this.isClosed = true;
+  }
 }
 
-export class SelectQuery<T = any> {
-  private sql: SQL;
-  private transaction?: any;
+export class SelectQuery<T = any> extends BaseQuery {
   private columns: string;
   private table?: string;
   private whereClauses: string[] = [];
@@ -118,9 +286,8 @@ export class SelectQuery<T = any> {
   private limitCount?: number;
   private offsetCount?: number;
 
-  constructor(sql: SQL, transaction?: any, columns?: string | string[]) {
-    this.sql = sql;
-    this.transaction = transaction;
+  constructor(sql: SQL, transaction?: any, columns?: string | string[], bunql?: BunQL) {
+    super(sql, transaction, bunql);
     this.columns = this.formatColumns(columns);
   }
 
@@ -136,27 +303,37 @@ export class SelectQuery<T = any> {
   }
 
   where(column: string, operator: string, value: any): this {
-    this.whereClauses.push(`${column} ${operator} ?`);
-    this.whereParams.push(value);
+    if (operator.toUpperCase() === 'IN' && Array.isArray(value)) {
+      const placeholders = value.map(() => '?').join(', ');
+      this.whereClauses.push(`"${column}" IN (${placeholders})`);
+      this.whereParams.push(...value);
+    } else if (operator.toUpperCase() === 'NOT IN' && Array.isArray(value)) {
+      const placeholders = value.map(() => '?').join(', ');
+      this.whereClauses.push(`"${column}" NOT IN (${placeholders})`);
+      this.whereParams.push(...value);
+    } else {
+      this.whereClauses.push(`"${column}" ${operator} ?`);
+      this.whereParams.push(value);
+    }
     return this;
   }
 
   whereIn(column: string, values: any[]): this {
     const placeholders = values.map(() => '?').join(', ');
-    this.whereClauses.push(`${column} IN (${placeholders})`);
+    this.whereClauses.push(`"${column}" IN (${placeholders})`);
     this.whereParams.push(...values);
     return this;
   }
 
   whereNotIn(column: string, values: any[]): this {
     const placeholders = values.map(() => '?').join(', ');
-    this.whereClauses.push(`${column} NOT IN (${placeholders})`);
+    this.whereClauses.push(`"${column}" NOT IN (${placeholders})`);
     this.whereParams.push(...values);
     return this;
   }
 
   orderBy(column: string, direction: 'ASC' | 'DESC' = 'ASC'): this {
-    this.orderByClause = `${column} ${direction}`;
+    this.orderByClause = `"${column}" ${direction}`;
     return this;
   }
 
@@ -171,31 +348,33 @@ export class SelectQuery<T = any> {
   }
 
   async execute(): Promise<T[]> {
-    if (!this.table) {
-      throw new Error('Table name is required. Use .from() method.');
-    }
+    return await this.executeWithAutoClose(async () => {
+      if (!this.table) {
+        throw new Error('Table name is required. Use .from() method.');
+      }
 
-    let query = `SELECT ${this.columns} FROM "${this.table}"`;
-    
-    if (this.whereClauses.length > 0) {
-      query += ` WHERE ${this.whereClauses.join(' AND ')}`;
-    }
+      let query = `SELECT ${this.columns} FROM "${this.table}"`;
+      
+      if (this.whereClauses.length > 0) {
+        query += ` WHERE ${this.whereClauses.join(' AND ')}`;
+      }
 
-    if (this.orderByClause) {
-      query += ` ORDER BY ${this.orderByClause}`;
-    }
+      if (this.orderByClause) {
+        query += ` ORDER BY ${this.orderByClause}`;
+      }
 
-    if (this.limitCount !== undefined) {
-      query += ` LIMIT ${this.limitCount}`;
-    }
+      if (this.limitCount !== undefined) {
+        query += ` LIMIT ${this.limitCount}`;
+      }
 
-    if (this.offsetCount !== undefined) {
-      query += ` OFFSET ${this.offsetCount}`;
-    }
+      if (this.offsetCount !== undefined) {
+        query += ` OFFSET ${this.offsetCount}`;
+      }
 
-    const executor = this.transaction || this.sql;
-    const result = await executeSql(executor, query, this.whereParams);
-    return Array.isArray(result) ? result : [];
+      const executor = this.transaction || this.sql;
+      const result = await executeSql(executor, query, this.whereParams);
+      return Array.isArray(result) ? result : [];
+    });
   }
 
   async first(): Promise<T | null> {
@@ -203,28 +382,34 @@ export class SelectQuery<T = any> {
     return results.length > 0 ? results[0]! : null;
   }
 
+  async get(): Promise<T | null> {
+    return this.first();
+  }
+
   async all(): Promise<T[]> {
     return this.execute();
   }
 
   async count(): Promise<number> {
-    if (!this.table) {
-      throw new Error('Table name is required. Use .from() method.');
-    }
+    return await this.executeWithAutoClose(async () => {
+      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 ')}`;
-    }
+      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;
+      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
@@ -236,65 +421,76 @@ export class SelectQuery<T = any> {
   }
 }
 
-export class UpdateQuery {
-  private sql: SQL;
-  private transaction?: any;
+export class UpdateQuery extends BaseQuery {
   private table: string;
   private setClauses: string[] = [];
   private setParams: any[] = [];
   private whereClauses: string[] = [];
   private whereParams: any[] = [];
 
-  constructor(sql: SQL, table: string, transaction?: any) {
-    this.sql = sql;
-    this.transaction = transaction;
+  constructor(sql: SQL, table: string, transaction?: any, bunql?: BunQL) {
+    super(sql, transaction, bunql);
     this.table = table;
   }
 
   set(data: Record<string, any>): this {
     Object.entries(data).forEach(([key, value]) => {
-      this.setClauses.push(`${key} = ?`);
+      this.setClauses.push(`"${key}" = ?`);
       this.setParams.push(value);
     });
     return this;
   }
 
   where(column: string, operator: string, value: any): this {
-    this.whereClauses.push(`${column} ${operator} ?`);
-    this.whereParams.push(value);
+    if (operator.toUpperCase() === 'IN' && Array.isArray(value)) {
+      const placeholders = value.map(() => '?').join(', ');
+      this.whereClauses.push(`"${column}" IN (${placeholders})`);
+      this.whereParams.push(...value);
+    } else if (operator.toUpperCase() === 'NOT IN' && Array.isArray(value)) {
+      const placeholders = value.map(() => '?').join(', ');
+      this.whereClauses.push(`"${column}" NOT IN (${placeholders})`);
+      this.whereParams.push(...value);
+    } else {
+      this.whereClauses.push(`"${column}" ${operator} ?`);
+      this.whereParams.push(value);
+    }
     return this;
   }
 
   async execute(): Promise<any> {
-    if (this.setClauses.length === 0) {
-      throw new Error('No values to update. Use .set() method.');
-    }
+    return await this.executeWithAutoClose(async () => {
+      if (this.setClauses.length === 0) {
+        throw new Error('No values to update. Use .set() method.');
+      }
 
-    let query = `UPDATE "${this.table}" SET ${this.setClauses.join(', ')}`;
-    
-    if (this.whereClauses.length > 0) {
-      query += ` WHERE ${this.whereClauses.join(' AND ')}`;
-    }
+      let query = `UPDATE "${this.table}" SET ${this.setClauses.join(', ')}`;
+      
+      if (this.whereClauses.length > 0) {
+        query += ` WHERE ${this.whereClauses.join(' AND ')}`;
+      }
 
-    const executor = this.transaction || this.sql;
-    const allParams = [...this.setParams, ...this.whereParams];
-    return await executeSql(executor, query, allParams);
+      const executor = this.transaction || this.sql;
+      const allParams = [...this.setParams, ...this.whereParams];
+      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 ')}`;
-    }
+    return await this.executeWithAutoClose(async () => {
+      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;
+      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
@@ -306,17 +502,16 @@ export class UpdateQuery {
   }
 }
 
-export class InsertQuery {
-  private sql: SQL;
-  private transaction?: any;
+export class InsertQuery extends BaseQuery {
   private table: string;
   private columns: string[] = [];
   private valuesArray: any[] = [];
   private isEmptyArray: boolean = false;
+  private isBulkInsert: boolean = false;
+  private bulkData: Record<string, any>[] = [];
 
-  constructor(sql: SQL, table: string, transaction?: any) {
-    this.sql = sql;
-    this.transaction = transaction;
+  constructor(sql: SQL, table: string, transaction?: any, bunql?: BunQL) {
+    super(sql, transaction, bunql);
     this.table = table;
   }
 
@@ -330,11 +525,9 @@ export class InsertQuery {
       const firstRow = data[0];
       this.columns = Object.keys(firstRow);
       
-      data.forEach(row => {
-        this.columns.forEach(col => {
-          this.valuesArray.push(row[col]);
-        });
-      });
+      // For bulk insert, store the data separately
+      this.isBulkInsert = true;
+      this.bulkData = data;
     } else {
       this.columns = Object.keys(data);
       this.valuesArray = Object.values(data);
@@ -343,32 +536,65 @@ export class InsertQuery {
   }
 
   async execute(): Promise<any> {
-    if (this.isEmptyArray) {
-      throw new Error('Cannot insert empty array');
-    }
-    
-    if (this.columns.length === 0 || this.valuesArray.length === 0) {
-      throw new Error('No values to insert. Use .values() method.');
-    }
-
-    const columnsStr = this.columns.map(col => `"${col}"`).join(', ');
-    const placeholders = this.columns.map(() => '?').join(', ');
-    
-    let query = `INSERT INTO "${this.table}" (${columnsStr}) VALUES (${placeholders})`;
-
-    const executor = this.transaction || this.sql;
-    return await executeSql(executor, query, this.valuesArray);
+    return await this.executeWithAutoClose(async () => {
+      if (this.isEmptyArray) {
+        throw new Error('Cannot insert empty array');
+      }
+      
+      if (this.isBulkInsert) {
+        if (this.columns.length === 0 || this.bulkData.length === 0) {
+          throw new Error('No values to insert. Use .values() method.');
+        }
+
+        const columnsStr = this.columns.map(col => `"${col}"`).join(', ');
+        const placeholders = this.columns.map(() => '?').join(', ');
+        
+        let query = `INSERT INTO "${this.table}" (${columnsStr}) VALUES (${placeholders})`;
+
+        const executor = this.transaction || this.sql;
+        
+        // Execute each row separately for bulk insert
+        let totalAffectedRows = 0;
+        let lastInsertRowid: any = null;
+        
+        for (const row of this.bulkData) {
+          const values = this.columns.map(col => row[col]);
+          const result = await executeSql(executor, query, values);
+          totalAffectedRows += result.affectedRows || 1;
+          lastInsertRowid = result.lastInsertRowid;
+        }
+        
+        return {
+          affectedRows: totalAffectedRows,
+          lastInsertRowid: lastInsertRowid
+        };
+      } else {
+        if (this.columns.length === 0 || this.valuesArray.length === 0) {
+          throw new Error('No values to insert. Use .values() method.');
+        }
+
+        const columnsStr = this.columns.map(col => `"${col}"`).join(', ');
+        const placeholders = this.columns.map(() => '?').join(', ');
+        
+        let query = `INSERT INTO "${this.table}" (${columnsStr}) VALUES (${placeholders})`;
+
+        const executor = this.transaction || this.sql;
+        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;
+    return await this.executeWithAutoClose(async () => {
+      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
@@ -380,50 +606,61 @@ export class InsertQuery {
   }
 }
 
-export class DeleteQuery {
-  private sql: SQL;
-  private transaction?: any;
+export class DeleteQuery extends BaseQuery {
   private table: string;
   private whereClauses: string[] = [];
   private whereParams: any[] = [];
 
-  constructor(sql: SQL, table: string, transaction?: any) {
-    this.sql = sql;
-    this.transaction = transaction;
+  constructor(sql: SQL, table: string, transaction?: any, bunql?: BunQL) {
+    super(sql, transaction, bunql);
     this.table = table;
   }
 
   where(column: string, operator: string, value: any): this {
-    this.whereClauses.push(`${column} ${operator} ?`);
-    this.whereParams.push(value);
+    if (operator.toUpperCase() === 'IN' && Array.isArray(value)) {
+      const placeholders = value.map(() => '?').join(', ');
+      this.whereClauses.push(`"${column}" IN (${placeholders})`);
+      this.whereParams.push(...value);
+    } else if (operator.toUpperCase() === 'NOT IN' && Array.isArray(value)) {
+      const placeholders = value.map(() => '?').join(', ');
+      this.whereClauses.push(`"${column}" NOT IN (${placeholders})`);
+      this.whereParams.push(...value);
+    } else {
+      this.whereClauses.push(`"${column}" ${operator} ?`);
+      this.whereParams.push(value);
+    }
     return this;
   }
 
   async execute(): Promise<any> {
-    let query = `DELETE FROM "${this.table}"`;
-    
-    if (this.whereClauses.length > 0) {
-      query += ` WHERE ${this.whereClauses.join(' AND ')}`;
-    }
+    return await this.executeWithAutoClose(async () => {
+      let query = `DELETE FROM "${this.table}"`;
+      
+      if (this.whereClauses.length > 0) {
+        query += ` WHERE ${this.whereClauses.join(' AND ')}`;
+      }
 
-    const executor = this.transaction || this.sql;
-    return await executeSql(executor, query, this.whereParams);
+      const executor = this.transaction || this.sql;
+      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 ')}`;
-    }
+    return await this.executeWithAutoClose(async () => {
+      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;
+      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