@dbcube/core 3.0.3 → 3.0.5

package/dist/index.d.mts

@@ -7,24 +7,41 @@ interface ResponseEngine {
 }
 
 declare class Engine {
+    private name;
+    private config;
+    private arguments;
+    private binary;
+    private timeout;
+    constructor(name: string, timeout?: number);
+    initializeBinary(): Promise<void>;
+    setArguments(): any[];
+    setConfig(name: string): {
+        [x: string]: any;
+    } | null;
+    getConfig(): any;
+    run(binary: string, args: []): Promise<ResponseEngine>;
+}
+
+declare class QueryEngine {
     private name;
     private config;
     private arguments;
     private binary;
     private timeout;
     private connectionId;
-    private isConnected;
+    private tcpPort;
     constructor(name: string, timeout?: number);
-    private generateConnectionId;
+    private generatePort;
     initializeBinary(): Promise<void>;
     setArguments(): any[];
     setConfig(name: string): {
         [x: string]: any;
     } | null;
     getConfig(): any;
-    ensurePersistentConnection(): Promise<void>;
     run(binary: string, args: string[]): Promise<ResponseEngine>;
-    private executeWithPersistentConnection;
+    private executeWithTcpServer;
+    private startTcpServer;
+    private sendTcpRequest;
     private createProcess;
     disconnect(): Promise<ResponseEngine>;
 }
@@ -352,4 +369,4 @@ declare class TriggerProcessor {
     static getTriggers(name: string): Promise<any[]>;
 }
 
-export { Arquitecture, Binary, ComputedFieldProcessor, Config, DbConfig, Engine, FileLogger, type InterceptController, TableProcessor, TriggerProcessor };
+export { Arquitecture, Binary, ComputedFieldProcessor, Config, DbConfig, Engine, FileLogger, type InterceptController, QueryEngine, TableProcessor, TriggerProcessor };

package/dist/index.d.ts

@@ -7,24 +7,41 @@ interface ResponseEngine {
 }
 
 declare class Engine {
+    private name;
+    private config;
+    private arguments;
+    private binary;
+    private timeout;
+    constructor(name: string, timeout?: number);
+    initializeBinary(): Promise<void>;
+    setArguments(): any[];
+    setConfig(name: string): {
+        [x: string]: any;
+    } | null;
+    getConfig(): any;
+    run(binary: string, args: []): Promise<ResponseEngine>;
+}
+
+declare class QueryEngine {
     private name;
     private config;
     private arguments;
     private binary;
     private timeout;
     private connectionId;
-    private isConnected;
+    private tcpPort;
     constructor(name: string, timeout?: number);
-    private generateConnectionId;
+    private generatePort;
     initializeBinary(): Promise<void>;
     setArguments(): any[];
     setConfig(name: string): {
         [x: string]: any;
     } | null;
     getConfig(): any;
-    ensurePersistentConnection(): Promise<void>;
     run(binary: string, args: string[]): Promise<ResponseEngine>;
-    private executeWithPersistentConnection;
+    private executeWithTcpServer;
+    private startTcpServer;
+    private sendTcpRequest;
     private createProcess;
     disconnect(): Promise<ResponseEngine>;
 }
@@ -352,4 +369,4 @@ declare class TriggerProcessor {
     static getTriggers(name: string): Promise<any[]>;
 }
 
-export { Arquitecture, Binary, ComputedFieldProcessor, Config, DbConfig, Engine, FileLogger, type InterceptController, TableProcessor, TriggerProcessor };
+export { Arquitecture, Binary, ComputedFieldProcessor, Config, DbConfig, Engine, FileLogger, type InterceptController, QueryEngine, TableProcessor, TriggerProcessor };

package/dist/index.js

@@ -556,17 +556,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) {
@@ -633,33 +627,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 = 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
+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);
+  }
+  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 = 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 {
-        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 = 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);
+      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();
@@ -667,7 +925,7 @@ var Engine = class {
       throw new Error("Binary not initialized");
     }
     return new Promise((resolve5, reject) => {
-      const child = spawn(this.binary[binary], [...this.arguments, ...args]);
+      const child = spawn2(this.binary[binary], [...this.arguments, ...args]);
       let stdoutBuffer = "";
       let stderrBuffer = "";
       let isResolved = false;
@@ -749,21 +1007,20 @@ 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
     };
   }
@@ -771,10 +1028,10 @@ var Engine = class {
 
 // 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;
@@ -785,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) => {
@@ -907,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) => {
@@ -955,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;
@@ -967,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 });
       }
@@ -986,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 });
           }
@@ -1171,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();
@@ -1186,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 });
       }
@@ -1225,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 });
         }
@@ -1948,6 +2205,7 @@ export {
   DbConfig,
   Engine,
   FileLogger,
+  QueryEngine,
   TableProcessor,
   TriggerProcessor
 };