refactor: code cleanup — remove dead code, deduplicate, add base classes

Step 1: Delete dead code + REST routers
- Remove Sheets repositories (member/repository.py, shorten/repository.py)
- Remove REST routers (member/router.py, shorten/router.py, track.py)
- Clean up main.py imports and router registrations
- Remove service.py alias imports (LinkRepository → PgLinkRepository)

Step 2: Unify auth token extraction
- Add extract_raw() and decode_or_none() to auth/token.py
- Replace duplicate logic in dependencies.py and graphql/context.py

Step 3: BaseRepository
- New repository.py with find_all() and find_by_id()
- PgMemberRepository: 19 lines → 9 lines
- PgLinkRepository: 57 lines → 45 lines (domain methods only)

Step 4: Auto type conversion
- New graphql/convert.py with from_model() and from_paged()
- Remove manual _to_member, _to_link, _to_detail helpers
- member/resolvers.py: 94 → 66 lines
- shorten/resolvers.py: 131 → 88 lines

~185 lines removed, 3 new shared utilities.

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

Author: ImTotem

src/bcsd_api/auth/token.py

@@ -1,5 +1,6 @@
 from datetime import datetime, timedelta, timezone
 
+from fastapi import Request
 from jose import JWTError, jwt
 
 from bcsd_api.exception import Unauthorized
@@ -16,3 +17,17 @@ def decode_token(token: str, secret: str, algorithm: str) -> dict:
         return jwt.decode(token, secret, algorithms=[algorithm])
     except JWTError:
         raise Unauthorized("invalid or expired token")
+
+
+def extract_raw(request: Request, cookie_name: str) -> str | None:
+    header = request.headers.get("Authorization", "")
+    if header.startswith("Bearer "):
+        return header[7:]
+    return request.cookies.get(cookie_name)
+
+
+def decode_or_none(raw: str, secret: str, algorithm: str) -> dict | None:
+    try:
+        return jwt.decode(raw, secret, algorithms=[algorithm])
+    except JWTError:
+        return None

src/bcsd_api/dependencies.py

@@ -67,19 +67,11 @@ def get_link_repo(conn: Connection = Depends(get_conn)) -> PgLinkRepository:
     return PgLinkRepository(conn)
 
 
-def _extract_token(request: Request, settings: Settings) -> str:
-    header = request.headers.get("Authorization", "")
-    if header.startswith("Bearer "):
-        return header[7:]
-    cookie = request.cookies.get(settings.cookie_name)
-    if cookie:
-        return cookie
-    raise Unauthorized("missing authorization")
-
-
 def current_user(
     request: Request,
     settings: Settings = Depends(get_settings),
 ) -> dict:
-    raw = _extract_token(request, settings)
+    raw = jwt_token.extract_raw(request, settings.cookie_name)
+    if not raw:
+        raise Unauthorized("missing authorization")
     return jwt_token.decode_token(raw, settings.jwt_secret, settings.jwt_algorithm)

src/bcsd_api/graphql/context.py

@@ -24,19 +24,10 @@ def __init__(self, conn, member_repo, link_repo, user):
 
 
 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, "")
+    raw = jwt_token.extract_raw(request, 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
+    return jwt_token.decode_or_none(raw, settings.jwt_secret, settings.jwt_algorithm)
 
 
 def require_user(ctx: GqlContext) -> dict:

src/bcsd_api/graphql/convert.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+
+
+def from_model(source: BaseModel, target_cls):
+    return target_cls(**source.model_dump())
+
+
+def from_paged(paged, item_cls, paged_cls):
+    items = [from_model(m, item_cls) for m in paged.items]
+    return paged_cls(
+        items=items, total=paged.total,
+        page=paged.page, size=paged.size,
+    )

src/bcsd_api/main.py

@@ -9,10 +9,7 @@
 from .auth.router import router as auth_router
 from .dependencies import get_authz, get_settings
 from .exception import register_handlers
-from .member.router import router as member_router
 from .redirect import router as redirect_router
-from .shorten.router import router as shorten_router
-from .track import router as track_router
 
 logger = logging.getLogger(__name__)
 
@@ -71,9 +68,6 @@ def create_app() -> FastAPI:
     )
     register_handlers(app)
     app.include_router(auth_router)
-    app.include_router(member_router)
-    app.include_router(track_router)
-    app.include_router(shorten_router)
     app.include_router(redirect_router)
     _mount_graphql(app)
     return app

src/bcsd_api/member/pg_repository.py

@@ -1,19 +1,9 @@
-from sqlalchemy import Connection, select
+from sqlalchemy import Connection
 
+from bcsd_api.repository import BaseRepository
 from bcsd_api.tables import members
 
 
-class PgMemberRepository:
+class PgMemberRepository(BaseRepository):
     def __init__(self, conn: Connection):
-        self._conn = conn
-
-    def find_all(self) -> list[dict]:
-        rows = self._conn.execute(select(members))
-        return [row._asdict() for row in rows]
-
-    def find_by_id(self, member_id: str) -> dict | None:
-        stmt = select(members).where(members.c.id == member_id)
-        row = self._conn.execute(stmt).first()
-        if not row:
-            return None
-        return row._asdict()
+        super().__init__(conn, members)

src/bcsd_api/member/repository.py

@@ -3,9 +3,9 @@
 
 from bcsd_api.filter.members import MemberFilter
 from bcsd_api.graphql.context import GqlContext, require_user
+from bcsd_api.graphql.convert import from_model, from_paged
 
 from . import service
-from .schema import MemberDetail, MemberResponse
 from .types import (
     FiltersType,
     MeType,
@@ -26,25 +26,6 @@ def _to_filter(inp: MemberFilterInput) -> MemberFilter:
     )
 
 
-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,
@@ -53,26 +34,18 @@ def resolve_members(
     require_user(ctx)
     filt = _to_filter(filter) if filter else MemberFilter.model_validate({})
     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,
-    )
+    return from_paged(paged, MemberType, PagedMembers)
 
 
 def resolve_member(info: Info[GqlContext, None], id: strawberry.ID) -> MemberDetailType:
     require_user(info.context)
     m = service.get_member(info.context.member_repo, id)
-    return _to_detail(m)
+    return from_model(m, MemberDetailType)
 
 
 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,
-    )
+    return from_model(f, FiltersType)
 
 
 def resolve_tracks(info: Info[GqlContext, None]) -> list[str]:
@@ -90,5 +63,5 @@ def resolve_me(info: Info[GqlContext, None]) -> MeType:
     return MeType(
         id=user["sub"],
         email=user["email"],
-        member=_to_detail(detail),
+        member=from_model(detail, MemberDetailType),
     )

src/bcsd_api/member/resolvers.py

@@ -0,0 +1,18 @@
+from sqlalchemy import Connection, select
+
+
+class BaseRepository:
+    def __init__(self, conn: Connection, table):
+        self._conn = conn
+        self._table = table
+
+    def find_all(self) -> list[dict]:
+        rows = self._conn.execute(select(self._table))
+        return [row._asdict() for row in rows]
+
+    def find_by_id(self, id: str) -> dict | None:
+        stmt = select(self._table).where(self._table.c.id == id)
+        row = self._conn.execute(stmt).first()
+        if not row:
+            return None
+        return row._asdict()