chore: wip.

Author: PttCodingMan

backend/app/database.py

@@ -275,14 +275,36 @@ async def rebuild_all_search_indexes(db):
         await db.commit()
 
 
+async def rebuild_all_backlinks(db):
+    """Rebuild backlinks for all existing pages."""
+    from app.services.wikilink import parse_and_update_backlinks
+
+    rows = await db.execute_fetchall("SELECT COUNT(*) as cnt FROM backlinks")
+    if rows[0]["cnt"] > 0:
+        return  # Already populated
+
+    pages = await db.execute_fetchall("SELECT id, content_md FROM pages")
+    for p in pages:
+        await parse_and_update_backlinks(db, p["id"], p["content_md"])
+    if pages:
+        await db.commit()
+
+
 async def init_db():
     db = await get_db()
-    await db.executescript(SCHEMA_SQL)
+    # Execute each statement individually to avoid blocking the event loop
+    for statement in SCHEMA_SQL.split(';'):
+        statement = statement.strip()
+        if statement:
+            await db.execute(statement)
     await db.commit()
 
     # Rebuild search index for existing pages
     await rebuild_all_search_indexes(db)
 
+    # Rebuild backlinks for existing pages
+    await rebuild_all_backlinks(db)
+
     # Seed default templates
     for t in DEFAULT_TEMPLATES:
         existing = await db.execute_fetchall(

backend/app/main.py

@@ -4,7 +4,7 @@
 
 from app.database import init_db, close_db
 from app.auth import ensure_admin_exists
-from app.routers import auth_router, pages, media, templates, search, tags, activity, bookmarks
+from app.routers import auth_router, pages, media, templates, search, tags, activity, bookmarks, versions, diagrams
 
 
 @asynccontextmanager
@@ -33,6 +33,8 @@ async def lifespan(app: FastAPI):
 app.include_router(tags.router)
 app.include_router(activity.router)
 app.include_router(bookmarks.router)
+app.include_router(versions.router)
+app.include_router(diagrams.router)
 
 
 @app.get("/api/health")

backend/app/routers/diagrams.py

@@ -0,0 +1,98 @@
+from fastapi import APIRouter, Depends, HTTPException
+from app.schemas import DiagramCreate, DiagramUpdate, DiagramResponse
+from app.auth import get_current_user
+from app.database import get_db
+
+router = APIRouter(prefix="/api/diagrams", tags=["diagrams"])
+
+
+@router.post("", response_model=DiagramResponse, status_code=201)
+async def create_diagram(
+    body: DiagramCreate,
+    user=Depends(get_current_user),
+):
+    db = await get_db()
+    cursor = await db.execute(
+        """INSERT INTO diagrams (name, xml_data, page_id, created_by, updated_at)
+           VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)""",
+        (body.name, body.xml_data, body.page_id, user["id"]),
+    )
+    await db.commit()
+    row = await db.execute_fetchall(
+        "SELECT * FROM diagrams WHERE id = ?", (cursor.lastrowid,)
+    )
+    d = row[0]
+    return dict(d)
+
+
+@router.get("/{diagram_id}", response_model=DiagramResponse)
+async def get_diagram(diagram_id: int, user=Depends(get_current_user)):
+    db = await get_db()
+    rows = await db.execute_fetchall(
+        "SELECT * FROM diagrams WHERE id = ?", (diagram_id,)
+    )
+    if not rows:
+        raise HTTPException(status_code=404, detail="Diagram not found")
+    return dict(rows[0])
+
+
+@router.put("/{diagram_id}", response_model=DiagramResponse)
+async def update_diagram(
+    diagram_id: int,
+    body: DiagramUpdate,
+    user=Depends(get_current_user),
+):
+    db = await get_db()
+    rows = await db.execute_fetchall(
+        "SELECT * FROM diagrams WHERE id = ?", (diagram_id,)
+    )
+    if not rows:
+        raise HTTPException(status_code=404, detail="Diagram not found")
+
+    updates = []
+    values = []
+    for field in ("name", "xml_data", "svg_cache", "page_id"):
+        val = getattr(body, field, None)
+        if val is not None:
+            updates.append(f"{field} = ?")
+            values.append(val)
+
+    if updates:
+        updates.append("updated_at = CURRENT_TIMESTAMP")
+        values.append(diagram_id)
+        await db.execute(
+            f"UPDATE diagrams SET {', '.join(updates)} WHERE id = ?", values
+        )
+        await db.commit()
+
+    rows = await db.execute_fetchall(
+        "SELECT * FROM diagrams WHERE id = ?", (diagram_id,)
+    )
+    return dict(rows[0])
+
+
+@router.delete("/{diagram_id}", status_code=204)
+async def delete_diagram(diagram_id: int, user=Depends(get_current_user)):
+    db = await get_db()
+    rows = await db.execute_fetchall(
+        "SELECT * FROM diagrams WHERE id = ?", (diagram_id,)
+    )
+    if not rows:
+        raise HTTPException(status_code=404, detail="Diagram not found")
+    await db.execute("DELETE FROM diagrams WHERE id = ?", (diagram_id,))
+    await db.commit()
+
+
+@router.get("/{diagram_id}/svg")
+async def get_diagram_svg(diagram_id: int, user=Depends(get_current_user)):
+    db = await get_db()
+    rows = await db.execute_fetchall(
+        "SELECT svg_cache FROM diagrams WHERE id = ?", (diagram_id,)
+    )
+    if not rows:
+        raise HTTPException(status_code=404, detail="Diagram not found")
+    svg = rows[0]["svg_cache"]
+    if not svg:
+        raise HTTPException(status_code=404, detail="No SVG cache available")
+    from fastapi.responses import Response
+    return Response(content=svg, media_type="image/svg+xml")

backend/app/routers/pages.py

@@ -1,11 +1,13 @@
 import re
 import unicodedata
 from fastapi import APIRouter, HTTPException, Depends, Query
-from app.schemas import PageCreate, PageUpdate, PageResponse, PageListResponse
+from app.schemas import PageCreate, PageUpdate, PageResponse, PageListResponse, PageMoveRequest
 from app.auth import get_current_user
 from app.database import get_db
 from app.services.search import rebuild_search_index, remove_from_search_index
+from app.services.wikilink import parse_and_update_backlinks
 from app.routers.activity import log_activity
+from app.routers.versions import save_version
 
 router = APIRouter(prefix="/api/pages", tags=["pages"])
 
@@ -90,6 +92,18 @@ def build_tree(parent_id):
     return build_tree(None)
 
 
+@router.get("/graph")
+async def page_graph(user=Depends(get_current_user)):
+    db = await get_db()
+    pages = await db.execute_fetchall("SELECT id, slug, title FROM pages")
+    nodes = [{"id": p["id"], "slug": p["slug"], "title": p["title"]} for p in pages]
+
+    backlinks = await db.execute_fetchall("SELECT source_page_id, target_page_id FROM backlinks")
+    links = [{"source": b["source_page_id"], "target": b["target_page_id"]} for b in backlinks]
+
+    return {"nodes": nodes, "links": links}
+
+
 @router.post("", response_model=PageResponse, status_code=201)
 async def create_page(body: PageCreate, user=Depends(get_current_user)):
     db = await get_db()
@@ -113,6 +127,8 @@ async def create_page(body: PageCreate, user=Depends(get_current_user)):
 
     # Update search index
     await rebuild_search_index(db, page_id, body.title, content)
+    # Parse wikilinks → update backlinks
+    await parse_and_update_backlinks(db, page_id, content)
     # Log activity
     await log_activity(db, user["id"], "created", "page", page_id, {"title": body.title, "slug": slug})
     await db.commit()
@@ -149,9 +165,12 @@ async def update_page(slug: str, body: PageUpdate, user=Depends(get_current_user
     current = dict(rows[0])
     title = body.title if body.title is not None else current["title"]
     content = body.content_md if body.content_md is not None else current["content_md"]
-    parent_id = body.parent_id if body.parent_id is not None else current["parent_id"]
+    parent_id = body.parent_id if "parent_id" in body.model_fields_set else current["parent_id"]
     sort_order = body.sort_order if body.sort_order is not None else current["sort_order"]
 
+    # Save current state as a version before updating
+    await save_version(db, current["id"], current["title"], current["content_md"], user["id"])
+
     await db.execute(
         """UPDATE pages SET title = ?, content_md = ?, parent_id = ?, sort_order = ?,
            updated_at = CURRENT_TIMESTAMP WHERE slug = ?""",
@@ -160,6 +179,8 @@ async def update_page(slug: str, body: PageUpdate, user=Depends(get_current_user
 
     # Update search index
     await rebuild_search_index(db, current["id"], title, content)
+    # Parse wikilinks → update backlinks
+    await parse_and_update_backlinks(db, current["id"], content)
     # Log activity
     await log_activity(db, user["id"], "updated", "page", current["id"], {"title": title, "slug": slug})
     await db.commit()
@@ -168,6 +189,63 @@ async def update_page(slug: str, body: PageUpdate, user=Depends(get_current_user
     return dict(rows[0])
 
 
+@router.get("/{slug}/children")
+async def get_children(slug: str, user=Depends(get_current_user)):
+    db = await get_db()
+    rows = await db.execute_fetchall("SELECT id FROM pages WHERE slug = ?", (slug,))
+    if not rows:
+        raise HTTPException(status_code=404, detail="Page not found")
+    page_id = rows[0]["id"]
+    children = await db.execute_fetchall(
+        "SELECT * FROM pages WHERE parent_id = ? ORDER BY sort_order, title",
+        (page_id,),
+    )
+    return [dict(c) for c in children]
+
+
+@router.get("/{slug}/backlinks")
+async def get_backlinks(slug: str, user=Depends(get_current_user)):
+    db = await get_db()
+    rows = await db.execute_fetchall("SELECT id FROM pages WHERE slug = ?", (slug,))
+    if not rows:
+        raise HTTPException(status_code=404, detail="Page not found")
+    page_id = rows[0]["id"]
+    backlinks = await db.execute_fetchall(
+        """SELECT p.id, p.slug, p.title
+           FROM backlinks b
+           JOIN pages p ON p.id = b.source_page_id
+           WHERE b.target_page_id = ?
+           ORDER BY p.title""",
+        (page_id,),
+    )
+    return [dict(b) for b in backlinks]
+
+
+@router.patch("/{slug}/move")
+async def move_page(slug: str, body: PageMoveRequest, user=Depends(get_current_user)):
+    db = await get_db()
+    rows = await db.execute_fetchall("SELECT id FROM pages WHERE slug = ?", (slug,))
+    if not rows:
+        raise HTTPException(status_code=404, detail="Page not found")
+
+    updates = []
+    params = []
+    if "parent_id" in body.model_fields_set:
+        updates.append("parent_id = ?")
+        params.append(body.parent_id)
+    if "sort_order" in body.model_fields_set:
+        updates.append("sort_order = ?")
+        params.append(body.sort_order)
+
+    if not updates:
+        raise HTTPException(status_code=400, detail="No fields to update")
+
+    params.append(slug)
+    await db.execute(f"UPDATE pages SET {', '.join(updates)} WHERE slug = ?", params)
+    await db.commit()
+    return {"ok": True}
+
+
 @router.delete("/{slug}")
 async def delete_page(slug: str, user=Depends(get_current_user)):
     db = await get_db()