upstream_rs/providers/github/

github_adapter.rs

use anyhow::Result;
use chrono::{DateTime, Utc};
use std::path::Path;

use crate::models::common::Version;
use crate::models::provider::{Asset, Release, RepositorySearchFilters, RepositorySearchResult};
use crate::providers::release_provider::ReleaseProvider;

use super::github_client::GithubClient;
use super::github_dtos::{GithubAssetDto, GithubReleaseDto, GithubRepositorySearchItemDto};

#[derive(Debug, Clone)]
pub struct GithubAdapter {
    client: GithubClient,
}

impl GithubAdapter {
    pub fn new(client: GithubClient) -> Self {
        Self { client }
    }

    pub async fn download_asset<F>(
        &self,
        asset: &Asset,
        destination_path: &Path,
        dl_callback: &mut Option<F>,
    ) -> Result<()>
    where
        F: FnMut(u64, u64),
    {
        self.client
            .download_file(&asset.download_url, destination_path, dl_callback)
            .await
    }

    pub async fn get_release_by_tag(&self, slug: &str, tag: &str) -> Result<Release> {
        let dto = self.client.get_release_by_tag(slug, tag).await?;
        Ok(self.convert_release(dto))
    }

    pub async fn get_latest_release(&self, slug: &str) -> Result<Release> {
        let dto = self.client.get_latest_release(slug).await?;
        Ok(self.convert_release(dto))
    }

    pub async fn get_releases(
        &self,
        slug: &str,
        per_page: Option<u32>,
        max_total: Option<u32>,
    ) -> Result<Vec<Release>> {
        let dtos = self.client.get_releases(slug, per_page, max_total).await?;
        Ok(dtos
            .into_iter()
            .map(|dto| self.convert_release(dto))
            .collect())
    }

    pub async fn get_releases_newer_than(
        &self,
        slug: &str,
        from_version: &Version,
        per_page: Option<u32>,
    ) -> Result<Vec<Release>> {
        let per_page = per_page.unwrap_or(30);
        let mut page = 1;
        let mut releases = Vec::new();

        loop {
            let batch = self.client.get_releases_page(slug, per_page, page).await?;
            if batch.is_empty() {
                break;
            }

            let partial_page = batch.len() < per_page as usize;
            let mut reached_from_version = false;
            for dto in batch {
                let parsed_version = Version::from_tag(&dto.tag_name).ok();
                let release = self.convert_release(dto);
                if parsed_version
                    .as_ref()
                    .is_some_and(|version| version <= from_version)
                {
                    reached_from_version = true;
                    continue;
                }
                releases.push(release);
            }

            if reached_from_version || partial_page {
                break;
            }

            page += 1;
        }

        Ok(releases)
    }

    pub async fn get_branch_head_sha(&self, slug: &str, branch: &str) -> Result<String> {
        self.client.get_branch_head_sha(slug, branch).await
    }

    pub async fn search_repositories(
        &self,
        query: &str,
        limit: Option<u32>,
        filters: &RepositorySearchFilters,
    ) -> Result<Vec<RepositorySearchResult>> {
        let dto = self
            .client
            .search_repositories(query, limit, filters)
            .await?;
        Ok(dto
            .items
            .into_iter()
            .map(Self::convert_search_result)
            .collect())
    }

    fn convert_asset(dto: GithubAssetDto) -> Asset {
        let created_at = Self::parse_timestamp(&dto.created_at);
        Asset::new(
            dto.browser_download_url,
            dto.id as u64,
            dto.name,
            dto.size as u64,
            created_at,
        )
    }

    fn convert_release(&self, dto: GithubReleaseDto) -> Release {
        let assets: Vec<Asset> = dto.assets.into_iter().map(Self::convert_asset).collect();
        let version =
            Version::from_tag(&dto.tag_name).unwrap_or_else(|_| Version::new(0, 0, 0, false));
        Release {
            id: dto.id as u64,
            tag: dto.tag_name,
            name: dto.name,
            body: dto.body,
            is_draft: dto.draft,
            is_prerelease: dto.prerelease,
            published_at: Self::parse_timestamp(&dto.published_at),
            assets,
            version,
        }
    }

    fn convert_search_result(dto: GithubRepositorySearchItemDto) -> RepositorySearchResult {
        RepositorySearchResult {
            repo_slug: dto.full_name,
            display_name: dto.name,
            description: dto.description,
            stars: dto.stargazers_count,
            language: dto.language,
            updated_at: Self::parse_timestamp(&dto.updated_at),
        }
    }

    fn parse_timestamp(raw: &str) -> DateTime<Utc> {
        if raw.trim().is_empty() {
            return DateTime::<Utc>::MIN_UTC;
        }
        raw.parse::<DateTime<Utc>>()
            .unwrap_or(DateTime::<Utc>::MIN_UTC)
    }
}

