@dbcube/core 5.1.12 → 5.1.15

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/lib/Engine.ts
-import path3 from "path";
+import path4 from "path";
 
 // src/lib/Arquitecture.ts
 import * as os from "os";
@@ -687,14 +687,216 @@ var Config = class {
 };
 
 // src/lib/Engine.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { createRequire } from "module";
+
+// src/lib/DaemonClient.ts
+import net from "net";
+import fs3 from "fs";
+import path3 from "path";
+import { spawn } from "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 path3.join(process.cwd(), ".dbcube", "daemon", `${this.name}.json`);
+  }
+  /**
+   * 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;
+    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;
+  }
+  readPortfile() {
+    try {
+      const raw = fs3.readFileSync(this.portfilePath(), "utf8");
+      const info = JSON.parse(raw);
+      return typeof info.port === "number" ? info.port : null;
+    } catch {
+      return null;
+    }
+  }
+  spawnDaemon() {
+    const child = 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 = net.createConnection({ host: "127.0.0.1", port }, async () => {
+        socket.setNoDelay(true);
+        this.attach(socket);
+        try {
+          const pong = await this.send({ action: "ping" });
+          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) {
+    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.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 {
+      fs3.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);
@@ -706,6 +908,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") {
@@ -744,7 +1017,7 @@ var Engine = class {
   setConfig(name) {
     const configInstance = new Config();
     try {
-      const configFilePath = path3.resolve(process.cwd(), "dbcube.config.js");
+      const configFilePath = path4.resolve(process.cwd(), "dbcube.config.js");
       const requireUrl = typeof __filename !== "undefined" ? __filename : process.cwd();
       const require2 = createRequire(requireUrl);
       if (require2.cache && require2.resolve) {
@@ -777,7 +1050,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;
@@ -863,10 +1136,10 @@ var Engine = class {
 };
 
 // src/lib/QueryEngine.ts
-import path4 from "path";
+import path5 from "path";
 import { createRequire as createRequire2 } from "module";
-import * as net from "net";
-import { spawn as spawn2 } from "child_process";
+import * as net2 from "net";
+import { spawn as spawn3 } from "child_process";
 var globalTcpServers = /* @__PURE__ */ new Map();
 var globalTcpConnections = /* @__PURE__ */ new Map();
 var connectionQueues = /* @__PURE__ */ new Map();
