@bunnykit/orm 0.1.17 → 0.1.19

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/dist/src/index.d.ts

@@ -20,6 +20,7 @@ export { ObserverRegistry, type ObserverContract } from "./model/Observer.js";
 export { MorphMap } from "./model/MorphMap.js";
 export { MorphTo, MorphOne, MorphMany, MorphToMany } from "./model/MorphRelations.js";
 export { BelongsToMany } from "./model/BelongsToMany.js";
+export { IdentityMap } from "./model/IdentityMap.js";
 export { Migration } from "./migration/Migration.js";
 export { Migrator } from "./migration/Migrator.js";
 export type { MigrationEvent, MigrationEventListener, MigrationEventPayload } from "./migration/Migrator.js";

package/dist/src/index.js

@@ -15,6 +15,7 @@ export { ObserverRegistry } from "./model/Observer.js";
 export { MorphMap } from "./model/MorphMap.js";
 export { MorphTo, MorphOne, MorphMany, MorphToMany } from "./model/MorphRelations.js";
 export { BelongsToMany } from "./model/BelongsToMany.js";
+export { IdentityMap } from "./model/IdentityMap.js";
 export { Migration } from "./migration/Migration.js";
 export { Migrator } from "./migration/Migrator.js";
 export { MigrationCreator } from "./migration/MigrationCreator.js";

package/dist/src/model/IdentityMap.d.ts

@@ -0,0 +1,8 @@
+import type { Model } from "./Model.js";
+export declare class IdentityMap {
+    static current(): Map<string, Model> | undefined;
+    static run<T>(callback: () => T | Promise<T>): Promise<T>;
+    static get(table: string, key: string | number): Model | undefined;
+    static set(table: string, key: string | number, model: Model): void;
+    static clear(): void;
+}

package/dist/src/model/IdentityMap.js

@@ -0,0 +1,28 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const storage = new AsyncLocalStorage();
+export class IdentityMap {
+    static current() {
+        return storage.getStore();
+    }
+    static async run(callback) {
+        return await storage.run(new Map(), callback);
+    }
+    static get(table, key) {
+        const map = this.current();
+        if (!map)
+            return undefined;
+        return map.get(`${table}:${String(key)}`);
+    }
+    static set(table, key, model) {
+        const map = this.current();
+        if (!map)
+            return;
+        map.set(`${table}:${String(key)}`, model);
+    }
+    static clear() {
+        const map = this.current();
+        if (!map)
+            return;
+        map.clear();
+    }
+}

package/dist/src/model/Model.d.ts

@@ -115,6 +115,7 @@ export declare class Model<T extends Record<string, any> = Record<string, any>>
     static getTable(): string;
     static getConnection(): Connection;
     static setConnection(connection: Connection): void;
+    static useIdentityMap<T>(callback: () => T | Promise<T>): Promise<T>;
     static on<M extends ModelConstructor>(this: M, connection: string | Connection): Builder<InstanceType<M>>;
     static forTenant<M extends ModelConstructor>(this: M, tenantId: string): Builder<InstanceType<M>>;
     static query<M extends ModelConstructor>(this: M): Builder<InstanceType<M>>;

package/dist/src/model/Model.js

@@ -7,6 +7,7 @@ import { Schema } from "../schema/Schema.js";
 import { ModelNotFoundError } from "./ModelNotFoundError.js";
 import { ConnectionManager } from "../connection/ConnectionManager.js";
 import { TenantContext } from "../connection/TenantContext.js";
+import { IdentityMap } from "./IdentityMap.js";
 const globalScopes = new WeakMap();
 function getGlobalScopes(model) {
     const scopes = new Map();
@@ -353,6 +354,9 @@ export class Model {
         this.connection = connection;
         ConnectionManager.setDefault(connection);
     }
+    static useIdentityMap(callback) {
+        return IdentityMap.run(callback);
+    }
     static on(connection) {
         const resolved = typeof connection === "string" ? ConnectionManager.require(connection) : connection;
         const builder = new Builder(resolved, resolved.qualifyTable(this.getTable()));
@@ -813,6 +817,13 @@ export class Model {
             await ObserverRegistry.dispatch("created", this);
             await ObserverRegistry.dispatch("saved", this);
         }
+        const identityMap = IdentityMap.current();
+        if (identityMap) {
+            const pk = this.getAttribute(constructor.primaryKey);
+            if (pk !== null && pk !== undefined && pk !== "") {
+                IdentityMap.set(constructor.getTable(), pk, this);
+            }
+        }
         return this;
     }
     updateTimestamps() {

package/dist/src/query/Builder.js

@@ -1,4 +1,5 @@
 import { ModelNotFoundError } from "../model/ModelNotFoundError.js";
+import { IdentityMap } from "../model/IdentityMap.js";
 export class Builder {
     connection;
     tableName;
@@ -589,13 +590,31 @@ export class Builder {
         const results = await this.connection.query(sql, this.bindings);
         const rows = Array.from(results);
         if (this.model) {
+            const identityMap = IdentityMap.current();
+            const table = this.model.getTable();
+            const primaryKey = this.model.primaryKey || "id";
             const models = rows.map((row) => {
+                if (identityMap) {
+                    const pk = row[primaryKey];
+                    if (pk !== null && pk !== undefined) {
+                        const cached = IdentityMap.get(table, pk);
+                        if (cached) {
+                            return cached;
+                        }
+                    }
+                }
                 const instance = new this.model(row);
                 instance.$exists = true;
                 instance.$original = { ...row };
                 if (typeof instance.setConnection === "function") {
                     instance.setConnection(this.connection);
                 }
+                if (identityMap) {
+                    const pk = row[primaryKey];
+                    if (pk !== null && pk !== undefined) {
+                        IdentityMap.set(table, pk, instance);
+                    }
+                }
                 return instance;
             });
             if (this.eagerLoads.length > 0) {

package/package.json

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