@dbcube/core 3.0.4 → 3.0.5

package/dist/index.js

@@ -556,10 +556,6 @@ 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);
@@ -582,9 +578,7 @@ var Engine = class {
         "--database",
         this.config.config.DATABASE + ".db",
         "--motor",
-        this.config.type,
-        "--persistent"
-        // Agregar flag para modo persistente si el binario lo soporta
+        this.config.type
       ];
     } else {
       args = [
@@ -603,9 +597,7 @@ var Engine = class {
         "--password",
         this.config.config.PASSWORD,
         "--motor",
-        this.config.type,
-        "--persistent"
-        // Agregar flag para modo persistente si el binario lo soporta
+        this.config.type
       ];
     }
     return args;
@@ -635,160 +627,411 @@ var Engine = class {
   getConfig() {
     return this.config;
   }
-  async ensureProcess(binary) {
-    if (this.childProcess && !this.childProcess.killed) {
-      return;
+  async run(binary, args) {
+    await this.initializeBinary();
+    if (!this.binary) {
+      throw new Error("Binary not initialized");
     }
-    if (this.isProcessStarting) {
-      return new Promise((resolve5) => {
-        const checkProcess = () => {
-          if (!this.isProcessStarting) {
-            resolve5();
-          } else {
-            setTimeout(checkProcess, 10);
+    return new Promise((resolve5, reject) => {
+      const child = 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
+            });
           }
-        };
-        checkProcess();
+        }
       });
-    }
-    this.isProcessStarting = true;
-    try {
-      await this.initializeBinary();
-      if (!this.binary) {
-        throw new Error("Binary not initialized");
-      }
-      this.childProcess = spawn(this.binary[binary], this.arguments, {
-        stdio: ["pipe", "pipe", "pipe"]
+      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.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("close", (code) => {
+        clearTimeout(timeoutId);
+        if (!isResolved) {
+          resolveOnce({
+            status: code === 0 ? 200 : 500,
+            message: code === 0 ? "Process completed" : `Process exited with code ${code}`,
+            data: null
           });
         }
-      } catch (error) {
-        console.error("Failed to parse response JSON:", error);
-      }
+      });
+      child.on("error", (error) => {
+        clearTimeout(timeoutId);
+        if (!isResolved) {
+          resolveOnce({
+            status: 500,
+            message: `Process error: ${error.message}`,
+            data: null
+          });
+        }
+      });
+      child.unref();
+    });
+  }
+};
+
+// src/lib/QueryEngine.ts
+import path4 from "path";
+import { createRequire as createRequire2 } from "module";
+import * as net from "net";
+import { spawn as spawn2 } from "child_process";
+var globalTcpServers = /* @__PURE__ */ new Map();
+var QueryEngine = class {
+  name;
+  config;
+  arguments;
+  binary = null;
+  timeout;
+  connectionId;
+  tcpPort;
+  constructor(name, timeout = 3e4) {
+    this.name = name;
+    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.tcpPort = this.generatePort();
+  }
+  generatePort() {
+    let hash = 0;
+    for (let i = 0; i < this.connectionId.length; i++) {
+      const char = this.connectionId.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
     }
+    return 8100 + Math.abs(hash % 900);
   }
-  handleProcessClose(code) {
-    this.childProcess = null;
-    for (const [requestId, request] of this.pendingRequests) {
-      clearTimeout(request.timeoutId);
-      request.reject(new Error(`Process closed with code ${code}`));
+  async initializeBinary() {
+    if (!this.binary) {
+      this.binary = await Binary.get();
     }
-    this.pendingRequests.clear();
   }
-  handleProcessError(error) {
-    this.childProcess = null;
-    for (const [requestId, request] of this.pendingRequests) {
-      clearTimeout(request.timeoutId);
-      request.reject(error);
+  setArguments() {
+    let args = [];
+    if (this.config.type == "sqlite") {
+      args = [
+        "--id",
+        "dbcube-" + this.name,
+        "--database-ref",
+        this.name,
+        "--database",
+        this.config.config.DATABASE + ".db",
+        "--motor",
+        this.config.type
+      ];
+    } else {
+      args = [
+        "--id",
+        "dbcube-" + this.name,
+        "--database-ref",
+        this.name,
+        "--database",
+        this.config.config.DATABASE,
+        "--host",
+        this.config.config.HOST,
+        "--port",
+        this.config.config.PORT,
+        "--user",
+        this.config.config.USER,
+        "--password",
+        this.config.config.PASSWORD,
+        "--motor",
+        this.config.type
+      ];
     }
-    this.pendingRequests.clear();
+    return args;
+  }
+  setConfig(name) {
+    const configInstance = new Config();
+    try {
+      const configFilePath = path4.resolve(process.cwd(), "dbcube.config.js");
+      const requireUrl = typeof __filename !== "undefined" ? __filename : process.cwd();
+      const require2 = createRequire2(requireUrl);
+      delete require2.cache[require2.resolve(configFilePath)];
+      const configModule = require2(configFilePath);
+      const configFn = configModule.default || configModule;
+      if (typeof configFn === "function") {
+        configFn(configInstance);
+      } else {
+        console.error("\u274C El archivo dbcube.config.js no exporta una funci\xF3n.");
+      }
+    } catch (error) {
+      console.error("\u274C Error loading config file:", error.message);
+      if (error.code === "MODULE_NOT_FOUND") {
+        console.error("\u274C Config file not found, please create a dbcube.config.js file");
+      }
+    }
+    return configInstance.getDatabase(name);
+  }
+  getConfig() {
+    return this.config;
   }
   async run(binary, args) {
-    await this.ensureProcess(binary);
-    if (!this.childProcess) {
-      throw new Error("Failed to start process");
+    const actionIndex = args.findIndex((arg) => arg === "--action");
+    const isExecuteAction = actionIndex !== -1 && args[actionIndex + 1] === "execute";
+    if (isExecuteAction) {
+      return this.executeWithTcpServer(args);
+    } else {
+      return this.createProcess(binary, args);
+    }
+  }
+  async executeWithTcpServer(args) {
+    const serverInfo = globalTcpServers.get(this.connectionId);
+    if (!serverInfo || !serverInfo.process || serverInfo.process.killed) {
+      console.log("\u{1F680} Starting TCP server for ultra-fast queries...");
+      await this.startTcpServer();
+    }
+    console.log("\u26A1 Using TCP server (ultra-fast)");
+    return this.sendTcpRequest(args);
+  }
+  async startTcpServer() {
+    await this.initializeBinary();
+    if (!this.binary) {
+      throw new Error("Binary not initialized");
     }
     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"));
+      const serverArgs = [...this.arguments, "--action", "server", "--port", this.tcpPort.toString()];
+      const serverProcess = spawn2(this.binary["query_engine"], serverArgs);
+      let started = false;
+      const timeout = setTimeout(() => {
+        if (!started) {
+          serverProcess.kill();
+          reject(new Error("TCP server startup timeout"));
+        }
+      }, 1e4);
+      serverProcess.stdout.on("data", (data) => {
+        const output = data.toString();
+        console.log(`[TCP Server] ${output.trim()}`);
+        if (output.includes("TCP Server listening on")) {
+          if (!started) {
+            started = true;
+            clearTimeout(timeout);
+            globalTcpServers.set(this.connectionId, {
+              port: this.tcpPort,
+              process: serverProcess
+            });
+            resolve5();
+          }
+        }
+      });
+      serverProcess.stderr.on("data", (data) => {
+        console.error(`[TCP Server Error] ${data.toString().trim()}`);
+      });
+      serverProcess.on("close", (code) => {
+        console.log(`[TCP Server] Process exited with code ${code}`);
+        globalTcpServers.delete(this.connectionId);
+      });
+      serverProcess.on("error", (error) => {
+        if (!started) {
+          clearTimeout(timeout);
+          reject(error);
         }
+      });
+    });
+  }
+  async sendTcpRequest(args) {
+    return new Promise((resolve5, reject) => {
+      const client = new net.Socket();
+      let responseBuffer = "";
+      const timeout = setTimeout(() => {
+        client.destroy();
+        reject(new Error("TCP request timeout"));
       }, this.timeout);
-      this.pendingRequests.set(requestId, {
-        resolve: resolve5,
-        reject,
-        timeoutId,
-        requestId
+      client.connect(this.tcpPort, "127.0.0.1", () => {
+        const command = {
+          action: "execute",
+          args
+        };
+        client.write(JSON.stringify(command) + "\n");
       });
-      const command = {
-        requestId,
-        args
-      };
-      try {
-        this.childProcess.stdin?.write(JSON.stringify(command) + "\n");
-      } catch (error) {
-        clearTimeout(timeoutId);
-        this.pendingRequests.delete(requestId);
+      client.on("data", (data) => {
+        responseBuffer += data.toString();
+        if (responseBuffer.includes("\n")) {
+          clearTimeout(timeout);
+          client.destroy();
+          try {
+            const response = JSON.parse(responseBuffer.trim());
+            resolve5({
+              status: response.status || 200,
+              message: response.message || "Success",
+              data: response.data
+            });
+          } catch (error) {
+            reject(new Error("Failed to parse TCP response"));
+          }
+        }
+      });
+      client.on("error", (error) => {
+        clearTimeout(timeout);
         reject(error);
-      }
+      });
+      client.on("close", () => {
+        clearTimeout(timeout);
+        if (responseBuffer && !responseBuffer.includes("\n")) {
+          reject(new Error("Incomplete TCP 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);
+  async createProcess(binary, args) {
+    await this.initializeBinary();
+    if (!this.binary) {
+      throw new Error("Binary not initialized");
+    }
+    return new Promise((resolve5, reject) => {
+      const child = spawn2(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
+            });
           }
-        }, 5e3);
+        }
       });
-    }
+      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) => {
+        clearTimeout(timeoutId);
+        if (!isResolved) {
+          resolveOnce({
+            status: 500,
+            message: `Process error: ${error.message}`,
+            data: null
+          });
+        }
+      });
+      child.unref();
+    });
   }
-  // Verificar si el proceso está activo
-  isProcessAlive() {
-    return this.childProcess !== null && !this.childProcess.killed;
+  async disconnect() {
+    const serverInfo = globalTcpServers.get(this.connectionId);
+    if (serverInfo && serverInfo.process && !serverInfo.process.killed) {
+      console.log("\u{1F50C} Stopping TCP server...");
+      serverInfo.process.kill();
+      globalTcpServers.delete(this.connectionId);
+      return {
+        status: 200,
+        message: "TCP server stopped",
+        data: null
+      };
+    }
+    return {
+      status: 200,
+      message: "No TCP server to stop",
+      data: null
+    };
   }
 };
 
 // src/lib/SqliteExecutor.ts
 import { exec } from "child_process";
-import * as path4 from "path";
+import * as path5 from "path";
 import * as fs3 from "fs";
 import { promisify } from "util";
-import { createRequire as createRequire2 } from "module";
+import { createRequire as createRequire3 } from "module";
 var execAsync = promisify(exec);
 var SqliteExecutor = class {
   binaryPath;
@@ -799,27 +1042,27 @@ var SqliteExecutor = class {
   }
   getBinaryPath() {
     const possibleDirs = [
-      path4.resolve(process.cwd(), ".dbcube", "bin"),
-      path4.resolve(process.cwd(), "node_modules", ".dbcube", "bin"),
-      path4.resolve(__dirname, "..", "bin")
+      path5.resolve(process.cwd(), ".dbcube", "bin"),
+      path5.resolve(process.cwd(), "node_modules", ".dbcube", "bin"),
+      path5.resolve(__dirname, "..", "bin")
     ];
     const platform2 = process.platform;
     const extension = platform2 === "win32" ? ".exe" : "";
     const binaryName = `sqlite-engine-${platform2 === "win32" ? "windows" : platform2 === "darwin" ? "macos" : "linux"}-x64${extension}`;
     for (const dir of possibleDirs) {
-      const fullPath = path4.join(dir, binaryName);
+      const fullPath = path5.join(dir, binaryName);
       if (fs3.existsSync(fullPath)) {
         return fullPath;
       }
     }
     const fallbackName = `sqlite-engine${extension}`;
     for (const dir of possibleDirs) {
-      const fullPath = path4.join(dir, fallbackName);
+      const fullPath = path5.join(dir, fallbackName);
       if (fs3.existsSync(fullPath)) {
         return fullPath;
       }
     }
-    return path4.join(possibleDirs[0], binaryName);
+    return path5.join(possibleDirs[0], binaryName);
   }
   async executeBinary(args) {
     const escapedArgs = args.map((arg) => {
@@ -921,7 +1164,7 @@ var SqliteExecutor = class {
   // Para compatibilidad con better-sqlite3 API sincrona usando deasync si es necesario
   prepareSync(sql) {
     const requireUrl = typeof __filename !== "undefined" ? __filename : process.cwd();
-    const require2 = createRequire2(requireUrl);
+    const require2 = createRequire3(requireUrl);
     const deasync = require2("deasync");
     return {
       all: (...params) => {
@@ -969,9 +1212,9 @@ var SqliteExecutor = class {
 };
 
 // src/lib/DbConfig.ts
-import * as path5 from "path";
+import * as path6 from "path";
 import fs4 from "fs";
-var rootPath = path5.resolve(process.cwd(), ".dbcube");
+var rootPath = path6.resolve(process.cwd(), ".dbcube");
 var SQLite = class {
   executor = null;
   database;
@@ -981,7 +1224,7 @@ var SQLite = class {
   async ifExist() {
     if (this.database) {
       const dbPath = this.database || ":memory:";
-      const configPath = path5.join(rootPath, dbPath + ".db");
+      const configPath = path6.join(rootPath, dbPath + ".db");
       if (!fs4.existsSync(rootPath)) {
         fs4.mkdirSync(rootPath, { recursive: true });
       }
@@ -1000,7 +1243,7 @@ var SQLite = class {
       try {
         if (!this.executor) {
           const dbPath = this.database || ":memory:";
-          const configPath = path5.join(rootPath, dbPath + ".db");
+          const configPath = path6.join(rootPath, dbPath + ".db");
           if (!fs4.existsSync(rootPath)) {
             fs4.mkdirSync(rootPath, { recursive: true });
           }
@@ -1185,7 +1428,7 @@ var DbConfig_default = DbConfig;
 
 // src/lib/FileLogger.ts
 import * as fs5 from "fs";
-import * as path6 from "path";
+import * as path7 from "path";
 import { EventEmitter } from "events";
 var FileLogger = class _FileLogger extends EventEmitter {
   static watchers = /* @__PURE__ */ new Map();
@@ -1200,7 +1443,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
    */
   static async write(filePath, message, level = "INFO", append = true) {
     try {
-      const dir = path6.dirname(filePath);
+      const dir = path7.dirname(filePath);
       if (!fs5.existsSync(dir)) {
         fs5.mkdirSync(dir, { recursive: true });
       }
@@ -1239,7 +1482,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
     const buffer = _FileLogger.buffers.get(filePath);
     if (buffer && buffer.length > 0) {
       try {
-        const dir = path6.dirname(filePath);
+        const dir = path7.dirname(filePath);
         if (!fs5.existsSync(dir)) {
           fs5.mkdirSync(dir, { recursive: true });
         }
@@ -1962,6 +2205,7 @@ export {
   DbConfig,
   Engine,
   FileLogger,
+  QueryEngine,
   TableProcessor,
   TriggerProcessor
 };