diff --git a/web/app/clients/forgejo.py b/web/app/clients/forgejo.py index 901974d..961e7ef 100644 --- a/web/app/clients/forgejo.py +++ b/web/app/clients/forgejo.py @@ -1,7 +1,9 @@ from __future__ import annotations +from dataclasses import dataclass from datetime import datetime from typing import Any, Literal +from urllib.parse import quote import httpx from fastapi import HTTPException, status @@ -11,6 +13,8 @@ from app.models.app_settings import AppSettings class Repo(BaseModel): + """A repository returned by Forgejo.""" + repo_name: str = Field(validation_alias="name") repo_full_name: str = Field(validation_alias="full_name") repo_owner: str = Field(validation_alias=AliasPath("owner", "username")) @@ -31,6 +35,13 @@ class Repo(BaseModel): return "private" if value else "public" +@dataclass(frozen=True) +class RepoPage: + repos: list[Repo] + total_count: int | None + has_next_page: bool + + class Commit(BaseModel): """A commit, normalized across Forgejo's two payload shapes. @@ -56,6 +67,8 @@ class Commit(BaseModel): class Branch(BaseModel): + """A branch returned by Forgejo.""" + name: str protected: bool commit: Commit @@ -67,7 +80,8 @@ async def get_repos( *, limit: int = 30, page: int = 1, -) -> list[Repo]: + owner: str | None = None, +) -> RepoPage: """Get the user's repositories from the Forgejo API. Forgejo paginates this endpoint and caps `limit` at the instance's @@ -80,18 +94,46 @@ async def get_repos( access_token: The Forgejo API token. limit: The maximum number of repositories to return. page: The page number to return. + owner: Restrict results to repositories owned by this username. Returns: - A list of repositories. + The repositories and Forgejo's total-count pagination metadata. """ - - repos = await get( - app_settings, - f"/api/v1/user/repos?limit={limit}&page={page}", - access_token, + params: dict[str, str | int] = {"limit": limit, "page": page} + endpoint = f"/users/{quote(owner, safe='')}/repos" if owner else "/user/repos" + path = f"/api/v1{endpoint}?{httpx.QueryParams(params)}" + try: + async with httpx.AsyncClient( + base_url=app_settings.forgejo_base_url, timeout=30.0 + ) as client: + response = await client.get( + path, headers={"Authorization": f"token {access_token}"} + ) + except httpx.RequestError: + raise HTTPException( + status_code=status.HTTP_502_BAD_GATEWAY, + detail="Cannot reach Forgejo. Check your connection settings.", + ) + if response.status_code in {401, 403}: + raise HTTPException( + status_code=status.HTTP_502_BAD_GATEWAY, + detail="Forgejo rejected your access token. Check its permissions or replace it in settings.", + ) + if response.status_code != 200: + raise HTTPException( + status_code=status.HTTP_502_BAD_GATEWAY, + detail=f"Forgejo could not load repositories ({response.status_code}). Try again later.", + ) + repos = [Repo.model_validate(repo) for repo in response.json()] + total_count_header = response.headers.get("x-total-count") + try: + total_count = int(total_count_header) if total_count_header else None + except ValueError: + total_count = None + return RepoPage( + repos=repos, + total_count=total_count, + has_next_page="next" in response.links, ) - if not repos: - return [] - return [Repo.model_validate(r) for r in repos] async def get_branches( diff --git a/web/app/main.py b/web/app/main.py index 5b91c78..3e09745 100644 --- a/web/app/main.py +++ b/web/app/main.py @@ -19,7 +19,7 @@ from app.database import Base from app.middleware import SetupRequiredMiddleware from app.models.app_settings import AppSettings from app.models.session import Session as UserBrowserSession -from app.routers import auth, links, settings, setup +from app.routers import auth, links, repositories, settings, setup from app.settings import get_settings from app.templating import templates @@ -88,6 +88,7 @@ app.mount( # Routers app.include_router(auth.router) app.include_router(links.router) +app.include_router(repositories.router) app.include_router(settings.router) app.include_router(setup.router) diff --git a/web/app/routers/links.py b/web/app/routers/links.py index 2f55f77..d33c38a 100644 --- a/web/app/routers/links.py +++ b/web/app/routers/links.py @@ -1,19 +1,8 @@ from datetime import datetime -from typing import Annotated, Literal +from typing import Literal -from fastapi import APIRouter, Depends, HTTPException, Path, Query, status +from fastapi import APIRouter from pydantic import BaseModel, EmailStr -from sqlalchemy import select -from sqlalchemy.ext.asyncio import AsyncSession - -from app.auth.crypto import decrypt_token -from app.auth.session import get_current_session -from app.clients import forgejo -from app.deps import get_db -from app.models.app_settings import AppSettings -from app.models.session import Session as UserBrowserSession -from app.models.user import LinkedIdentity -from app.settings import get_app_settings, get_fernet router = APIRouter(prefix="/links", tags=["links"]) @@ -33,94 +22,7 @@ class CreateLinkResponse(BaseModel): share_url: str -async def get_forgejo_token( - sess: Annotated[UserBrowserSession, Depends(get_current_session)], -) -> str: - if not sess.user.has_pat: - raise HTTPException( - status_code=status.HTTP_403_FORBIDDEN, - detail="Personal access token not found. Please register one and try again.", - ) - try: - return decrypt_token(get_fernet(), sess.user.pat_encrypted) - except ValueError: - raise HTTPException( - status_code=status.HTTP_503_SERVICE_UNAVAILABLE, - detail="Stored Forgejo token cannot be decrypted. Reconnect your account in settings.", - ) from None - - @router.post("/", status_code=501) async def create_link(request: CreateLinkRequest) -> dict: """Stub — link creation not yet implemented.""" return {"detail": "Link creation is not yet implemented."} - - -@router.get("/repositories") -async def get_repositories( - app_settings: Annotated[AppSettings, Depends(get_app_settings)], - access_token: Annotated[str, Depends(get_forgejo_token)], -): - """Get a list of the user's repositories from Forgejo.""" - - repos = await forgejo.get_repos(app_settings, access_token) - return repos - - -@router.get("/repositories/{repo}/branches") -async def get_repository_branches( - app_settings: Annotated[AppSettings, Depends(get_app_settings)], - sess: Annotated[UserBrowserSession, Depends(get_current_session)], - access_token: Annotated[str, Depends(get_forgejo_token)], - db: Annotated[AsyncSession, Depends(get_db)], - repo: Annotated[str, Path(min_length=1, description="The name of the repository")], - limit: int = 10, - page: int = 1, -): - # Derive {owner} path param from users linked identity provider server-side - stmt = select(LinkedIdentity).where( - LinkedIdentity.user_id == sess.user_id, LinkedIdentity.provider == "forgejo" - ) - result = await db.execute(stmt) - identity = result.scalar_one_or_none() - if identity is None: - raise HTTPException( - status_code=status.HTTP_403_FORBIDDEN, - detail="No linked identity for forgejo was found. Please sign-in and try again.", - ) - owner = identity.provider_username - - branches = await forgejo.get_branches( - app_settings, access_token, owner, repo, limit=limit, page=page - ) - return branches - - -@router.get("/repositories/{repo}/commits") -async def get_repository_commits( - app_settings: Annotated[AppSettings, Depends(get_app_settings)], - sess: Annotated[UserBrowserSession, Depends(get_current_session)], - access_token: Annotated[str, Depends(get_forgejo_token)], - db: Annotated[AsyncSession, Depends(get_db)], - repo: Annotated[str, Path(min_length=1, description="The name of the repository")], - ref: Annotated[str, Query(description="Branch name, commit sha, or tag")] = "main", - limit: int = 10, - page: int = 1, -): - # Derive {owner} path param from users linked identity provider server-side - stmt = select(LinkedIdentity).where( - LinkedIdentity.user_id == sess.user_id, LinkedIdentity.provider == "forgejo" - ) - result = await db.execute(stmt) - identity = result.scalar_one_or_none() - if identity is None: - raise HTTPException( - status_code=status.HTTP_403_FORBIDDEN, - detail="No linked identity for forgejo was found. Please sign-in and try again.", - ) - owner = identity.provider_username - - commits = await forgejo.get_commits( - app_settings, access_token, owner, repo, ref=ref, limit=limit, page=page - ) - return commits diff --git a/web/app/routers/repositories.py b/web/app/routers/repositories.py new file mode 100644 index 0000000..0af6111 --- /dev/null +++ b/web/app/routers/repositories.py @@ -0,0 +1,124 @@ +from typing import Annotated + +from fastapi import APIRouter, Depends, HTTPException, Path, Query, status +from sqlalchemy import select +from sqlalchemy.ext.asyncio import AsyncSession + +from app.auth.crypto import decrypt_token +from app.auth.session import get_current_session +from app.clients import forgejo +from app.deps import get_db +from app.models.app_settings import AppSettings +from app.models.session import Session as UserBrowserSession +from app.models.user import LinkedIdentity +from app.settings import get_app_settings, get_fernet + +router = APIRouter(prefix="/links", tags=["repositories"]) + + +async def get_forgejo_token( + sess: Annotated[UserBrowserSession, Depends(get_current_session)], +) -> str: + """Decrypt the current user's Forgejo access token. + + Args: + sess: The authenticated browser session. + Returns: + The decrypted Forgejo access token. + Raises: + HTTPException: If no token is registered, or it cannot be decrypted. + """ + encrypted_token = sess.user.pat_encrypted + if encrypted_token is None: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="Personal access token not found. Please register one and try again.", + ) + try: + return decrypt_token(get_fernet(), encrypted_token) + except ValueError: + raise HTTPException( + status_code=status.HTTP_503_SERVICE_UNAVAILABLE, + detail="Stored Forgejo token cannot be decrypted. Reconnect your account in settings.", + ) from None + + +async def get_forgejo_owner( + sess: Annotated[UserBrowserSession, Depends(get_current_session)], + db: Annotated[AsyncSession, Depends(get_db)], +) -> str: + """Resolve the {owner} path value from the user's linked identity. + + Owner is derived server-side rather than taken from the request so a + caller cannot address repositories belonging to someone else. + + Args: + sess: The authenticated browser session. + db: A request-scoped database session. + Returns: + The Forgejo username linked to the signed-in user. + Raises: + HTTPException: If the session has no linked Forgejo identity. + """ + stmt = select(LinkedIdentity).where( + LinkedIdentity.user_id == sess.user_id, LinkedIdentity.provider == "forgejo" + ) + result = await db.execute(stmt) + identity = result.scalar_one_or_none() + if identity is None: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="No linked identity for forgejo was found. Please sign-in and try again.", + ) + return identity.provider_username + + +@router.get("/repositories") +async def get_repositories( + app_settings: Annotated[AppSettings, Depends(get_app_settings)], + access_token: Annotated[str, Depends(get_forgejo_token)], + owner: Annotated[str, Depends(get_forgejo_owner)], + limit: Annotated[int, Query(ge=1, le=50)] = 30, + page: Annotated[int, Query(ge=1)] = 1, +): + """Get a page of repositories owned by the linked Forgejo account.""" + + repo_page = await forgejo.get_repos( + app_settings, access_token, owner=owner, limit=limit, page=page + ) + return repo_page.repos + + +@router.get("/repositories/{repo}/branches") +async def get_repository_branches( + app_settings: Annotated[AppSettings, Depends(get_app_settings)], + access_token: Annotated[str, Depends(get_forgejo_token)], + owner: Annotated[str, Depends(get_forgejo_owner)], + repo: Annotated[str, Path(min_length=1, description="The name of the repository")], + limit: int = 10, + page: int = 1, +): + """List the branches of the signed-in user's repository.""" + + branches = await forgejo.get_branches( + app_settings, access_token, owner, repo, limit=limit, page=page + ) + return branches + + +@router.get("/repositories/{repo}/commits") +async def get_repository_commits( + app_settings: Annotated[AppSettings, Depends(get_app_settings)], + access_token: Annotated[str, Depends(get_forgejo_token)], + owner: Annotated[str, Depends(get_forgejo_owner)], + repo: Annotated[str, Path(min_length=1, description="The name of the repository")], + ref: Annotated[str, Query(description="Branch name, commit sha, or tag")] = "main", + limit: int = 10, + page: int = 1, +): + """List the commits of the signed-in user's repository at a ref.""" + + commits = await forgejo.get_commits( + app_settings, access_token, owner, repo, ref=ref, limit=limit, page=page + ) + return commits