readinglist, bookmark, profile some backend + frontend changes

api.py

@@ -3,7 +3,7 @@ Read-only API for the frontend. Wraps db list_entries, get_segments, get_chapter
 Run from backend:  uvicorn api:app --reload --host 0.0.0.0 --port 8000
 """
 
-from fastapi import APIRouter, FastAPI, HTTPException, Query
+from fastapi import APIRouter, FastAPI, HTTPException, Query, Response
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 import proxy
@@ -23,6 +23,7 @@ from db.schemas import (
     ReadingListCollectionRenameIn,
     ReadingListItemOut,
     SegmentListOut,
+    UserDisplayNamePatchIn,
 )
 
 # app = FastAPI(
@@ -152,6 +153,7 @@ def post_reading_list_collection(
         manga_count=0,
         created_at=col.created_at,
         updated_at=col.updated_at,
+        latest_external_manga_id=None,
     )
 
 
@@ -178,6 +180,7 @@ def patch_reading_list_collection(
         manga_count=0,
         created_at=col.created_at,
         updated_at=col.updated_at,
+        latest_external_manga_id=None,
     )
 
 
@@ -240,6 +243,21 @@ def delete_reading_list_item(
         raise HTTPException(status_code=404, detail="Not on this reading list")
     return {"ok": True}
 
+
+@router.patch("/users/me")
+def patch_me_display_name(ctx: CurrentAuthContext, body: UserDisplayNamePatchIn):
+    """Update display_name on public.users for the signed-in user."""
+    try:
+        db.update_app_user_display_name(
+            ctx.user_id,
+            body.display_name,
+            email=ctx.email,
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e)) from e
+    return Response(status_code=204)
+
+
 ###########
 ###########
 ###########
@@ -252,6 +270,15 @@ async def proxy_manga_page(chapter_id: str, page_index: int):
 
     return await proxy.get_manga_page_stream(urls[page_index])
 
+
+@router.get("/api/manga/chapter/{chapter_id}/pages")
+def get_chapter_page_urls(chapter_id: str):
+    """MangaDex at-home CDN URLs for every page in a chapter (for client readers)."""
+    urls = mangadex_service.get_chapter_panel_urls(chapter_id)
+    if not urls:
+        raise HTTPException(status_code=404, detail="No pages for this chapter")
+    return {"urls": urls}
+
 @router.get("/api/manga/cover_art")
 async def proxy_manga_cover_art(manga_id: str, file_name: str, size: int = 256):
     url = f"https://uploads.mangadex.org/covers/{manga_id}/{file_name}.{size}.jpg"
@@ -266,6 +293,13 @@ async def get_manga_cover_json(manga_id: str):
     return {"cover_url": cover_url}
 
 
+@router.get("/api/manga/{manga_id}/info")
+async def get_manga_info_json(manga_id: str):
+    """MangaDex title + synopsis for reading-list rows (no DB storage)."""
+    info = await mangadex_service.get_manga_public_info(manga_id)
+    return info
+
+
 @router.get("/api/manga/search")
 async def get_popular_manga(
     title: str = "",

db/db.py

@@ -537,6 +537,29 @@ def ensure_app_user(
         session.commit()
 
 
+def update_app_user_display_name(
+    user_id: UUID,
+    display_name: Optional[str],
+    email: Optional[str] = None,
+    db_url=None,
+) -> None:
+    """Sync display_name on public.users (client updates Supabase Auth metadata separately)."""
+    trimmed = (display_name or "").strip() or None
+    if trimmed and len(trimmed) > 200:
+        raise ValueError("Display name is too long")
+    ensure_app_user(user_id, email=email, db_url=db_url)
+    engine = get_engine(db_url)
+    now = datetime.now(timezone.utc)
+    with Session(engine) as session:
+        row = session.exec(select(Users).where(Users.id == user_id)).first()
+        if row is None:
+            return
+        row.display_name = trimmed
+        row.updated_at = now
+        session.add(row)
+        session.commit()
+
+
 def get_reading_list_collection(
     user_id: UUID, collection_id: int, db_url=None
 ) -> Optional[ReadingListCollection]:
@@ -631,6 +654,38 @@ def list_reading_list_collections_with_counts(
             .group_by(ReadingListItem.reading_list_id)
         )
         count_map = {rid: int(n) for rid, n in session.exec(cnt_stmt).all()}
+        latest_ext: dict[int, Optional[str]] = {}
+        if ids:
+            rows = list(
+                session.exec(
+                    select(ReadingListItem, MangaSource)
+                    .join(Manga, ReadingListItem.manga_id == Manga.id)
+                    .outerjoin(
+                        MangaSource,
+                        (MangaSource.manga_id == Manga.id)
+                        & (MangaSource.provider_id == PROVIDER_MANGADEX),
+                    )
+                    .where(ReadingListItem.reading_list_id.in_(ids))
+                    .order_by(
+                        ReadingListItem.reading_list_id,
+                        desc(ReadingListItem.created_at),
+                    )
+                ).all()
+            )
+            for item, src in rows:
+                lid = item.reading_list_id
+                if lid in latest_ext:
+                    continue
+                ext: Optional[str] = None
+                if (
+                    src
+                    and src.external_manga_id
+                    and not _is_placeholder_external_manga_id(
+                        src.external_manga_id
+                    )
+                ):
+                    ext = src.external_manga_id
+                latest_ext[lid] = ext
     return [
         ReadingListCollectionOut(
             id=c.id,
@@ -638,6 +693,7 @@ def list_reading_list_collections_with_counts(
             created_at=c.created_at,
             updated_at=c.updated_at,
             manga_count=count_map.get(c.id, 0),
+            latest_external_manga_id=latest_ext.get(c.id),
         )
         for c in cols
     ]

db/models.py

@@ -1,6 +1,6 @@
 """
 User table: app profile keyed by Supabase auth user id (UUID)
