fetch directly using tag api if tag is provided

Author: QaidVoid

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "soar-dl"
-version = "0.3.5"
+version = "0.4.0"
 authors = ["Rabindra Dhakal <[email protected]>"]
 description = "A fast download manager"
 license = "MIT"
@@ -25,6 +25,7 @@ indicatif = { version = "0.17.9", optional = true }
 regex = { version = "1.11.1", default-features = false, features = ["std", "unicode-case", "unicode-perl"] }
 reqwest = { version = "0.12.9", default-features = false, features = ["rustls-tls", "stream", "http2", "blocking", "json"] }
 serde = { version = "1.0.215", features = ["derive"] }
+serde_json = "1.0.139"
 tokio = { version = "1.41.1", features = ["macros", "rt-multi-thread"] }
 url = "2.5.4"
 

Cargo.toml

@@ -80,7 +80,7 @@ impl DownloadManager {
         };
 
         let options = self.create_platform_options(tag.map(String::from));
-        let releases = handler.fetch_releases::<R>(project).await?;
+        let releases = handler.fetch_releases::<R>(project, tag).await?;
         let assets = handler.filter_releases(&releases, &options).await?;
 
         let selected_asset = self.select_asset(&assets)?;

src/bin/soar-dl/download_manager.rs

@@ -25,9 +25,16 @@ impl ReleasePlatform for Github {
         }
     }
 
-    fn format_api_path(project: &str) -> Result<String, PlatformError> {
+    fn format_api_path(project: &str, tag: Option<&str>) -> Result<String, PlatformError> {
         let (owner, repo) = Self::format_project_path(project)?;
-        Ok(format!("/repos/{}/{}/releases?per_page=100", owner, repo))
+        if let Some(tag) = tag {
+            Ok(format!(
+                "/repos/{}/{}/releases/tags/{}?per_page=100",
+                owner, repo, tag
+            ))
+        } else {
+            Ok(format!("/repos/{}/{}/releases?per_page=100", owner, repo))
+        }
     }
 }
 

src/github.rs

@@ -24,11 +24,14 @@ impl ReleasePlatform for Gitlab {
         }
     }
 
-    fn format_api_path(project: &str) -> Result<String, PlatformError> {
-        if project.chars().all(|c| c.is_numeric()) {
-            Ok(format!("/api/v4/projects/{}/releases", project))
+    fn format_api_path(project: &str, tag: Option<&str>) -> Result<String, PlatformError> {
+        let encoded_path = project.replace('/', "%2F");
+        if let Some(tag) = tag {
+            Ok(format!(
+                "/api/v4/projects/{}/releases/{}",
+                encoded_path, tag
+            ))
         } else {
-            let encoded_path = project.replace('/', "%2F");
             Ok(format!("/api/v4/projects/{}/releases", encoded_path))
         }
     }

src/gitlab.rs

@@ -6,6 +6,7 @@ use std::{
 use regex::Regex;
 use reqwest::header::{HeaderMap, AUTHORIZATION, USER_AGENT};
 use serde::Deserialize;
+use serde_json::Value;
 use url::Url;
 
 use crate::{
@@ -89,7 +90,7 @@ pub trait ReleasePlatform {
     const TOKEN_ENV_VAR: &'static str;
 
     fn format_project_path(project: &str) -> Result<(String, String), PlatformError>;
-    fn format_api_path(project: &str) -> Result<String, PlatformError>;
+    fn format_api_path(project: &str, tag: Option<&str>) -> Result<String, PlatformError>;
 }
 
 pub trait ReleaseAsset {
@@ -137,13 +138,14 @@ impl<P: ReleasePlatform> ReleaseHandler<P> {
         &self,
         api_type: &ApiType,
         project: &str,
+        tag: Option<&str>,
     ) -> Result<reqwest::Response, PlatformError> {
         let base_url = match api_type {
             ApiType::PkgForge => P::API_BASE_PKGFORGE,
             ApiType::Primary => P::API_BASE_PRIMARY,
         };
 
-        let api_path = P::format_api_path(project)?;
+        let api_path = P::format_api_path(project, tag)?;
         let url = format!("{}{}", base_url, api_path);
 
         let mut headers = HeaderMap::new();
@@ -164,15 +166,19 @@ impl<P: ReleasePlatform> ReleaseHandler<P> {
             .map_err(|err| DownloadError::NetworkError { source: err })?)
     }
 
-    pub async fn fetch_releases<R>(&self, project: &str) -> Result<Vec<R>, PlatformError>
+    pub async fn fetch_releases<R>(
+        &self,
+        project: &str,
+        tag: Option<&str>,
+    ) -> Result<Vec<R>, PlatformError>
     where
         R: for<'de> Deserialize<'de>,
     {
-        let response = match self.call_api(&ApiType::PkgForge, project).await {
+        let response = match self.call_api(&ApiType::PkgForge, project, tag).await {
             Ok(resp) => {
                 let status = resp.status();
                 if should_fallback(status) {
-                    self.call_api(&ApiType::Primary, project).await?
+                    self.call_api(&ApiType::Primary, project, tag).await?
                 } else {
                     resp
                 }
@@ -188,10 +194,22 @@ impl<P: ReleasePlatform> ReleaseHandler<P> {
             .into());
         }
 
-        response
+        let value: Value = response
             .json()
             .await
-            .map_err(|_| PlatformError::InvalidResponse)
+            .map_err(|_| PlatformError::InvalidResponse)?;
+
+        match value {
+            Value::Array(_) => {
+                serde_json::from_value(value).map_err(|_| PlatformError::InvalidResponse)
+            }
+            Value::Object(_) => {
+                let single: R =
+                    serde_json::from_value(value).map_err(|_| PlatformError::InvalidResponse)?;
+                Ok(vec![single])
+            }
+            _ => Err(PlatformError::InvalidResponse),
+        }
     }
 
     pub async fn filter_releases<R, A>(