feat(graphql): migrate REST to Strawberry GraphQL

Phase 1-3 of REST → GraphQL migration:

- Add strawberry-graphql[fastapi] dependency
- GraphQL endpoint at /graphql with GraphiQL UI
- GqlContext: JWT auth from cookie/header, DI via FastAPI Depends
- AppErrorExtension: AppException + ValidationError → GraphQL errors

Queries: members, member, memberFilters, tracks, me,
         links, link, linkFilters
Mutations: createLink, updateLink, toggleLink, deleteLink

Service layer unchanged — resolvers call existing services.
REST endpoints kept alongside for gradual frontend migration.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ImTotem

pyproject.toml

@@ -20,6 +20,7 @@ dependencies = [
     "sqlalchemy>=2.0",
     "psycopg[binary]>=3.1",
     "alembic>=1.13",
+    "strawberry-graphql[fastapi]>=0.235.0",
 ]
 
 [project.optional-dependencies]

src/bcsd_api/graphql/__init__.py

@@ -0,0 +1,62 @@
+from dataclasses import dataclass
+
+from fastapi import Depends, Request
+from sqlalchemy import Connection
+
+from bcsd_api.auth import token as jwt_token
+from bcsd_api.config import Settings
+from bcsd_api.dependencies import (
+    get_conn,
+    get_link_repo,
+    get_member_repo,
+    get_settings,
+)
+from bcsd_api.exception import Unauthorized
+from bcsd_api.member.pg_repository import PgMemberRepository
+from bcsd_api.shorten.pg_repository import PgLinkRepository
+
+
+@dataclass
+class GqlContext:
+    conn: Connection
+    member_repo: PgMemberRepository
+    link_repo: PgLinkRepository
+    user: dict | None
+
+
+def _try_auth(request: Request, settings: Settings) -> dict | None:
+    header = request.headers.get("Authorization", "")
+    if header.startswith("Bearer "):
+        raw = header[7:]
+    else:
+        raw = request.cookies.get(settings.cookie_name, "")
+    if not raw:
+        return None
+    try:
+        return jwt_token.decode_token(
+            raw, settings.jwt_secret, settings.jwt_algorithm,
+        )
+    except Exception:
+        return None
+
+
+def require_user(ctx: GqlContext) -> dict:
+    if not ctx.user:
+        raise Unauthorized("authentication required")
+    return ctx.user
+
+
+async def context_getter(
+    request: Request,
+    settings: Settings = Depends(get_settings),
+    conn: Connection = Depends(get_conn),
+    member_repo: PgMemberRepository = Depends(get_member_repo),
+    link_repo: PgLinkRepository = Depends(get_link_repo),
+) -> GqlContext:
+    user = _try_auth(request, settings)
+    return GqlContext(
+        conn=conn,
+        member_repo=member_repo,
+        link_repo=link_repo,
+        user=user,
+    )

src/bcsd_api/graphql/context.py

@@ -0,0 +1,45 @@
+from graphql import GraphQLError
+from pydantic import ValidationError
+from strawberry.extensions import SchemaExtension
+
+from bcsd_api.exception.base import AppException
+
+
+class AppErrorExtension(SchemaExtension):
+    def on_operation(self):
+        yield
+        result = self.execution_context.result
+        if not result:
+            return
+        if not result.errors:
+            return
+        result.errors = [_map_error(e) for e in result.errors]
+
+
+def _map_error(err: GraphQLError) -> GraphQLError:
+    orig = err.original_error
+    if isinstance(orig, AppException):
+        return _from_app(orig)
+    if isinstance(orig, ValidationError):
+        return _from_validation(orig)
+    return err
+
+
+def _from_app(exc: AppException) -> GraphQLError:
+    return GraphQLError(
+        message=exc.message,
+        extensions={
+            "error_code": exc.error_code,
+            "status_code": exc.status_code,
+        },
+    )
+
+
+def _from_validation(exc: ValidationError) -> GraphQLError:
+    return GraphQLError(
+        message=str(exc),
+        extensions={
+            "error_code": "VALIDATION_ERROR",
+            "status_code": 400,
+        },
+    )

src/bcsd_api/graphql/errors.py

@@ -0,0 +1,54 @@
+import strawberry
+
+from bcsd_api.member import resolvers as member_resolvers
+from bcsd_api.member.types import (
+    FiltersType,
+    MeType,
+    MemberDetailType,
+    MemberFilterInput,
+    PagedMembers,
+)
+from bcsd_api.shorten import resolvers as link_resolvers
+from bcsd_api.shorten.types import (
+    CreateLinkInput,
+    LinkDetailType,
+    LinkFilterInput,
+    LinkFiltersType,
+    LinkType,
+    PagedLinks,
+    UpdateLinkInput,
+)
+
+from .errors import AppErrorExtension
+
+
+@strawberry.type
+class Query:
+    @strawberry.field
+    def health(self) -> str:
+        return "ok"
+
+    members: PagedMembers = strawberry.field(resolver=member_resolvers.resolve_members)
+    member: MemberDetailType = strawberry.field(resolver=member_resolvers.resolve_member)
+    member_filters: FiltersType = strawberry.field(resolver=member_resolvers.resolve_filters)
+    tracks: list[str] = strawberry.field(resolver=member_resolvers.resolve_tracks)
+    me: MeType = strawberry.field(resolver=member_resolvers.resolve_me)
+
+    links: PagedLinks = strawberry.field(resolver=link_resolvers.resolve_links)
+    link: LinkDetailType = strawberry.field(resolver=link_resolvers.resolve_link)
+    link_filters: LinkFiltersType = strawberry.field(resolver=link_resolvers.resolve_link_filters)
+
+
+@strawberry.type
+class Mutation:
+    create_link: LinkType = strawberry.mutation(resolver=link_resolvers.resolve_create)
+    update_link: LinkType = strawberry.mutation(resolver=link_resolvers.resolve_update)
+    toggle_link: LinkType = strawberry.mutation(resolver=link_resolvers.resolve_toggle)
+    delete_link: bool = strawberry.mutation(resolver=link_resolvers.resolve_delete)
+
+
+schema = strawberry.Schema(
+    query=Query,
+    mutation=Mutation,
+    extensions=[AppErrorExtension],
+)

