Merge pull request #435 from Mng-dev-ai/feat/github-service

Extract GitHubService from route handlers

Author: Mng-dev-ai

backend/app/api/endpoints/github.py

@@ -1,10 +1,8 @@
-import logging
-from typing import Any
+from typing import NoReturn
 
-import httpx
-from fastapi import APIRouter, Depends, HTTPException, Query, status
+from fastapi import APIRouter, Depends, HTTPException, Query
 
-from app.core.deps import require_github_token
+from app.core.deps import get_github_service
 from app.core.security import get_current_user
 from app.models.db_models.user import User
 from app.models.schemas.github import (
@@ -13,40 +11,16 @@
     GitHubCollaborator,
     GitHubPRCommentsResponse,
     GitHubPRListResponse,
-    GitHubPullRequest,
-    GitHubRepo,
     GitHubReposResponse,
-    GitHubReviewComment,
 )
+from app.services.exceptions import GitHubException
+from app.services.github import GitHubService
 
 router = APIRouter()
-logger = logging.getLogger(__name__)
 
-GITHUB_API_BASE = "https://api.github.com"
 
-
-def _github_headers(token: str) -> dict[str, str]:
-    return {
-        "Authorization": f"Bearer {token}",
-        "Accept": "application/vnd.github+json",
-        "X-GitHub-Api-Version": "2022-11-28",
-    }
-
-
-def _check_github_response(response: httpx.Response) -> None:
-    if response.status_code == 401:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="GitHub token is invalid or expired",
-        )
-    if response.status_code != 200:
-        logger.warning(
-            "GitHub API returned %d: %s", response.status_code, response.text[:200]
-        )
-        raise HTTPException(
-            status_code=status.HTTP_502_BAD_GATEWAY,
-            detail="GitHub API request failed",
-        )
+def _raise_from_github(exc: GitHubException) -> NoReturn:
+    raise HTTPException(status_code=exc.status_code, detail=exc.message) from exc
 
 
 @router.get("/repositories", response_model=GitHubReposResponse)
@@ -55,110 +29,25 @@ async def list_repositories(
     page: int = Query(default=1, ge=1),
     per_page: int = Query(default=20, ge=1, le=100),
     _current_user: User = Depends(get_current_user),
-    github_token: str = Depends(require_github_token),
+    github: GitHubService = Depends(get_github_service),
 ) -> GitHubReposResponse:
-    headers = _github_headers(github_token)
-
-    async with httpx.AsyncClient(timeout=10.0) as client:
-        if q.strip():
-            response = await client.get(
-                f"{GITHUB_API_BASE}/search/repositories",
-                params={
-                    "q": q.strip(),
-                    "sort": "updated",
-                    "order": "desc",
-                    "per_page": per_page,
-                    "page": page,
-                },
-                headers=headers,
-            )
-        else:
-            response = await client.get(
-                f"{GITHUB_API_BASE}/user/repos",
-                params={
-                    "sort": "pushed",
-                    "direction": "desc",
-                    "per_page": per_page,
-                    "page": page,
-                    "affiliation": "owner,collaborator,organization_member",
-                },
-                headers=headers,
-            )
-
-    _check_github_response(response)
-
-    data = response.json()
-    raw_repos = data.get("items", data) if isinstance(data, dict) else data
-
-    repos = [
-        GitHubRepo(
-            name=r["name"],
-            full_name=r["full_name"],
-            description=r.get("description"),
-            language=r.get("language"),
-            html_url=r["html_url"],
-            clone_url=r["clone_url"],
-            private=r.get("private", False),
-            pushed_at=r.get("pushed_at"),
-            stargazers_count=r.get("stargazers_count", 0),
-        )
-        for r in raw_repos
-    ]
-
-    return GitHubReposResponse(items=repos, has_more=len(raw_repos) == per_page)
+    try:
+        return await github.list_repositories(q, page, per_page)
+    except GitHubException as exc:
+        _raise_from_github(exc)
 
 
 @router.get("/pulls", response_model=GitHubPRListResponse)
 async def list_pull_requests(
     owner: str = Query(..., min_length=1),
     repo: str = Query(..., min_length=1),
     _current_user: User = Depends(get_current_user),
-    github_token: str = Depends(require_github_token),
+    github: GitHubService = Depends(get_github_service),
 ) -> GitHubPRListResponse:
