@dbcube/core 3.0.3 → 3.0.5

package/dist/index.cjs

@@ -37,6 +37,7 @@ __export(index_exports, {
   DbConfig: () => DbConfig,
   Engine: () => Engine,
   FileLogger: () => FileLogger,
+  QueryEngine: () => QueryEngine,
   TableProcessor: () => TableProcessor,
   TriggerProcessor: () => TriggerProcessor
 });
@@ -600,17 +601,11 @@ var Engine = class {
   arguments;
   binary = null;
   timeout;
-  connectionId;
-  isConnected = 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) {
@@ -677,33 +672,297 @@ 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");
+  async run(binary, args) {
+    await this.initializeBinary();
+    if (!this.binary) {
+      throw new Error("Binary not initialized");
+    }
+    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
+            });
+          }
+        }
+      });
+      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();
+    });
+  }
+};
+
+// src/lib/QueryEngine.ts
+var import_path2 = __toESM(require("path"));
+var import_module2 = require("module");
+var net = __toESM(require("net"));
+var import_child_process2 = require("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);
+  }
+  async initializeBinary() {
+    if (!this.binary) {
+      this.binary = await Binary.get();
+    }
+  }
+  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
+      ];
+    }
+    return args;
+  }
+  setConfig(name) {
+    const configInstance = new Config();
+    try {
+      const configFilePath = import_path2.default.resolve(process.cwd(), "dbcube.config.js");
+      const requireUrl = typeof __filename !== "undefined" ? __filename : process.cwd();
+      const require2 = (0, import_module2.createRequire)(requireUrl);
+      delete require2.cache[require2.resolve(configFilePath)];
+      const configModule = require2(configFilePath);
+      const configFn = configModule.default || configModule;
+      if (typeof configFn === "function") {
+        configFn(configInstance);
       } else {
-        throw new Error(`Failed to create persistent connection: ${response.message}`);
+        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) {
-    const actionIndex = args.indexOf("--action");
+    const actionIndex = args.findIndex((arg) => arg === "--action");
     const isExecuteAction = actionIndex !== -1 && args[actionIndex + 1] === "execute";
     if (isExecuteAction) {
-      await this.ensurePersistentConnection();
-      return this.executeWithPersistentConnection(args);
+      return this.executeWithTcpServer(args);
     } else {
       return this.createProcess(binary, args);
     }
   }
-  async executeWithPersistentConnection(args) {
-    return this.createProcess("query_engine", 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 serverArgs = [...this.arguments, "--action", "server", "--port", this.tcpPort.toString()];
+      const serverProcess = (0, import_child_process2.spawn)(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);
+      client.connect(this.tcpPort, "127.0.0.1", () => {
+        const command = {
+          action: "execute",
+          args
+        };
+        client.write(JSON.stringify(command) + "\n");
+      });
+      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"));
+        }
+      });
+    });
   }
   async createProcess(binary, args) {
     await this.initializeBinary();
@@ -711,7 +970,7 @@ var Engine = class {
       throw new Error("Binary not initialized");
     }
     return new Promise((resolve5, reject) => {
-      const child = (0, import_child_process.spawn)(this.binary[binary], [...this.arguments, ...args]);
+      const child = (0, import_child_process2.spawn)(this.binary[binary], [...this.arguments, ...args]);
       let stdoutBuffer = "";
       let stderrBuffer = "";
       let isResolved = false;
@@ -793,33 +1052,32 @@ var Engine = class {
     });
   }
   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;
+    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 persistent connection to disconnect",
+      message: "No TCP server to stop",
       data: null
     };
   }
 };
 
 // src/lib/SqliteExecutor.ts
-var import_child_process2 = require("child_process");
-var path4 = __toESM(require("path"));
+var import_child_process3 = require("child_process");
+var path5 = __toESM(require("path"));
 var fs3 = __toESM(require("fs"));
 var import_util = require("util");
-var import_module2 = require("module");
-var execAsync = (0, import_util.promisify)(import_child_process2.exec);
+var import_module3 = require("module");
+var execAsync = (0, import_util.promisify)(import_child_process3.exec);
 var SqliteExecutor = class {
   binaryPath;
   dbPath;
@@ -829,27 +1087,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) => {
@@ -951,7 +1209,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 = (0, import_module2.createRequire)(requireUrl);
+    const require2 = (0, import_module3.createRequire)(requireUrl);
     const deasync = require2("deasync");
     return {
       all: (...params) => {
@@ -999,9 +1257,9 @@ var SqliteExecutor = class {
 };
 
 // src/lib/DbConfig.ts
-var path5 = __toESM(require("path"));
+var path6 = __toESM(require("path"));
 var import_fs = __toESM(require("fs"));
-var rootPath = path5.resolve(process.cwd(), ".dbcube");
+var rootPath = path6.resolve(process.cwd(), ".dbcube");
 var SQLite = class {
   executor = null;
   database;
@@ -1011,7 +1269,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 (!import_fs.default.existsSync(rootPath)) {
         import_fs.default.mkdirSync(rootPath, { recursive: true });
       }
@@ -1030,7 +1288,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 (!import_fs.default.existsSync(rootPath)) {
             import_fs.default.mkdirSync(rootPath, { recursive: true });
           }
@@ -1215,7 +1473,7 @@ var DbConfig_default = DbConfig;
 
 // src/lib/FileLogger.ts
 var fs5 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var path7 = __toESM(require("path"));
 var import_events = require("events");
 var FileLogger = class _FileLogger extends import_events.EventEmitter {
   static watchers = /* @__PURE__ */ new Map();
@@ -1230,7 +1488,7 @@ var FileLogger = class _FileLogger extends import_events.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 });
       }
@@ -1269,7 +1527,7 @@ var FileLogger = class _FileLogger extends import_events.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 });
         }
@@ -1993,6 +2251,7 @@ function convertToType(value, type2) {
   DbConfig,
   Engine,
   FileLogger,
+  QueryEngine,
   TableProcessor,
   TriggerProcessor
 });