@dbcube/core 3.0.21 → 3.0.23

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
@@ -1456,13 +1293,20 @@ var path5 = __toESM(require("path"));
 var fs3 = __toESM(require("fs"));
 var import_util = require("util");
 var import_module3 = require("module");
+var net2 = __toESM(require("net"));
 var execAsync = (0, import_util.promisify)(import_child_process3.exec);
+var globalSqliteServers = /* @__PURE__ */ new Map();
+var globalSqliteConnections = /* @__PURE__ */ new Map();
 var SqliteExecutor = class {
   binaryPath;
   dbPath;
+  connectionId;
+  tcpPort = 9944;
+  useTcp = true;
   constructor(dbPath) {
     this.dbPath = dbPath;
     this.binaryPath = this.getBinaryPath();
+    this.connectionId = `sqlite_${dbPath.replace(/[^a-zA-Z0-9]/g, "_")}`;
   }
   getBinaryPath() {
     const possibleDirs = [
@@ -1545,7 +1389,173 @@ var SqliteExecutor = class {
       return false;
     }
   }
+  async findAvailablePort(startPort) {
+    for (let port = startPort; port >= 9900; port--) {
+      if (await this.isPortAvailable(port)) {
+        return port;
+      }
+    }
+    throw new Error("No available ports found in range 9900-9944");
+  }
+  isPortAvailable(port) {
+    return new Promise((resolve5) => {
+      const tester = net2.createServer();
+      tester.once("error", () => resolve5(false));
+      tester.once("listening", () => {
+        tester.close();
+        resolve5(true);
+      });
+      tester.listen(port, "127.0.0.1");
+    });
+  }
+  async startTcpServer() {
+    this.tcpPort = await this.findAvailablePort(this.tcpPort);
+    return new Promise((resolve5, reject) => {
+      const serverArgs = [
+        "--action",
+        "serve",
+        "--id",
+        this.connectionId,
+        "--database-ref",
+        "config",
+        "--database",
+        this.dbPath
+      ];
+      const serverProcess = (0, import_child_process3.spawn)(this.binaryPath, serverArgs);
+      let started = false;
+      const timeout = setTimeout(() => {
+        if (!started) {
+          serverProcess.kill();
+          reject(new Error("SQLite TCP server startup timeout"));
+        }
+      }, 1e4);
+      serverProcess.stdout.on("data", (data) => {
+        const output = data.toString();
+        if (output.includes("SQLite TCP Server started") || output.includes("PROCESS_RESPONSE:")) {
+          if (!started) {
+            started = true;
+            clearTimeout(timeout);
+            const match = output.match(/PROCESS_RESPONSE:(\{.*\})/);
+            if (match) {
+              try {
+                const response = JSON.parse(match[1]);
+                if (response.data && response.data.port) {
+                  this.tcpPort = response.data.port;
+                }
+              } catch (e) {
+              }
+            }
+            globalSqliteServers.set(this.connectionId, {
+              port: this.tcpPort,
+              process: serverProcess
+            });
+            resolve5();
+          }
+        }
+      });
+      serverProcess.stderr.on("data", (data) => {
+        console.error(`[SQLite Server Error] ${data.toString().trim()}`);
+      });
+      serverProcess.on("close", () => {
+        globalSqliteServers.delete(this.connectionId);
+        globalSqliteConnections.delete(this.connectionId);
+      });
+      serverProcess.on("error", (error) => {
+        if (!started) {
+          clearTimeout(timeout);
+          reject(error);
+        }
+      });
+    });
+  }
+  async sendTcpQuery(sql, params) {
+    const serverInfo = globalSqliteServers.get(this.connectionId);
+    if (!serverInfo || !serverInfo.process || serverInfo.process.killed) {
+      await this.startTcpServer();
+      await this.sleep(500);
+    }
+    return new Promise((resolve5, reject) => {
+      const client = new net2.Socket();
+      let responseBuffer = "";
+      let isResolved = false;
+      const timeout = setTimeout(() => {
+        if (!isResolved) {
+          isResolved = true;
+          client.destroy();
+          reject(new Error("TCP query timeout"));
+        }
+      }, 1e4);
+      client.connect(this.tcpPort, "127.0.0.1", () => {
+        const command = {
+          action: "query",
+          query: sql,
+          params: params || []
+        };
+        client.write(JSON.stringify(command) + "\n");
+      });
+      client.on("data", (data) => {
+        responseBuffer += data.toString();
+        const match = responseBuffer.match(/PROCESS_RESPONSE:(\{.*\})/);
+        if (match && !isResolved) {
+          isResolved = true;
+          clearTimeout(timeout);
+          client.destroy();
+          try {
+            const response = JSON.parse(match[1]);
+            if (response.code === 200) {
+              resolve5({
+                status: "success",
+                message: response.message,
+                data: response.data
+              });
+            } else {
+              resolve5({
+                status: "error",
+                message: response.message,
+                data: null
+              });
+            }
+          } catch (error) {
+            reject(new Error("Failed to parse TCP response"));
+          }
+        }
+      });
+      client.on("error", (error) => {
+        if (!isResolved) {
+          isResolved = true;
+          clearTimeout(timeout);
+          this.useTcp = false;
+          this.executeBinary([
+            "--action",
+            "query",
+            "--database",
+            this.dbPath,
+            "--query",
+            sql,
+            ...params && params.length > 0 ? ["--params", JSON.stringify(params)] : []
+          ]).then(resolve5).catch(reject);
+        }
+      });
+      client.on("close", () => {
+        if (!isResolved) {
+          clearTimeout(timeout);
+          reject(new Error("Connection closed without valid response"));
+        }
+      });
+    });
+  }
+  sleep(ms) {
+    return new Promise((resolve5) => setTimeout(resolve5, ms));
+  }
   async query(sql, params) {
+    if (this.useTcp) {
+      try {
+        return await this.sendTcpQuery(sql, params);
+      } catch (error) {
+        console.warn("TCP query failed, falling back to direct execution");
+        this.useTcp = false;
+      }
+    }
     const args = [
       "--action",
       "query",