@@ -903,7 +1176,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();
@@ -955,7 +1228,7 @@ var QueryEngine = class {
   setConfig(name) {
     const configInstance = new Config();
     try {
-      const configFilePath = path4.resolve(process.cwd(), "dbcube.config.js");
+      const configFilePath = path5.resolve(process.cwd(), "dbcube.config.js");
       const requireUrl = typeof __filename !== "undefined" ? __filename : process.cwd();
       const require2 = createRequire2(requireUrl);
       if (require2.cache && require2.resolve) {
@@ -1017,7 +1290,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);
@@ -1055,7 +1328,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 = spawn2(this.binary["query_engine"], serverArgs);
+      const serverProcess = spawn3(this.binary["query_engine"], serverArgs);
       let started = false;
       const timeout = setTimeout(() => {
         if (!started) {
@@ -1138,7 +1411,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(() => {
@@ -1215,7 +1488,7 @@ var QueryEngine = class {
       throw new Error("Binary not initialized");
     }
     return new Promise((resolve5, reject) => {
-      const child = spawn2(this.binary[binary], [...this.arguments, ...args]);
+      const child = spawn3(this.binary[binary], [...this.arguments, ...args]);
       let stdoutBuffer = "";
       let stderrBuffer = "";
       let isResolved = false;
@@ -1323,8 +1596,8 @@ var QueryEngine = class {
 
 // src/lib/SqliteExecutor.ts
 import { exec } from "child_process";
-import * as path5 from "path";
-import * as fs3 from "fs";
+import * as path6 from "path";
+import * as fs4 from "fs";
 import { promisify } from "util";
 import { createRequire as createRequire3 } from "module";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -1339,13 +1612,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) {
     }
@@ -1355,34 +1628,34 @@ var SqliteExecutor = class {
     const __filename2 = typeof import.meta !== "undefined" && import.meta.url ? fileURLToPath3(import.meta.url) : "";
     const __dirname = __filename2 ? dirname3(__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) => {
@@ -1533,9 +1806,9 @@ var SqliteExecutor = class {
 };
 
 // src/lib/DbConfig.ts
-import * as path6 from "path";
-import fs4 from "fs";
-var rootPath = path6.resolve(process.cwd(), ".dbcube");
+import * as path7 from "path";
+import fs5 from "fs";
+var rootPath = path7.resolve(process.cwd(), ".dbcube");
 var SQLite = class {
   executor = null;
   database;
@@ -1545,11 +1818,11 @@ var SQLite = class {
   async ifExist() {
     if (this.database) {
       const dbPath = this.database || ":memory:";
-      const configPath = path6.join(rootPath, dbPath + ".db");
-      if (!fs4.existsSync(rootPath)) {
-        fs4.mkdirSync(rootPath, { recursive: true });
+      const configPath = path7.join(rootPath, dbPath + ".db");
+      if (!fs5.existsSync(rootPath)) {
+        fs5.mkdirSync(rootPath, { recursive: true });
       }
-      if (fs4.existsSync(configPath)) {
+      if (fs5.existsSync(configPath)) {
         return true;
       }
       if (!this.executor) {
@@ -1564,9 +1837,9 @@ var SQLite = class {
       try {
         if (!this.executor) {
           const dbPath = this.database || ":memory:";
-          const configPath = path6.join(rootPath, dbPath + ".db");
-          if (!fs4.existsSync(rootPath)) {
-            fs4.mkdirSync(rootPath, { recursive: true });
+          const configPath = path7.join(rootPath, dbPath + ".db");
+          if (!fs5.existsSync(rootPath)) {
+            fs5.mkdirSync(rootPath, { recursive: true });
           }
           this.executor = new SqliteExecutor(configPath);
           const connected = await this.executor.connect();
@@ -1748,8 +2021,8 @@ var DbConfig = new SQLite({ DATABASE: "config" });
 var DbConfig_default = DbConfig;
 
 // src/lib/FileLogger.ts
-import * as fs5 from "fs";
-import * as path7 from "path";
+import * as fs6 from "fs";
+import * as path8 from "path";
 import { EventEmitter } from "events";
 var FileLogger = class _FileLogger extends EventEmitter {
   static watchers = /* @__PURE__ */ new Map();
@@ -1764,9 +2037,9 @@ var FileLogger = class _FileLogger extends 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}
@@ -1776,9 +2049,9 @@ var FileLogger = class _FileLogger extends 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) {
@@ -1803,12 +2076,12 @@ var FileLogger = class _FileLogger extends 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) {
@@ -1944,10 +2217,10 @@ var FileLogger = class _FileLogger extends 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) {
@@ -1990,15 +2263,15 @@ var FileLogger = class _FileLogger extends 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"
@@ -2026,7 +2299,7 @@ var FileLogger = class _FileLogger extends 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 {
@@ -2034,7 +2307,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
       stop: () => {
         const storedListener = _FileLogger.watchers.get(watcherId);
         if (storedListener) {
-          fs5.unwatchFile(filePath, storedListener);
+          fs6.unwatchFile(filePath, storedListener);
           _FileLogger.watchers.delete(watcherId);
         }
       },
@@ -2047,7 +2320,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
   static stopAllWatchers() {
     for (const [watcherId] of _FileLogger.watchers) {
       const filePath = watcherId.split("_")[0];
-      fs5.unwatchFile(filePath);
+      fs6.unwatchFile(filePath);
     }
     _FileLogger.watchers.clear();
   }
@@ -2077,7 +2350,7 @@ var FileLogger = class _FileLogger extends 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;
@@ -2092,8 +2365,8 @@ var FileLogger = class _FileLogger extends 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;
@@ -2523,6 +2796,7 @@ export {
   Binary,
   ComputedFieldProcessor,
   Config,
+  DaemonClient,
   DbConfig,
   Engine,
   FileLogger,