@dbcube/core 3.0.3 → 3.0.4

package/dist/index.cjs

@@ -600,17 +600,15 @@ var Engine = class {
   arguments;
   binary = null;
   timeout;
-  connectionId;
-  isConnected = false;
+  childProcess = null;
+  pendingRequests = /* @__PURE__ */ new Map();
+  requestCounter = 0;
+  isProcessStarting = false;
   constructor(name, timeout = 3e4) {
     this.name = name;
     this.config = this.setConfig(name);
     this.arguments = this.setArguments();
     this.timeout = timeout;
-    this.connectionId = this.generateConnectionId();
-  }
-  generateConnectionId() {
-    return `${this.name}_${this.config.type}_${this.config.config.DATABASE}_${this.config.config.HOST || "localhost"}`;
   }
   async initializeBinary() {
     if (!this.binary) {
@@ -628,7 +626,9 @@ var Engine = class {
         "--database",
         this.config.config.DATABASE + ".db",
         "--motor",
-        this.config.type
+        this.config.type,
+        "--persistent"
+        // Agregar flag para modo persistente si el binario lo soporta
       ];
     } else {
       args = [
@@ -647,7 +647,9 @@ var Engine = class {
         "--password",
         this.config.config.PASSWORD,
         "--motor",
-        this.config.type
+        this.config.type,
+        "--persistent"
+        // Agregar flag para modo persistente si el binario lo soporta
       ];
     }
     return args;
@@ -677,139 +679,151 @@ var Engine = class {
   getConfig() {
     return this.config;
   }
-  async ensurePersistentConnection() {
-    if (!this.isConnected) {
-      console.log("\u{1F50C} Creating persistent connection...");
-      const response = await this.createProcess("query_engine", [
-        "--action",
-        "connect"
-      ]);
-      if (response.status === 200) {
-        this.isConnected = true;
-        console.log("\u2705 Persistent connection established");
-      } else {
-        throw new Error(`Failed to create persistent connection: ${response.message}`);
+  async ensureProcess(binary) {
+    if (this.childProcess && !this.childProcess.killed) {
+      return;
+    }
+    if (this.isProcessStarting) {
+      return new Promise((resolve5) => {
+        const checkProcess = () => {
+          if (!this.isProcessStarting) {
+            resolve5();
+          } else {
+            setTimeout(checkProcess, 10);
+          }
+        };
+        checkProcess();
+      });
+    }
+    this.isProcessStarting = true;
+    try {
+      await this.initializeBinary();
+      if (!this.binary) {
+        throw new Error("Binary not initialized");
       }
+      this.childProcess = (0, import_child_process.spawn)(this.binary[binary], this.arguments, {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      this.setupProcessHandlers();
+    } finally {
+      this.isProcessStarting = false;
     }
   }
-  async run(binary, args) {
-    const actionIndex = args.indexOf("--action");
-    const isExecuteAction = actionIndex !== -1 && args[actionIndex + 1] === "execute";
-    if (isExecuteAction) {
-      await this.ensurePersistentConnection();
-      return this.executeWithPersistentConnection(args);
-    } else {
-      return this.createProcess(binary, args);
+  setupProcessHandlers() {
+    if (!this.childProcess) return;
+    let stdoutBuffer = "";
+    let stderrBuffer = "";
+    this.childProcess.stdout?.on("data", (data) => {
+      stdoutBuffer += data.toString();
+      this.processBuffer(stdoutBuffer, "stdout");
+    });
+    this.childProcess.stderr?.on("data", (data) => {
+      stderrBuffer += data.toString();
+      this.processBuffer(stderrBuffer, "stderr");
+    });
+    this.childProcess.on("close", (code) => {
+      this.handleProcessClose(code);
+    });
+    this.childProcess.on("error", (error) => {
+      this.handleProcessError(error);
+    });
+    this.childProcess.unref();
+  }
+  processBuffer(buffer, source) {
+    const responsePattern = /PROCESS_RESPONSE:(\{[^}]*\})/g;
+    let match;
+    while ((match = responsePattern.exec(buffer)) !== null) {
+      try {
+        const response = JSON.parse(match[1]);
+        const requestId = response.requestId || "unknown";
+        const pendingRequest = this.pendingRequests.get(requestId);
+        if (pendingRequest) {
+          clearTimeout(pendingRequest.timeoutId);
+          this.pendingRequests.delete(requestId);
+          pendingRequest.resolve({
+            status: response.status,
+            message: response.message,
+            data: response.data
+          });
+        }
+      } catch (error) {
+        console.error("Failed to parse response JSON:", error);
+      }
     }
   }
-  async executeWithPersistentConnection(args) {
-    return this.createProcess("query_engine", args);
+  handleProcessClose(code) {
+    this.childProcess = null;
+    for (const [requestId, request] of this.pendingRequests) {
+      clearTimeout(request.timeoutId);
+      request.reject(new Error(`Process closed with code ${code}`));
+    }
+    this.pendingRequests.clear();
   }
-  async createProcess(binary, args) {
-    await this.initializeBinary();
-    if (!this.binary) {
-      throw new Error("Binary not initialized");
+  handleProcessError(error) {
+    this.childProcess = null;
+    for (const [requestId, request] of this.pendingRequests) {
+      clearTimeout(request.timeoutId);
+      request.reject(error);
+    }
+    this.pendingRequests.clear();
+  }
+  async run(binary, args) {
+    await this.ensureProcess(binary);
+    if (!this.childProcess) {
+      throw new Error("Failed to start process");
     }
     return new Promise((resolve5, reject) => {
-      const child = (0, import_child_process.spawn)(this.binary[binary], [...this.arguments, ...args]);
-      let stdoutBuffer = "";
-      let stderrBuffer = "";
-      let isResolved = false;
+      const requestId = `req_${++this.requestCounter}_${Date.now()}`;
       const timeoutId = setTimeout(() => {
-        if (!isResolved) {
-          isResolved = true;
-          child.kill();
-          reject(new Error("Process timeout"));
+        const request = this.pendingRequests.get(requestId);
+        if (request) {
+          this.pendingRequests.delete(requestId);
+          reject(new Error("Request timeout"));
         }
       }, this.timeout);
-      const resolveOnce = (response) => {
-        if (!isResolved) {
-          isResolved = true;
-          clearTimeout(timeoutId);
-          resolve5(response);
-        }
-      };
-      child.stdout.on("data", (data) => {
-        stdoutBuffer += data.toString();
-        const match = stdoutBuffer.match(/PROCESS_RESPONSE:(\{.*\})/);
-        if (match) {
-          try {
-            const response = JSON.parse(match[1]);
-            resolveOnce({
-              status: response.status,
-              message: response.message,
-              data: response.data
-            });
-          } catch (error) {
-            resolveOnce({
-              status: 500,
-              message: "Failed to parse response JSON",
-              data: null
-            });
-          }
-        }
+      this.pendingRequests.set(requestId, {
+        resolve: resolve5,
+        reject,
+        timeoutId,
+        requestId
       });
-      child.stderr.on("data", (data) => {
-        stderrBuffer += data.toString();
-        const match = stderrBuffer.match(/PROCESS_RESPONSE:(\{.*\})/);
-        if (match) {
-          try {
-            const response = JSON.parse(match[1]);
-            resolveOnce({
-              status: response.status,
-              message: response.message,
-              data: response.data
-            });
-          } catch (error) {
-            resolveOnce({
-              status: 500,
-              message: "Failed to parse response JSON",
-              data: null
-            });
-          }
-        }
-      });
-      child.on("close", (code) => {
-        clearTimeout(timeoutId);
-        if (!isResolved) {
-          resolveOnce({
-            status: code === 0 ? 200 : 500,
-            message: code === 0 ? "Process completed" : `Process exited with code ${code}`,
-            data: null
-          });
-        }
-      });
-      child.on("error", (error) => {
+      const command = {
+        requestId,
+        args
+      };
+      try {
+        this.childProcess.stdin?.write(JSON.stringify(command) + "\n");
+      } catch (error) {
         clearTimeout(timeoutId);
-        if (!isResolved) {
-          resolveOnce({
-            status: 500,
-            message: `Process error: ${error.message}`,
-            data: null
-          });
-        }
-      });
-      child.unref();
+        this.pendingRequests.delete(requestId);
+        reject(error);
+      }
     });
   }
-  async disconnect() {
-    if (this.isConnected) {
-      console.log("\u{1F50C} Disconnecting persistent connection...");
-      const response = await this.createProcess("query_engine", [
-        "--action",
-        "disconnect"
-      ]);
-      if (response.status === 200) {
-        this.isConnected = false;
-        console.log("\u2705 Persistent connection closed");
-      }
-      return response;
+  // Método para cerrar el proceso manualmente
+  async close() {
+    if (this.childProcess && !this.childProcess.killed) {
+      return new Promise((resolve5) => {
+        this.childProcess.once("close", () => {
+          resolve5();
+        });
+        this.childProcess.stdin?.end();
+        setTimeout(() => {
+          if (this.childProcess && !this.childProcess.killed) {
+            this.childProcess.kill("SIGTERM");
+            setTimeout(() => {
+              if (this.childProcess && !this.childProcess.killed) {
+                this.childProcess.kill("SIGKILL");
+              }
+            }, 2e3);
+          }
+        }, 5e3);
+      });
     }
-    return {
-      status: 200,
-      message: "No persistent connection to disconnect",
-      data: null
-    };
+  }
+  // Verificar si el proceso está activo
+  isProcessAlive() {
+    return this.childProcess !== null && !this.childProcess.killed;
   }
 };