@dbcube/core 1.0.24 → 1.0.28

package/dist/index.js

@@ -6,7 +6,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/lib/Engine.ts
-import path from "path";
+import path3 from "path";
 
 // src/lib/Arquitecture.ts
 import * as os from "os";
@@ -130,18 +130,314 @@ var Arquitecture = class {
   }
 };
 
+// src/lib/Donwloader.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os2 from "os";
+import { https } from "follow-redirects";
+import * as unzipper from "unzipper";
+var Downloader = class {
+  static get(prefix) {
+    const arch2 = new Arquitecture();
+    const platform2 = arch2.getPlatform();
+    const architecture = arch2.getArchitecture();
+    const platformMap = {
+      windows: "windows",
+      linux: "linux",
+      darwin: "macos"
+    };
+    const archMap = {
+      x86_64: "x64",
+      aarch64: "arm64"
+    };
+    const plat = platformMap[platform2];
+    const archSuffix = archMap[architecture];
+    if (plat && archSuffix) {
+      const baseName = `${prefix}-engine-${plat}-${archSuffix}`;
+      const binaryName = platform2 === "windows" ? `${baseName}.exe` : baseName;
+      const url = `https://github.com/Dbcube/binaries/releases/download/${prefix}-engine/${prefix}-engine-latest-${plat}-${archSuffix}.zip`;
+      return {
+        name: binaryName,
+        url,
+        query_engine: binaryName,
+        schema_engine: `${prefix}-engine-${plat}-${archSuffix}${platform2 === "windows" ? ".exe" : ""}`
+      };
+    }
+    return {
+      name: "",
+      url: "",
+      query_engine: "",
+      schema_engine: ""
+    };
+  }
+  static async download(targetDir) {
+    const binaries = ["schema", "query", "sqlite"];
+    const binDir = targetDir || this.getDefaultBinDir();
+    fs.mkdirSync(binDir, { recursive: true });
+    for (const prefix of binaries) {
+      const maxRetries = 3;
+      let attempt = 0;
+      while (attempt <= maxRetries) {
+        try {
+          console.log(`\u{1F4E5} Descargando ${prefix} (intento ${attempt + 1}/${maxRetries + 1})...`);
+          const binaryInfo = this.get(prefix);
+          if (!binaryInfo.name || !binaryInfo.url) {
+            throw new Error("Plataforma o arquitectura no soportada");
+          }
+          const tempZipPath = path.join(os2.tmpdir(), `dbcube-${prefix}-${Date.now()}.zip`);
+          const finalBinaryPath = path.join(binDir, binaryInfo.name);
+          if (fs.existsSync(finalBinaryPath)) {
+            console.log(`\u2705 ${prefix} ya existe, omitiendo`);
+            break;
+          }
+          await this.downloadFile(binaryInfo.url, tempZipPath, prefix);
+          await this.extractBinary(tempZipPath, finalBinaryPath, prefix);
+          console.log(`\u2705 ${prefix} descargado correctamente`);
+          break;
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Error desconocido";
+          if (attempt < maxRetries && (errorMessage.includes("ECONNRESET") || errorMessage.includes("timeout") || errorMessage.includes("ETIMEDOUT") || errorMessage.includes("ENOTFOUND"))) {
+            console.warn(`\u26A0\uFE0F  Error de red para ${prefix}: ${errorMessage}`);
+            console.log(`\u{1F504} Reintentando en 3 segundos...`);
+            attempt++;
+            await new Promise((resolve5) => setTimeout(resolve5, 3e3));
+          } else {
+            console.error(`\u274C Error final descargando ${prefix}:`, errorMessage);
+            throw error;
+          }
+        }
+      }
+    }
+  }
+  static downloadFile(url, outputPath, prefix) {
+    return new Promise((resolve5, reject) => {
+      const request = https.get(url, { timeout: 6e4 }, (response) => {
+        if (response.statusCode === 302 || response.statusCode === 301) {
+          const redirectUrl = response.headers.location;
+          if (redirectUrl) {
+            return this.downloadFile(redirectUrl, outputPath, prefix).then(resolve5).catch(reject);
+          }
+        }
+        if (response.statusCode !== 200) {
+          reject(new Error(`HTTP ${response.statusCode} para ${prefix}`));
+          return;
+        }
+        const file = fs.createWriteStream(outputPath);
+        const totalBytes = parseInt(response.headers["content-length"] || "0", 10);
+        let downloadedBytes = 0;
+        if (totalBytes > 0) {
+          console.log(`\u{1F4E6} Descargando ${(totalBytes / 1024 / 1024).toFixed(1)}MB...`);
+        }
+        response.on("data", (chunk) => {
+          downloadedBytes += chunk.length;
+          file.write(chunk);
+          if (totalBytes > 0) {
+            const progress = (downloadedBytes / totalBytes * 100).toFixed(1);
+            process.stdout.write(`\r\u23F3 Progreso: ${progress}%`);
+          }
+        });
+        response.on("end", () => {
+          file.end();
+          console.log(`
+\u2705 Descarga de ${prefix} completada`);
+          resolve5();
+        });
+        response.on("error", (err) => {
+          file.close();
+          this.cleanupFile(outputPath);
+          reject(err);
+        });
+        file.on("error", (err) => {
+          file.close();
+          this.cleanupFile(outputPath);
+          reject(err);
+        });
+      });
+      request.on("error", reject);
+      request.on("timeout", () => {
+        request.destroy();
+        reject(new Error(`Timeout descargando ${prefix}`));
+      });
+    });
+  }
+  static extractBinary(zipPath, outputPath, prefix) {
+    return new Promise((resolve5, reject) => {
+      let extracted = false;
+      fs.createReadStream(zipPath).pipe(unzipper.Parse()).on("entry", (entry) => {
+        if (entry.type === "File" && !extracted) {
+          extracted = true;
+          const writeStream = fs.createWriteStream(outputPath);
+          entry.pipe(writeStream);
+          writeStream.on("finish", () => {
+            if (process.platform !== "win32") {
+              fs.chmodSync(outputPath, 493);
+            }
+            this.cleanupFile(zipPath);
+            console.log(`\u{1F4C1} ${prefix} extra\xEDdo correctamente`);
+            resolve5();
+          });
+          writeStream.on("error", (err) => {
+            this.cleanupFile(zipPath);
+            reject(err);
+          });
+        } else {
+          entry.autodrain();
+        }
+      }).on("error", (err) => {
+        this.cleanupFile(zipPath);
+        reject(err);
+      }).on("close", () => {
+        if (!extracted) {
+          this.cleanupFile(zipPath);
+          reject(new Error(`No se encontr\xF3 archivo v\xE1lido en el ZIP para ${prefix}`));
+        }
+      });
+    });
+  }
+  static cleanupFile(filePath) {
+    try {
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+    } catch {
+    }
+  }
+  static getDefaultBinDir() {
+    const possibleDirs = [
+      path.resolve(process.cwd(), "bin"),
+      path.resolve(process.cwd(), "node_modules", ".dbcube", "bin"),
+      path.resolve(__dirname, "..", "bin")
+    ];
+    for (const dir of possibleDirs) {
+      try {
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+        const testFile = path.join(dir, ".test");
+        fs.writeFileSync(testFile, "test");
+        fs.unlinkSync(testFile);
+        return dir;
+      } catch {
+        continue;
+      }
+    }
+    const tempDir = path.join(os2.tmpdir(), "dbcube-bin");
+    fs.mkdirSync(tempDir, { recursive: true });
+    return tempDir;
+  }
+};
+
 // src/lib/Binary.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
 var Binary = class {
-  static get() {
+  static isDownloading = false;
+  static downloadPromise = null;
+  static async ensureBinariesExist() {
+    if (this.isDownloading && this.downloadPromise) {
+      await this.downloadPromise;
+      return;
+    }
+    const binDir = this.getBinDir();
+    const binaries = ["schema", "query", "sqlite"];
+    const allExist = binaries.every((prefix) => {
+      const binaryInfo = Downloader.get(prefix);
+      if (!binaryInfo.name) return false;
+      const binaryPath = path2.join(binDir, binaryInfo.name);
+      return fs2.existsSync(binaryPath);
+    });
+    if (allExist) {
+      return;
+    }
+    if (!this.isDownloading) {
+      this.isDownloading = true;
+      this.downloadPromise = this.downloadBinaries();
+      try {
+        await this.downloadPromise;
+      } finally {
+        this.isDownloading = false;
+        this.downloadPromise = null;
+      }
+    }
+  }
+  static async downloadBinaries() {
+    console.log("\u{1F680} DBCube: Descargando binarios necesarios...");
+    try {
+      const binDir = this.getBinDir();
+      await Downloader.download(binDir);
+      console.log("\u2705 DBCube: Binarios descargados correctamente");
+    } catch (error) {
+      console.warn("\u26A0\uFE0F DBCube: Error descargando binarios:", error.message);
+      console.log("\u{1F527} Los binarios se intentar\xE1n descargar en la pr\xF3xima ejecuci\xF3n");
+    }
+  }
+  static getBinDir() {
+    const possibleDirs = [
+      path2.resolve(process.cwd(), "bin"),
+      path2.resolve(process.cwd(), "node_modules", ".dbcube", "bin"),
+      path2.resolve(__dirname, "..", "bin")
+    ];
+    for (const dir of possibleDirs) {
+      try {
+        if (!fs2.existsSync(dir)) {
+          fs2.mkdirSync(dir, { recursive: true });
+        }
+        return dir;
+      } catch {
+        continue;
+      }
+    }
+    return process.cwd();
+  }
+  static async get() {
+    await this.ensureBinariesExist();
     const arch2 = new Arquitecture();
     const platform2 = arch2.getPlatform();
     const architecture = arch2.getArchitecture();
+    const binDir = this.getBinDir();
+    const getFullPath = (binaryName) => {
+      return path2.join(binDir, binaryName);
+    };
     switch (platform2) {
       case "windows":
         if (architecture == "x86_64") {
           return {
-            query_engine: "query-engine-windows-x64.exe",
-            schema_engine: "schema-engine-windows-x64.exe"
+            query_engine: getFullPath("query-engine-windows-x64.exe"),
+            schema_engine: getFullPath("schema-engine-windows-x64.exe")
+          };
+        }
+        if (architecture == "aarch64") {
+          return {
+            query_engine: getFullPath("query-engine-windows-arm64.exe"),
+            schema_engine: getFullPath("schema-engine-windows-arm64.exe")
+          };
+        }
+        break;
+      case "linux":
+        if (architecture == "x86_64") {
+          return {
+            query_engine: getFullPath("query-engine-linux-x64"),
+            schema_engine: getFullPath("schema-engine-linux-x64")
+          };
+        }
+        if (architecture == "aarch64") {
+          return {
+            query_engine: getFullPath("query-engine-linux-arm64"),
+            schema_engine: getFullPath("schema-engine-linux-arm64")
+          };
+        }
+        break;
+      case "macos":
+        if (architecture == "x86_64") {
+          return {
+            query_engine: getFullPath("query-engine-macos-x64"),
+            schema_engine: getFullPath("schema-engine-macos-x64")
+          };
+        }
+        if (architecture == "aarch64") {
+          return {
+            query_engine: getFullPath("query-engine-macos-arm64"),
+            schema_engine: getFullPath("schema-engine-macos-arm64")
           };
         }
         break;
@@ -198,19 +494,19 @@ var Engine = class {
   name;
   config;
   arguments;
-  binary;
+  binary = null;
   timeout;
   constructor(name, timeout = 3e4) {
     this.name = name;
     this.config = this.setConfig(name);
-    const binary = Binary.get();
-    this.binary = {
-      query_engine: path.resolve(__dirname, "../bin", binary.query_engine),
-      schema_engine: path.resolve(__dirname, "../bin", binary.schema_engine)
-    };
     this.arguments = this.setArguments();
     this.timeout = timeout;
   }
+  async initializeBinary() {
+    if (!this.binary) {
+      this.binary = await Binary.get();
+    }
+  }
   setArguments() {
     let args = [];
     if (this.config.type == "sqlite") {
@@ -248,7 +544,7 @@ var Engine = class {
   }
   setConfig(name) {
     const configInstance = new Config();
-    const configFilePath = path.resolve(process.cwd(), "dbcube.config.js");
+    const configFilePath = path3.resolve(process.cwd(), "dbcube.config.js");
     const configFn = __require(configFilePath);
     if (typeof configFn === "function") {
       configFn(configInstance);
@@ -261,7 +557,11 @@ var Engine = class {
     return this.config;
   }
   async run(binary, args) {
-    return new Promise((resolve3, reject) => {
+    await this.initializeBinary();
+    if (!this.binary) {
+      throw new Error("Binary not initialized");
+    }
+    return new Promise((resolve5, reject) => {
       const child = spawn(this.binary[binary], [...this.arguments, ...args]);
       let stdoutBuffer = "";
       let stderrBuffer = "";
@@ -277,7 +577,7 @@ var Engine = class {
         if (!isResolved) {
           isResolved = true;
           clearTimeout(timeoutId);
-          resolve3(response);
+          resolve5(response);
         }
       };
       child.stdout.on("data", (data) => {
@@ -347,7 +647,7 @@ var Engine = class {
 
 // src/lib/SqliteExecutor.ts
 import { exec } from "child_process";
-import * as path2 from "path";
+import * as path4 from "path";
 import { promisify } from "util";
 var execAsync = promisify(exec);
 var SqliteExecutor = class {
@@ -358,11 +658,11 @@ var SqliteExecutor = class {
     this.binaryPath = this.getBinaryPath();
   }
   getBinaryPath() {
-    const binDir = path2.resolve(__dirname, "..", "bin");
+    const binDir = path4.resolve(__dirname, "..", "bin");
     const platform2 = process.platform;
     const extension = platform2 === "win32" ? ".exe" : "";
     const binaryName = `sqlite-engine${extension}`;
-    return path2.join(binDir, binaryName);
+    return path4.join(binDir, binaryName);
   }
   async executeBinary(args) {
     const command = `"${this.binaryPath}" ${args.map((arg) => `"${arg}"`).join(" ")}`;
@@ -504,9 +804,9 @@ var SqliteExecutor = class {
 };
 
 // src/lib/DbConfig.ts
-import * as path3 from "path";
-import fs from "fs";
-var rootPath = path3.resolve(process.cwd(), ".dbcube");
+import * as path5 from "path";
+import fs3 from "fs";
+var rootPath = path5.resolve(process.cwd(), ".dbcube");
 var SQLite = class {
   executor = null;
   database;
@@ -516,11 +816,11 @@ var SQLite = class {
   async ifExist() {
     if (this.database) {
       const dbPath = this.database || ":memory:";
-      const configPath = path3.join(rootPath, dbPath + ".db");
-      if (!fs.existsSync(rootPath)) {
-        fs.mkdirSync(rootPath, { recursive: true });
+      const configPath = path5.join(rootPath, dbPath + ".db");
+      if (!fs3.existsSync(rootPath)) {
+        fs3.mkdirSync(rootPath, { recursive: true });
       }
-      if (fs.existsSync(configPath)) {
+      if (fs3.existsSync(configPath)) {
         return true;
       }
       if (!this.executor) {
@@ -531,13 +831,13 @@ var SQLite = class {
     return false;
   }
   async connect() {
-    return new Promise(async (resolve3, reject) => {
+    return new Promise(async (resolve5, reject) => {
       try {
         if (!this.executor) {
           const dbPath = this.database || ":memory:";
-          const configPath = path3.join(rootPath, dbPath + ".db");
-          if (!fs.existsSync(rootPath)) {
-            fs.mkdirSync(rootPath, { recursive: true });
+          const configPath = path5.join(rootPath, dbPath + ".db");
+          if (!fs3.existsSync(rootPath)) {
+            fs3.mkdirSync(rootPath, { recursive: true });
           }
           this.executor = new SqliteExecutor(configPath);
           const connected = await this.executor.connect();
@@ -545,22 +845,22 @@ var SQLite = class {
             throw new Error("Failed to connect to SQLite database");
           }
         }
-        resolve3(this.executor);
+        resolve5(this.executor);
       } catch (error) {
         reject(error);
       }
     });
   }
   async disconnect() {
-    return new Promise((resolve3) => {
+    return new Promise((resolve5) => {
       if (this.executor) {
         this.executor = null;
       }
-      resolve3();
+      resolve5();
     });
   }
   async query(sqlQuery) {
-    return new Promise(async (resolve3) => {
+    return new Promise(async (resolve5) => {
       try {
         if (typeof sqlQuery !== "string") {
           throw new Error("The SQL query must be a string.");
@@ -573,20 +873,20 @@ var SQLite = class {
         }
         const result = await this.executor.queryMultiple(sqlQuery);
         if (result.status === "error") {
-          resolve3({
+          resolve5({
             status: "error",
             message: result.message,
             data: null
           });
         } else {
-          resolve3({
+          resolve5({
             status: "success",
             message: "Query executed successfully",
             data: result.data
           });
         }
       } catch (error) {
-        resolve3({
+        resolve5({
           status: "error",
           message: error.message || "An error occurred while executing the query.",
           data: null
@@ -595,7 +895,7 @@ var SQLite = class {
     });
   }
   async queryWithParameters(sqlQuery, params = []) {
-    return new Promise(async (resolve3) => {
+    return new Promise(async (resolve5) => {
       try {
         if (typeof sqlQuery !== "string") {
           throw new Error("The SQL query must be a string.");
@@ -611,13 +911,13 @@ var SQLite = class {
         }
         const result = await this.executor.query(sqlQuery, params);
         if (result.status === "error") {
-          resolve3({
+          resolve5({
             status: "error",
             message: result.message,
             data: null
           });
         } else {
-          resolve3({
+          resolve5({
             status: "success",
             message: "Query executed successfully",
             data: result.data
@@ -625,7 +925,7 @@ var SQLite = class {
         }
       } catch (error) {
         console.log(error);
-        resolve3({
+        resolve5({
           status: "error",
           message: error.message || "An error occurred while executing the query.",
           data: null
@@ -719,8 +1019,8 @@ var DbConfig = new SQLite({ DATABASE: "config" });
 var DbConfig_default = DbConfig;
 
 // src/lib/FileLogger.ts
-import * as fs2 from "fs";
-import * as path4 from "path";
+import * as fs4 from "fs";
+import * as path6 from "path";
 import { EventEmitter } from "events";
 var FileLogger = class _FileLogger extends EventEmitter {
   static watchers = /* @__PURE__ */ new Map();
@@ -735,9 +1035,9 @@ var FileLogger = class _FileLogger extends EventEmitter {
    */
   static async write(filePath, message, level = "INFO", append = true) {
     try {
-      const dir = path4.dirname(filePath);
-      if (!fs2.existsSync(dir)) {
-        fs2.mkdirSync(dir, { recursive: true });
+      const dir = path6.dirname(filePath);
+      if (!fs4.existsSync(dir)) {
+        fs4.mkdirSync(dir, { recursive: true });
       }
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       const formattedMessage = `[${timestamp}] [${level}] ${message}
@@ -747,9 +1047,9 @@ var FileLogger = class _FileLogger extends EventEmitter {
         return true;
       }
       if (append) {
-        await fs2.promises.appendFile(filePath, formattedMessage, "utf8");
+        await fs4.promises.appendFile(filePath, formattedMessage, "utf8");
       } else {
-        await fs2.promises.writeFile(filePath, formattedMessage, "utf8");
+        await fs4.promises.writeFile(filePath, formattedMessage, "utf8");
       }
       return true;
     } catch (error) {
@@ -774,12 +1074,12 @@ var FileLogger = class _FileLogger extends EventEmitter {
     const buffer = _FileLogger.buffers.get(filePath);
     if (buffer && buffer.length > 0) {
       try {
-        const dir = path4.dirname(filePath);
-        if (!fs2.existsSync(dir)) {
-          fs2.mkdirSync(dir, { recursive: true });
+        const dir = path6.dirname(filePath);
+        if (!fs4.existsSync(dir)) {
+          fs4.mkdirSync(dir, { recursive: true });
         }
         const content = buffer.join("");
-        await fs2.promises.appendFile(filePath, content, "utf8");
+        await fs4.promises.appendFile(filePath, content, "utf8");
         _FileLogger.buffers.delete(filePath);
         return true;
       } catch (error) {
@@ -915,10 +1215,10 @@ var FileLogger = class _FileLogger extends EventEmitter {
       // Si debe retornar como array de líneas
     } = options;
     try {
-      if (!fs2.existsSync(filePath)) {
+      if (!fs4.existsSync(filePath)) {
         return asArray ? [] : "";
       }
-      let content = await fs2.promises.readFile(filePath, "utf8");
+      let content = await fs4.promises.readFile(filePath, "utf8");
       if (asArray) {
         let linesArray = content.split("\n").filter((line) => line.trim() !== "");
         if (lines !== null) {
@@ -961,15 +1261,15 @@ var FileLogger = class _FileLogger extends EventEmitter {
     } = options;
     let lastSize = 0;
     let lastPosition = 0;
-    if (fs2.existsSync(filePath)) {
-      const stats = fs2.statSync(filePath);
+    if (fs4.existsSync(filePath)) {
+      const stats = fs4.statSync(filePath);
       lastSize = stats.size;
       lastPosition = fromEnd ? stats.size : 0;
     }
     const listener = async (curr, prev) => {
       try {
         if (curr.size > lastSize) {
-          const stream = fs2.createReadStream(filePath, {
+          const stream = fs4.createReadStream(filePath, {
             start: lastPosition,
             end: curr.size - 1,
             encoding: "utf8"
@@ -997,7 +1297,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
         console.error("Error en watcher:", error);
       }
     };
-    fs2.watchFile(filePath, { persistent, interval }, listener);
+    fs4.watchFile(filePath, { persistent, interval }, listener);
     const watcherId = `${filePath}_${Date.now()}`;
     _FileLogger.watchers.set(watcherId, listener);
     return {
@@ -1005,7 +1305,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
       stop: () => {
         const storedListener = _FileLogger.watchers.get(watcherId);
         if (storedListener) {
-          fs2.unwatchFile(filePath, storedListener);
+          fs4.unwatchFile(filePath, storedListener);
           _FileLogger.watchers.delete(watcherId);
         }
       },
@@ -1018,7 +1318,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
   static stopAllWatchers() {
     for (const [watcherId] of _FileLogger.watchers) {
       const filePath = watcherId.split("_")[0];
-      fs2.unwatchFile(filePath);
+      fs4.unwatchFile(filePath);
     }
     _FileLogger.watchers.clear();
   }
@@ -1048,7 +1348,7 @@ var FileLogger = class _FileLogger extends EventEmitter {
       if (lines.length > maxLines) {
         const keepLines = lines.slice(-maxLines);
         const content = keepLines.join("\n") + "\n";
-        await fs2.promises.writeFile(filePath, content, "utf8");
+        await fs4.promises.writeFile(filePath, content, "utf8");
         return lines.length - maxLines;
       }
       return 0;
@@ -1063,8 +1363,8 @@ var FileLogger = class _FileLogger extends EventEmitter {
    */
   static async deleteLogFile(filePath) {
     try {
-      if (fs2.existsSync(filePath)) {
-        await fs2.promises.unlink(filePath);
+      if (fs4.existsSync(filePath)) {
+        await fs4.promises.unlink(filePath);
         return true;
       }
       return false;