-    headers = _github_headers(github_token)
-
-    async with httpx.AsyncClient(timeout=10.0) as client:
-        response = await client.get(
-            f"{GITHUB_API_BASE}/repos/{owner}/{repo}/pulls",
-            params={
-                "state": "open",
-                "per_page": 30,
-                "sort": "updated",
-                "direction": "desc",
-            },
-            headers=headers,
-        )
-
-    _check_github_response(response)
-
-    raw_prs = response.json()
-    prs = [
-        GitHubPullRequest(
-            number=pr["number"],
-            title=pr["title"],
-            body=pr.get("body"),
-            state=pr["state"],
-            html_url=pr["html_url"],
-            head={
-                "ref": pr["head"]["ref"],
-                "repo": {
-                    "full_name": pr["head"]["repo"]["full_name"]
-                    if pr["head"].get("repo")
-                    else ""
-                },
-            },
-            base={"ref": pr["base"]["ref"]},
-            user={
-                "login": pr["user"]["login"],
-                "avatar_url": pr["user"].get("avatar_url", ""),
-            },
-            draft=pr.get("draft", False),
-            review_comments=pr.get("review_comments", 0),
-        )
-        for pr in raw_prs
-    ]
-
-    return GitHubPRListResponse(items=prs)
+    try:
+        return await github.list_pull_requests(owner, repo)
+    except GitHubException as exc:
+        _raise_from_github(exc)
 
 
 @router.get(
@@ -170,152 +59,34 @@ async def get_pr_comments(
     repo: str,
     number: int,
     _current_user: User = Depends(get_current_user),
-    github_token: str = Depends(require_github_token),
+    github: GitHubService = Depends(get_github_service),
 ) -> GitHubPRCommentsResponse:
-    headers = _github_headers(github_token)
-    url = f"{GITHUB_API_BASE}/repos/{owner}/{repo}/pulls/{number}/comments"
-    raw_comments: list[dict[str, Any]] = []
-
-    async with httpx.AsyncClient(timeout=10.0) as client:
-        page = 1
-        while page <= 10:
-            response = await client.get(
-                url,
-                params={"per_page": 100, "page": page},
-                headers=headers,
-            )
-            _check_github_response(response)
-            batch = response.json()
-            raw_comments.extend(batch)
-            if len(batch) < 100:
-                break
-            page += 1
-
-    comments = [
-        GitHubReviewComment(
-            id=c["id"],
-            body=c["body"],
-            path=c.get("path"),
-            line=c.get("line") or c.get("original_line"),
-            user={
-                "login": c["user"]["login"],
-                "avatar_url": c["user"].get("avatar_url", ""),
-            },
-            created_at=c["created_at"],
-        )
-        for c in raw_comments
-    ]
-
-    return GitHubPRCommentsResponse(comments=comments)
+    try:
+        return await github.get_pr_comments(owner, repo, number)
+    except GitHubException as exc:
+        _raise_from_github(exc)
 
 
 @router.post("/pulls", response_model=CreatePullRequestResponse)
 async def create_pull_request(
     request: CreatePullRequestRequest,
     _current_user: User = Depends(get_current_user),
-    github_token: str = Depends(require_github_token),
+    github: GitHubService = Depends(get_github_service),
 ) -> CreatePullRequestResponse:
-    headers = _github_headers(github_token)
-
-    async with httpx.AsyncClient(timeout=15.0) as client:
-        response = await client.post(
-            f"{GITHUB_API_BASE}/repos/{request.owner}/{request.repo}/pulls",
-            json={
-                "title": request.title,
-                "body": request.body,
-                "head": request.head,
-                "base": request.base,
-            },
-            headers=headers,
-        )
-
-        if response.status_code == 401:
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="GitHub token is invalid or expired",
-            )
-        if response.status_code not in (200, 201):
-            logger.warning(
-                "GitHub API returned %d: %s",
-                response.status_code,
-                response.text[:200],
-            )
-            try:
-                detail = response.json().get("message", "Failed to create pull request")
-            except (ValueError, KeyError):
-                detail = "Failed to create pull request"
-            raise HTTPException(
-                status_code=status.HTTP_502_BAD_GATEWAY,
-                detail=detail,
-            )
-
-        pr_data = response.json()
-
-        reviewer_warning = None
-        if request.reviewers:
-            try:
-                reviewer_resp = await client.post(
-                    f"{GITHUB_API_BASE}/repos/{request.owner}/{request.repo}/pulls/{pr_data['number']}/requested_reviewers",
-                    json={"reviewers": request.reviewers},
-                    headers=headers,
-                )
-                if reviewer_resp.status_code not in (200, 201):
-                    reviewer_warning = "Failed to assign reviewers"
-                    logger.warning(
-                        "Failed to assign reviewers to PR #%d: %s",
-                        pr_data["number"],
-                        reviewer_resp.text[:200],
-                    )
-            except httpx.HTTPError:
-                reviewer_warning = "Failed to assign reviewers"
-                logger.warning(
-                    "Failed to assign reviewers to PR #%d", pr_data["number"]
-                )
-
-    return CreatePullRequestResponse(
-        number=pr_data["number"],
-        html_url=pr_data["html_url"],
-        title=pr_data["title"],
-        reviewer_warning=reviewer_warning,
-    )
+    try:
+        return await github.create_pull_request(request)
+    except GitHubException as exc:
+        _raise_from_github(exc)
 
 
 @router.get("/collaborators")
 async def list_collaborators(
     owner: str = Query(..., min_length=1),
     repo: str = Query(..., min_length=1),
     _current_user: User = Depends(get_current_user),
-    github_token: str = Depends(require_github_token),
+    github: GitHubService = Depends(get_github_service),
 ) -> list[GitHubCollaborator]:
