appks/service/repo/git/repository.rs

use crate::error::AppError;
use crate::service::RepoService;
use crate::session::Session;

impl RepoService {
    pub async fn git_repo_info(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
    ) -> Result<crate::pb::repo::Repository, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_readable(user_uid, &repo).await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.repository;
        let resp = svc
            .get_repository(tonic::Request::new(crate::pb::repo::GetRepositoryRequest {
                repository: Some(header),
            }))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_repo_exists(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
    ) -> Result<bool, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_readable(user_uid, &repo).await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.repository;
        let resp = svc
            .repository_exists(tonic::Request::new(
                crate::pb::repo::RepositoryExistsRequest {
                    repository: Some(header),
                },
            ))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner().exists)
    }

    pub async fn git_repo_stats(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
    ) -> Result<crate::pb::repo::RepositoryStatistics, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_readable(user_uid, &repo).await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.repository;
        let resp = svc
            .get_repository_statistics(tonic::Request::new(
                crate::pb::repo::RepositoryStatisticsRequest {
                    repository: Some(header),
                },
            ))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_repo_health(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
    ) -> Result<crate::pb::repo::RepositoryHealthResponse, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_role_at_least(user_uid, &repo, crate::models::common::Role::Admin)
            .await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.repository;
        let resp = svc
            .check_repository_health(tonic::Request::new(
                crate::pb::repo::RepositoryHealthRequest {
                    repository: Some(header),
                    connectivity_only: false,
                },
            ))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_garbage_collect(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
    ) -> Result<crate::pb::repo::RepositoryMaintenanceResponse, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_role_at_least(user_uid, &repo, crate::models::common::Role::Admin)
            .await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.repository;
        let resp = svc
            .garbage_collect(tonic::Request::new(
                crate::pb::repo::GarbageCollectRequest {
                    repository: Some(header),
                    prune: true,
                    aggressive: false,
                },
            ))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_set_default_branch(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        branch_name: &str,
    ) -> Result<(), AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_role_at_least(user_uid, &repo, crate::models::common::Role::Admin)
            .await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.repository;
        svc.set_default_branch(tonic::Request::new(
            crate::pb::repo::SetDefaultBranchRequest {
                repository: Some(header),
                name: branch_name.to_string(),
            },
        ))
        .await
        .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(())
    }
}