@dbcube/core 5.1.13 → 5.2.1

package/dist/index.cjs

@@ -34,6 +34,7 @@ __export(index_exports, {
   Binary: () => Binary,
   ComputedFieldProcessor: () => ComputedFieldProcessor,
   Config: () => Config,
+  DaemonClient: () => DaemonClient,
   DbConfig: () => DbConfig,
   Engine: () => Engine,
   FileLogger: () => FileLogger,
@@ -44,7 +45,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/lib/Engine.ts
-var import_path3 = __toESM(require("path"));
+var import_path4 = __toESM(require("path"));
 
 // src/lib/Arquitecture.ts
 var os = __toESM(require("os"));
@@ -391,7 +392,7 @@ var Downloader = class {
     }
     this.mainSpinner.text = import_chalk.default.blue(`Updating ${binariesToDownload.length} binary(ies)...`);
     try {
-      await Promise.all(binariesToDownload.map(async (binary) => {
+      const results = await Promise.allSettled(binariesToDownload.map(async (binary) => {
         const maxRetries = 3;
         let attempt = 0;
         while (attempt <= maxRetries) {
@@ -419,6 +420,11 @@ var Downloader = class {
           }
         }
       }));
+      const failures = results.filter((r) => r.status === "rejected");
+      if (failures.length > 0) {
+        const messages = failures.map((f) => f.reason instanceof Error ? f.reason.message : String(f.reason));
+        throw new Error(messages.join(" | "));
+      }
       this.mainSpinner.succeed(import_chalk.default.green("Binaries updated successfully"));
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
@@ -483,8 +489,7 @@ var Downloader = class {
           }
         });
         response.on("end", () => {
-          file.end();
-          resolve5();
+          file.end(() => resolve5());
         });
         response.on("error", (err) => {
           file.close();
@@ -711,7 +716,6 @@ var Config = class {
   /**
    * Obtiene un valor de configuración
    * @param key - Clave de configuración
-   * @returns Valor de configuración
    */
   get(key) {
     return this.data[key];
@@ -719,14 +723,12 @@ var Config = class {
   /**
    * Obtiene la configuración de una base de datos específica
    * @param dbName - Nombre de la base de datos
-   * @returns Configuración de la base de datos o null
    */
   getDatabase(dbName) {
     return this.databases[dbName] || null;
   }
   /**
    * Obtiene todas las bases de datos configuradas
-   * @returns Todas las configuraciones de bases de datos
    */
   getAllDatabases() {
     return this.databases;
@@ -734,14 +736,258 @@ var Config = class {
 };
 
 // src/lib/Engine.ts
-var import_child_process = require("child_process");
+var import_child_process2 = require("child_process");
 var import_module = require("module");
+
+// src/lib/DaemonClient.ts
+var import_net = __toESM(require("net"));
+var import_fs = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var import_child_process = require("child_process");
+var DaemonClient = class _DaemonClient {
+  static registry = /* @__PURE__ */ new Map();
+  name;
+  binaryPath;
+  engineArgs;
+  socket = null;
+  buffer = "";
+  pending = [];
+  starting = null;
+  requestTimeout;
+  constructor(name, binaryPath, engineArgs, requestTimeout = 3e4) {
+    this.name = name;
+    this.binaryPath = binaryPath;
+    this.engineArgs = engineArgs;
+    this.requestTimeout = requestTimeout;
+  }
+  static get(name, binaryPath, engineArgs) {
+    let client = this.registry.get(name);
+    if (!client) {
+      client = new _DaemonClient(name, binaryPath, engineArgs);
+      this.registry.set(name, client);
+    }
+    return client;
+  }
+  static isEnabled() {
+    const flag = process.env.DBCUBE_DAEMON;
+    if (flag === "0" || flag === "false") return false;
+    return true;
+  }
+  portfilePath() {
+    return import_path3.default.join(process.cwd(), ".dbcube", "daemon", `${this.name}.json`);
+  }
+  lockfilePath() {
+    return import_path3.default.join(process.cwd(), ".dbcube", "daemon", `${this.name}.lock`);
+  }
+  /**
+   * Exclusive-create lock so two processes never spawn two daemons for the
+   * same database at once. Stale locks (crashed starter) expire after 15s.
+   */
+  acquireSpawnLock() {
+    const lockPath = this.lockfilePath();
+    try {
+      import_fs.default.mkdirSync(import_path3.default.dirname(lockPath), { recursive: true });
+      const fd = import_fs.default.openSync(lockPath, "wx");
+      import_fs.default.writeSync(fd, String(process.pid));
+      import_fs.default.closeSync(fd);
+      return true;
+    } catch {
+      try {
+        const age = Date.now() - import_fs.default.statSync(lockPath).mtimeMs;
+        if (age > 15e3) {
+          import_fs.default.unlinkSync(lockPath);
+          return this.acquireSpawnLock();
+        }
+      } catch {
+      }
+      return false;
+    }
+  }
+  releaseSpawnLock() {
+    try {
+      import_fs.default.unlinkSync(this.lockfilePath());
+    } catch {
+    }
+  }
+  /**
+   * Ensures a usable daemon connection. Returns false when the daemon
+   * can't be used (old binary, startup failure) so callers fall back
+   * to one-shot spawn mode.
+   */
+  async ensure() {
+    if (this.socket && !this.socket.destroyed) return true;
+    if (this.starting) return this.starting;
+    this.starting = this.connectOrStart().catch(() => false);
+    const result = await this.starting;
+    this.starting = null;
+    return result;
+  }
+  async connectOrStart() {
+    const port = this.readPortfile();
+    if (port && await this.tryConnect(port)) return true;
+    const gotLock = this.acquireSpawnLock();
+    try {
+      if (gotLock) {
+        try {
+          import_fs.default.unlinkSync(this.portfilePath());
+        } catch {
+        }
+        this.spawnDaemon();
+      }
+      const deadline = Date.now() + 1e4;
+      while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 150));
+        const newPort = this.readPortfile();
+        if (newPort && await this.tryConnect(newPort)) return true;
+      }
+      return false;
+    } finally {
+      if (gotLock) this.releaseSpawnLock();
+    }
+  }
+  readPortfile() {
+    try {
+      const raw = import_fs.default.readFileSync(this.portfilePath(), "utf8");
+      const info = JSON.parse(raw);
+      const port = info?.port;
+      return Number.isInteger(port) && port > 0 && port <= 65535 ? port : null;
+    } catch {
+      return null;
+    }
+  }
+  spawnDaemon() {
+    const child = (0, import_child_process.spawn)(this.binaryPath, [...this.engineArgs, "--action", "server", "--tcp-port", "9944"], {
+      detached: true,
+      stdio: "ignore",
+      cwd: process.cwd()
+    });
+    child.unref();
+  }
+  tryConnect(port) {
+    return new Promise((resolve5) => {
+      const socket = import_net.default.createConnection({ host: "127.0.0.1", port }, async () => {
+        socket.setNoDelay(true);
+        this.attach(socket);
+        try {
+          const pong = await this.send({ action: "ping" }, 2e3);
+          resolve5(pong.status === 200);
+        } catch {
+          this.detach();
+          resolve5(false);
+        }
+      });
+      socket.once("error", () => resolve5(false));
+      socket.setTimeout(3e3, () => {
+        socket.destroy();
+        resolve5(false);
+      });
+    });
+  }
+  attach(socket) {
+    this.socket = socket;
+    this.buffer = "";
+    socket.setTimeout(0);
+    socket.on("data", (chunk) => this.onData(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+    socket.on("close", () => this.detach());
+    socket.on("error", () => this.detach());
+  }
+  detach() {
+    if (this.socket) {
+      this.socket.removeAllListeners();
+      this.socket.destroy();
+      this.socket = null;
+    }
+    for (const req of this.pending.splice(0)) {
+      clearTimeout(req.timer);
+      req.reject(new Error("Daemon connection lost"));
+    }
+  }
+  onData(chunk) {
+    this.buffer += chunk.toString("utf8");
+    let idx;
+    while ((idx = this.buffer.indexOf("\n")) !== -1) {
+      const line = this.buffer.slice(0, idx).trim();
+      this.buffer = this.buffer.slice(idx + 1);
+      if (!line) continue;
+      const marker = line.indexOf("PROCESS_RESPONSE:");
+      if (marker === -1) continue;
+      const jsonPart = line.slice(marker + "PROCESS_RESPONSE:".length);
+      const req = this.pending.shift();
+      if (!req) continue;
+      clearTimeout(req.timer);
+      try {
+        req.resolve(JSON.parse(jsonPart));
+      } catch (e) {
+        req.reject(new Error(`Invalid daemon response: ${e.message}`));
+      }
+    }
+  }
+  /**
+   * Sends a request to the daemon. Responses arrive in FIFO order on the
+   * single socket, so pending requests resolve in send order.
+   */
+  send(payload, timeoutMs) {
+    return new Promise((resolve5, reject) => {
+      if (!this.socket || this.socket.destroyed) {
+        reject(new Error("Daemon not connected"));
+        return;
+      }
+      const timer = setTimeout(() => {
+        const i = this.pending.findIndex((p) => p.timer === timer);
+        if (i !== -1) this.pending.splice(i, 1);
+        reject(new Error("Daemon request timeout"));
+        this.detach();
+      }, timeoutMs ?? this.requestTimeout);
+      this.pending.push({ resolve: resolve5, reject, timer });
+      this.socket.write(JSON.stringify(payload) + "\n");
+    });
+  }
+  async execute(dml, txId) {
+    const payload = { action: "execute", dml: JSON.stringify(dml) };
+    if (txId) payload.tx_id = txId;
+    return this.send(payload);
+  }
+  async raw(query, params = [], txId) {
+    const payload = { action: "raw", query, params };
+    if (txId) payload.tx_id = txId;
+    return this.send(payload);
+  }
+  async begin() {
+    const res = await this.send({ action: "begin" });
+    if (res.status !== 200 || !res.data?.tx_id) {
+      throw new Error(res.message || "Failed to begin transaction");
+    }
+    return res.data.tx_id;
+  }
+  async commit(txId) {
+    const res = await this.send({ action: "commit", tx_id: txId });
+    if (res.status !== 200) throw new Error(res.message || "Failed to commit transaction");
+  }
+  async rollback(txId) {
+    const res = await this.send({ action: "rollback", tx_id: txId });
+    if (res.status !== 200) throw new Error(res.message || "Failed to rollback transaction");
+  }
+  async shutdown() {
+    try {
+      await this.send({ action: "shutdown" });
+    } catch {
+    }
+    this.detach();
+    try {
+      import_fs.default.unlinkSync(this.portfilePath());
+    } catch {
+    }
+  }
+};
+
+// src/lib/Engine.ts
 var Engine = class {
   name;
   config;
   arguments;
   binary = null;
   timeout;
+  daemonFailed = false;
   constructor(name, timeout = 3e4) {
     this.name = name;
     this.config = this.setConfig(name);
@@ -753,6 +999,77 @@ var Engine = class {
       this.binary = await Binary.get();
     }
   }
+  /**
+   * Returns a connected DaemonClient for this database, or null when
+   * daemon mode is disabled/unavailable (then callers use spawn mode).
+   */
+  async getDaemon() {
+    if (this.daemonFailed || !DaemonClient.isEnabled()) return null;
+    await this.initializeBinary();
+    if (!this.binary) return null;
+    const binaryPath = this.binary["query_engine"];
+    if (!binaryPath) return null;
+    const client = DaemonClient.get(this.name, binaryPath, this.arguments);
+    const ok = await client.ensure();
+    if (!ok) {
+      this.daemonFailed = true;
+      return null;
+    }
+    return client;
+  }
+  /**
+   * Executes a DML plan. Uses the persistent daemon (sub-millisecond
+   * overhead) when available; falls back to one-shot spawn otherwise.
+   */
+  async executeDml(dml, txId) {
+    const daemon = await this.getDaemon();
+    if (daemon) {
+      try {
+        return await daemon.execute(dml, txId);
+      } catch (error) {
+        if (txId) throw error;
+      }
+    }
+    if (txId) {
+      throw new Error("Transactions require daemon mode. Make sure the query-engine binary is up to date (npx dbcube update).");
+    }
+    return this.run("query_engine", ["--action", "execute", "--dml", JSON.stringify(dml)]);
+  }
+  /**
+   * Executes raw SQL (or a MongoDB command document) with bound parameters.
+   */
+  async rawQuery(query, params = [], txId) {
+    const daemon = await this.getDaemon();
+    if (daemon) {
+      try {
+        return await daemon.raw(query, params, txId);
+      } catch (error) {
+        if (txId) throw error;
+      }
+    }
+    if (txId) {
+      throw new Error("Transactions require daemon mode. Make sure the query-engine binary is up to date (npx dbcube update).");
+    }
+    return this.run("query_engine", ["--action", "raw", "--query", query, "--params", JSON.stringify(params)]);
+  }
+  /** Starts a transaction (daemon mode only). Returns the transaction id. */
+  async beginTransaction() {
+    const daemon = await this.getDaemon();
+    if (!daemon) {
+      throw new Error("Transactions require daemon mode. Make sure the query-engine binary is up to date (npx dbcube update).");
+    }
+    return daemon.begin();
+  }
+  async commitTransaction(txId) {
+    const daemon = await this.getDaemon();
+    if (!daemon) throw new Error("Daemon connection lost during transaction");
+    return daemon.commit(txId);
+  }
+  async rollbackTransaction(txId) {
+    const daemon = await this.getDaemon();
+    if (!daemon) throw new Error("Daemon connection lost during transaction");
+    return daemon.rollback(txId);
+  }
   setArguments() {
     let args = [];
     if (this.config.type == "sqlite") {
@@ -777,21 +1094,23 @@ var Engine = class {
         "--host",
         this.config.config.HOST,
         "--port",
-        this.config.config.PORT,
-        "--user",
-        this.config.config.USER,
-        "--password",
-        this.config.config.PASSWORD,
+        String(this.config.config.PORT),
         "--motor",
         this.config.type
       ];
+      if (this.config.config.USER != null && this.config.config.USER !== "") {
+        args.push("--user", this.config.config.USER);
+      }
+      if (this.config.config.PASSWORD != null && this.config.config.PASSWORD !== "") {
+        args.push("--password", this.config.config.PASSWORD);
+      }
     }
     return args;
   }
   setConfig(name) {
     const configInstance = new Config();
     try {
-      const configFilePath = import_path3.default.resolve(process.cwd(), "dbcube.config.js");
+      const configFilePath = import_path4.default.resolve(process.cwd(), "dbcube.config.js");
       const requireUrl = typeof __filename !== "undefined" ? __filename : process.cwd();
       const require2 = (0, import_module.createRequire)(requireUrl);
       if (require2.cache && require2.resolve) {
@@ -824,7 +1143,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;
@@ -843,8 +1162,10 @@ var Engine = class {
         }
       };
       child.stdout.on("data", (data) => {
-        stdoutBuffer += data.toString();
-        console.log(stdoutBuffer);
+        const text = data.toString();
+        stdoutBuffer += text;
+        const visible = text.split("\n").filter((l) => l.trim() && !l.includes("PROCESS_RESPONSE:")).join("\n");
+        if (visible) console.log(visible);
         const match = stdoutBuffer.match(/PROCESS_RESPONSE:(\{.*\})/);
         if (match) {
           try {
@@ -864,8 +1185,10 @@ var Engine = class {
         }
       });
       child.stderr.on("data", (data) => {
-        stderrBuffer += data.toString();
-        console.log(stderrBuffer);
+        const text = data.toString();
+        stderrBuffer += text;
+        const visible = text.split("\n").filter((l) => l.trim() && !l.includes("PROCESS_RESPONSE:")).join("\n");
+        if (visible) console.log(visible);
         const match = stderrBuffer.match(/PROCESS_RESPONSE:(\{.*\})/);
         if (match) {
           try {
@@ -910,16 +1233,15 @@ var Engine = class {
 };
 
 // src/lib/QueryEngine.ts
-var import_path4 = __toESM(require("path"));
+var import_path5 = __toESM(require("path"));
 var import_module2 = require("module");
-var net = __toESM(require("net"));
-var import_child_process2 = require("child_process");
+var net2 = __toESM(require("net"));
+var import_child_process3 = require("child_process");
 var globalTcpServers = /* @__PURE__ */ new Map();
 var globalTcpConnections = /* @__PURE__ */ new Map();
 var connectionQueues = /* @__PURE__ */ new Map();
 var connectionProcessing = /* @__PURE__ */ new Map();
 var queryCache = /* @__PURE__ */ new Map();
-var cacheSize = 0;
 var MAX_CACHE_SIZE = 500;
 var QueryEngine = class {
   name;
@@ -933,7 +1255,7 @@ var QueryEngine = class {
     this.name = name;
     this.config = this.setConfig(name);
     this.arguments = this.setArguments();
-    this.timeout = timeout;
+    this.timeout = this.config?.daemon?.requestTimeoutMs ?? timeout;
     this.connectionId = `${name}_query_engine_${this.config.type}_${this.config.config.DATABASE}_${this.config.config.HOST || "localhost"}`;
     this.tcpPort = this.generatePort();
   }
@@ -950,7 +1272,7 @@ var QueryEngine = class {
   }
   isPortAvailable(port) {
     return new Promise((resolve5) => {
-      const tester = net.createServer();
+      const tester = net2.createServer();
       tester.once("error", () => resolve5(false));
       tester.once("listening", () => {
         tester.close();
@@ -988,21 +1310,34 @@ var QueryEngine = class {
         "--host",
         this.config.config.HOST,
         "--port",
-        this.config.config.PORT,
-        "--user",
-        this.config.config.USER,
-        "--password",
-        this.config.config.PASSWORD,
+        String(this.config.config.PORT),
         "--motor",
         this.config.type
       ];
+      if (this.config.config.USER != null && this.config.config.USER !== "") {
+        args.push("--user", this.config.config.USER);
+      }
+      if (this.config.config.PASSWORD != null && this.config.config.PASSWORD !== "") {
+        args.push("--password", this.config.config.PASSWORD);
+      }
     }
+    const pool = this.config.pool ?? {};
+    if (pool.maxConnections != null) args.push("--max-connections", String(pool.maxConnections));
+    if (pool.minConnections != null) args.push("--min-connections", String(pool.minConnections));
+    if (pool.acquireTimeoutMs != null) args.push("--acquire-timeout-ms", String(pool.acquireTimeoutMs));
+    if (pool.idleTimeoutMs != null) args.push("--idle-timeout-ms", String(pool.idleTimeoutMs));
     return args;
   }
+  /** El daemon puede desactivarse por config (daemon.enabled=false) o por env (DBCUBE_DAEMON=0). */
+  daemonEnabled() {
+    const flag = process.env.DBCUBE_DAEMON;
+    if (flag === "0" || flag === "false") return false;
+    return this.config?.daemon?.enabled !== false;
+  }
   setConfig(name) {
     const configInstance = new Config();
     try {
-      const configFilePath = import_path4.default.resolve(process.cwd(), "dbcube.config.js");
+      const configFilePath = import_path5.default.resolve(process.cwd(), "dbcube.config.js");
       const requireUrl = typeof __filename !== "undefined" ? __filename : process.cwd();
       const require2 = (0, import_module2.createRequire)(requireUrl);
       if (require2.cache && require2.resolve) {
@@ -1034,18 +1369,71 @@ var QueryEngine = class {
     const isExecuteAction = actionIndex !== -1 && args[actionIndex + 1] === "execute";
     const isQueryEngine = binary === "query_engine";
     if (isQueryEngine && isExecuteAction) {
-      return this.executeWithTcpServer(args);
+      return this.executeWithTcpServer(this.argsToCommand(args));
     } else {
       return this.createProcess(binary, args);
     }
   }
-  async executeWithTcpServer(args) {
+  argsToCommand(args) {
+    const command = {};
+    for (let i = 0; i < args.length; i += 2) {
+      if (args[i].startsWith("--")) {
+        command[args[i].substring(2)] = args[i + 1];
+      }
+    }
+    return command;
+  }
+  /**
+   * Executes a DML plan over the persistent TCP server.
+   * Pass txId to run it inside an active transaction.
+   */
+  async executeDml(dml, txId) {
+    const command = { action: "execute", dml: JSON.stringify(dml) };
+    if (txId) command.tx_id = txId;
+    return this.executeWithTcpServer(command);
+  }
+  /**
+   * Executes raw SQL (or a MongoDB command document) with bound parameters
+   * over the persistent TCP server.
+   */
+  async rawQuery(query, params = [], txId) {
+    const command = { action: "raw", query, params };
+    if (txId) command.tx_id = txId;
+    return this.executeWithTcpServer(command);
+  }
+  /** Starts a server-side transaction and returns its id. */
+  async beginTransaction() {
+    const res = await this.executeWithTcpServer({ action: "begin" });
+    if (res.status !== 200 || !res.data?.tx_id) {
+      throw new Error(String(res.message || "Failed to begin transaction (update the query-engine binary: npx dbcube update)"));
+    }
+    return res.data.tx_id;
+  }
+  async commitTransaction(txId) {
+    const res = await this.executeWithTcpServer({ action: "commit", tx_id: txId });
+    if (res.status !== 200) throw new Error(String(res.message || "Failed to commit transaction"));
+  }
+  async rollbackTransaction(txId) {
+    const res = await this.executeWithTcpServer({ action: "rollback", tx_id: txId });
+    if (res.status !== 200) throw new Error(String(res.message || "Failed to rollback transaction"));
+  }
+  async executeWithTcpServer(command) {
+    if (!this.daemonEnabled()) {
+      if (command.tx_id || ["begin", "commit", "rollback"].includes(command.action)) {
+        throw new Error("Transactions require daemon mode. Remove daemon.enabled=false from dbcube.config.js (or unset DBCUBE_DAEMON=0).");
+      }
+      const args = [];
+      for (const [key, value] of Object.entries(command)) {
+        args.push(`--${key.replace(/_/g, "-")}`, typeof value === "string" ? value : JSON.stringify(value));
+      }
+      return this.createProcess("query_engine", args);
+    }
     const serverInfo = globalTcpServers.get(this.connectionId);
     if (!serverInfo || !serverInfo.process || serverInfo.process.killed) {
       await this.startTcpServer();
       await this.waitForServerReady();
     }
-    return this.sendTcpRequestFast(args);
+    return this.sendTcpRequestFast(command);
   }
   async waitForServerReady() {
     const maxRetries = 10;
@@ -1064,7 +1452,7 @@ var QueryEngine = class {
   }
   async isServerResponding(port) {
     return new Promise((resolve5) => {
-      const client = new net.Socket();
+      const client = new net2.Socket();
       const timeout = setTimeout(() => {
         client.destroy();
         resolve5(false);
@@ -1088,10 +1476,11 @@ var QueryEngine = class {
       return queryCache.get(dmlJson);
     }
     const parsed = JSON.parse(dmlJson);
-    if (cacheSize < MAX_CACHE_SIZE) {
-      queryCache.set(dmlJson, parsed);
-      cacheSize++;
+    if (queryCache.size >= MAX_CACHE_SIZE) {
+      const oldest = queryCache.keys().next().value;
+      if (oldest !== void 0) queryCache.delete(oldest);
     }
+    queryCache.set(dmlJson, parsed);
     return parsed;
   }
   async startTcpServer() {
@@ -1102,7 +1491,7 @@ var QueryEngine = class {
     this.tcpPort = await this.findAvailablePort(this.tcpPort);
     return new Promise((resolve5, reject) => {
       const serverArgs = [...this.arguments, "--action", "server", "--tcp-port", this.tcpPort.toString()];
-      const serverProcess = (0, import_child_process2.spawn)(this.binary["query_engine"], serverArgs);
+      const serverProcess = (0, import_child_process3.spawn)(this.binary["query_engine"], serverArgs);
       let started = false;
       const timeout = setTimeout(() => {
         if (!started) {
@@ -1138,14 +1527,14 @@ var QueryEngine = class {
       });
     });
   }
-  async sendTcpRequestFast(args) {
+  async sendTcpRequestFast(command) {
     return new Promise((resolve5, reject) => {
       let queue = connectionQueues.get(this.connectionId);
       if (!queue) {
         queue = [];
         connectionQueues.set(this.connectionId, queue);
       }
-      queue.push({ args, resolve: resolve5, reject });
+      queue.push({ command, resolve: resolve5, reject });
       this.processQueue();
     });
   }
@@ -1172,9 +1561,16 @@ var QueryEngine = class {
             connection = await this.createNewConnection(serverInfo.port);
             globalTcpConnections.set(this.connectionId, connection);
           }
-          const result = await this.executeOnConnection(connection, request.args);
+          const result = await this.executeOnConnection(connection, request.command);
           request.resolve(result);
         } catch (error) {
+          const staleConnection = globalTcpConnections.get(this.connectionId);
+          if (staleConnection) {
+            try {
+              staleConnection.destroy();
+            } catch {
+            }
+          }
           globalTcpConnections.delete(this.connectionId);
           request.reject(error);
         }
@@ -1185,7 +1581,7 @@ var QueryEngine = class {
   }
   async createNewConnection(port) {
     return new Promise((resolve5, reject) => {
-      const client = new net.Socket();
+      const client = new net2.Socket();
       client.setNoDelay(true);
       client.setKeepAlive(true, 6e4);
       const timeout = setTimeout(() => {
@@ -1202,16 +1598,8 @@ var QueryEngine = class {
       });
     });
   }
-  async executeOnConnection(connection, args) {
+  async executeOnConnection(connection, command) {
     return new Promise((resolve5, reject) => {
-      const command = {};
-      for (let i = 0; i < args.length; i += 2) {
-        if (args[i].startsWith("--")) {
-          const key = args[i].substring(2);
-          const value = args[i + 1];
-          command[key] = value;
-        }
-      }
       let responseBuffer = "";
       let isResolved = false;
       const timeout = setTimeout(() => {
@@ -1253,7 +1641,7 @@ var QueryEngine = class {
       };
       connection.on("data", onData);
       connection.on("error", onError);
-      connection.write(JSON.stringify(command));
+      connection.write(JSON.stringify(command) + "\n");
     });
   }
   async createProcess(binary, args) {
@@ -1262,7 +1650,7 @@ var QueryEngine = class {
       throw new Error("Binary not initialized");
     }
     return new Promise((resolve5, reject) => {
-      const child = (0, import_child_process2.spawn)(this.binary[binary], [...this.arguments, ...args]);
+      const child = (0, import_child_process3.spawn)(this.binary[binary], [...this.arguments, ...args]);
       let stdoutBuffer = "";
       let stderrBuffer = "";
       let isResolved = false;
@@ -1369,15 +1757,15 @@ var QueryEngine = class {
 };
 
 // src/lib/SqliteExecutor.ts
-var import_child_process3 = require("child_process");
-var path5 = __toESM(require("path"));
-var fs3 = __toESM(require("fs"));
+var import_child_process4 = require("child_process");
+var path6 = __toESM(require("path"));
+var fs4 = __toESM(require("fs"));
 var import_util = require("util");
 var import_module3 = require("module");
 var import_url3 = require("url");
-var import_path5 = require("path");
+var import_path6 = require("path");
 var import_meta3 = {};
-var execAsync = (0, import_util.promisify)(import_child_process3.exec);
+var execAsync = (0, import_util.promisify)(import_child_process4.exec);
 var SqliteExecutor = class {
   binaryPath;
   dbPath;
@@ -1387,13 +1775,13 @@ var SqliteExecutor = class {
   }
   findVersionedBinary(binDir, platform2) {
     try {
-      const files = fs3.readdirSync(binDir);
+      const files = fs4.readdirSync(binDir);
       const extension = platform2 === "win32" ? ".exe" : "";
       const platformName = platform2 === "win32" ? "windows" : platform2 === "darwin" ? "macos" : "linux";
       const pattern = new RegExp(`^sqlite-engine-v\\d+\\.\\d+\\.\\d+-${platformName}-x64${extension.replace(".", "\\.")}$`);
       const matchingFile = files.find((f) => pattern.test(f));
       if (matchingFile) {
-        return path5.join(binDir, matchingFile);
+        return path6.join(binDir, matchingFile);
       }
     } catch (error) {
     }
@@ -1401,36 +1789,36 @@ var SqliteExecutor = class {
   }
   getBinaryPath() {
     const __filename2 = typeof import_meta3 !== "undefined" && import_meta3.url ? (0, import_url3.fileURLToPath)(import_meta3.url) : "";
-    const __dirname = __filename2 ? (0, import_path5.dirname)(__filename2) : process.cwd();
+    const __dirname = __filename2 ? (0, import_path6.dirname)(__filename2) : process.cwd();
     const possibleDirs = [
-      path5.resolve(process.cwd(), ".dbcube", "bin"),
-      path5.resolve(process.cwd(), "node_modules", ".dbcube", "bin"),
-      path5.resolve(__dirname, "..", "bin")
+      path6.resolve(process.cwd(), ".dbcube", "bin"),
+      path6.resolve(process.cwd(), "node_modules", ".dbcube", "bin"),
+      path6.resolve(__dirname, "..", "bin")
     ];
     const platform2 = process.platform;
     const extension = platform2 === "win32" ? ".exe" : "";
     const platformName = platform2 === "win32" ? "windows" : platform2 === "darwin" ? "macos" : "linux";
     for (const dir of possibleDirs) {
       const versionedPath = this.findVersionedBinary(dir, platform2);
-      if (versionedPath && fs3.existsSync(versionedPath)) {
+      if (versionedPath && fs4.existsSync(versionedPath)) {
         return versionedPath;
       }
     }
     const binaryName = `sqlite-engine-${platformName}-x64${extension}`;
     for (const dir of possibleDirs) {
-      const fullPath = path5.join(dir, binaryName);
-      if (fs3.existsSync(fullPath)) {
+      const fullPath = path6.join(dir, binaryName);
+      if (fs4.existsSync(fullPath)) {
         return fullPath;
       }
     }
     const fallbackName = `sqlite-engine${extension}`;
     for (const dir of possibleDirs) {
-      const fullPath = path5.join(dir, fallbackName);
-      if (fs3.existsSync(fullPath)) {
+      const fullPath = path6.join(dir, fallbackName);
+      if (fs4.existsSync(fullPath)) {
         return fullPath;
       }
     }
-    return path5.join(possibleDirs[0], binaryName);
+    return path6.join(possibleDirs[0], binaryName);
   }
   async executeBinary(args) {
     const escapedArgs = args.map((arg) => {
@@ -1581,9 +1969,9 @@ var SqliteExecutor = class {
 };
 
 // src/lib/DbConfig.ts
-var path6 = __toESM(require("path"));
-var import_fs = __toESM(require("fs"));
-var rootPath = path6.resolve(process.cwd(), ".dbcube");
+var path7 = __toESM(require("path"));
+var import_fs2 = __toESM(require("fs"));
+var rootPath = path7.resolve(process.cwd(), ".dbcube");
 var SQLite = class {
   executor = null;
   database;
@@ -1593,11 +1981,11 @@ var SQLite = class {
   async ifExist() {
     if (this.database) {
       const dbPath = this.database || ":memory:";
-      const configPath = path6.join(rootPath, dbPath + ".db");
-      if (!import_fs.default.existsSync(rootPath)) {
-        import_fs.default.mkdirSync(rootPath, { recursive: true });
+      const configPath = path7.join(rootPath, dbPath + ".db");
+      if (!import_fs2.default.existsSync(rootPath)) {
+        import_fs2.default.mkdirSync(rootPath, { recursive: true });
       }
-      if (import_fs.default.existsSync(configPath)) {
+      if (import_fs2.default.existsSync(configPath)) {
         return true;
       }
       if (!this.executor) {
@@ -1612,9 +2000,9 @@ var SQLite = class {
       try {
         if (!this.executor) {
           const dbPath = this.database || ":memory:";
-          const configPath = path6.join(rootPath, dbPath + ".db");
-          if (!import_fs.default.existsSync(rootPath)) {
-            import_fs.default.mkdirSync(rootPath, { recursive: true });
+          const configPath = path7.join(rootPath, dbPath + ".db");
+          if (!import_fs2.default.existsSync(rootPath)) {
+            import_fs2.default.mkdirSync(rootPath, { recursive: true });
           }
           this.executor = new SqliteExecutor(configPath);
           const connected = await this.executor.connect();
@@ -1796,8 +2184,8 @@ var DbConfig = new SQLite({ DATABASE: "config" });
 var DbConfig_default = DbConfig;
 
 // src/lib/FileLogger.ts
-var fs5 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 var import_events = require("events");
 var FileLogger = class _FileLogger extends import_events.EventEmitter {
   static watchers = /* @__PURE__ */ new Map();
@@ -1812,9 +2200,9 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
    */
   static async write(filePath, message, level = "INFO", append = true) {
     try {
-      const dir = path7.dirname(filePath);
-      if (!fs5.existsSync(dir)) {
-        fs5.mkdirSync(dir, { recursive: true });
+      const dir = path8.dirname(filePath);
+      if (!fs6.existsSync(dir)) {
+        fs6.mkdirSync(dir, { recursive: true });
       }
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       const formattedMessage = `[${timestamp}] [${level}] ${message}
@@ -1824,9 +2212,9 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
         return true;
       }
       if (append) {
-        await fs5.promises.appendFile(filePath, formattedMessage, "utf8");
+        await fs6.promises.appendFile(filePath, formattedMessage, "utf8");
       } else {
-        await fs5.promises.writeFile(filePath, formattedMessage, "utf8");
+        await fs6.promises.writeFile(filePath, formattedMessage, "utf8");
       }
       return true;
     } catch (error) {
@@ -1851,12 +2239,12 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
     const buffer = _FileLogger.buffers.get(filePath);
     if (buffer && buffer.length > 0) {
       try {
-        const dir = path7.dirname(filePath);
-        if (!fs5.existsSync(dir)) {
-          fs5.mkdirSync(dir, { recursive: true });
+        const dir = path8.dirname(filePath);
+        if (!fs6.existsSync(dir)) {
+          fs6.mkdirSync(dir, { recursive: true });
         }
         const content = buffer.join("");
-        await fs5.promises.appendFile(filePath, content, "utf8");
+        await fs6.promises.appendFile(filePath, content, "utf8");
         _FileLogger.buffers.delete(filePath);
         return true;
       } catch (error) {
@@ -1992,10 +2380,10 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
       // Si debe retornar como array de líneas
     } = options;
     try {
-      if (!fs5.existsSync(filePath)) {
+      if (!fs6.existsSync(filePath)) {
         return asArray ? [] : "";
       }
-      let content = await fs5.promises.readFile(filePath, "utf8");
+      let content = await fs6.promises.readFile(filePath, "utf8");
       if (asArray) {
         let linesArray = content.split("\n").filter((line) => line.trim() !== "");
         if (lines !== null) {
@@ -2038,15 +2426,15 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
     } = options;
     let lastSize = 0;
     let lastPosition = 0;
-    if (fs5.existsSync(filePath)) {
-      const stats = fs5.statSync(filePath);
+    if (fs6.existsSync(filePath)) {
+      const stats = fs6.statSync(filePath);
       lastSize = stats.size;
       lastPosition = fromEnd ? stats.size : 0;
     }
     const listener = async (curr, prev) => {
       try {
         if (curr.size > lastSize) {
-          const stream = fs5.createReadStream(filePath, {
+          const stream = fs6.createReadStream(filePath, {
             start: lastPosition,
             end: curr.size - 1,
             encoding: "utf8"
@@ -2074,7 +2462,7 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
         console.error("Error en watcher:", error);
       }
     };
-    fs5.watchFile(filePath, { persistent, interval }, listener);
+    fs6.watchFile(filePath, { persistent, interval }, listener);
     const watcherId = `${filePath}_${Date.now()}`;
     _FileLogger.watchers.set(watcherId, listener);
     return {
@@ -2082,7 +2470,7 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
       stop: () => {
         const storedListener = _FileLogger.watchers.get(watcherId);
         if (storedListener) {
-          fs5.unwatchFile(filePath, storedListener);
+          fs6.unwatchFile(filePath, storedListener);
           _FileLogger.watchers.delete(watcherId);
         }
       },
@@ -2095,7 +2483,7 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
   static stopAllWatchers() {
     for (const [watcherId] of _FileLogger.watchers) {
       const filePath = watcherId.split("_")[0];
-      fs5.unwatchFile(filePath);
+      fs6.unwatchFile(filePath);
     }
     _FileLogger.watchers.clear();
   }
@@ -2125,7 +2513,7 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
       if (lines.length > maxLines) {
         const keepLines = lines.slice(-maxLines);
         const content = keepLines.join("\n") + "\n";
-        await fs5.promises.writeFile(filePath, content, "utf8");
+        await fs6.promises.writeFile(filePath, content, "utf8");
         return lines.length - maxLines;
       }
       return 0;
@@ -2140,8 +2528,8 @@ var FileLogger = class _FileLogger extends import_events.EventEmitter {
    */
   static async deleteLogFile(filePath) {
     try {
-      if (fs5.existsSync(filePath)) {
-        await fs5.promises.unlink(filePath);
+      if (fs6.existsSync(filePath)) {
+        await fs6.promises.unlink(filePath);
         return true;
       }
       return false;
@@ -2178,7 +2566,7 @@ var ComputedFieldProcessor = class {
         const tableExistsQuery = `SELECT name FROM sqlite_master WHERE type='table' AND name='dbcube_computes_config'`;
         const tableExistsResult = await DbConfig_default.query(tableExistsQuery);
         if (tableExistsResult.status === "success" && tableExistsResult.data && tableExistsResult.data.length > 0) {
-          const queryComputes = await DbConfig_default.query(`SELECT * FROM dbcube_computes_config WHERE database_ref='${name}'`);
+          const queryComputes = await DbConfig_default.queryWithParameters(`SELECT * FROM dbcube_computes_config WHERE database_ref=?`, [name]);
           computedFields = queryComputes.data;
         } else {
           computedFields = [];
@@ -2209,21 +2597,10 @@ var ComputedFieldProcessor = class {
       }
       functionBody = functionBody.replace(/@column\(([^)]+)\)/g, (_match, columnName) => {
         const cleanColumnName = columnName.trim().replace(/['"]/g, "");
-        const value = rowData[cleanColumnName];
-        if (value === null || value === void 0) {
-          return "null";
-        } else if (typeof value === "string") {
-          return `"${value.replace(/"/g, '\\"')}"`;
-        } else if (typeof value === "number" || typeof value === "boolean") {
-          return value.toString();
-        } else if (value instanceof Date) {
-          return `new Date("${value.toISOString()}")`;
-        } else {
-          return JSON.stringify(value);
-        }
+        return `__row[${JSON.stringify(cleanColumnName)}]`;
       });
-      const computeFunction = new Function(functionBody);
-      return computeFunction();
+      const computeFunction = new Function("__row", functionBody);
+      return computeFunction(rowData);
     } catch (error) {
       console.error("Error processing computed field:", error);
       return null;
@@ -2266,14 +2643,7 @@ var ComputedFieldProcessor = class {
             /@column\(([^)]+)\)/g,
             (match, columnName) => {
               const cleanColumnName = columnName.replace(/['"]/g, "");
-              const value = processedItem[cleanColumnName];
-              if (typeof value === "string") {
-                return `"${value}"`;
-              } else if (value === null || value === void 0) {
-                return "null";
-              } else {
-                return String(value);
-              }
+              return `__row[${JSON.stringify(cleanColumnName)}]`;
             }
           );
           const computeMatch = processedExpression.match(/@compute\s*\(\s*\(\s*\)\s*=>\s*\{(.*)\}\s*\)/s);
@@ -2281,8 +2651,8 @@ var ComputedFieldProcessor = class {
             throw new Error(`Formato de @compute inv\xE1lido para campo ${fieldName}`);
           }
           const functionBody = computeMatch[1];
-          const computeFunction = new Function(functionBody);
-          let result = computeFunction();
+          const computeFunction = new Function("__row", functionBody);
+          let result = computeFunction(processedItem);
           result = convertToType(result, type2);
           processedItem[fieldName] = result;
         } catch (error) {
@@ -2474,14 +2844,14 @@ var TableProcessor = class {
     if (await DbConfig_default.ifExist()) {
       await DbConfig_default.connect();
       try {
-        const tableExistsQuery = `SELECT name FROM sqlite_master WHERE type='table' AND name='dbcube_computes_config'`;
+        const tableExistsQuery = `SELECT name FROM sqlite_master WHERE type='table' AND name='dbcube_schemas_config'`;
         const tableExistsResult = await DbConfig_default.query(tableExistsQuery);
         if (tableExistsResult.status === "success" && tableExistsResult.data && tableExistsResult.data.length > 0) {
-          const queryComputes = await DbConfig_default.query(`SELECT * FROM dbcube_schemas_config WHERE table_ref='${tableName}' AND database_ref='${database_ref}'`);
+          const queryComputes = await DbConfig_default.queryWithParameters(`SELECT * FROM dbcube_schemas_config WHERE table_ref=? AND database_ref=?`, [tableName, database_ref]);
           const oldQuery = queryComputes.data[0];
           if (!oldQuery || !oldQuery.struct) {
-            console.error("No exist a previus schema please execute the refresh first...", oldQuery);
-            return [];
+            await DbConfig_default.disconnect();
+            return [nowQuery];
           }
           const nowSchema = parseCreateTableQuery(nowQuery, dbType);
           const oldSchema = parseCreateTableQuery(oldQuery.struct, dbType);
@@ -2516,7 +2886,7 @@ var TableProcessor = class {
     if (await DbConfig_default.ifExist()) {
       await DbConfig_default.connect();
       try {
-        await DbConfig_default.query(`DELETE FROM dbcube_schemas_config WHERE table_ref='${table_ref}' AND database_ref='${database_ref}'`);
+        await DbConfig_default.queryWithParameters(`DELETE FROM dbcube_schemas_config WHERE table_ref=? AND database_ref=?`, [table_ref, database_ref]);
         const tableExistsQuery = `INSERT INTO dbcube_schemas_config (table_ref, database_ref, struct) VALUES (?, ?, ?)`;
         await DbConfig_default.queryWithParameters(tableExistsQuery, [table_ref, database_ref, struct]);
       } catch (error) {
@@ -2535,7 +2905,7 @@ var TriggerProcessor = class {
         const tableExistsQuery = `SELECT name FROM sqlite_master WHERE type='table' AND name='dbcube_triggers_config'`;
         const tableExistsResult = await DbConfig_default.query(tableExistsQuery);
         if (tableExistsResult.status === "success" && tableExistsResult.data && tableExistsResult.data.length > 0) {
-          const queryComputes = await DbConfig_default.query(`SELECT * FROM dbcube_triggers_config WHERE database_ref='${name}'`);
+          const queryComputes = await DbConfig_default.queryWithParameters(`SELECT * FROM dbcube_triggers_config WHERE database_ref=?`, [name]);
           triggers = queryComputes.data;
         } else {
           triggers = [];
@@ -2572,6 +2942,7 @@ function convertToType(value, type2) {
   Binary,
   ComputedFieldProcessor,
   Config,
+  DaemonClient,
   DbConfig,
   Engine,
   FileLogger,