@dbcube/core 5.2.3 → 5.2.5

package/dist/index.js

@@ -6,7 +6,8 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/lib/Engine.ts
-import path4 from "path";
+import path5 from "path";
+import * as fs5 from "fs";
 
 // src/lib/Arquitecture.ts
 import * as os from "os";
@@ -146,8 +147,7 @@ var Downloader = class {
   static currentSpinner = null;
   static VERSION_URLS = {
     query: "https://raw.githubusercontent.com/Dbcube/binaries/main/query-engines.json",
-    schema: "https://raw.githubusercontent.com/Dbcube/binaries/main/schema-engines.json",
-    sqlite: "https://raw.githubusercontent.com/Dbcube/binaries/main/sqlite-engines.json"
+    schema: "https://raw.githubusercontent.com/Dbcube/binaries/main/schema-engines.json"
   };
   /**
    * Fetch latest version from GitHub
@@ -317,7 +317,7 @@ var Downloader = class {
       spinner: "dots12"
     }).start();
     const binariesToProcess = [];
-    for (const prefix of ["query", "schema", "sqlite"]) {
+    for (const prefix of ["query", "schema"]) {
       try {
         const localVersion = this.getLocalVersion(binDir, prefix);
         const remoteVersion = await this.fetchLatestVersion(prefix);
@@ -706,14 +706,75 @@ var Config = class {
   }
 };
 
+// src/lib/EnvLoader.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+var EnvLoader = class _EnvLoader {
+  /**
+   * Carga el archivo .env indicado (o ./.env del cwd) en process.env.
+   * Silencioso si el archivo no existe. Devuelve true si cargó algo.
+   */
+  static load(envPath) {
+    const file = envPath || path3.resolve(process.cwd(), ".env");
+    if (!fs3.existsSync(file)) return false;
+    const proc = process;
+    if (typeof proc.loadEnvFile === "function") {
+      try {
+        proc.loadEnvFile(file);
+        return true;
+      } catch {
+      }
+    }
+    try {
+      const parsed = _EnvLoader.parse(fs3.readFileSync(file, "utf8"));
+      for (const [key, value] of Object.entries(parsed)) {
+        if (process.env[key] === void 0) {
+          process.env[key] = value;
+        }
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Parser mínimo de formato .env. Soporta:
+   *   KEY=value · KEY="value con espacios" · KEY='literal' · export KEY=value
+   *   comentarios con # · líneas en blanco · \n \t en comillas dobles.
+   */
+  static parse(content) {
+    const out = {};
+    for (const rawLine of content.split(/\r?\n/)) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#")) continue;
+      const withoutExport = line.startsWith("export ") ? line.slice(7).trim() : line;
+      const eq = withoutExport.indexOf("=");
+      if (eq === -1) continue;
+      const key = withoutExport.slice(0, eq).trim();
+      if (!key) continue;
+      let value = withoutExport.slice(eq + 1).trim();
+      if (value.length >= 2 && value[0] === '"' && value[value.length - 1] === '"') {
+        value = value.slice(1, -1).replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\"/g, '"');
+      } else if (value.length >= 2 && value[0] === "'" && value[value.length - 1] === "'") {
+        value = value.slice(1, -1);
+      } else {
+        const hash = value.indexOf(" #");
+        if (hash !== -1) value = value.slice(0, hash).trim();
+      }
+      out[key] = value;
+    }
+    return out;
+  }
+};
+
 // src/lib/Engine.ts
 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 fs4 from "fs";
+import path4 from "path";
 import { spawn } from "child_process";
 var DaemonClient = class _DaemonClient {
   static registry = /* @__PURE__ */ new Map();
@@ -745,10 +806,10 @@ var DaemonClient = class _DaemonClient {
     return true;
   }
   portfilePath() {
-    return path3.join(process.cwd(), ".dbcube", "daemon", `${this.name}.json`);
+    return path4.join(process.cwd(), ".dbcube", "daemon", `${this.name}.json`);
   }
   lockfilePath() {
-    return path3.join(process.cwd(), ".dbcube", "daemon", `${this.name}.lock`);
+    return path4.join(process.cwd(), ".dbcube", "daemon", `${this.name}.lock`);
   }
   /**
    * Exclusive-create lock so two processes never spawn two daemons for the
@@ -757,16 +818,16 @@ var DaemonClient = class _DaemonClient {
   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);
+      fs4.mkdirSync(path4.dirname(lockPath), { recursive: true });
+      const fd = fs4.openSync(lockPath, "wx");
+      fs4.writeSync(fd, String(process.pid));
+      fs4.closeSync(fd);
       return true;
     } catch {
       try {
-        const age = Date.now() - fs3.statSync(lockPath).mtimeMs;
+        const age = Date.now() - fs4.statSync(lockPath).mtimeMs;
         if (age > 15e3) {
-          fs3.unlinkSync(lockPath);
+          fs4.unlinkSync(lockPath);
           return this.acquireSpawnLock();
         }
       } catch {
@@ -776,7 +837,7 @@ var DaemonClient = class _DaemonClient {
   }
   releaseSpawnLock() {
     try {
-      fs3.unlinkSync(this.lockfilePath());
+      fs4.unlinkSync(this.lockfilePath());
     } catch {
     }
   }
@@ -800,7 +861,7 @@ var DaemonClient = class _DaemonClient {
     try {
       if (gotLock) {
         try {
-          fs3.unlinkSync(this.portfilePath());
+          fs4.unlinkSync(this.portfilePath());
         } catch {
         }
         this.spawnDaemon();
@@ -818,7 +879,7 @@ var DaemonClient = class _DaemonClient {
   }
   readPortfile() {
     try {
-      const raw = fs3.readFileSync(this.portfilePath(), "utf8");
+      const raw = fs4.readFileSync(this.portfilePath(), "utf8");
       const info = JSON.parse(raw);
       const port = info?.port;
       return Number.isInteger(port) && port > 0 && port <= 65535 ? port : null;
@@ -945,7 +1006,7 @@ var DaemonClient = class _DaemonClient {
     }
     this.detach();
     try {
-      fs3.unlinkSync(this.portfilePath());
+      fs4.unlinkSync(this.portfilePath());
     } catch {
     }
   }
@@ -1043,6 +1104,7 @@ var Engine = class {
   }
   setArguments() {
     let args = [];
+    const motor = this.config.type === "postgres" ? "postgresql" : this.config.type;
     if (this.config.type == "sqlite") {
       args = [
         "--id",
@@ -1052,7 +1114,7 @@ var Engine = class {
         "--database",
         this.config.config.DATABASE + ".db",
         "--motor",
-        this.config.type
+        motor
       ];
     } else {
       args = [
@@ -1067,7 +1129,7 @@ var Engine = class {
         "--port",
         String(this.config.config.PORT),
         "--motor",
-        this.config.type
+        motor
       ];
       if (this.config.config.USER != null && this.config.config.USER !== "") {
         args.push("--user", this.config.config.USER);
@@ -1080,8 +1142,10 @@ var Engine = class {
   }
   setConfig(name) {
     const configInstance = new Config();
+    EnvLoader.load();
     try {
-      const configFilePath = path4.resolve(process.cwd(), "dbcube.config.js");
+      const cjsPath = path5.resolve(process.cwd(), "dbcube.config.cjs");
+      const configFilePath = fs5.existsSync(cjsPath) ? cjsPath : path5.resolve(process.cwd(), "dbcube.config.js");
       const requireUrl = typeof __filename !== "undefined" ? __filename : process.cwd();
       const require2 = createRequire(requireUrl);
       if (require2.cache && require2.resolve) {
@@ -1194,11 +1258,12 @@ var Engine = class {
 };
 
 // src/lib/QueryEngine.ts
-import path6 from "path";
+import path7 from "path";
+import * as fs7 from "fs";
 
 // src/lib/EmbeddedEngine.ts
-import * as fs4 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 if (!process.env.UV_THREADPOOL_SIZE) {
   process.env.UV_THREADPOOL_SIZE = "16";
 }
@@ -1214,11 +1279,11 @@ function platTag() {
 }
 function findFile(name) {
   const candidates = [
-    path5.resolve(process.cwd(), ".dbcube", "bin", name),
-    path5.resolve(process.cwd(), "node_modules", ".dbcube", "bin", name)
+    path6.resolve(process.cwd(), ".dbcube", "bin", name),
+    path6.resolve(process.cwd(), "node_modules", ".dbcube", "bin", name)
   ];
   for (const c of candidates) {
-    if (fs4.existsSync(c)) return c;
+    if (fs6.existsSync(c)) return c;
   }
   return null;
 }
@@ -1463,9 +1528,9 @@ var QueryEngine = class {
   timeout;
   connectionId;
   tcpPort;
-  constructor(name, timeout = 3e4) {
+  constructor(name, timeout = 3e4, explicitConfig) {
     this.name = name;
-    this.config = this.setConfig(name);
+    this.config = explicitConfig ?? this.setConfig(name);
     this.arguments = this.setArguments();
     this.timeout = this.config?.daemon?.requestTimeoutMs ?? timeout;
     this.connectionId = `${name}_query_engine_${this.config.type}_${this.config.config.DATABASE}_${this.config.config.HOST || "localhost"}`;
@@ -1500,6 +1565,7 @@ var QueryEngine = class {
   }
   setArguments() {
     let args = [];
+    const motor = this.config.type === "postgres" ? "postgresql" : this.config.type;
     if (this.config.type == "sqlite") {
       args = [
         "--id",
@@ -1509,7 +1575,7 @@ var QueryEngine = class {
         "--database",
         this.config.config.DATABASE + ".db",
         "--motor",
-        this.config.type
+        motor
       ];
     } else {
       args = [
@@ -1524,7 +1590,7 @@ var QueryEngine = class {
         "--port",
         String(this.config.config.PORT),
         "--motor",
-        this.config.type
+        motor
       ];
       if (this.config.config.USER != null && this.config.config.USER !== "") {
         args.push("--user", this.config.config.USER);
@@ -1548,8 +1614,10 @@ var QueryEngine = class {
   }
   setConfig(name) {
     const configInstance = new Config();
+    EnvLoader.load();
     try {
-      const configFilePath = path6.resolve(process.cwd(), "dbcube.config.js");
+      const cjsPath = path7.resolve(process.cwd(), "dbcube.config.cjs");
+      const configFilePath = fs7.existsSync(cjsPath) ? cjsPath : path7.resolve(process.cwd(), "dbcube.config.js");
       const requireUrl = typeof __filename !== "undefined" ? __filename : process.cwd();
       const require2 = createRequire2(requireUrl);
       if (require2.cache && require2.resolve) {
@@ -2012,346 +2080,70 @@ var QueryEngine = class {
   }
 };
 
-// src/lib/SqliteExecutor.ts
-import { exec } from "child_process";
-import * as path7 from "path";
-import * as fs5 from "fs";
-import { promisify } from "util";
-import { createRequire as createRequire3 } from "module";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname4 } from "path";
-var execAsync = promisify(exec);
-var SqliteExecutor = class {
-  binaryPath;
-  dbPath;
-  constructor(dbPath) {
-    this.dbPath = dbPath;
-    this.binaryPath = this.getBinaryPath();
-  }
-  findVersionedBinary(binDir, platform2) {
-    try {
-      const files = fs5.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 path7.join(binDir, matchingFile);
-      }
-    } catch (error) {
-    }
-    return null;
-  }
-  getBinaryPath() {
-    const __filename2 = typeof import.meta !== "undefined" && import.meta.url ? fileURLToPath3(import.meta.url) : "";
-    const __dirname = __filename2 ? dirname4(__filename2) : process.cwd();
-    const possibleDirs = [
-      path7.resolve(process.cwd(), ".dbcube", "bin"),
-      path7.resolve(process.cwd(), "node_modules", ".dbcube", "bin"),
-      path7.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 && fs5.existsSync(versionedPath)) {
-        return versionedPath;
-      }
-    }
-    const binaryName = `sqlite-engine-${platformName}-x64${extension}`;
-    for (const dir of possibleDirs) {
-      const fullPath = path7.join(dir, binaryName);
-      if (fs5.existsSync(fullPath)) {
-        return fullPath;
-      }
-    }
-    const fallbackName = `sqlite-engine${extension}`;
-    for (const dir of possibleDirs) {
-      const fullPath = path7.join(dir, fallbackName);
-      if (fs5.existsSync(fullPath)) {
-        return fullPath;
-      }
-    }
-    return path7.join(possibleDirs[0], binaryName);
-  }
-  async executeBinary(args) {
-    const escapedArgs = args.map((arg) => {
-      if (arg.includes(" ") || arg.includes('"') || arg.includes("(") || arg.includes(")")) {
-        return `"${arg.replace(/"/g, '\\"')}"`;
-      }
-      return arg;
-    });
-    const command = `"${this.binaryPath}" ${escapedArgs.join(" ")}`;
-    try {
-      const { stdout, stderr } = await execAsync(command, {
-        maxBuffer: 10 * 1024 * 1024,
-        // 10MB buffer
-        timeout: 3e4
-        // 30s timeout
-      });
-      if (stderr && stderr.trim()) {
-        console.warn("SQLite Engine Warning:", stderr);
-      }
-      const result = JSON.parse(stdout.trim());
-      return result;
-    } catch (error) {
-      if (error.stdout) {
-        try {
-          const result = JSON.parse(error.stdout.trim());
-          return result;
-        } catch (parseError) {
-        }
-      }
-      throw new Error(`SQLite execution failed: ${error.message}`);
-    }
-  }
-  async connect() {
-    try {
-      const result = await this.executeBinary([
-        "--action",
-        "connect",
-        "--database",
-        this.dbPath
-      ]);
-      return result.status === "success";
-    } catch (error) {
-      return false;
-    }
-  }
-  async exists() {
-    try {
-      const result = await this.executeBinary([
-        "--action",
-        "exists",
-        "--database",
-        this.dbPath
-      ]);
-      return result.status === "success" && result.data === true;
-    } catch (error) {
-      return false;
-    }
-  }
-  async query(sql, params) {
-    const args = [
-      "--action",
-      "query",
-      "--database",
-      this.dbPath,
-      "--query",
-      sql
-    ];
-    if (params && params.length > 0) {
-      args.push("--params", JSON.stringify(params));
-    }
-    return this.executeBinary(args);
-  }
-  // Método para múltiples queries (como lo hace better-sqlite3)
-  async queryMultiple(sql) {
-    return this.query(sql);
-  }
-  // Método prepare que simula prepared statements
-  prepare(sql) {
-    return {
-      all: async (...params) => {
-        const result = await this.query(sql, params);
-        if (result.status === "error") {
-          throw new Error(result.message);
-        }
-        return Array.isArray(result.data) ? result.data : [];
-      },
-      run: async (...params) => {
-        const result = await this.query(sql, params);
-        if (result.status === "error") {
-          throw new Error(result.message);
-        }
-        if (typeof result.data === "object" && result.data.hasOwnProperty("changes") && result.data.hasOwnProperty("lastID")) {
-          return result.data;
-        }
-        return { changes: 0, lastID: 0 };
-      }
-    };
-  }
-  // Para compatibilidad con better-sqlite3 API sincrona usando deasync si es necesario
-  prepareSync(sql) {
-    const __filename2 = typeof import.meta !== "undefined" && import.meta.url ? fileURLToPath3(import.meta.url) : "";
-    const requireUrl = __filename2 || import.meta.url;
-    const require2 = createRequire3(requireUrl);
-    const deasync = require2("deasync");
-    return {
-      all: (...params) => {
-        let result;
-        let done = false;
-        let error;
-        this.query(sql, params).then((res) => {
-          if (res.status === "error") {
-            error = new Error(res.message);
-          } else {
-            result = Array.isArray(res.data) ? res.data : [];
-          }
-          done = true;
-        }).catch((err) => {
-          error = err;
-          done = true;
-        });
-        deasync.loopWhile(() => !done);
-        if (error) throw error;
-        return result;
-      },
-      run: (...params) => {
-        let result;
-        let done = false;
-        let error;
-        this.query(sql, params).then((res) => {
-          if (res.status === "error") {
-            error = new Error(res.message);
-          } else if (typeof res.data === "object" && res.data.hasOwnProperty("changes") && res.data.hasOwnProperty("lastID")) {
-            result = res.data;
-          } else {
-            result = { changes: 0, lastID: 0 };
-          }
-          done = true;
-        }).catch((err) => {
-          error = err;
-          done = true;
-        });
-        deasync.loopWhile(() => !done);
-        if (error) throw error;
-        return result;
-      }
-    };
-  }
-};
-
 // src/lib/DbConfig.ts
 import * as path8 from "path";
-import fs6 from "fs";
+import fs8 from "fs";
 var rootPath = path8.resolve(process.cwd(), ".dbcube");
 var SQLite = class {
-  executor = null;
   database;
+  engine = null;
   constructor(config) {
-    this.database = config.DATABASE;
+    this.database = config.DATABASE || "config";
+  }
+  /** Ruta del archivo SQLite interno (.dbcube/<database>.db). */
+  dbFilePath() {
+    return path8.join(rootPath, this.database + ".db");
+  }
+  /** QueryEngine sqlite apuntando al archivo interno, con config explícito
+   *  (no vive en dbcube.config.js). La ruta relativa `.dbcube/<db>` deja que
+   *  QueryEngine le añada `.db` → `.dbcube/<db>.db`, relativo al CWD. */
+  getEngine() {
+    if (!this.engine) {
+      const relativeDb = path8.join(".dbcube", this.database).replace(/\\/g, "/");
+      this.engine = new QueryEngine(`dbcube-internal-${this.database}`, 3e4, {
+        type: "sqlite",
+        config: { DATABASE: relativeDb }
+      });
+    }
+    return this.engine;
   }
   async ifExist() {
-    if (this.database) {
-      const dbPath = this.database || ":memory:";
-      const configPath = path8.join(rootPath, dbPath + ".db");
-      if (!fs6.existsSync(rootPath)) {
-        fs6.mkdirSync(rootPath, { recursive: true });
-      }
-      if (fs6.existsSync(configPath)) {
-        return true;
-      }
-      if (!this.executor) {
-        this.executor = new SqliteExecutor(configPath);
-      }
-      return await this.executor.exists();
+    if (!fs8.existsSync(rootPath)) {
+      fs8.mkdirSync(rootPath, { recursive: true });
     }
-    return false;
+    return fs8.existsSync(this.dbFilePath());
   }
   async connect() {
-    return new Promise(async (resolve6, reject) => {
-      try {
-        if (!this.executor) {
-          const dbPath = this.database || ":memory:";
-          const configPath = path8.join(rootPath, dbPath + ".db");
-          if (!fs6.existsSync(rootPath)) {
-            fs6.mkdirSync(rootPath, { recursive: true });
-          }
-          this.executor = new SqliteExecutor(configPath);
-          const connected = await this.executor.connect();
-          if (!connected) {
-            throw new Error("Failed to connect to SQLite database");
-          }
-        }
-        resolve6(this.executor);
-      } catch (error) {
-        reject(error);
-      }
-    });
+    if (!fs8.existsSync(rootPath)) {
+      fs8.mkdirSync(rootPath, { recursive: true });
+    }
+    return this.getEngine();
   }
   async disconnect() {
-    return new Promise((resolve6) => {
-      if (this.executor) {
-        this.executor = null;
-      }
-      resolve6();
-    });
   }
   async query(sqlQuery) {
-    return new Promise(async (resolve6) => {
-      try {
-        if (typeof sqlQuery !== "string") {
-          throw new Error("The SQL query must be a string.");
-        }
-        if (!this.executor) {
-          await this.connect();
-        }
-        if (!this.executor) {
-          throw new Error("Database connection is not available.");
-        }
-        const result = await this.executor.queryMultiple(sqlQuery);
-        if (result.status === "error") {
-          resolve6({
-            status: "error",
-            message: result.message,
-            data: null
-          });
-        } else {
-          resolve6({
-            status: "success",
-            message: "Query executed successfully",
-            data: result.data
-          });
-        }
-      } catch (error) {
-        resolve6({
-          status: "error",
-          message: error.message || "An error occurred while executing the query.",
-          data: null
-        });
-      }
-    });
+    return this.queryWithParameters(sqlQuery, []);
   }
   async queryWithParameters(sqlQuery, params = []) {
-    return new Promise(async (resolve6) => {
-      try {
-        if (typeof sqlQuery !== "string") {
-          throw new Error("The SQL query must be a string.");
-        }
-        if (!Array.isArray(params)) {
-          throw new Error("Parameters must be an array.");
-        }
-        if (!this.executor) {
-          await this.connect();
-        }
-        if (!this.executor) {
-          throw new Error("Database connection is not available.");
-        }
-        const result = await this.executor.query(sqlQuery, params);
-        if (result.status === "error") {
-          resolve6({
-            status: "error",
-            message: result.message,
-            data: null
-          });
-        } else {
-          resolve6({
-            status: "success",
-            message: "Query executed successfully",
-            data: result.data
-          });
-        }
-      } catch (error) {
-        console.log(error);
-        resolve6({
-          status: "error",
-          message: error.message || "An error occurred while executing the query.",
-          data: null
-        });
+    try {
+      if (typeof sqlQuery !== "string") {
+        throw new Error("The SQL query must be a string.");
       }
-    });
+      if (!Array.isArray(params)) {
+        throw new Error("Parameters must be an array.");
+      }
+      const response = await this.getEngine().rawQuery(sqlQuery, params);
+      if (response.status !== 200) {
+        return { status: "error", message: response.message || "Query failed", data: null };
+      }
+      return { status: "success", message: "Query executed successfully", data: response.data };
+    } catch (error) {
+      return {
+        status: "error",
+        message: error.message || "An error occurred while executing the query.",
+        data: null
+      };
+    }
   }
   convertToParameterizedQuery(sql) {
     const normalizedSql = sql.replace(/\s+/g, " ").trim();
@@ -2439,7 +2231,7 @@ var DbConfig = new SQLite({ DATABASE: "config" });
 var DbConfig_default = DbConfig;
 
 // src/lib/FileLogger.ts
-import * as fs7 from "fs";
+import * as fs9 from "fs";
 import * as path9 from "path";
 import { EventEmitter } from "events";
 var FileLogger = class _FileLogger extends EventEmitter {
@@ -2456,8 +2248,8 @@ var FileLogger = class _FileLogger extends EventEmitter {
   static async write(filePath, message, level = "INFO", append = true) {
     try {
       const dir = path9.dirname(filePath);
-      if (!fs7.existsSync(dir)) {
-        fs7.mkdirSync(dir, { recursive: true });
+      if (!fs9.existsSync(dir)) {
+        fs9.mkdirSync(dir, { recursive: true });
       }
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       const formattedMessage = `[${timestamp}] [${level}] ${message}
@@ -2467,9 +2259,9 @@ var FileLogger = class _FileLogger extends EventEmitter {
         return true;
       }
       if (append) {
-        await fs7.promises.appendFile(filePath, formattedMessage, "utf8");
+        await fs9.promises.appendFile(filePath, formattedMessage, "utf8");
       } else {
-        await fs7.promises.writeFile(filePath, formattedMessage, "utf8");
+        await fs9.promises.writeFile(filePath, formattedMessage, "utf8");
       }
       return true;
     } catch (error) {
@@ -2495,11 +2287,11 @@ var FileLogger = class _FileLogger extends EventEmitter {
     if (buffer && buffer.length > 0) {
       try {
         const dir = path9.dirname(filePath);
-        if (!fs7.existsSync(dir)) {
-          fs7.mkdirSync(dir, { recursive: true });
+        if (!fs9.existsSync(dir)) {
+          fs9.mkdirSync(dir, { recursive: true });
         }
         const content = buffer.join("");
-        await fs7.promises.appendFile(filePath, content, "utf8");
+        await fs9.promises.appendFile(filePath, content, "utf8");
         _FileLogger.buffers.delete(filePath);
         return true;
       } catch (error) {
@@ -2635,10 +2427,10 @@ var FileLogger = class _FileLogger extends EventEmitter {
       // Si debe retornar como array de líneas
     } = options;
     try {
-      if (!fs7.existsSync(filePath)) {
+      if (!fs9.existsSync(filePath)) {
         return asArray ? [] : "";
       }
-      let content = await fs7.promises.readFile(filePath, "utf8");
+      let content = await fs9.promises.readFile(filePath, "utf8");
       if (asArray) {
         let linesArray = content.split("\n").filter((line) => line.trim() !== "");
         if (lines !== null) {
@@ -2681,15 +2473,15 @@ var FileLogger = class _FileLogger extends EventEmitter {
     } = options;
     let lastSize = 0;
     let lastPosition = 0;
-    if (fs7.existsSync(filePath)) {
-      const stats = fs7.statSync(filePath);
+    if (fs9.existsSync(filePath)) {
+      const stats = fs9.statSync(filePath);
       lastSize = stats.size;
       lastPosition = fromEnd ? stats.size : 0;
     }
     const listener = async (curr, prev) => {
       try {
         if (curr.size > lastSize) {
-          const stream = fs7.createReadStream(filePath, {
+          const stream = fs9.createReadStream(filePath, {
             start: lastPosition,
             end: curr.size - 1,
             encoding: "utf8"
@@ -2717,7 +2509,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
         console.error("Error en watcher:", error);
       }
     };
-    fs7.watchFile(filePath, { persistent, interval }, listener);
+    fs9.watchFile(filePath, { persistent, interval }, listener);
     const watcherId = `${filePath}_${Date.now()}`;
     _FileLogger.watchers.set(watcherId, listener);
     return {
@@ -2725,7 +2517,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
       stop: () => {
         const storedListener = _FileLogger.watchers.get(watcherId);
         if (storedListener) {
-          fs7.unwatchFile(filePath, storedListener);
+          fs9.unwatchFile(filePath, storedListener);
           _FileLogger.watchers.delete(watcherId);
         }
       },
@@ -2738,7 +2530,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
   static stopAllWatchers() {
     for (const [watcherId] of _FileLogger.watchers) {
       const filePath = watcherId.split("_")[0];
-      fs7.unwatchFile(filePath);
+      fs9.unwatchFile(filePath);
     }
     _FileLogger.watchers.clear();
   }
@@ -2768,7 +2560,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
       if (lines.length > maxLines) {
         const keepLines = lines.slice(-maxLines);
         const content = keepLines.join("\n") + "\n";
-        await fs7.promises.writeFile(filePath, content, "utf8");
+        await fs9.promises.writeFile(filePath, content, "utf8");
         return lines.length - maxLines;
       }
       return 0;
@@ -2783,8 +2575,8 @@ var FileLogger = class _FileLogger extends EventEmitter {
    */
   static async deleteLogFile(filePath) {
     try {
-      if (fs7.existsSync(filePath)) {
-        await fs7.promises.unlink(filePath);
+      if (fs9.existsSync(filePath)) {
+        await fs9.promises.unlink(filePath);
         return true;
       }
       return false;
@@ -3199,6 +2991,7 @@ export {
   DaemonClient,
   DbConfig,
   Engine,
+  EnvLoader,
   FileLogger,
   QueryEngine,
   TableProcessor,