@dbcube/core 1.0.28 → 1.0.30

package/dist/index.js

@@ -136,7 +136,11 @@ import * as path from "path";
 import * as os2 from "os";
 import { https } from "follow-redirects";
 import * as unzipper from "unzipper";
+import ora from "ora";
+import chalk from "chalk";
 var Downloader = class {
+  static mainSpinner = null;
+  static currentSpinner = null;
   static get(prefix) {
     const arch2 = new Arquitecture();
     const platform2 = arch2.getPlatform();
@@ -174,12 +178,16 @@ var Downloader = class {
     const binaries = ["schema", "query", "sqlite"];
     const binDir = targetDir || this.getDefaultBinDir();
     fs.mkdirSync(binDir, { recursive: true });
-    for (const prefix of binaries) {
+    this.mainSpinner = ora({
+      text: chalk.blue("Descargando binarios necesarios..."),
+      spinner: "dots12"
+    }).start();
+    for (let i = 0; i < binaries.length; i++) {
+      const prefix = binaries[i];
       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");
@@ -187,35 +195,65 @@ var Downloader = class {
           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`);
+            this.updateMainProgress(prefix, i + 1, binaries.length, "exists");
             break;
           }
-          await this.downloadFile(binaryInfo.url, tempZipPath, prefix);
+          this.updateMainProgress(prefix, i + 1, binaries.length, "downloading");
+          await this.downloadFileWithProgress(binaryInfo.url, tempZipPath, prefix);
+          this.updateMainProgress(prefix, i + 1, binaries.length, "extracting");
           await this.extractBinary(tempZipPath, finalBinaryPath, prefix);
-          console.log(`\u2705 ${prefix} descargado correctamente`);
+          this.updateMainProgress(prefix, i + 1, binaries.length, "completed");
           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));
+            this.updateMainProgress(prefix, i + 1, binaries.length, "retrying", attempt);
+            await new Promise((resolve5) => setTimeout(resolve5, 2e3));
           } else {
-            console.error(`\u274C Error final descargando ${prefix}:`, errorMessage);
+            this.mainSpinner.fail(chalk.red(`Error descargando ${prefix}: ${errorMessage}`));
             throw error;
           }
         }
       }
     }
-  }
-  static downloadFile(url, outputPath, prefix) {
+    this.mainSpinner.succeed(chalk.green("Binarios descargados correctamente"));
+  }
+  static updateMainProgress(binary, current, total, status, attempt) {
+    const progressBar = this.createProgressBar(current, total);
+    const statusEmojis = {
+      downloading: "\u{1F4E5}",
+      extracting: "\u{1F4E6}",
+      completed: "\u2705",
+      exists: "\u2705",
+      retrying: "\u{1F504}"
+    };
+    const statusMessages = {
+      downloading: chalk.blue("descargando"),
+      extracting: chalk.yellow("extrayendo"),
+      completed: chalk.green("completado"),
+      exists: chalk.gray("existe"),
+      retrying: chalk.orange(`reintentando (${attempt}/${3})`)
+    };
+    const emoji = statusEmojis[status] || "\u{1F4E5}";
+    const message = statusMessages[status] || status;
+    this.mainSpinner.text = `${progressBar} ${emoji} ${chalk.bold(binary)} - ${message}`;
+  }
+  static createProgressBar(current, total, width = 20) {
+    const filled = Math.round(current / total * width);
+    const empty = width - filled;
+    const filledBar = chalk.green("\u2588".repeat(filled));
+    const emptyBar = chalk.gray("\u2591".repeat(empty));
+    const percentage = chalk.bold(`${current}/${total}`);
+    return `[${filledBar}${emptyBar}] ${percentage}`;
+  }
+  static downloadFileWithProgress(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);
+            return this.downloadFileWithProgress(redirectUrl, outputPath, prefix).then(resolve5).catch(reject);
           }
         }
         if (response.statusCode !== 200) {
@@ -225,21 +263,20 @@ var Downloader = class {
         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}%`);
+            const progress = {
+              downloaded: downloadedBytes,
+              total: totalBytes,
+              percentage: downloadedBytes / totalBytes * 100
+            };
+            this.updateDownloadProgress(prefix, progress);
           }
         });
         response.on("end", () => {
           file.end();
-          console.log(`
-\u2705 Descarga de ${prefix} completada`);
           resolve5();
         });
         response.on("error", (err) => {
@@ -260,6 +297,17 @@ var Downloader = class {
       });
     });
   }
+  static updateDownloadProgress(binary, progress) {
+    const percentage = progress.percentage.toFixed(1);
+    const downloaded = (progress.downloaded / 1024 / 1024).toFixed(1);
+    const total = (progress.total / 1024 / 1024).toFixed(1);
+    const barWidth = 15;
+    const filled = Math.round(progress.percentage / 100 * barWidth);
+    const empty = barWidth - filled;
+    const progressBar = chalk.green("\u2588".repeat(filled)) + chalk.gray("\u2591".repeat(empty));
+    const progressText = `[${progressBar}] ${percentage}% (${downloaded}/${total}MB)`;
+    this.mainSpinner.text = `\u{1F4E5} ${chalk.bold(binary)} - ${progressText}`;
+  }
   static extractBinary(zipPath, outputPath, prefix) {
     return new Promise((resolve5, reject) => {
       let extracted = false;
@@ -273,7 +321,6 @@ var Downloader = class {
               fs.chmodSync(outputPath, 493);
             }
             this.cleanupFile(zipPath);
-            console.log(`\u{1F4C1} ${prefix} extra\xEDdo correctamente`);
             resolve5();
           });
           writeStream.on("error", (err) => {
@@ -361,11 +408,9 @@ var Binary = class {
     }
   }
   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");