@dbcube/core 3.0.2 → 3.0.4

package/dist/index.cjs

@@ -600,6 +600,10 @@ var Engine = class {
   arguments;
   binary = null;
   timeout;
+  childProcess = null;
+  pendingRequests = /* @__PURE__ */ new Map();
+  requestCounter = 0;
+  isProcessStarting = false;
   constructor(name, timeout = 3e4) {
     this.name = name;
     this.config = this.setConfig(name);
@@ -622,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 = [
@@ -641,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;
@@ -671,93 +679,152 @@ var Engine = class {
   getConfig() {
     return this.config;
   }
-  async run(binary, args) {
-    await this.initializeBinary();
-    if (!this.binary) {
-      throw new Error("Binary not initialized");
+  async ensureProcess(binary) {
+    if (this.childProcess && !this.childProcess.killed) {
+      return;
     }
-    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 timeoutId = setTimeout(() => {
-        if (!isResolved) {
-          isResolved = true;
-          child.kill();
-          reject(new Error("Process 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
-            });
+    if (this.isProcessStarting) {
+      return new Promise((resolve5) => {
+        const checkProcess = () => {
+          if (!this.isProcessStarting) {
+            resolve5();
+          } else {
+            setTimeout(checkProcess, 10);
           }
-        }
+        };
+        checkProcess();
       });
-      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
-            });
-          }
-        }
+    }
+    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"]
       });
-      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
+      this.setupProcessHandlers();
+    } finally {
+      this.isProcessStarting = false;
+    }
+  }
+  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
           });
         }
-      });
-      child.on("error", (error) => {
-        clearTimeout(timeoutId);
-        if (!isResolved) {
-          resolveOnce({
-            status: 500,
-            message: `Process error: ${error.message}`,
-            data: null
-          });
+      } catch (error) {
+        console.error("Failed to parse response JSON:", error);
+      }
+    }
+  }
+  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();
+  }
+  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 requestId = `req_${++this.requestCounter}_${Date.now()}`;
+      const timeoutId = setTimeout(() => {
+        const request = this.pendingRequests.get(requestId);
+        if (request) {
+          this.pendingRequests.delete(requestId);
+          reject(new Error("Request timeout"));
         }
+      }, this.timeout);
+      this.pendingRequests.set(requestId, {
+        resolve: resolve5,
+        reject,
+        timeoutId,
+        requestId
       });
-      child.unref();
+      const command = {
+        requestId,
+        args
+      };
+      try {
+        this.childProcess.stdin?.write(JSON.stringify(command) + "\n");
+      } catch (error) {
+        clearTimeout(timeoutId);
+        this.pendingRequests.delete(requestId);
+        reject(error);
+      }
     });
   }
+  // 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);
+      });
+    }
+  }
+  // Verificar si el proceso está activo
+  isProcessAlive() {
+    return this.childProcess !== null && !this.childProcess.killed;
+  }
 };
 
 // src/lib/SqliteExecutor.ts