@dbcube/core 1.0.34 → 1.0.36

package/dist/index.d.mts

@@ -74,7 +74,6 @@ declare class Binary {
     static ensureBinariesExist(): Promise<void>;
     private static downloadBinaries;
     private static getBinDir;
-    private static ensureGitIgnore;
     static get(): Promise<BinaryType>;
 }
 

package/dist/index.d.ts

@@ -74,7 +74,6 @@ declare class Binary {
     static ensureBinariesExist(): Promise<void>;
     private static downloadBinaries;
     private static getBinDir;
-    private static ensureGitIgnore;
     static get(): Promise<BinaryType>;
 }
 

package/dist/index.js

@@ -428,9 +428,6 @@ var Binary = class {
         if (!fs2.existsSync(dir)) {
           fs2.mkdirSync(dir, { recursive: true });
         }
-        if (dir.includes(path2.resolve(process.cwd(), ".dbcube"))) {
-          this.ensureGitIgnore(path2.resolve(process.cwd(), ".dbcube"));
-        }
         return dir;
       } catch {
         continue;
@@ -440,21 +437,6 @@ var Binary = class {
     fs2.mkdirSync(tempDir, { recursive: true });
     return tempDir;
   }
-  static ensureGitIgnore(dbcubeDir) {
-    try {
-      const gitignorePath = path2.join(dbcubeDir, ".gitignore");
-      if (!fs2.existsSync(gitignorePath)) {
-        const gitignoreContent = `# DBCube binaries
-bin/
-*.exe
-*.log
-*.tmp
-`;
-        fs2.writeFileSync(gitignorePath, gitignoreContent);
-      }
-    } catch {
-    }
-  }
   static async get() {
     await this.ensureBinariesExist();
     const arch2 = new Arquitecture();
@@ -714,24 +696,40 @@ var Engine = class {
 // src/lib/SqliteExecutor.ts
 import { exec } from "child_process";
 import * as path4 from "path";
+import * as fs3 from "fs";
 import { promisify } from "util";
 var execAsync = promisify(exec);
 var SqliteExecutor = class {
-  binaryPath;
+  binaryPath = null;
   dbPath;
   constructor(dbPath) {
     this.dbPath = dbPath;
-    this.binaryPath = this.getBinaryPath();
   }
-  getBinaryPath() {
-    const binDir = path4.resolve(__dirname, "..", "bin");
-    const platform2 = process.platform;
-    const extension = platform2 === "win32" ? ".exe" : "";
-    const binaryName = `sqlite-engine${extension}`;
-    return path4.join(binDir, binaryName);
+  async getBinaryPath() {
+    if (!this.binaryPath) {
+      await Binary.ensureBinariesExist();
+      const possibleDirs = [
+        path4.resolve(process.cwd(), ".dbcube", "bin"),
+        path4.resolve(process.cwd(), "node_modules", ".dbcube", "bin"),
+        path4.resolve(__dirname, "..", "bin")
+      ];
+      let binDir = "";
+      for (const dir of possibleDirs) {
+        if (fs3.existsSync(dir)) {
+          binDir = dir;
+          break;
+        }
+      }
+      const platform2 = process.platform;
+      const extension = platform2 === "win32" ? ".exe" : "";
+      const binaryName = `sqlite-engine-${platform2 === "win32" ? "windows" : platform2 === "darwin" ? "macos" : "linux"}-x64${extension}`;
+      this.binaryPath = path4.join(binDir, binaryName);
+    }
+    return this.binaryPath;
   }
   async executeBinary(args) {
-    const command = `"${this.binaryPath}" ${args.map((arg) => `"${arg}"`).join(" ")}`;
+    const binaryPath = await this.getBinaryPath();
+    const command = `"${binaryPath}" ${args.map((arg) => `"${arg}"`).join(" ")}`;
     try {
       const { stdout, stderr } = await execAsync(command, {
         maxBuffer: 10 * 1024 * 1024,
@@ -871,7 +869,7 @@ var SqliteExecutor = class {
 
 // src/lib/DbConfig.ts
 import * as path5 from "path";
-import fs3 from "fs";
+import fs4 from "fs";
 var rootPath = path5.resolve(process.cwd(), ".dbcube");
 var SQLite = class {
   executor = null;
@@ -883,10 +881,10 @@ var SQLite = class {
     if (this.database) {
       const dbPath = this.database || ":memory:";
       const configPath = path5.join(rootPath, dbPath + ".db");
-      if (!fs3.existsSync(rootPath)) {
-        fs3.mkdirSync(rootPath, { recursive: true });
+      if (!fs4.existsSync(rootPath)) {
+        fs4.mkdirSync(rootPath, { recursive: true });
       }
-      if (fs3.existsSync(configPath)) {
+      if (fs4.existsSync(configPath)) {
         return true;
       }
       if (!this.executor) {
@@ -902,8 +900,8 @@ var SQLite = class {
         if (!this.executor) {
           const dbPath = this.database || ":memory:";
           const configPath = path5.join(rootPath, dbPath + ".db");
-          if (!fs3.existsSync(rootPath)) {
-            fs3.mkdirSync(rootPath, { recursive: true });
+          if (!fs4.existsSync(rootPath)) {
+            fs4.mkdirSync(rootPath, { recursive: true });
           }
           this.executor = new SqliteExecutor(configPath);
           const connected = await this.executor.connect();
@@ -1085,7 +1083,7 @@ var DbConfig = new SQLite({ DATABASE: "config" });
 var DbConfig_default = DbConfig;
 
 // src/lib/FileLogger.ts
-import * as fs4 from "fs";
+import * as fs5 from "fs";
 import * as path6 from "path";
 import { EventEmitter } from "events";
 var FileLogger = class _FileLogger extends EventEmitter {
@@ -1102,8 +1100,8 @@ var FileLogger = class _FileLogger extends EventEmitter {
   static async write(filePath, message, level = "INFO", append = true) {
     try {
       const dir = path6.dirname(filePath);
-      if (!fs4.existsSync(dir)) {
-        fs4.mkdirSync(dir, { recursive: true });
+      if (!fs5.existsSync(dir)) {
+        fs5.mkdirSync(dir, { recursive: true });
       }
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       const formattedMessage = `[${timestamp}] [${level}] ${message}
@@ -1113,9 +1111,9 @@ var FileLogger = class _FileLogger extends EventEmitter {
         return true;
       }
       if (append) {
-        await fs4.promises.appendFile(filePath, formattedMessage, "utf8");
+        await fs5.promises.appendFile(filePath, formattedMessage, "utf8");
       } else {
-        await fs4.promises.writeFile(filePath, formattedMessage, "utf8");
+        await fs5.promises.writeFile(filePath, formattedMessage, "utf8");
       }
       return true;
     } catch (error) {
@@ -1141,11 +1139,11 @@ var FileLogger = class _FileLogger extends EventEmitter {
     if (buffer && buffer.length > 0) {
       try {
         const dir = path6.dirname(filePath);
-        if (!fs4.existsSync(dir)) {
-          fs4.mkdirSync(dir, { recursive: true });
+        if (!fs5.existsSync(dir)) {
+          fs5.mkdirSync(dir, { recursive: true });
         }
         const content = buffer.join("");
-        await fs4.promises.appendFile(filePath, content, "utf8");
+        await fs5.promises.appendFile(filePath, content, "utf8");
         _FileLogger.buffers.delete(filePath);
         return true;
       } catch (error) {
@@ -1281,10 +1279,10 @@ var FileLogger = class _FileLogger extends EventEmitter {
       // Si debe retornar como array de líneas
     } = options;
     try {
-      if (!fs4.existsSync(filePath)) {
+      if (!fs5.existsSync(filePath)) {
         return asArray ? [] : "";
       }
-      let content = await fs4.promises.readFile(filePath, "utf8");
+      let content = await fs5.promises.readFile(filePath, "utf8");
       if (asArray) {
         let linesArray = content.split("\n").filter((line) => line.trim() !== "");
         if (lines !== null) {
@@ -1327,15 +1325,15 @@ var FileLogger = class _FileLogger extends EventEmitter {
     } = options;
     let lastSize = 0;
     let lastPosition = 0;
-    if (fs4.existsSync(filePath)) {
-      const stats = fs4.statSync(filePath);
+    if (fs5.existsSync(filePath)) {
+      const stats = fs5.statSync(filePath);
       lastSize = stats.size;
       lastPosition = fromEnd ? stats.size : 0;
     }
     const listener = async (curr, prev) => {
       try {
         if (curr.size > lastSize) {
-          const stream = fs4.createReadStream(filePath, {
+          const stream = fs5.createReadStream(filePath, {
             start: lastPosition,
             end: curr.size - 1,
             encoding: "utf8"
@@ -1363,7 +1361,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
         console.error("Error en watcher:", error);
       }
     };
-    fs4.watchFile(filePath, { persistent, interval }, listener);
+    fs5.watchFile(filePath, { persistent, interval }, listener);
     const watcherId = `${filePath}_${Date.now()}`;
     _FileLogger.watchers.set(watcherId, listener);
     return {
@@ -1371,7 +1369,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
       stop: () => {
         const storedListener = _FileLogger.watchers.get(watcherId);
         if (storedListener) {
-          fs4.unwatchFile(filePath, storedListener);
+          fs5.unwatchFile(filePath, storedListener);
           _FileLogger.watchers.delete(watcherId);
         }
       },
@@ -1384,7 +1382,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
   static stopAllWatchers() {
     for (const [watcherId] of _FileLogger.watchers) {
       const filePath = watcherId.split("_")[0];
-      fs4.unwatchFile(filePath);
+      fs5.unwatchFile(filePath);
     }
     _FileLogger.watchers.clear();
   }
@@ -1414,7 +1412,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
       if (lines.length > maxLines) {
         const keepLines = lines.slice(-maxLines);
         const content = keepLines.join("\n") + "\n";
-        await fs4.promises.writeFile(filePath, content, "utf8");
+        await fs5.promises.writeFile(filePath, content, "utf8");
         return lines.length - maxLines;
       }
       return 0;
@@ -1429,8 +1427,8 @@ var FileLogger = class _FileLogger extends EventEmitter {
    */
   static async deleteLogFile(filePath) {
     try {
-      if (fs4.existsSync(filePath)) {
-        await fs4.promises.unlink(filePath);
+      if (fs5.existsSync(filePath)) {
+        await fs5.promises.unlink(filePath);
         return true;
       }
       return false;