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

package/README.md

@@ -1,6 +1,6 @@
 # BunQL
 
-A fluent SQL query builder for Bun with transaction support, built on top of Bun's native SQL bindings.
+A fluent SQL query builder for Bun with transaction support, built on top of Bun's native SQL bindings. **PostgreSQL-only** for maximum performance and efficiency.
 
 ## Features
 
@@ -8,10 +8,12 @@ A fluent SQL query builder for Bun with transaction support, built on top of Bun
 - ⚡ **Auto-Execute**: Queries automatically execute when awaited (no `.execute()` needed!)
 - 🔄 **Transaction Support**: Built-in transaction handling with rollback support
 - 🛡️ **SQL Injection Protection**: Parameterized queries prevent SQL injection
-- 🗄️ **Multi-Database Support**: Works with PostgreSQL, MySQL, and SQLite
+- 🐘 **PostgreSQL Optimized**: Built specifically for PostgreSQL for maximum performance
 - 📦 **Zero Dependencies**: Built on Bun's native SQL bindings
 - 🧪 **TypeScript Support**: Full TypeScript support with type safety
-- 🏗️ **Schema Management**: Complete database schema creation and management API
+- 🏗️ **Schema Management**: Complete PostgreSQL schema creation and management API
+- 🔒 **Auto-Close**: Connections automatically close after non-transaction queries
+- 🔄 **Auto-Reconnect**: Automatically reconnects when needed for subsequent queries
 
 ## Installation
 
@@ -49,6 +51,49 @@ const users = await db.select('*').from('users').execute();
 
 This makes the API more concise and intuitive while maintaining backward compatibility.
 
+## Auto-Close & Auto-Reconnect
+
+BunQL automatically manages database connections for optimal performance and resource usage:
+
+### Auto-Close
+- **Non-transaction queries**: Connections automatically close after execution
+- **Transaction queries**: Connections stay open during the transaction, then auto-close
+- **Error handling**: Connections auto-close even if queries fail
+
+### Auto-Reconnect
+- **Seamless reconnection**: Automatically reconnects when needed for subsequent queries
+- **No manual management**: No need to manually open/close connections
+- **Resource efficient**: Prevents connection leaks and "too many clients" errors
+
+```typescript
+// ✅ Auto-close after each query
+const count1 = await db.select('*').from('users').count();
+const count2 = await db.select('*').from('users').count(); // Auto-reconnects
+
+// ✅ Transaction keeps connection open
+const result = await db.transaction(async (trx) => {
+  const user = await trx.insert('users').values({ name: 'John' });
+  const profile = await trx.insert('profiles').values({ user_id: user.lastInsertRowid });
+  return { user, profile };
+}); // Auto-closes after transaction
+
+// ✅ Perfect for Bun.serve applications
+Bun.serve({
+  port: 3000,
+  async fetch(request) {
+    const db = new BunQL(process.env.DATABASE_URL!);
+    
+    try {
+      const users = await db.select('*').from('users').all();
+      return new Response(JSON.stringify(users));
+    } catch (error) {
+      return new Response('Error', { status: 500 });
+    }
+    // Connection automatically closed - no manual cleanup needed!
+  }
+});
+```
+
 ## Count Functionality
 
 BunQL provides `.count()` methods on all query types to get the number of records:
@@ -475,6 +520,48 @@ BunQL works with all databases supported by Bun's native SQL bindings:
 - **MySQL**: `mysql://user:pass@localhost:3306/db`
 - **SQLite**: `sqlite://path/to/database.db` or `:memory:`
 
+## Connection Management
+
+### Opening Connections
+
+```typescript
+// SQLite (file)
+const db = new BunQL('sqlite://database.db');
+
+// SQLite (in-memory)
+const db = new BunQL('sqlite://:memory:');
+
+// PostgreSQL
+const db = new BunQL('postgres://user:pass@localhost:5432/mydb');
+
+// MySQL
+const db = new BunQL('mysql://user:pass@localhost:3306/mydb');
+```
+
+### Closing Connections
+
+Always close database connections when you're done to free up resources:
+
+```typescript
+const db = new BunQL('sqlite://database.db');
+
+try {
+  // Your database operations
+  await db.insert('users').values({ name: 'John' });
+  const users = await db.select('*').from('users').all();
+} finally {
+  // Always close the connection
+  await db.close();
+}
+```
+
+### Best Practices
+
+- **Always close connections** in `finally` blocks or use try-catch-finally
+- **Use connection pooling** for production applications
+- **Close connections** after transactions complete
+- **Handle connection errors** gracefully
+
 ## API Reference
 
 ### BunQL
@@ -492,6 +579,7 @@ Main class for building and executing queries.
 - `get(query, params?)`: Execute raw SQL and return first result
 - `begin(callback)`: Execute queries in a transaction (legacy)
 - `transaction(callback)`: Execute queries in a transaction (recommended)
+- `close()`: Close the database connection
 
 ### SelectQuery
 

package/package.json

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

package/src/index.test.ts

@@ -298,5 +298,9 @@ describe('BunQL', () => {
     it('should have rollback method', () => {
       expect(typeof db.rollback).toBe('function');
     });
+
+    it('should have close method', () => {
+      expect(typeof db.close).toBe('function');
+    });
   });
 });