@dbcube/core 3.0.21 → 3.0.22

package/dist/index.cjs

@@ -766,166 +766,11 @@ 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 connectionPool = new ConnectionPool(MAX_CONNECTIONS_PER_DB);
-var queryCache = new LRUCache(MAX_CACHE_ENTRIES, CACHE_CLEANUP_THRESHOLD);
+var globalTcpConnections = /* @__PURE__ */ new Map();
+var queryCache = /* @__PURE__ */ new Map();
+var cacheSize = 0;
+var MAX_CACHE_SIZE = 500;
 var QueryEngine = class {
   name;
   config;
@@ -955,8 +800,7 @@ var QueryEngine = class {
   }
   isPortAvailable(port) {
     return new Promise((resolve5) => {
-      const net2 = require("net");
-      const tester = net2.createServer();
+      const tester = net.createServer();
       tester.once("error", () => resolve5(false));
       tester.once("listening", () => {
         tester.close();
@@ -1080,12 +924,14 @@ var QueryEngine = class {
     return new Promise((resolve5) => setTimeout(resolve5, ms));
   }
   getCachedDML(dmlJson) {
-    const cached = queryCache.get(dmlJson);
-    if (cached !== void 0) {
-      return cached;
+    if (queryCache.has(dmlJson)) {
+      return queryCache.get(dmlJson);
     }
     const parsed = JSON.parse(dmlJson);
-    queryCache.set(dmlJson, parsed);
+    if (cacheSize < MAX_CACHE_SIZE) {
+      queryCache.set(dmlJson, parsed);
+      cacheSize++;
+    }
     return parsed;
   }
   async startTcpServer() {
@@ -1199,12 +1045,13 @@ var QueryEngine = class {
     });
   }
   async sendTcpRequestFast(args) {
-    const existingConnection = connectionPool.getConnection(this.connectionId);
+    const existingConnection = globalTcpConnections.get(this.connectionId);
     if (existingConnection && existingConnection.readyState === "open") {
       try {
         return await this.sendOnExistingConnection(existingConnection, args);
       } catch (error) {
-        connectionPool.removeConnection(this.connectionId, existingConnection);
+        globalTcpConnections.delete(this.connectionId);
+        existingConnection.destroy();
       }
     }
     return await this.createPersistentConnection(args);
@@ -1289,7 +1136,7 @@ var QueryEngine = class {
           }
           return;
         }
-        connectionPool.addConnection(this.connectionId, client);
+        globalTcpConnections.set(this.connectionId, client);
         const command = {
           action: "execute",
           dml: dmlJson
@@ -1316,12 +1163,12 @@ var QueryEngine = class {
       client.on("error", (error) => {
         if (!isResolved) {
           isResolved = true;
-          connectionPool.removeConnection(this.connectionId, client);
+          globalTcpConnections.delete(this.connectionId);
           reject(error);
         }
       });
       client.on("close", () => {
-        connectionPool.removeConnection(this.connectionId, client);
+        globalTcpConnections.delete(this.connectionId);
         if (!isResolved && !responseBuffer.includes("PROCESS_RESPONSE:")) {
           reject(new Error("Connection closed without valid response"));
         }
@@ -1416,7 +1263,12 @@ var QueryEngine = class {
     });
   }
   async disconnect() {
-    connectionPool.closeAll(this.connectionId);
+    const connection = globalTcpConnections.get(this.connectionId);
+    if (connection && connection.readyState === "open") {
+      connection.write(JSON.stringify({ action: "disconnect" }));
+      connection.destroy();
+      globalTcpConnections.delete(this.connectionId);
+    }
     const serverInfo = globalTcpServers.get(this.connectionId);
     if (serverInfo && serverInfo.process && !serverInfo.process.killed) {
       serverInfo.process.kill();
@@ -1433,21 +1285,6 @@ 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