#[async_trait::async_trait(?Send)]
impl ReleaseProvider for GithubAdapter {
    async fn get_latest_release(&self, slug: &str) -> Result<Release> {
        GithubAdapter::get_latest_release(self, slug).await
    }

    async fn get_releases(
        &self,
        slug: &str,
        per_page: Option<u32>,
        max_total: Option<u32>,
    ) -> Result<Vec<Release>> {
        GithubAdapter::get_releases(self, slug, per_page, max_total).await
    }

    async fn get_releases_newer_than(
        &self,
        slug: &str,
        from_version: &Version,
        per_page: Option<u32>,
    ) -> Result<Vec<Release>> {
        GithubAdapter::get_releases_newer_than(self, slug, from_version, per_page).await
    }

    async fn get_release_by_tag(&self, slug: &str, tag: &str) -> Result<Release> {
        GithubAdapter::get_release_by_tag(self, slug, tag).await
    }

    async fn get_branch_head_sha(&self, slug: &str, branch: &str) -> Result<String> {
        GithubAdapter::get_branch_head_sha(self, slug, branch).await
    }

    async fn search_repositories(
        &self,
        query: &str,
        limit: Option<u32>,
        filters: &RepositorySearchFilters,
    ) -> Result<Vec<RepositorySearchResult>> {
        GithubAdapter::search_repositories(self, query, limit, filters).await
    }

    async fn download_asset(
        &self,
        asset: &Asset,
        destination_path: &Path,
        dl_callback: Option<&mut (dyn FnMut(u64, u64) + '_)>,
    ) -> Result<()> {
        let mut forwarded = dl_callback;
        GithubAdapter::download_asset(self, asset, destination_path, &mut forwarded).await
    }
}

#[cfg(test)]
mod tests {
    use super::GithubAdapter;
    use crate::providers::github::github_client::GithubClient;
    use crate::providers::github::github_dtos::{
        GithubAssetDto, GithubReleaseDto, GithubRepositorySearchItemDto,
    };

    #[test]
    fn parse_timestamp_returns_min_for_invalid_or_empty_values() {
        assert_eq!(
            GithubAdapter::parse_timestamp(""),
            chrono::DateTime::<chrono::Utc>::MIN_UTC
        );
        assert_eq!(
            GithubAdapter::parse_timestamp("not-a-date"),
            chrono::DateTime::<chrono::Utc>::MIN_UTC
        );
    }

    #[test]
    fn convert_release_maps_assets_and_version() {
        let adapter =
            GithubAdapter::new(GithubClient::new(None, Default::default()).expect("github client"));
        let dto = GithubReleaseDto {
            id: 12,
            tag_name: "v2.3.4".to_string(),
            name: "Release 2.3.4".to_string(),
            body: "notes".to_string(),
            prerelease: true,
            draft: false,
            published_at: "2026-02-21T00:00:00Z".to_string(),
            assets: vec![GithubAssetDto {
                id: 9,
                name: "tool-linux-x86_64.tar.gz".to_string(),
                browser_download_url: "https://example.invalid/tool-linux-x86_64.tar.gz"
                    .to_string(),
                size: 123,
                content_type: "application/gzip".to_string(),
                created_at: "2026-02-20T00:00:00Z".to_string(),
            }],
        };

        let release = adapter.convert_release(dto);
        assert_eq!(release.id, 12);
        assert_eq!(release.version.to_string(), "2.3.4");
        assert!(release.is_prerelease);
        assert_eq!(release.assets.len(), 1);
        assert_eq!(release.assets[0].id, 9);
    }

    #[test]
    fn convert_search_result_maps_fields() {
        let dto = GithubRepositorySearchItemDto {
            full_name: "BurntSushi/ripgrep".to_string(),
            name: "ripgrep".to_string(),
            description: "fast grep".to_string(),
            stargazers_count: 123,
            language: "Rust".to_string(),
            updated_at: "2026-05-09T00:00:00Z".to_string(),
            archived: false,
            fork: false,
        };

        let result = GithubAdapter::convert_search_result(dto);
        assert_eq!(result.repo_slug, "BurntSushi/ripgrep");
        assert_eq!(result.display_name, "ripgrep");
        assert_eq!(result.description, "fast grep");
        assert_eq!(result.stars, 123);
        assert_eq!(result.language, "Rust");
    }

    #[test]
    fn convert_search_result_invalid_timestamp_uses_min() {
        let dto = GithubRepositorySearchItemDto {
            full_name: "owner/repo".to_string(),
            name: "repo".to_string(),
            description: String::new(),
            stargazers_count: 0,
            language: String::new(),
            updated_at: "nope".to_string(),
            archived: false,
            fork: false,
        };

        let result = GithubAdapter::convert_search_result(dto);
        assert_eq!(result.updated_at, chrono::DateTime::<chrono::Utc>::MIN_UTC);
    }
}