@dbcube/core 4.0.1 → 4.0.3

package/dist/index.js

@@ -1069,68 +1069,98 @@ var QueryEngine = class {
   }
   async createPersistentConnection(args) {
     return new Promise((resolve5, reject) => {
-      const client = new net.Socket();
+      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;
-      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);
+      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;
-            client.destroy();
             reject(new Error("No DML found in arguments"));
           }
           return;
         }
-        globalTcpConnections.set(this.connectionId, client);
         const command = {
           action: "execute",
           dml: dmlJson
         };
-        console.log(dmlJson);
-        client.write(JSON.stringify(command));
-      });
-      client.on("data", (data) => {
+        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"));
           }
         }
-      });
-      client.on("error", (error) => {
+      };
+      const errorHandler = (error) => {
         if (!isResolved) {
           isResolved = true;
+          clearTimeout(timeout);
           globalTcpConnections.delete(this.connectionId);
+          client.removeListener("data", dataHandler);
           reject(error);
         }
-      });
-      client.on("close", () => {
+      };
+      const closeHandler = () => {
         globalTcpConnections.delete(this.connectionId);
-        if (!isResolved && !responseBuffer.includes("PROCESS_RESPONSE:")) {
-          reject(new Error("Connection closed without valid response"));
+        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) {