src/bcsd_api/graphql/schema.py

@@ -75,9 +75,20 @@ def create_app() -> FastAPI:
     app.include_router(track_router)
     app.include_router(shorten_router)
     app.include_router(redirect_router)
+    _mount_graphql(app)
     return app
 
 
+def _mount_graphql(app: FastAPI) -> None:
+    from strawberry.fastapi import GraphQLRouter
+
+    from .graphql.context import context_getter
+    from .graphql.schema import schema
+
+    router = GraphQLRouter(schema, context_getter=context_getter)
+    app.include_router(router, prefix="/graphql")
+
+
 app = create_app()
 
 

src/bcsd_api/main.py

@@ -0,0 +1,88 @@
+from strawberry.types import Info
+
+from bcsd_api.filter.members import MemberFilter
+from bcsd_api.graphql.context import GqlContext, require_user
+
+from . import service
+from .schema import MemberDetail, MemberResponse
+from .types import (
+    FiltersType,
+    MeType,
+    MemberDetailType,
+    MemberFilterInput,
+    MemberType,
+    PagedMembers,
+)
+
+
+def _to_filter(inp: MemberFilterInput) -> MemberFilter:
+    return MemberFilter(
+        page=inp.page, size=inp.size,
+        sort_by=inp.sort_by, sort_order=inp.sort_order,
+        status=inp.status, track=inp.track,
+        team=inp.team, payment_status=inp.payment_status,
+        name=inp.name,
+    )
+
+
+def _to_member(m: MemberResponse) -> MemberType:
+    return MemberType(
+        id=m.id, name=m.name, email=m.email,
+        status=m.status, track=m.track,
+        team=m.team, payment_status=m.payment_status,
+    )
+
+
+def _to_detail(m: MemberDetail) -> MemberDetailType:
+    return MemberDetailType(
+        id=m.id, name=m.name, email=m.email,
+        status=m.status, track=m.track,
+        team=m.team, payment_status=m.payment_status,
+        department=m.department, student_id=m.student_id,
+        school_email=m.school_email, phone=m.phone,
+        join_date=m.join_date, last_updated=m.last_updated,
+    )
+
+
+def resolve_members(
+    info: Info[GqlContext, None],
+    filter: MemberFilterInput | None = None,
+) -> PagedMembers:
+    ctx = info.context
+    require_user(ctx)
+    filt = _to_filter(filter) if filter else MemberFilter()
+    paged = service.list_members(ctx.member_repo, filt)
+    items = [_to_member(m) for m in paged.items]
+    return PagedMembers(
+        items=items, total=paged.total,
+        page=paged.page, size=paged.size,
+    )
+
+
+def resolve_member(info: Info[GqlContext, None], id: str) -> MemberDetailType:
+    require_user(info.context)
+    m = service.get_member(info.context.member_repo, id)
+    return _to_detail(m)
+
+
+def resolve_filters(info: Info[GqlContext, None]) -> FiltersType:
+    f = service.get_filters(info.context.conn)
+    return FiltersType(
+        tracks=f.tracks,
+        statuses=f.statuses,
+        payment_statuses=f.payment_statuses,
+    )
+
+
+def resolve_tracks(info: Info[GqlContext, None]) -> list[str]:
+    from sqlalchemy import select
+
+    from bcsd_api.tables import tracks
+
+    rows = info.context.conn.execute(select(tracks.c.name))
+    return [row.name for row in rows]
+
+
+def resolve_me(info: Info[GqlContext, None]) -> MeType:
+    user = require_user(info.context)
+    return MeType(id=user["sub"], email=user["email"])

src/bcsd_api/member/resolvers.py

@@ -0,0 +1,56 @@
+import strawberry
+
+
+@strawberry.type
+class MemberType:
+    id: str
+    name: str
+    email: str
+    status: str
+    track: str
+    team: str
+    payment_status: str
+
+
+@strawberry.type
+class MemberDetailType(MemberType):
+    department: str
+    student_id: str
+    school_email: str
+    phone: str
+    join_date: str
+    last_updated: str
+
+
+@strawberry.type
+class FiltersType:
+    tracks: list[str]
+    statuses: list[str]
+    payment_statuses: list[str]
+
+
+@strawberry.type
+class MeType:
+    id: str
+    email: str
+
+
+@strawberry.type
+class PagedMembers:
+    items: list[MemberType]
+    total: int
+    page: int
+    size: int
+
+
+@strawberry.input
+class MemberFilterInput:
+    page: int = 1
+    size: int = 20
+    sort_by: str = "id"
+    sort_order: str = "asc"
+    status: str | None = None
+    track: str | None = None
+    team: str | None = None
+    payment_status: str | None = None
+    name: str | None = None