@dbcube/core 3.0.20 → 3.0.21

package/dist/index.cjs

@@ -766,11 +766,166 @@ var import_path2 = __toESM(require("path"));
 var import_module2 = require("module");
 var net = __toESM(require("net"));
 var import_child_process2 = require("child_process");
+var MAX_CONNECTIONS_PER_DB = 10;
+var MAX_CACHE_ENTRIES = 1e3;
+var CACHE_CLEANUP_THRESHOLD = 0.9;
+var CONNECTION_IDLE_TIMEOUT = 3e5;
+var CONNECTION_MAX_AGE = 36e5;
+var LRUCache = class {
+  cache;
+  maxSize;
+  cleanupThreshold;
+  constructor(maxSize, cleanupThreshold = 0.9) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+    this.cleanupThreshold = cleanupThreshold;
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return void 0;
+    entry.lastAccessed = Date.now();
+    entry.accessCount++;
+    return entry.value;
+  }
+  set(key, value) {
+    if (this.cache.size >= this.maxSize * this.cleanupThreshold) {
+      this.evictLRU();
+    }
+    this.cache.set(key, {
+      value,
+      lastAccessed: Date.now(),
+      accessCount: 1
+    });
+  }
+  evictLRU() {
+    const entries = Array.from(this.cache.entries()).sort((a, b) => {
+      const scoreDiff = this.calculateScore(a[1]) - this.calculateScore(b[1]);
+      if (scoreDiff !== 0) return scoreDiff;
+      return a[1].lastAccessed - b[1].lastAccessed;
+    });
+    const toRemove = Math.floor(this.maxSize * 0.2);
+    for (let i = 0; i < toRemove && i < entries.length; i++) {
+      this.cache.delete(entries[i][0]);
+    }
+  }
+  calculateScore(entry) {
+    const now = Date.now();
+    const age = now - entry.lastAccessed;
+    const recencyScore = 1 / (age + 1);
+    const frequencyScore = entry.accessCount;
+    return recencyScore * 0.3 + frequencyScore * 0.7;
+  }
+  clear() {
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size;
+  }
+};
+var ConnectionPool = class {
+  pools;
+  maxConnectionsPerDb;
+  constructor(maxConnectionsPerDb = MAX_CONNECTIONS_PER_DB) {
+    this.pools = /* @__PURE__ */ new Map();
+    this.maxConnectionsPerDb = maxConnectionsPerDb;
+    setInterval(() => this.cleanupIdleConnections(), 6e4);
+  }
+  getConnection(connectionId) {
+    const pool = this.pools.get(connectionId);
+    if (!pool || pool.length === 0) return null;
+    for (let i = 0; i < pool.length; i++) {
+      const conn = pool[i];
+      if (this.isConnectionValid(conn)) {
+        conn.lastUsed = Date.now();
+        conn.requestCount++;
+        return conn.socket;
+      } else {
+        conn.socket.destroy();
+        pool.splice(i, 1);
+        i--;
+      }
+    }
+    return null;
+  }
+  addConnection(connectionId, socket) {
+    if (!this.pools.has(connectionId)) {
+      this.pools.set(connectionId, []);
+    }
+    const pool = this.pools.get(connectionId);
+    if (pool.length >= this.maxConnectionsPerDb) {
+      const oldest = pool.shift();
+      if (oldest) {
+        oldest.socket.destroy();
+      }
+    }
+    pool.push({
+      socket,
+      lastUsed: Date.now(),
+      createdAt: Date.now(),
+      requestCount: 0
+    });
+  }
+  removeConnection(connectionId, socket) {
+    const pool = this.pools.get(connectionId);
+    if (!pool) return;
+    const index = pool.findIndex((c) => c.socket === socket);
+    if (index !== -1) {
+      pool[index].socket.destroy();
+      pool.splice(index, 1);
+    }
+    if (pool.length === 0) {
+      this.pools.delete(connectionId);
+    }
+  }
+  closeAll(connectionId) {
+    if (connectionId) {
+      const pool = this.pools.get(connectionId);
+      if (pool) {
+        pool.forEach((conn) => conn.socket.destroy());
+        this.pools.delete(connectionId);
+      }
+    } else {
+      this.pools.forEach((pool) => {
+        pool.forEach((conn) => conn.socket.destroy());
+      });
+      this.pools.clear();
+    }
+  }
+  isConnectionValid(conn) {
+    const now = Date.now();
+    const age = now - conn.createdAt;
+    return conn.socket.readyState === "open" && age < CONNECTION_MAX_AGE;
+  }
+  cleanupIdleConnections() {
+    const now = Date.now();
+    this.pools.forEach((pool, connectionId) => {
+      for (let i = pool.length - 1; i >= 0; i--) {
+        const conn = pool[i];
+        const idleTime = now - conn.lastUsed;
+        if (idleTime > CONNECTION_IDLE_TIMEOUT || !this.isConnectionValid(conn)) {
+          conn.socket.destroy();
+          pool.splice(i, 1);
+        }
+      }
+      if (pool.length === 0) {
+        this.pools.delete(connectionId);
+      }
+    });
+  }
+  getStats() {
+    const stats = {};
+    this.pools.forEach((pool, id) => {
+      stats[id] = {
+        activeConnections: pool.length,
+        totalRequests: pool.reduce((sum, c) => sum + c.requestCount, 0)
+      };
+    });
+    return stats;
+  }
+};
 var globalTcpServers = /* @__PURE__ */ new Map();
