@dbcube/core 4.1.11 → 4.1.13

package/dist/index.cjs

@@ -916,6 +916,8 @@ var net = __toESM(require("net"));
 var import_child_process2 = require("child_process");
 var globalTcpServers = /* @__PURE__ */ new Map();
 var globalTcpConnections = /* @__PURE__ */ new Map();
+var connectionQueues = /* @__PURE__ */ new Map();
+var connectionProcessing = /* @__PURE__ */ new Map();
 var queryCache = /* @__PURE__ */ new Map();
 var cacheSize = 0;
 var MAX_CACHE_SIZE = 500;
@@ -1028,41 +1030,49 @@ var QueryEngine = class {
     return this.config;
   }
   async run(binary, args) {
+    const isQueryEngine = binary === "query_engine";
+    const isSchemaEngine = binary === "schema_engine";
     const actionIndex = args.findIndex((arg) => arg === "--action");
-    const isExecuteAction = actionIndex !== -1 && args[actionIndex + 1] === "execute";
-    if (isExecuteAction) {
-      return this.executeWithTcpServer(args);
+    const action = actionIndex !== -1 ? args[actionIndex + 1] : "";
+    const isExecuteAction = action === "execute";
+    if (isQueryEngine && isExecuteAction || isSchemaEngine) {
+      return this.executeWithTcpServer(args, binary);
     } else {
       return this.createProcess(binary, args);
     }
   }
-  async executeWithTcpServer(args) {
-    const serverInfo = globalTcpServers.get(this.connectionId);
+  async executeWithTcpServer(args, binary = "query_engine") {
+    const serverConnectionId = `${this.connectionId}_${binary}`;
+    const serverInfo = globalTcpServers.get(serverConnectionId);
     if (!serverInfo || !serverInfo.process || serverInfo.process.killed) {
-      await this.startTcpServer();
-      await this.waitForServerReady();
+      await this.startTcpServer(binary, serverConnectionId);
+      await this.waitForServerReady(serverConnectionId);
     }
-    return this.sendTcpRequestFast(args);
+    return this.sendTcpRequestFast(args, serverConnectionId);
   }
-  async waitForServerReady() {
+  async waitForServerReady(serverConnectionId) {
     const maxRetries = 10;
     const retryDelay = 500;
+    const serverInfo = globalTcpServers.get(serverConnectionId);
+    if (!serverInfo) {
+      throw new Error("Server not found");
+    }
     for (let i = 0; i < maxRetries; i++) {
-      if (await this.isServerResponding()) {
+      if (await this.isServerResponding(serverInfo.port)) {
         return;
       }
       await this.sleep(retryDelay);
     }
     throw new Error("TCP server failed to become ready within timeout");
   }
-  async isServerResponding() {
+  async isServerResponding(port) {
     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", () => {
+      client.connect(port, "127.0.0.1", () => {
         clearTimeout(timeout);
         client.destroy();
         resolve5(true);
@@ -1087,15 +1097,16 @@ var QueryEngine = class {
     }
     return parsed;
   }
-  async startTcpServer() {
+  async startTcpServer(binary, serverConnectionId) {
     await this.initializeBinary();
     if (!this.binary) {
       throw new Error("Binary not initialized");
     }
-    this.tcpPort = await this.findAvailablePort(this.tcpPort);
+    const basePort = binary === "schema_engine" ? 9900 : 9944;
+    const tcpPort = await this.findAvailablePort(basePort);
     return new Promise((resolve5, reject) => {
-      const serverArgs = [...this.arguments, "--action", "server", "--tcp-port", this.tcpPort.toString()];
-      const serverProcess = (0, import_child_process2.spawn)(this.binary["query_engine"], serverArgs);
+      const serverArgs = [...this.arguments, "--action", "server", "--tcp-port", tcpPort.toString()];
+      const serverProcess = (0, import_child_process2.spawn)(this.binary[binary], serverArgs);
       let started = false;
       const timeout = setTimeout(() => {
         if (!started) {
@@ -1109,8 +1120,8 @@ var QueryEngine = class {
           if (!started) {
             started = true;
             clearTimeout(timeout);
-            globalTcpServers.set(this.connectionId, {
-              port: this.tcpPort,
+            globalTcpServers.set(serverConnectionId, {
+              port: tcpPort,
               process: serverProcess
             });
             resolve5();
@@ -1118,10 +1129,10 @@ var QueryEngine = class {
         }
       });
       serverProcess.stderr.on("data", (data) => {
-        console.error(`[TCP Server Error] ${data.toString().trim()}`);
+        console.error(`[${binary} TCP Server Error] ${data.toString().trim()}`);
       });
       serverProcess.on("close", (code) => {
-        globalTcpServers.delete(this.connectionId);
+        globalTcpServers.delete(serverConnectionId);
       });
       serverProcess.on("error", (error) => {
         if (!started) {
@@ -1197,17 +1208,123 @@ var QueryEngine = class {
       });
     });
   }
-  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();
+  async sendTcpRequestFast(args, serverConnectionId) {
+    return new Promise((resolve5, reject) => {
+      let queue = connectionQueues.get(serverConnectionId);
+      if (!queue) {
+        queue = [];
+        connectionQueues.set(serverConnectionId, queue);
+      }
+      queue.push({ args, resolve: resolve5, reject });
+      this.processQueue(serverConnectionId);
+    });
+  }
+  async processQueue(serverConnectionId) {
+    if (connectionProcessing.get(serverConnectionId)) {
+      return;
+    }
+    const queue = connectionQueues.get(serverConnectionId);
+    if (!queue || queue.length === 0) {
+      return;
+    }
+    connectionProcessing.set(serverConnectionId, true);
+    try {
+      const serverInfo = globalTcpServers.get(serverConnectionId);
+      if (!serverInfo) {
+        throw new Error("Server not initialized");
+      }
+      while (queue.length > 0) {
+        const request = queue.shift();
+        if (!request) break;
+        try {
+          let connection = globalTcpConnections.get(serverConnectionId);
+          if (!connection || connection.destroyed || connection.readyState !== "open") {
+            connection = await this.createNewConnection(serverInfo.port);
+            globalTcpConnections.set(serverConnectionId, connection);
+          }
+          const result = await this.executeOnConnection(connection, request.args);
+          request.resolve(result);
+        } catch (error) {
+          globalTcpConnections.delete(serverConnectionId);
+          request.reject(error);
+        }
       }
+    } finally {
+      connectionProcessing.set(serverConnectionId, false);
     }
-    return await this.createPersistentConnection(args);
+  }
+  async createNewConnection(port) {
+    return new Promise((resolve5, reject) => {
+      const client = new net.Socket();
+      client.setNoDelay(true);
+      client.setKeepAlive(true, 6e4);
+      const timeout = setTimeout(() => {
+        client.destroy();
+        reject(new Error("Connection timeout"));
+      }, 5e3);
+      client.connect(port, "127.0.0.1", () => {
+        clearTimeout(timeout);
+        resolve5(client);
+      });
+      client.on("error", (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      });
+    });
+  }
+  async executeOnConnection(connection, args) {
+    return new Promise((resolve5, reject) => {
+      const command = {};
+      for (let i = 0; i < args.length; i += 2) {
+        if (args[i].startsWith("--")) {
+          const key = args[i].substring(2);
+          const value = args[i + 1];
+          command[key] = value;
+        }
+      }
+      let responseBuffer = "";
+      let isResolved = false;
+      const timeout = setTimeout(() => {
+        if (!isResolved) {
+          isResolved = true;
+          connection.removeListener("data", onData);
+          connection.removeListener("error", onError);
+          reject(new Error("Request timeout"));
+        }
+      }, this.timeout);
+      const onData = (data) => {
+        responseBuffer += data.toString();
+        const match = responseBuffer.match(/PROCESS_RESPONSE:(\{.*\})/);
+        if (match && !isResolved) {
+          isResolved = true;
+          clearTimeout(timeout);
+          connection.removeListener("data", onData);
+          connection.removeListener("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 response"));
+          }
+        }
+      };
+      const onError = (error) => {
+        if (!isResolved) {
+          isResolved = true;
+          clearTimeout(timeout);
+          connection.removeListener("data", onData);
+          connection.removeListener("error", onError);
+          reject(error);
+        }
+      };
+      connection.on("data", onData);
+      connection.on("error", onError);
+      connection.write(JSON.stringify(command));
+    });
   }
   async sendOnExistingConnection(connection, args) {
     return new Promise((resolve5, reject) => {