@dbcube/core 4.1.13 → 4.1.14

package/dist/index.cjs

@@ -934,7 +934,7 @@ var QueryEngine = class {
     this.config = this.setConfig(name);
     this.arguments = this.setArguments();
     this.timeout = timeout;
-    this.connectionId = `${name}_${this.config.type}_${this.config.config.DATABASE}_${this.config.config.HOST || "localhost"}`;
+    this.connectionId = `${name}_query_engine_${this.config.type}_${this.config.config.DATABASE}_${this.config.config.HOST || "localhost"}`;
     this.tcpPort = this.generatePort();
   }
   generatePort() {
@@ -1030,30 +1030,27 @@ 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 action = actionIndex !== -1 ? args[actionIndex + 1] : "";
-    const isExecuteAction = action === "execute";
-    if (isQueryEngine && isExecuteAction || isSchemaEngine) {
-      return this.executeWithTcpServer(args, binary);
+    const isExecuteAction = actionIndex !== -1 && args[actionIndex + 1] === "execute";
+    const isQueryEngine = binary === "query_engine";
+    if (isQueryEngine && isExecuteAction) {
+      return this.executeWithTcpServer(args);
     } else {
       return this.createProcess(binary, args);
     }
   }
-  async executeWithTcpServer(args, binary = "query_engine") {
-    const serverConnectionId = `${this.connectionId}_${binary}`;
-    const serverInfo = globalTcpServers.get(serverConnectionId);
+  async executeWithTcpServer(args) {
+    const serverInfo = globalTcpServers.get(this.connectionId);
     if (!serverInfo || !serverInfo.process || serverInfo.process.killed) {
-      await this.startTcpServer(binary, serverConnectionId);
-      await this.waitForServerReady(serverConnectionId);
+      await this.startTcpServer();
+      await this.waitForServerReady();
     }
-    return this.sendTcpRequestFast(args, serverConnectionId);
+    return this.sendTcpRequestFast(args);
   }
-  async waitForServerReady(serverConnectionId) {
+  async waitForServerReady() {
     const maxRetries = 10;
     const retryDelay = 500;
-    const serverInfo = globalTcpServers.get(serverConnectionId);
+    const serverInfo = globalTcpServers.get(this.connectionId);
     if (!serverInfo) {
       throw new Error("Server not found");
     }
@@ -1097,16 +1094,15 @@ var QueryEngine = class {
     }
     return parsed;
   }
-  async startTcpServer(binary, serverConnectionId) {
+  async startTcpServer() {
     await this.initializeBinary();
     if (!this.binary) {
       throw new Error("Binary not initialized");
     }
-    const basePort = binary === "schema_engine" ? 9900 : 9944;
-    const tcpPort = await this.findAvailablePort(basePort);
+    this.tcpPort = await this.findAvailablePort(this.tcpPort);
     return new Promise((resolve5, reject) => {
-      const serverArgs = [...this.arguments, "--action", "server", "--tcp-port", tcpPort.toString()];
-      const serverProcess = (0, import_child_process2.spawn)(this.binary[binary], serverArgs);
+      const serverArgs = [...this.arguments, "--action", "server", "--tcp-port", this.tcpPort.toString()];
+      const serverProcess = (0, import_child_process2.spawn)(this.binary["query_engine"], serverArgs);
       let started = false;
       const timeout = setTimeout(() => {
         if (!started) {
@@ -1120,8 +1116,8 @@ var QueryEngine = class {
           if (!started) {
             started = true;
             clearTimeout(timeout);
-            globalTcpServers.set(serverConnectionId, {
-              port: tcpPort,
+            globalTcpServers.set(this.connectionId, {
+              port: this.tcpPort,
               process: serverProcess
             });
             resolve5();
@@ -1129,10 +1125,10 @@ var QueryEngine = class {
         }
       });
       serverProcess.stderr.on("data", (data) => {
-        console.error(`[${binary} TCP Server Error] ${data.toString().trim()}`);
+        console.error(`[query_engine TCP Server Error] ${data.toString().trim()}`);
       });
       serverProcess.on("close", (code) => {
-        globalTcpServers.delete(serverConnectionId);
+        globalTcpServers.delete(this.connectionId);
       });
       serverProcess.on("error", (error) => {
         if (!started) {
@@ -1142,94 +1138,28 @@ var QueryEngine = class {
       });
     });
   }
-  async sendTcpRequest(args) {
+  async sendTcpRequestFast(args) {
     return new Promise((resolve5, reject) => {
-      const client = new net.Socket();
-      let responseBuffer = "";
-      let isResolved = false;
-      const timeout = setTimeout(() => {
-        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) {
-          if (!isResolved) {
-            isResolved = true;
-            clearTimeout(timeout);
-            client.destroy();
-            reject(new Error("No DML found in arguments"));
-          }
-          return;
-        }
-        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;
-          clearTimeout(timeout);
-          client.destroy();
-          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;
-          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, serverConnectionId) {
-    return new Promise((resolve5, reject) => {
-      let queue = connectionQueues.get(serverConnectionId);
+      let queue = connectionQueues.get(this.connectionId);
       if (!queue) {
         queue = [];
-        connectionQueues.set(serverConnectionId, queue);
+        connectionQueues.set(this.connectionId, queue);
       }
       queue.push({ args, resolve: resolve5, reject });
-      this.processQueue(serverConnectionId);
+      this.processQueue();
     });
   }
-  async processQueue(serverConnectionId) {
-    if (connectionProcessing.get(serverConnectionId)) {
+  async processQueue() {
+    if (connectionProcessing.get(this.connectionId)) {
       return;
     }
-    const queue = connectionQueues.get(serverConnectionId);
+    const queue = connectionQueues.get(this.connectionId);
     if (!queue || queue.length === 0) {
       return;
     }
-    connectionProcessing.set(serverConnectionId, true);
+    connectionProcessing.set(this.connectionId, true);
     try {
-      const serverInfo = globalTcpServers.get(serverConnectionId);
+      const serverInfo = globalTcpServers.get(this.connectionId);
       if (!serverInfo) {
         throw new Error("Server not initialized");
       }
@@ -1237,20 +1167,20 @@ var QueryEngine = class {
         const request = queue.shift();
         if (!request) break;
         try {
-          let connection = globalTcpConnections.get(serverConnectionId);
+          let connection = globalTcpConnections.get(this.connectionId);
           if (!connection || connection.destroyed || connection.readyState !== "open") {
             connection = await this.createNewConnection(serverInfo.port);
-            globalTcpConnections.set(serverConnectionId, connection);
+            globalTcpConnections.set(this.connectionId, connection);
           }
           const result = await this.executeOnConnection(connection, request.args);
           request.resolve(result);
         } catch (error) {
-          globalTcpConnections.delete(serverConnectionId);
+          globalTcpConnections.delete(this.connectionId);
           request.reject(error);
         }
       }
     } finally {
-      connectionProcessing.set(serverConnectionId, false);
+      connectionProcessing.set(this.connectionId, false);
     }
   }
   async createNewConnection(port) {
@@ -1326,161 +1256,6 @@ var QueryEngine = class {
       connection.write(JSON.stringify(command));
     });
   }
-  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;
-          connection.off("data", onData);
-          connection.off("error", onError);
-          globalTcpConnections.delete(this.connectionId);
-          reject(new Error("TCP request timeout"));
-        }
-      }, this.timeout);
-      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) => {
-      let client = globalTcpConnections.get(this.connectionId);
-      let isNewConnection = false;
-      if (!client || client.destroyed) {
-        client = new net.Socket();
-        isNewConnection = true;
-        client.setNoDelay(true);
-        client.setKeepAlive(true, 6e4);
-        client.setMaxListeners(20);
-      }
-      let responseBuffer = "";
-      let isResolved = false;
-      const timeout = setTimeout(() => {
-        if (!isResolved) {
-          isResolved = true;
-          client.removeListener("data", dataHandler);
-          globalTcpConnections.delete(this.connectionId);
-          reject(new Error("TCP connection timeout"));
-        }
-      }, this.timeout);
-      const executeQuery = () => {
-        const dmlIndex = args.findIndex((arg) => arg === "--dml");
-        const dmlJson = dmlIndex !== -1 ? args[dmlIndex + 1] : null;
-        if (!dmlJson) {
-          clearTimeout(timeout);
-          if (!isResolved) {
-            isResolved = true;
-            reject(new Error("No DML found in arguments"));
-          }
-          return;
-        }
-        const command = {
-          action: "execute",
-          dml: dmlJson
-        };
-        const commandStr = JSON.stringify(command);
-        const canWrite = client.write(commandStr);
-        if (!canWrite) {
-          client.once("drain", () => {
-          });
-        }
-      };
-      const dataHandler = (data) => {
-        responseBuffer += data.toString();
-        const match = responseBuffer.match(/PROCESS_RESPONSE:(\{.*\})/);
-        if (match && !isResolved) {
-          isResolved = true;
-          clearTimeout(timeout);
-          try {
-            const response = JSON.parse(match[1]);
-            responseBuffer = "";
-            client.removeListener("data", dataHandler);
-            resolve5({
-              status: response.status,
-              message: response.message,
-              data: response.data
-            });
-          } catch (error) {
-            client.removeListener("data", dataHandler);
-            reject(new Error("Failed to parse TCP response"));
-          }
-        }
-      };
-      const errorHandler = (error) => {
-        if (!isResolved) {
-          isResolved = true;
-          clearTimeout(timeout);
-          globalTcpConnections.delete(this.connectionId);
-          client.removeListener("data", dataHandler);
-          reject(error);
-        }
-      };
-      const closeHandler = () => {
-        globalTcpConnections.delete(this.connectionId);
-        if (!isResolved) {
-          isResolved = true;
-          clearTimeout(timeout);
-          client.removeListener("data", dataHandler);
-          reject(new Error("Connection closed unexpectedly"));
-        }
-      };
-      if (isNewConnection) {
-        client.connect(this.tcpPort, "127.0.0.1", () => {
-          clearTimeout(timeout);
-          globalTcpConnections.set(this.connectionId, client);
-          client.on("error", errorHandler);
-          client.on("close", closeHandler);
-          client.on("data", dataHandler);
-          executeQuery();
-        });
-      } else {
-        clearTimeout(timeout);
-        client.on("data", dataHandler);
-        executeQuery();
-      }
-    });
-  }
   async createProcess(binary, args) {
     await this.initializeBinary();
     if (!this.binary) {