-var globalTcpConnections = /* @__PURE__ */ new Map();
-var queryCache = /* @__PURE__ */ new Map();
-var cacheSize = 0;
-var MAX_CACHE_SIZE = 500;
+var connectionPool = new ConnectionPool(MAX_CONNECTIONS_PER_DB);
+var queryCache = new LRUCache(MAX_CACHE_ENTRIES, CACHE_CLEANUP_THRESHOLD);
 var QueryEngine = class {
   name;
   config;
@@ -925,14 +1080,12 @@ var QueryEngine = class {
     return new Promise((resolve5) => setTimeout(resolve5, ms));
   }
   getCachedDML(dmlJson) {
-    if (queryCache.has(dmlJson)) {
-      return queryCache.get(dmlJson);
+    const cached = queryCache.get(dmlJson);
+    if (cached !== void 0) {
+      return cached;
     }
     const parsed = JSON.parse(dmlJson);
-    if (cacheSize < MAX_CACHE_SIZE) {
-      queryCache.set(dmlJson, parsed);
-      cacheSize++;
-    }
+    queryCache.set(dmlJson, parsed);
     return parsed;
   }
   async startTcpServer() {
@@ -1046,13 +1199,12 @@ var QueryEngine = class {
     });
   }
   async sendTcpRequestFast(args) {
-    const existingConnection = globalTcpConnections.get(this.connectionId);
+    const existingConnection = connectionPool.getConnection(this.connectionId);
     if (existingConnection && existingConnection.readyState === "open") {
       try {
         return await this.sendOnExistingConnection(existingConnection, args);
       } catch (error) {
-        globalTcpConnections.delete(this.connectionId);
-        existingConnection.destroy();
+        connectionPool.removeConnection(this.connectionId, existingConnection);
       }
     }
     return await this.createPersistentConnection(args);
@@ -1137,7 +1289,7 @@ var QueryEngine = class {
           }
           return;
         }
-        globalTcpConnections.set(this.connectionId, client);
+        connectionPool.addConnection(this.connectionId, client);
         const command = {
           action: "execute",
           dml: dmlJson
@@ -1164,12 +1316,12 @@ var QueryEngine = class {
       client.on("error", (error) => {
         if (!isResolved) {
           isResolved = true;
-          globalTcpConnections.delete(this.connectionId);
+          connectionPool.removeConnection(this.connectionId, client);
           reject(error);
         }
       });
       client.on("close", () => {
-        globalTcpConnections.delete(this.connectionId);
+        connectionPool.removeConnection(this.connectionId, client);
         if (!isResolved && !responseBuffer.includes("PROCESS_RESPONSE:")) {
           reject(new Error("Connection closed without valid response"));
         }
@@ -1264,12 +1416,7 @@ var QueryEngine = class {
     });
   }
   async disconnect() {
-    const connection = globalTcpConnections.get(this.connectionId);
-    if (connection && connection.readyState === "open") {
-      connection.write(JSON.stringify({ action: "disconnect" }));
-      connection.destroy();
-      globalTcpConnections.delete(this.connectionId);
-    }
+    connectionPool.closeAll(this.connectionId);
     const serverInfo = globalTcpServers.get(this.connectionId);
     if (serverInfo && serverInfo.process && !serverInfo.process.killed) {
       serverInfo.process.kill();
@@ -1286,6 +1433,21 @@ var QueryEngine = class {
       data: null
     };
   }
+  // Método para obtener estadísticas del pool y cache
+  static getStats() {
+    return {
+      connectionPool: connectionPool.getStats(),
+      cache: {
+        size: queryCache.size(),
+        maxSize: MAX_CACHE_ENTRIES
+      }
+    };
+  }
+  // Método para limpiar todo el cache y conexiones
+  static clearAll() {
+    queryCache.clear();
+    connectionPool.closeAll();
+  }
 };
 
 // src/lib/SqliteExecutor.ts