@bunnykit/orm 0.1.17 → 0.1.18

package/dist/src/connection/Connection.d.ts

@@ -8,6 +8,7 @@ export declare class Connection {
     private config;
     private schema?;
     private ownsDriver;
+    private transactionDepth;
     constructor(config: ConnectionConfig, options?: {
         driver?: SQL;
         schema?: string;
@@ -25,6 +26,7 @@ export declare class Connection {
     beginTransaction(): Promise<void>;
     commit(): Promise<void>;
     rollback(): Promise<void>;
+    isInTransaction(): boolean;
     transaction<T>(callback: (connection: Connection) => T | Promise<T>): Promise<T>;
     withTenant<T>(tenantId: string, callback: (connection: Connection) => T | Promise<T>, setting?: string): Promise<T>;
     withSearchPath<T>(schema: string, callback: (connection: Connection) => T | Promise<T>): Promise<T>;

package/dist/src/connection/Connection.js

@@ -9,6 +9,7 @@ export class Connection {
     config;
     schema;
     ownsDriver;
+    transactionDepth = 0;
     constructor(config, options = {}) {
         this.config = config;
         this.schema = options.schema || ("schema" in config ? config.schema : undefined);
@@ -83,12 +84,18 @@ export class Connection {
     }
     async beginTransaction() {
         await this.driver.unsafe("BEGIN");
+        this.transactionDepth++;
     }
     async commit() {
         await this.driver.unsafe("COMMIT");
+        this.transactionDepth = Math.max(0, this.transactionDepth - 1);
     }
     async rollback() {
         await this.driver.unsafe("ROLLBACK");
+        this.transactionDepth = Math.max(0, this.transactionDepth - 1);
+    }
+    isInTransaction() {
+        return this.transactionDepth > 0;
     }
     async transaction(callback) {
         return await this.driver.begin(async (sql) => {

package/dist/src/connection/ConnectionManager.d.ts

@@ -33,16 +33,18 @@ export declare class ConnectionManager {
     private static poolConfigs;
     private static tenantResolver?;
     private static tenantCache;
+    private static waiters;
     static setDefault(connection: Connection): void;
     static getDefault(): Connection | undefined;
     static setPoolConfig(name: string, config: PoolConfig): void;
     static getPoolConfig(name: string): PoolConfig | undefined;
     private static getPooledConnection;
+    private static removeWaiter;
     private static releasePooledConnection;
     static add(name: string, connection: Connection | ConnectionConfig): Connection;
     static get(name: string): Connection | undefined;
     static getPooled(name: string, config?: ConnectionConfig): Promise<Connection>;
-    static release(name: string, connection: Connection): void;
+    static release(name: string, connection: Connection): Promise<void>;
     static require(name: string): Connection;
     static setTenantResolver(resolver: TenantResolver): void;
     static resolveTenant(tenantId: string): Promise<ActiveTenantContext>;

package/dist/src/connection/ConnectionManager.js

@@ -6,6 +6,7 @@ export class ConnectionManager {
     static poolConfigs = new Map();
     static tenantResolver;
     static tenantCache = new Map();
+    static waiters = new Map();
     static setDefault(connection) {
         this.defaultConnection = connection;
     }
@@ -34,7 +35,7 @@ export class ConnectionManager {
             const pooled = pool[idx];
             pool.splice(idx, 1);
             try {
-                pooled.connection.query("SELECT 1").catch(() => null);
+                await pooled.connection.query("SELECT 1");
                 pooled.inUse = true;
                 return pooled.connection;
             }
@@ -48,30 +49,54 @@ export class ConnectionManager {
             return connection;
         }
         return new Promise((resolve, reject) => {
-            const checkInterval = setInterval(() => {
-                const available = pool.find((c) => !c.inUse);
-                if (available) {
-                    clearInterval(checkInterval);
-                    available.inUse = true;
-                    available.lastUsed = Date.now();
-                    resolve(available.connection);
-                }
-            }, 50);
-            setTimeout(() => {
-                clearInterval(checkInterval);
+            const timer = setTimeout(() => {
+                this.removeWaiter(name, waiter);
                 reject(new Error(`Connection pool exhausted for "${name}"`));
             }, 30000);
+            const waiter = { resolve, reject, timer };
+            let poolWaiters = this.waiters.get(name);
+            if (!poolWaiters) {
+                poolWaiters = [];
+                this.waiters.set(name, poolWaiters);
+            }
+            poolWaiters.push(waiter);
         });
     }
-    static releasePooledConnection(name, connection) {
+    static removeWaiter(name, waiter) {
+        const poolWaiters = this.waiters.get(name);
+        if (!poolWaiters)
+            return;
+        const idx = poolWaiters.indexOf(waiter);
+        if (idx !== -1)
+            poolWaiters.splice(idx, 1);
+    }
+    static async releasePooledConnection(name, connection) {
         const pool = this.pools.get(name);
         if (!pool)
             return;
         const pooled = pool.find((p) => p.connection === connection);
-        if (pooled) {
-            pooled.inUse = false;
+        if (!pooled)
+            return;
+        // Safety: roll back any leaked transaction before returning to pool
+        if (pooled.connection.isInTransaction()) {
+            try {
+                await pooled.connection.rollback();
+            }
+            catch {
+                // Connection may already be dead; ignore rollback errors
+            }
+        }
+        // Hand off directly to a waiter if one exists
+        const poolWaiters = this.waiters.get(name);
+        if (poolWaiters && poolWaiters.length > 0) {
+            const waiter = poolWaiters.shift();
+            clearTimeout(waiter.timer);
             pooled.lastUsed = Date.now();
+            waiter.resolve(connection);
+            return;
         }
+        pooled.inUse = false;
+        pooled.lastUsed = Date.now();
     }
     static add(name, connection) {
         const resolved = connection instanceof Connection ? connection : new Connection(connection);
@@ -90,8 +115,8 @@ export class ConnectionManager {
             return existing;
         throw new Error(`No connection registered for "${name}". Use add() first or provide config.`);
     }
-    static release(name, connection) {
-        this.releasePooledConnection(name, connection);
+    static async release(name, connection) {
+        await this.releasePooledConnection(name, connection);
     }
     static require(name) {
         const connection = this.get(name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bunnykit/orm",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "description": "An Eloquent-inspired ORM for Bun's native SQL client supporting SQLite, MySQL, and PostgreSQL.",
   "license": "MIT",
   "packageManager": "bun@1.3.12",