feat(repositories): extract routes and paginate owned listings

This commit is contained in:
ZTatman 2026-10-16 15:07:51 -04:00
parent 394e68abeb
commit 9d0e0b481a
4 changed files with 180 additions and 111 deletions

View file

@ -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(

View file

@ -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)

View file

@ -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

View file

@ -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