@dbcube/core 4.1.4 → 4.1.5

package/dist/index.cjs

@@ -183,6 +183,97 @@ var { https } = import_follow_redirects.default;
 var Downloader = class {
   static mainSpinner = null;
   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"
+  };
+  /**
+   * Fetch latest version from GitHub
+   */
+  static async fetchLatestVersion(prefix) {
+    const url = this.VERSION_URLS[prefix];
+    return new Promise((resolve5, reject) => {
+      https.get(url, (response) => {
+        let data = "";
+        response.on("data", (chunk) => {
+          data += chunk;
+        });
+        response.on("end", () => {
+          try {
+            const versions = JSON.parse(data);
+            if (versions && versions.length > 0) {
+              resolve5(versions[0].version);
+            } else {
+              reject(new Error("No versions found"));
+            }
+          } catch (error) {
+            reject(error);
+          }
+        });
+        response.on("error", reject);
+      }).on("error", reject);
+    });
+  }
+  /**
+   * Extract version from binary filename
+   * Example: schema-engine-v1.0.0-windows-x64.exe -> v1.0.0
+   */
+  static extractVersionFromFilename(filename) {
+    const match = filename.match(/-(v\d+\.\d+\.\d+)-/);
+    return match ? match[1] : null;
+  }
+  /**
+   * Get local version of installed binary
+   */
+  static getLocalVersion(binDir, prefix) {
+    try {
+      const files = fs.readdirSync(binDir);
+      const binaryPattern = new RegExp(`^${prefix}-engine-v`);
+      const binaryFile = files.find((f) => binaryPattern.test(f));
+      if (binaryFile) {
+        return this.extractVersionFromFilename(binaryFile);
+      }
+    } catch (error) {
+    }
+    return null;
+  }
+  /**
+   * Compare versions (returns true if remote is newer)
+   */
+  static isNewerVersion(localVersion, remoteVersion) {
+    if (!localVersion) return true;
+    const cleanLocal = localVersion.replace(/^v/, "");
+    const cleanRemote = remoteVersion.replace(/^v/, "");
+    const localParts = cleanLocal.split(".").map(Number);
+    const remoteParts = cleanRemote.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+      if (remoteParts[i] > localParts[i]) return true;
+      if (remoteParts[i] < localParts[i]) return false;
+    }
+    return false;
+  }
+  /**
+   * Delete old binary files
+   */
+  static deleteOldBinary(binDir, prefix) {
+    try {
+      const files = fs.readdirSync(binDir);
+      const binaryPattern = new RegExp(`^${prefix}-engine-`);
+      files.forEach((file) => {
+        if (binaryPattern.test(file)) {
+          const filePath = path.join(binDir, file);
+          try {
+            fs.unlinkSync(filePath);
+            console.log(`\u{1F5D1}\uFE0F  Deleted old binary: ${file}`);
+          } catch (err) {
+            console.warn(`\u26A0\uFE0F  Could not delete: ${file}`);
+          }
+        }
+      });
+    } catch (error) {
+    }
+  }
   static get(prefix) {
     const arch2 = new Arquitecture();
     const platform2 = arch2.getPlatform();
@@ -205,6 +296,7 @@ var Downloader = class {
       return {
         name: binaryName,
         url,
+        version: "latest",
         query_engine: binaryName,
         schema_engine: `${prefix}-engine-${plat}-${archSuffix}${platform2 === "windows" ? ".exe" : ""}`
       };
@@ -212,69 +304,125 @@ var Downloader = class {
     return {
       name: "",
       url: "",
+      version: "",
+      query_engine: "",
+      schema_engine: ""
+    };
+  }
+  /**
+   * Get binary info with actual version from GitHub
+   */
+  static async getWithVersion(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 version = await this.fetchLatestVersion(prefix);
+      const baseName = `${prefix}-engine-${version}-${plat}-${archSuffix}`;
+      const binaryName = platform2 === "windows" ? `${baseName}.exe` : baseName;
+      const url = `https://github.com/Dbcube/binaries/releases/download/${prefix}-engine/${prefix}-engine-${version}-${plat}-${archSuffix}.zip`;
+      return {
+        name: binaryName,
+        url,
+        version,
+        query_engine: binaryName,
+        schema_engine: binaryName
+      };
+    }
+    return {
+      name: "",
+      url: "",
+      version: "",
       query_engine: "",
       schema_engine: ""
     };
   }
   static async download(targetDir) {
-    const binaries = ["schema", "query", "sqlite"];
     const binDir = targetDir || this.getDefaultBinDir();
     fs.mkdirSync(binDir, { recursive: true });
     this.mainSpinner = (0, import_ora.default)({
-      text: import_chalk.default.blue("Descargando binarios necesarios..."),
+      text: import_chalk.default.blue("Verificando versiones de binarios..."),
       spinner: "dots12"
     }).start();
-    const binariesToDownload = [];
-    let existingCount = 0;
-    for (const prefix of binaries) {
-      const binaryInfo = this.get(prefix);
-      if (!binaryInfo.name || !binaryInfo.url) {
-        throw new Error(`Plataforma o arquitectura no soportada para ${prefix}`);
-      }
-      const finalBinaryPath = path.join(binDir, binaryInfo.name);
-      if (fs.existsSync(finalBinaryPath)) {
-        existingCount++;
-        continue;
+    const binariesToProcess = [];
+    for (const prefix of ["query", "schema", "sqlite"]) {
+      try {
+        const localVersion = this.getLocalVersion(binDir, prefix);
+        const remoteVersion = await this.fetchLatestVersion(prefix);
+        const needsUpdate = this.isNewerVersion(localVersion, remoteVersion);
+        binariesToProcess.push({
+          prefix,
+          needsUpdate,
+          localVersion,
+          remoteVersion
+        });
+        if (needsUpdate) {
+          console.log(`
+\u{1F4E6} ${prefix}-engine: ${localVersion || "not installed"} \u2192 ${remoteVersion}`);
+        } else if (localVersion) {
+          console.log(`
+\u2705 ${prefix}-engine: ${localVersion} (up to date)`);
+        }
+      } catch (error) {
+        console.warn(`\u26A0\uFE0F  Could not check version for ${prefix}-engine, will attempt download`);
+        binariesToProcess.push({
+          prefix,
+          needsUpdate: true,
+          localVersion: null,
+          remoteVersion: "latest"
+        });
       }
-      binariesToDownload.push({
-        prefix,
-        binaryInfo,
-        tempZipPath: path.join(os2.tmpdir(), `dbcube-${prefix}-${Date.now()}.zip`),
-        finalBinaryPath
-      });
     }
+    const binariesToDownload = binariesToProcess.filter((b) => b.needsUpdate);
     if (binariesToDownload.length === 0) {
-      this.mainSpinner.succeed(import_chalk.default.green("Todos los binarios ya est\xE1n descargados"));
+      this.mainSpinner.succeed(import_chalk.default.green("All binaries are up to date"));
       return;
     }
-    this.updateMainProgress("paralelo", existingCount, binaries.length, "downloading");
+    this.mainSpinner.text = import_chalk.default.blue(`Updating ${binariesToDownload.length} binary(ies)...`);
     try {
-      await Promise.all(binariesToDownload.map(async (binary, index) => {
+      await Promise.all(binariesToDownload.map(async (binary) => {
         const maxRetries = 3;
         let attempt = 0;
         while (attempt <= maxRetries) {
           try {
-            await this.downloadFileWithProgress(binary.binaryInfo.url, binary.tempZipPath, binary.prefix);
-            await this.extractBinary(binary.tempZipPath, binary.finalBinaryPath, binary.prefix);
-            const completed = existingCount + index + 1;
-            this.updateMainProgress(binary.prefix, completed, binaries.length, "completed");
+            const binaryInfo = await this.getWithVersion(binary.prefix);
+            if (!binaryInfo.name || !binaryInfo.url) {
+              throw new Error(`Platform or architecture not supported for ${binary.prefix}`);
+            }
+            const tempZipPath = path.join(os2.tmpdir(), `dbcube-${binary.prefix}-${Date.now()}.zip`);
+            const finalBinaryPath = path.join(binDir, binaryInfo.name);
+            this.deleteOldBinary(binDir, binary.prefix);
+            await this.downloadFileWithProgress(binaryInfo.url, tempZipPath, binary.prefix);
+            await this.extractBinary(tempZipPath, finalBinaryPath, binary.prefix);
+            console.log(`\u2705 ${binary.prefix}-engine updated to ${binary.remoteVersion}`);
             break;
           } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : "Error desconocido";
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
             if (attempt < maxRetries && (errorMessage.includes("ECONNRESET") || errorMessage.includes("timeout") || errorMessage.includes("ETIMEDOUT") || errorMessage.includes("ENOTFOUND"))) {
               attempt++;
-              this.updateMainProgress(binary.prefix, existingCount, binaries.length, "retrying", attempt);
+              console.log(`\u{1F504} Retrying ${binary.prefix}-engine (${attempt}/${maxRetries})...`);
               await new Promise((resolve5) => setTimeout(resolve5, 1e3 + Math.random() * 1e3));
             } else {
-              throw new Error(`Error descargando ${binary.prefix}: ${errorMessage}`);
+              throw new Error(`Error downloading ${binary.prefix}: ${errorMessage}`);
             }
           }
         }
       }));
-      this.mainSpinner.succeed(import_chalk.default.green("Binarios descargados correctamente"));
+      this.mainSpinner.succeed(import_chalk.default.green("Binaries updated successfully"));
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Error desconocido";
-      this.mainSpinner.fail(import_chalk.default.red(`Error en descarga paralela: ${errorMessage}`));
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.mainSpinner.fail(import_chalk.default.red(`Error updating binaries: ${errorMessage}`));
       throw error;
     }
   }
@@ -445,22 +593,13 @@ var import_meta2 = {};
 var Binary = class {
   static isDownloading = false;
   static downloadPromise = null;
+  static cachedBinaries = {};
   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();
@@ -503,58 +642,50 @@ var Binary = class {
     fs2.mkdirSync(tempDir, { recursive: true });
     return tempDir;
   }
+  static findVersionedBinary(binDir, prefix, platform2, arch2) {
+    const cacheKey = `${prefix}-${platform2}-${arch2}`;
+    if (this.cachedBinaries[cacheKey]) {
+      const cachedPath = path2.join(binDir, this.cachedBinaries[cacheKey]);
+      if (fs2.existsSync(cachedPath)) {
+        return cachedPath;
+      }
+    }
+    try {
+      const files = fs2.readdirSync(binDir);
+      const extension = platform2 === "windows" ? ".exe" : "";
+      const pattern = new RegExp(`^${prefix}-engine-v\\d+\\.\\d+\\.\\d+-${platform2}-${arch2}${extension.replace(".", "\\.")}$`);
+      const matchingFile = files.find((f) => pattern.test(f));
+      if (matchingFile) {
+        this.cachedBinaries[cacheKey] = matchingFile;
+        return path2.join(binDir, matchingFile);
+      }
+    } catch (error) {
+    }
+    const fallbackName = `${prefix}-engine-${platform2}-${arch2}${platform2 === "windows" ? ".exe" : ""}`;
+    return path2.join(binDir, fallbackName);
+  }
   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);
+    const platformMap = {
+      windows: "windows",
+      linux: "linux",
+      darwin: "macos"
     };
-    switch (platform2) {
-      case "windows":
-        if (architecture == "x86_64") {
-          return {
-            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;
+    const archMap = {
+      x86_64: "x64",
+      aarch64: "arm64"
+    };
+    const plat = platformMap[platform2];
+    const archSuffix = archMap[architecture];
+    if (plat && archSuffix) {
+      return {
+        query_engine: this.findVersionedBinary(binDir, "query", plat, archSuffix),
+        schema_engine: this.findVersionedBinary(binDir, "schema", plat, archSuffix)
+      };
     }
     return {
       query_engine: "",