@dbcube/core 3.0.6 → 3.0.8

package/dist/index.d.mts

@@ -32,6 +32,8 @@ declare class QueryEngine {
     private tcpPort;
     constructor(name: string, timeout?: number);
     private generatePort;
+    private findAvailablePort;
+    private isPortAvailable;
     initializeBinary(): Promise<void>;
     setArguments(): any[];
     setConfig(name: string): {
@@ -40,8 +42,14 @@ declare class QueryEngine {
     getConfig(): any;
     run(binary: string, args: string[]): Promise<ResponseEngine>;
     private executeWithTcpServer;
+    private waitForServerReady;
+    private isServerResponding;
+    private sleep;
     private startTcpServer;
     private sendTcpRequest;
+    private sendTcpRequestFast;
+    private sendOnExistingConnection;
+    private createPersistentConnection;
     private createProcess;
     disconnect(): Promise<ResponseEngine>;
 }

package/dist/index.d.ts

@@ -32,6 +32,8 @@ declare class QueryEngine {
     private tcpPort;
     constructor(name: string, timeout?: number);
     private generatePort;
+    private findAvailablePort;
+    private isPortAvailable;
     initializeBinary(): Promise<void>;
     setArguments(): any[];
     setConfig(name: string): {
@@ -40,8 +42,14 @@ declare class QueryEngine {
     getConfig(): any;
     run(binary: string, args: string[]): Promise<ResponseEngine>;
     private executeWithTcpServer;
+    private waitForServerReady;
+    private isServerResponding;
+    private sleep;
     private startTcpServer;
     private sendTcpRequest;
+    private sendTcpRequestFast;
+    private sendOnExistingConnection;
+    private createPersistentConnection;
     private createProcess;
     disconnect(): Promise<ResponseEngine>;
 }

package/dist/index.js

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/lib/Engine.ts
 import path3 from "path";
 
@@ -722,6 +729,7 @@ import { createRequire as createRequire2 } from "module";
 import * as net from "net";
 import { spawn as spawn2 } from "child_process";
 var globalTcpServers = /* @__PURE__ */ new Map();
+var globalTcpConnections = /* @__PURE__ */ new Map();
 var QueryEngine = class {
   name;
   config;
@@ -739,13 +747,27 @@ var QueryEngine = class {
     this.tcpPort = this.generatePort();
   }
   generatePort() {
-    let hash = 0;
-    for (let i = 0; i < this.connectionId.length; i++) {
-      const char = this.connectionId.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash = hash & hash;
+    return 9944;
+  }
+  async findAvailablePort(startPort) {
+    for (let port = startPort; port >= 9900; port--) {
+      if (await this.isPortAvailable(port)) {
+        return port;
+      }
     }
-    return 8100 + Math.abs(hash % 900);
+    throw new Error("No available ports found in range 9900-9944");
+  }
+  isPortAvailable(port) {
+    return new Promise((resolve5) => {
+      const net2 = __require("net");
+      const tester = net2.createServer();
+      tester.once("error", () => resolve5(false));
+      tester.once("listening", () => {
+        tester.close();
+        resolve5(true);
+      });
+      tester.listen(port, "127.0.0.1");
+    });
   }
   async initializeBinary() {
     if (!this.binary) {
@@ -826,15 +848,51 @@ var QueryEngine = class {
     if (!serverInfo || !serverInfo.process || serverInfo.process.killed) {
       console.log("\u{1F680} Starting TCP server for ultra-fast queries...");
       await this.startTcpServer();
+      await this.waitForServerReady();
     }
     console.log("\u26A1 Using TCP server (ultra-fast)");
-    return this.sendTcpRequest(args);
+    return this.sendTcpRequestFast(args);
+  }
+  async waitForServerReady() {
+    const maxRetries = 10;
+    const retryDelay = 500;
+    for (let i = 0; i < maxRetries; i++) {
+      if (await this.isServerResponding()) {
+        return;
+      }
+      console.log(`\u23F3 Waiting for TCP server to be ready... (${i + 1}/${maxRetries})`);
+      await this.sleep(retryDelay);
+    }
+    throw new Error("TCP server failed to become ready within timeout");
+  }
+  async isServerResponding() {
+    return new Promise((resolve5) => {
+      const client = new net.Socket();
+      const timeout = setTimeout(() => {
+        client.destroy();
+        resolve5(false);
+      }, 1e3);
+      client.connect(this.tcpPort, "127.0.0.1", () => {
+        clearTimeout(timeout);
+        client.destroy();
+        resolve5(true);
+      });
+      client.on("error", () => {
+        clearTimeout(timeout);
+        resolve5(false);
+      });
+    });
+  }
+  sleep(ms) {
+    return new Promise((resolve5) => setTimeout(resolve5, ms));
   }
   async startTcpServer() {
     await this.initializeBinary();
     if (!this.binary) {
       throw new Error("Binary not initialized");
     }
+    this.tcpPort = await this.findAvailablePort(this.tcpPort);
+    console.log(`\u{1F310} Using port ${this.tcpPort} for TCP server`);
     return new Promise((resolve5, reject) => {
       const serverArgs = [...this.arguments, "--action", "server", "--port", this.tcpPort.toString()];
       const serverProcess = spawn2(this.binary["query_engine"], serverArgs);
@@ -844,7 +902,7 @@ var QueryEngine = class {
           serverProcess.kill();
           reject(new Error("TCP server startup timeout"));
         }
-      }, 1e4);
+      }, 15e3);
       serverProcess.stdout.on("data", (data) => {
         const output = data.toString();
         console.log(`[TCP Server] ${output.trim()}`);
@@ -879,16 +937,24 @@ var QueryEngine = class {
     return new Promise((resolve5, reject) => {
       const client = new net.Socket();
       let responseBuffer = "";
+      let isResolved = false;
       const timeout = setTimeout(() => {
-        client.destroy();
-        reject(new Error("TCP request timeout"));
-      }, this.timeout);
+        if (!isResolved) {
+          isResolved = true;
+          client.destroy();
+          reject(new Error("TCP request timeout"));
+        }
+      }, this.timeout * 2);
       client.connect(this.tcpPort, "127.0.0.1", () => {
         const dmlIndex = args.findIndex((arg) => arg === "--dml");
         const dmlJson = dmlIndex !== -1 ? args[dmlIndex + 1] : null;
         if (!dmlJson) {
-          client.destroy();
-          reject(new Error("No DML found in arguments"));
+          if (!isResolved) {
+            isResolved = true;
+            clearTimeout(timeout);
+            client.destroy();
+            reject(new Error("No DML found in arguments"));
+          }
           return;
         }
         const command = {
@@ -900,7 +966,8 @@ var QueryEngine = class {
       client.on("data", (data) => {
         responseBuffer += data.toString();
         const match = responseBuffer.match(/PROCESS_RESPONSE:(\{.*\})/);
-        if (match) {
+        if (match && !isResolved) {
+          isResolved = true;
           clearTimeout(timeout);
           client.destroy();
           try {
@@ -916,13 +983,149 @@ var QueryEngine = class {
         }
       });
       client.on("error", (error) => {
-        clearTimeout(timeout);
-        reject(error);
+        if (!isResolved) {
+          isResolved = true;
+          clearTimeout(timeout);
+          reject(error);
+        }
       });
       client.on("close", () => {
+        if (!isResolved) {
+          clearTimeout(timeout);
+          if (!responseBuffer.includes("PROCESS_RESPONSE:")) {
+            reject(new Error("Connection closed without valid response"));
+          }
+        }
+      });
+    });
+  }
+  async sendTcpRequestFast(args) {
+    const existingConnection = globalTcpConnections.get(this.connectionId);
+    if (existingConnection && existingConnection.readyState === "open") {
+      try {
+        return await this.sendOnExistingConnection(existingConnection, args);
+      } catch (error) {
+        globalTcpConnections.delete(this.connectionId);
+        existingConnection.destroy();
+      }
+    }
+    return await this.createPersistentConnection(args);
+  }
+  async sendOnExistingConnection(connection, args) {
+    return new Promise((resolve5, reject) => {
+      const dmlIndex = args.findIndex((arg) => arg === "--dml");
+      const dmlJson = dmlIndex !== -1 ? args[dmlIndex + 1] : null;
+      if (!dmlJson) {
+        reject(new Error("No DML found in arguments"));
+        return;
+      }
+      let responseBuffer = "";
+      let isResolved = false;
+      const timeout = setTimeout(() => {
+        if (!isResolved) {
+          isResolved = true;
+          reject(new Error("TCP request timeout"));
+        }
+      }, 5e3);
+      const onData = (data) => {
+        responseBuffer += data.toString();
+        const match = responseBuffer.match(/PROCESS_RESPONSE:(\{.*\})/);
+        if (match && !isResolved) {
+          isResolved = true;
+          clearTimeout(timeout);
+          connection.off("data", onData);
+          connection.off("error", onError);
+          try {
+            const response = JSON.parse(match[1]);
+            resolve5({
+              status: response.status,
+              message: response.message,
+              data: response.data
+            });
+          } catch (error) {
+            reject(new Error("Failed to parse TCP response"));
+          }
+        }
+      };
+      const onError = (error) => {
+        if (!isResolved) {
+          isResolved = true;
+          clearTimeout(timeout);
+          connection.off("data", onData);
+          connection.off("error", onError);
+          reject(error);
+        }
+      };
+      connection.on("data", onData);
+      connection.on("error", onError);
+      const command = {
+        action: "execute",
+        dml: dmlJson
+      };
+      connection.write(JSON.stringify(command));
+    });
+  }
+  async createPersistentConnection(args) {
+    return new Promise((resolve5, reject) => {
+      const client = new net.Socket();
+      let responseBuffer = "";
+      let isResolved = false;
+      client.setNoDelay(true);
+      client.setKeepAlive(true, 6e4);
+      const timeout = setTimeout(() => {
+        if (!isResolved) {
+          isResolved = true;
+          client.destroy();
+          reject(new Error("TCP connection timeout"));
+        }
+      }, 5e3);
+      client.connect(this.tcpPort, "127.0.0.1", () => {
         clearTimeout(timeout);
-        if (responseBuffer && !responseBuffer.includes("\n")) {
-          reject(new Error("Incomplete TCP response"));
+        const dmlIndex = args.findIndex((arg) => arg === "--dml");
+        const dmlJson = dmlIndex !== -1 ? args[dmlIndex + 1] : null;
+        if (!dmlJson) {
+          if (!isResolved) {
+            isResolved = true;
+            client.destroy();
+            reject(new Error("No DML found in arguments"));
+          }
+          return;
+        }
+        globalTcpConnections.set(this.connectionId, client);
+        const command = {
+          action: "execute",
+          dml: dmlJson
+        };
+        client.write(JSON.stringify(command));
+      });
+      client.on("data", (data) => {
+        responseBuffer += data.toString();
+        const match = responseBuffer.match(/PROCESS_RESPONSE:(\{.*\})/);
+        if (match && !isResolved) {
+          isResolved = true;
+          try {
+            const response = JSON.parse(match[1]);
+            resolve5({
+              status: response.status,
+              message: response.message,
+              data: response.data
+            });
+          } catch (error) {
+            reject(new Error("Failed to parse TCP response"));
+          }
+        }
+      });
+      client.on("error", (error) => {
+        if (!isResolved) {
+          isResolved = true;
+          globalTcpConnections.delete(this.connectionId);
+          reject(error);
+        }
+      });
+      client.on("close", () => {
+        globalTcpConnections.delete(this.connectionId);
+        if (!isResolved && !responseBuffer.includes("PROCESS_RESPONSE:")) {
+          reject(new Error("Connection closed without valid response"));
         }
       });
     });
@@ -1015,6 +1218,12 @@ 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);
+    }
     const serverInfo = globalTcpServers.get(this.connectionId);
     if (serverInfo && serverInfo.process && !serverInfo.process.killed) {
       console.log("\u{1F50C} Stopping TCP server...");
@@ -1022,7 +1231,7 @@ var QueryEngine = class {
       globalTcpServers.delete(this.connectionId);
       return {
         status: 200,
-        message: "TCP server stopped",
+        message: "TCP server and connections stopped",
         data: null
       };
     }