@bunnykit/orm 0.1.14 → 0.1.15

package/dist/src/connection/Connection.js

@@ -76,7 +76,6 @@ export class Connection {
         return `"${value.replace(/"/g, '""')}"`;
     }
     async query(sqlString) {
-        // Use unsafe for generated SQL strings
         return (await this.driver.unsafe(sqlString));
     }
     async run(sqlString) {

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

@@ -21,15 +21,28 @@ export type TenantResolution = {
     setting?: string;
 };
 export type TenantResolver = (tenantId: string) => TenantResolution | Promise<TenantResolution>;
+export interface PoolConfig {
+    maxConnections?: number;
+    minConnections?: number;
+    idleTimeout?: number;
+}
 export declare class ConnectionManager {
     private static defaultConnection?;
     private static connections;
+    private static pools;
+    private static poolConfigs;
     private static tenantResolver?;
     private static tenantCache;
     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 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 require(name: string): Connection;
     static setTenantResolver(resolver: TenantResolver): void;
     static resolveTenant(tenantId: string): Promise<ActiveTenantContext>;

package/dist/src/connection/ConnectionManager.js

@@ -2,6 +2,8 @@ import { Connection } from "./Connection.js";
 export class ConnectionManager {
     static defaultConnection;
     static connections = new Map();
+    static pools = new Map();
+    static poolConfigs = new Map();
     static tenantResolver;
     static tenantCache = new Map();
     static setDefault(connection) {
@@ -10,6 +12,67 @@ export class ConnectionManager {
     static getDefault() {
         return this.defaultConnection;
     }
+    static setPoolConfig(name, config) {
+        this.poolConfigs.set(name, { maxConnections: 10, minConnections: 1, idleTimeout: 30000, ...config });
+    }
+    static getPoolConfig(name) {
+        return this.poolConfigs.get(name);
+    }
+    static async getPooledConnection(name, config) {
+        const poolConfig = this.poolConfigs.get(name) || { maxConnections: 10, minConnections: 1, idleTimeout: 30000 };
+        let pool = this.pools.get(name);
+        if (!pool) {
+            pool = [];
+            this.pools.set(name, pool);
+        }
+        const now = Date.now();
+        const idleTimeout = poolConfig.idleTimeout || 30000;
+        while (pool.length > 0) {
+            const idx = pool.findIndex((c) => !c.inUse && (now - c.lastUsed) < idleTimeout);
+            if (idx === -1)
+                break;
+            const pooled = pool[idx];
+            pool.splice(idx, 1);
+            try {
+                pooled.connection.query("SELECT 1").catch(() => null);
+                pooled.inUse = true;
+                return pooled.connection;
+            }
+            catch {
+                await pooled.connection.close().catch(() => null);
+            }
+        }
+        if (pool.length < (poolConfig.maxConnections || 10)) {
+            const connection = new Connection(config);
+            pool.push({ connection, lastUsed: Date.now(), inUse: true });
+            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);
+                reject(new Error(`Connection pool exhausted for "${name}"`));
+            }, 30000);
+        });
+    }
+    static 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;
+            pooled.lastUsed = Date.now();
+        }
+    }
     static add(name, connection) {
         const resolved = connection instanceof Connection ? connection : new Connection(connection);
         this.connections.set(name, resolved);
@@ -18,6 +81,18 @@ export class ConnectionManager {
     static get(name) {
         return this.connections.get(name);
     }
+    static async getPooled(name, config) {
+        if (config) {
+            return this.getPooledConnection(name, config);
+        }
+        const existing = this.connections.get(name);
+        if (existing)
+            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 require(name) {
         const connection = this.get(name);
         if (!connection) {
@@ -93,9 +168,15 @@ export class ConnectionManager {
     }
     static async closeAll() {
         const connections = new Set(this.connections.values());
+        for (const pool of this.pools.values()) {
+            for (const { connection } of pool) {
+                connections.add(connection);
+            }
+        }
         if (this.defaultConnection)
             connections.add(this.defaultConnection);
         this.connections.clear();
+        this.pools.clear();
         this.tenantCache.clear();
         for (const connection of connections) {
             await connection.close();

package/dist/src/query/Builder.d.ts

@@ -30,6 +30,7 @@ export declare class Builder<T = Record<string, any>> {
     unions: UnionClause[];
     fromRaw?: string;
     updateJoins: string[];
+    bindings: any[];
     constructor(connection: Connection, table: string);
     private get grammar();
     setModel(model: ModelConstructor): this;
@@ -157,7 +158,7 @@ export declare class Builder<T = Record<string, any>> {
     paginate(perPage?: number, page?: number): Promise<Paginator<T>>;
     chunk(count: number, callback: (items: T[]) => void | Promise<void>): Promise<void>;
     each(count: number, callback: (item: T) => void | Promise<void>): Promise<void>;
-    cursor(): AsyncGenerator<T>;
+    cursor(keyset?: Record<string, any>): AsyncGenerator<T>;
     lazy(count?: number): AsyncGenerator<T>;
     insert(data: ModelAttributeInput<T> | ModelAttributeInput<T>[]): Promise<any>;
     insertGetId(data: ModelAttributeInput<T>, idColumn?: ModelColumn<T>): Promise<any>;

package/dist/src/query/Builder.js

@@ -18,6 +18,7 @@ export class Builder {
     unions = [];
     fromRaw;
     updateJoins = [];
+    bindings = [];
     constructor(connection, table) {
         this.connection = connection;
         this.tableName = table;
@@ -455,6 +456,7 @@ export class Builder {
         cloned.unions = [...this.unions];
         cloned.fromRaw = this.fromRaw;
         cloned.updateJoins = [...this.updateJoins];
+        cloned.bindings = [...this.bindings];
         return cloned;
     }
     wrapColumn(value) {
@@ -697,14 +699,34 @@ export class Builder {
             }
         });
     }
-    async *cursor() {
-        let offset = 0;
-        while (true) {
-            const items = await this.clone().offset(offset).limit(1).get();
-            if (items.length === 0)
-                break;
-            yield items[0];
-            offset++;
+    async *cursor(keyset) {
+        const model = this.model;
+        const primaryKey = model ? model.primaryKey || "id" : "id";
+        const orderColumn = this.orders[0]?.column || primaryKey;
+        const orderDirection = this.orders[0]?.direction || "asc";
+        const builder = this.clone();
+        builder.orders = [{ column: orderColumn, direction: orderDirection }];
+        builder.offsetValue = undefined;
+        if (keyset) {
+            const op = orderDirection === "asc" ? ">" : "<";
+            builder.wheres.push({
+                type: "basic",
+                column: orderColumn,
+                operator: op,
+                value: keyset[orderColumn],
+                boolean: "and",
+                scope: undefined,
+            });
+        }
+        const items = await builder.limit(1).get();
+        if (items.length === 0)
+            return;
+        yield items[0];
+        const nextKeyset = items[0] && typeof items[0] === "object"
+            ? { [orderColumn]: items[0][orderColumn] }
+            : undefined;
+        if (nextKeyset) {
+            yield* this.cursor(nextKeyset);
         }
     }
     async *lazy(count = 1000) {

package/package.json

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