@dbcube/core 5.1.15 → 5.2.1

package/dist/index.js

@@ -345,7 +345,7 @@ var Downloader = class {
     }
     this.mainSpinner.text = chalk.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) {
@@ -373,6 +373,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(chalk.green("Binaries updated successfully"));
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
@@ -437,8 +442,7 @@ var Downloader = class {
           }
         });
         response.on("end", () => {
-          file.end();
-          resolve5();
+          file.end(() => resolve5());
         });
         response.on("error", (err) => {
           file.close();
@@ -664,7 +668,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];
@@ -672,14 +675,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;
@@ -727,6 +728,39 @@ var DaemonClient = class _DaemonClient {
   portfilePath() {
     return path3.join(process.cwd(), ".dbcube", "daemon", `${this.name}.json`);
   }
+  lockfilePath() {
+    return path3.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 {
+      fs3.mkdirSync(path3.dirname(lockPath), { recursive: true });
+      const fd = fs3.openSync(lockPath, "wx");
+      fs3.writeSync(fd, String(process.pid));
+      fs3.closeSync(fd);
+      return true;
+    } catch {
+      try {
+        const age = Date.now() - fs3.statSync(lockPath).mtimeMs;
+        if (age > 15e3) {
+          fs3.unlinkSync(lockPath);
+          return this.acquireSpawnLock();
+        }
+      } catch {
+      }
+      return false;
+    }
+  }
+  releaseSpawnLock() {
+    try {
+      fs3.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
@@ -743,24 +777,32 @@ var DaemonClient = class _DaemonClient {
   async connectOrStart() {
     const port = this.readPortfile();
     if (port && await this.tryConnect(port)) return true;
+    const gotLock = this.acquireSpawnLock();
     try {
-      fs3.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;
+      if (gotLock) {
+        try {
+          fs3.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();
     }
-    return false;
   }
   readPortfile() {
     try {
       const raw = fs3.readFileSync(this.portfilePath(), "utf8");
       const info = JSON.parse(raw);
-      return typeof info.port === "number" ? info.port : null;
+      const port = info?.port;
+      return Number.isInteger(port) && port > 0 && port <= 65535 ? port : null;
     } catch {
       return null;
     }
@@ -779,7 +821,7 @@ var DaemonClient = class _DaemonClient {
         socket.setNoDelay(true);
         this.attach(socket);
         try {
-          const pong = await this.send({ action: "ping" });
+          const pong = await this.send({ action: "ping" }, 2e3);
           resolve5(pong.status === 200);
         } catch {
           this.detach();
@@ -836,7 +878,7 @@ var DaemonClient = class _DaemonClient {
    * Sends a request to the daemon. Responses arrive in FIFO order on the
    * single socket, so pending requests resolve in send order.
    */
-  send(payload) {
+  send(payload, timeoutMs) {
     return new Promise((resolve5, reject) => {
       if (!this.socket || this.socket.destroyed) {
         reject(new Error("Daemon not connected"));
@@ -846,7 +888,8 @@ var DaemonClient = class _DaemonClient {
         const i = this.pending.findIndex((p) => p.timer === timer);
         if (i !== -1) this.pending.splice(i, 1);
         reject(new Error("Daemon request timeout"));
-      }, this.requestTimeout);
+        this.detach();
+      }, timeoutMs ?? this.requestTimeout);
       this.pending.push({ resolve: resolve5, reject, timer });
       this.socket.write(JSON.stringify(payload) + "\n");
     });
@@ -1003,14 +1046,16 @@ 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;
   }
@@ -1069,8 +1114,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 {
@@ -1090,8 +1137,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 {
@@ -1145,7 +1194,6 @@ 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;
@@ -1159,7 +1207,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();
   }
@@ -1214,17 +1262,30 @@ 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 {
@@ -1260,18 +1321,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;
@@ -1314,10 +1428,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() {
@@ -1364,14 +1479,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();
     });
   }
@@ -1398,9 +1513,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);
         }
@@ -1428,16 +1550,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(() => {
@@ -1479,7 +1593,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) {
@@ -2403,7 +2517,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 = [];
@@ -2434,21 +2548,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;
@@ -2491,14 +2594,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);
@@ -2506,8 +2602,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) {
@@ -2699,14 +2795,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);
@@ -2741,7 +2837,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) {
@@ -2760,7 +2856,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 = [];