-    headers = _github_headers(github_token)
-
-    async with httpx.AsyncClient(timeout=10.0) as client:
-        response = await client.get(
-            f"{GITHUB_API_BASE}/repos/{owner}/{repo}/collaborators",
-            params={"per_page": 50},
-            headers=headers,
-        )
-
-    if response.status_code == 401:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="GitHub token is invalid or expired",
-        )
-    # 403/404 are expected when user lacks push access to the repo
-    if response.status_code in (403, 404):
-        return []
-    if response.status_code != 200:
-        logger.warning(
-            "GitHub collaborators API returned %d: %s",
-            response.status_code,
-            response.text[:200],
-        )
-        raise HTTPException(
-            status_code=status.HTTP_502_BAD_GATEWAY,
-            detail="Failed to load collaborators",
-        )
-
-    return [
-        GitHubCollaborator(login=c["login"], avatar_url=c.get("avatar_url", ""))
-        for c in response.json()
-    ]
+    try:
+        return await github.list_collaborators(owner, repo)
+    except GitHubException as exc:
+        _raise_from_github(exc)

backend/app/core/deps.py

@@ -14,6 +14,7 @@
 from app.services.chat import ChatService
 from app.services.command import CommandService
 from app.services.exceptions import UserException
+from app.services.github import GitHubService
 from app.services.marketplace import MarketplaceService
 from app.services.plugin_installer import PluginInstallerService
 from app.services.provider import ProviderService
@@ -79,6 +80,12 @@ async def require_github_token(
     return github_token
 
 
+def get_github_service(
+    github_token: str = Depends(require_github_token),
+) -> GitHubService:
+    return GitHubService(token=github_token)
+
+
 def get_marketplace_service() -> MarketplaceService:
     return MarketplaceService()
 

backend/app/services/exceptions.py

@@ -23,6 +23,8 @@ class ErrorCode(str, Enum):
     WORKSPACE_NOT_FOUND = "WORKSPACE_NOT_FOUND"
     VALIDATION_ERROR = "VALIDATION_ERROR"
     RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED"
+    GITHUB_TOKEN_INVALID = "GITHUB_TOKEN_INVALID"
+    GITHUB_API_FAILED = "GITHUB_API_FAILED"
 
 
 class ServiceException(Exception):
@@ -172,6 +174,17 @@ def __init__(
         super().__init__(message, error_code, details, status_code)
 
 
+class GitHubException(ServiceException):
+    def __init__(
+        self,
+        message: str,
+        error_code: ErrorCode = ErrorCode.GITHUB_API_FAILED,
+        details: dict[str, str] | None = None,
+        status_code: int = 502,
+    ):
+        super().__init__(message, error_code, details, status_code)
+
+
 class WorkspaceException(ServiceException):
     def __init__(
         self,