-  id: UUID, primary key — use auth.users.id when using Supabase Auth
+  id: UUID, primary key — same as auth.users.id when using Supabase Auth
   email: optional, unique when set
   display_name: optional
   created_at / updated_at: datetime

db/schemas.py

@@ -35,6 +35,8 @@ class ReadingListCollectionOut(SQLModel):
     manga_count: int = 0
     created_at: Optional[datetime] = None
     updated_at: Optional[datetime] = None
+    #: MangaDex id of the most recently *added* list item (for cover thumbnails).
+    latest_external_manga_id: Optional[str] = None
 
 
 class ReadingListCollectionCreateIn(SQLModel):
@@ -45,6 +47,12 @@ class ReadingListCollectionRenameIn(SQLModel):
     name: str
 
 
+class UserDisplayNamePatchIn(SQLModel):
+    """Display name stored in public.users and mirrored from Supabase Auth user_metadata."""
+
+    display_name: str = Field(default="", max_length=200)
+
+
 class ReadingListItemOut(SQLModel):
     """One manga row inside a named list (with umbrella title + optional MangaDex id)."""
 

services/mangadex_service.py

@@ -39,6 +39,54 @@ async def get_manga_cover_url_256(manga_id: str) -> str | None:
     return _cover_url_from_manga_payload(data, manga_id)
 
 
+def _pick_localized_string(obj) -> str | None:
+    if not isinstance(obj, dict) or not obj:
+        return None
+    en = obj.get("en")
+    if isinstance(en, str) and en.strip():
+        return en.strip()
+    for v in obj.values():
+        if isinstance(v, str) and v.strip():
+            return v.strip()
+    return None
+
+
+def _available_translated_languages(attrs: dict) -> list[str]:
+    raw = attrs.get("availableTranslatedLanguages")
+    if not isinstance(raw, list):
+        return []
+    return [str(x) for x in raw if isinstance(x, str)]
+
+
+async def get_manga_public_info(manga_id: str) -> dict:
+    """Localized title, description, and chapter languages from GET /manga/{id}."""
+    empty = {
+        "title": None,
+        "description": None,
+        "availableTranslatedLanguages": [],
+    }
+    url = f"{BASE_URL}/manga/{manga_id}"
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.get(url, timeout=10.0)
+            response.raise_for_status()
+            payload = response.json()
+        except Exception as e:
+            print(f"get_manga_public_info: {e}")
+            return empty
+    data = payload.get("data")
+    if not isinstance(data, dict):
+        return empty
+    attrs = data.get("attributes") or {}
+    if not isinstance(attrs, dict):
+        attrs = {}
+    return {
+        "title": _pick_localized_string(attrs.get("title")),
+        "description": _pick_localized_string(attrs.get("description")),
+        "availableTranslatedLanguages": _available_translated_languages(attrs),
+    }
+
+
 async def search_manga(title: str, limit: int =20, offset: int = 0, order_by: str = "followedCount", order_direction: str = "desc", cover_art: bool = True):
     """
     Todo: filters by tags (include, exclude)