feat: v6.5.0 Synced blocks production — pages contenu par lignes de DB, résolution serveur à chaque lecture, propagation écrite réelle

app/routers/api_v2.py

@@ -802,9 +802,20 @@ async def get_page_v2(page_id: int, request: Request, authorization: str | None
             if not row2:
                 raise HTTPException(404, "Page not found")
             d = row_to_dict(row2)
+            # v6.5.0: resolve synced blocks server-side (fresh content).
+            if (d.get("content_format") or "blocks") == "blocks" and d.get("content"):
+                from app.services.synced_blocks import resolve_content_json
+                d["content"] = resolve_content_json(d["content"], d["content_format"])
             return d
         d = row_to_dict(row)
         # property_values_json already parsed by row_to_dict
+        # v6.5.0: expose the row's content page when it exists (no lazy
+        # creation on a read-only endpoint).
+        content_page_id = conn.execute(
+            "SELECT id FROM pages WHERE collection_row_id=?",
+            (page_id,),
+        ).fetchone()
+        d["content_page_id"] = content_page_id["id"] if content_page_id else None
         return d
 
 @router.patch("/pages/{page_id}")

app/routers/board.py

@@ -431,7 +431,7 @@ def _build_page_tree(conn, parent_id: int | None, ws_key: str, depth: int = 0, m
     if depth >= max_depth:
         return []
     rows = conn.execute(
-        "SELECT id, title, updated_at FROM pages WHERE workspace=? AND parent_id IS ? AND deleted_at IS NULL ORDER BY sort_order ASC, updated_at DESC",
+        "SELECT id, title, updated_at FROM pages WHERE workspace=? AND parent_id IS ? AND deleted_at IS NULL AND collection_row_id IS NULL ORDER BY sort_order ASC, updated_at DESC",
         (ws_key, parent_id),
     ).fetchall()
     items = []
@@ -499,7 +499,7 @@ def _load_workspace_pages(ws_cookie: str) -> list:
             rows = conn.execute(
                 "SELECT id, title, parent_section, content_format, "
                 "is_shared, share_mode, COALESCE(published,0) AS published "
-                "FROM pages WHERE workspace_id=? AND parent_id IS NULL AND deleted_at IS NULL ORDER BY created_at DESC",
+                "FROM pages WHERE workspace_id=? AND parent_id IS NULL AND deleted_at IS NULL AND collection_row_id IS NULL ORDER BY created_at DESC",
                 (ws_id,),
             ).fetchall()
         items = []
@@ -916,13 +916,13 @@ async def library_page(request: Request, owner: str = Query(default=""), repo: s
         if ws_key:
             rows = conn.execute(
                 "SELECT id, title, workspace, updated_at FROM pages "
-                "WHERE workspace=? ORDER BY updated_at DESC",
+                "WHERE workspace=? AND collection_row_id IS NULL ORDER BY updated_at DESC",
                 (ws_key,),
             ).fetchall()
         else:
             rows = conn.execute(
                 "SELECT id, title, workspace, updated_at FROM pages "
-                "ORDER BY updated_at DESC",
+                "WHERE collection_row_id IS NULL ORDER BY updated_at DESC",
             ).fetchall()
     all_pages = []
     for r in rows:
@@ -1125,11 +1125,21 @@ async def update_synced_block_api(request: Request, sid: int):
         body = await request.json()
     except Exception:
         raise HTTPException(400, "Invalid JSON body") from None
-    from app.services.synced_blocks import get_synced_block, update_synced_block
+    from app.services.synced_blocks import (
+        get_synced_block,
+        page_ids_for_synced,
+        sync_synced_blocks_in_page,
+        update_synced_block,
+    )
     sb = get_synced_block(sid)
     if not sb:
         raise HTTPException(404, "Synced block not found")
     update_synced_block(sid, body.get("title", sb["title"]), body.get("content", []))
+    # v6.5.0: rewrite every referencing page's stored content first (DB row
+    # content pages included), THEN push the realtime update so open rooms
+    # reload the fresh content from the DB.
+    for pid in page_ids_for_synced(sid):
+        sync_synced_blocks_in_page(pid)
     from app.services.realtime_server import manager
     await manager._propagate_synced(sid)
     return {"status": "ok"}
@@ -1138,11 +1148,22 @@ async def update_synced_block_api(request: Request, sid: int):
 @router.delete("/api/synced-blocks/{sid}")
 async def delete_synced_block_api(request: Request, sid: int):
     """Delete a synced block."""
-    from app.services.synced_blocks import delete_synced_block, get_synced_block
+    from app.services.synced_blocks import (
+        delete_synced_block,
+        get_synced_block,
+        mark_synced_block_deleted,
+        page_ids_for_synced,
+    )
     sb = get_synced_block(sid)
     if not sb:
         raise HTTPException(404, "Synced block not found")
+    # v6.5.0: collect referencing pages BEFORE the FK cascade wipes the
+    # refs, rewrite their stored content (deleted state), then broadcast.
+    pids = page_ids_for_synced(sid)
     delete_synced_block(sid)
+    mark_synced_block_deleted(sid, pids)
+    from app.services.realtime_server import manager
+    await manager._broadcast_synced_to(pids, sid)
     return {"status": "ok"}
 
 
@@ -1426,6 +1447,9 @@ async def update_page(request: Request, page_id: int, title: str = Query(default
         _ensure_page_editable(conn, page_id, user)
         if title:
             conn.execute("UPDATE pages SET title=?, updated_at=CURRENT_TIMESTAMP WHERE id=?", (title, page_id))
+            # v6.5.0: renaming a database row's content page updates the row.
+            from app.services.row_pages import sync_page_title_to_row
+            sync_page_title_to_row(conn, page_id)
         if content:
             conn.execute("UPDATE pages SET content=?, updated_at=CURRENT_TIMESTAMP WHERE id=?", (content, page_id))
         if content_format:
@@ -1473,6 +1497,9 @@ async def save_page_blocks(request: Request, page_id: int):
         _ensure_page_editable(conn, page_id, user)
         if title:
             conn.execute("UPDATE pages SET title=?, updated_at=CURRENT_TIMESTAMP WHERE id=?", (title, page_id))
+            # v6.5.0: renaming a database row's content page updates the row.
+            from app.services.row_pages import sync_page_title_to_row
+            sync_page_title_to_row(conn, page_id)
         conn.execute(
             "UPDATE pages SET content=?, content_format='blocks', updated_at=CURRENT_TIMESTAMP WHERE id=?",
             (blocks_json, page_id),
@@ -1974,6 +2001,10 @@ async def view_page(request: Request, page_id: int):
         if not row:
             return HTMLResponse("<h2>Page not found</h2>", status_code=404)
     page = dict(row)
+    # v6.5.0: synced blocks resolve server-side at read time (fresh content
+    # even when the stored cache is stale).
+    from app.services.synced_blocks import resolve_content_json
+    page["content"] = resolve_content_json(page.get("content", ""), page.get("content_format"))
 
     ws = page.get("workspace", "")
     parts = ws.split("/") if "/" in ws else ["", ""]

app/routers/collections.py

@@ -499,6 +499,32 @@ async def get_page_api(request: Request, page_id: int):
     return dict(page)
 
 
+@router.get("/pages/{page_id}/open/api")
+async def open_row_page_api(request: Request, page_id: int):
+    """v6.5.0 — content page of a database row (lazy-created).
+
+    Any DB view (table/board/gallery/list/calendar) opens a row through
+    this endpoint: it returns the shadow ``pages`` id whose full page
+    editor carries the row's block content (synced blocks included).
+    """
+    with get_conn() as conn:
+        row = conn.execute(
+            "SELECT collection_id FROM collection_pages WHERE id=?",
+            (page_id,),
+        ).fetchone()
+        if not row:
+            raise HTTPException(status_code=404, detail="Page not found")
+        coll_id = row["collection_id"]
+    # v6.0.0: granular collection permissions (same gate as the row itself).
+    _require_view(coll_id, _session_user(request))
+    from app.services.row_pages import ensure_row_page
+    try:
+        content_page_id = ensure_row_page(page_id)
+    except KeyError:
+        raise HTTPException(status_code=404, detail="Page not found") from None
+    return {"page_id": content_page_id, "row_id": page_id}
+
+
 @router.put("/pages/{page_id}/api")
 async def update_page_api(request: Request, page_id: int):
     """API: update a page's properties."""
@@ -552,6 +578,9 @@ async def update_page_api(request: Request, page_id: int):
                WHERE id=?""",
             (title, icon, cover_url, position, parent_id, property_values, page_id),
         )
+        # v6.5.0: keep the row's content page title in sync (row → page).
+        from app.services.row_pages import sync_row_title_to_page
+        sync_row_title_to_page(conn, page_id)
         conn.commit()
 
     await fire_event("page.updated", {

app/routers/dashboard.py

@@ -321,6 +321,9 @@ async def view_page_root(request: Request, page_id: int):
         if not row:
             return RedirectResponse("/workspaces", status_code=302)
     page = dict(row)
+    # v6.5.0: synced blocks resolve server-side at read time.
+    from app.services.synced_blocks import resolve_content_json
+    page["content"] = resolve_content_json(page.get("content", ""), page.get("content_format"))
 
     ws = page.get("workspace", "")
     parts = ws.split("/") if "/" in ws else ["", ""]
@@ -885,7 +888,7 @@ async def list_workspace_projects(request: Request):
     builtin = []
     with get_conn() as conn:
         rows = conn.execute(
-            "SELECT id, title FROM pages WHERE parent_id IS NULL ORDER BY updated_at DESC LIMIT 20"
+            "SELECT id, title FROM pages WHERE parent_id IS NULL AND collection_row_id IS NULL ORDER BY updated_at DESC LIMIT 20"
         ).fetchall()
         for r in rows:
             count = conn.execute("SELECT COUNT(*) FROM pages WHERE parent_id=?", (r["id"],)).fetchone()[0]
@@ -1081,7 +1084,9 @@ async def get_page_content(page_id: int):
     fmt = row["content_format"]
     if fmt == "file":
         return JSONResponse({"content": "(uploaded file)", "format": fmt})
-    return {"content": row["content"] or "", "format": fmt}
+    # v6.5.0: resolve synced blocks server-side (fresh content on read).
+    from app.services.synced_blocks import resolve_content_json
+    return {"content": resolve_content_json(row["content"] or "", fmt), "format": fmt}
 
 
 def _file_page_disk_path(page: dict):
@@ -1185,7 +1190,7 @@ def _build_tree_children(conn, parent_id: int | None, ws_id: int, uid: int | Non
             "SELECT id, title, parent_section, content_format, content, page_icon, "
             "(is_shared OR share_mode != 'private' OR COALESCE(published,0)) as is_shared, "
             "created_at, updated_at FROM pages "
-            "WHERE parent_id IS NULL AND workspace_id=? AND deleted_at IS NULL "
+            "WHERE parent_id IS NULL AND workspace_id=? AND deleted_at IS NULL AND collection_row_id IS NULL "
             "ORDER BY created_at DESC",
             (ws_id,),
         ).fetchall()
@@ -1364,7 +1369,7 @@ async def nav_menu(request: Request, workspace_id: int = None, parent_id: int =
         else:
             rows = conn.execute(
                 "SELECT id, title, parent_section, content_format FROM pages "
-                "WHERE parent_id IS NULL AND workspace_id=? AND deleted_at IS NULL "
+                "WHERE parent_id IS NULL AND workspace_id=? AND deleted_at IS NULL AND collection_row_id IS NULL "
                 "ORDER BY sort_order ASC, created_at DESC",
                 (ws_id,),
             ).fetchall()
@@ -1726,7 +1731,7 @@ async def list_workspaces(request: Request):
     uid = user["id"] if user and user.get("id") else 1
     with get_conn() as conn:
         rows = conn.execute(
-            "SELECT w.*, (SELECT COUNT(*) FROM pages WHERE workspace_id=w.id) as page_count "
+            "SELECT w.*, (SELECT COUNT(*) FROM pages WHERE workspace_id=w.id AND collection_row_id IS NULL) as page_count "
             "FROM workspaces w WHERE w.owner_id=? ORDER BY w.created_at DESC",
             (uid,),
         ).fetchall()
@@ -2213,6 +2218,8 @@ h1{font-size:3rem;opacity:.3}</style></head><body><h1>404</h1></body></html>""",
         import json as _json
         try:
             blocks = _json.loads(page["content"])
+            from app.services.synced_blocks import resolve_synced_block
+            blocks = resolve_synced_block(blocks)
             from app.db import get_conn as _gc
             from app.services.wiki_links import token_labels
             with _gc() as conn:
@@ -2413,6 +2420,31 @@ def _render_blocks_public(blocks: list, titles: dict | None = None) -> str:
                     f'background:#0a0a0a;"><iframe src="{src}" loading="lazy" frameborder="0" '
                     f'style="position:absolute;inset:0;width:100%;height:100%;" allowfullscreen allow="autoplay; encrypted-media; picture-in-picture"></iframe></div>'
                 )
+        elif t == "synced":
+            # v6.5.0: render synced block instances (resolved server-side).
+            if b.get("_synced_deleted"):
+                html_parts.append(
+                    '<div style="margin:8px 0;padding:8px 12px;border-left:3px solid #e05e5e;'
+                    'background:rgba(224,94,94,.08);border-radius:4px;font-size:13px;opacity:.8;">'
+                    'Deleted synced block</div>'
+                )
+            else:
+                inner = b.get("_synced_content")
+                if not isinstance(inner, list) or not inner:
+                    try:
+                        import json as _sj
+                        parsed = _sj.loads(b.get("content") or "[]")
+                        inner = parsed if isinstance(parsed, list) else []
+                    except (ValueError, TypeError):
+                        inner = []
+                inner = [{"type": "paragraph", "content": str(x)} if not isinstance(x, dict) else x
+                         for x in inner]
+                if inner:
+                    html_parts.append(
+                        '<div style="margin:8px 0;padding-left:12px;'
+                        'border-left:3px solid var(--accent,#4c9aff);">'
+                        + _render_blocks_public(inner, titles) + '</div>'
+                    )
         else:
             html_parts.append(f'<p style="margin:4px 0;line-height:1.7;">{c}</p>')
     return "\n".join(html_parts)
@@ -2430,9 +2462,11 @@ async def api_page_content(page_id: int):
         ).fetchone()
         if not row:
             return JSONResponse({"error": "Not found"}, status_code=404)
+    # v6.5.0: resolve synced blocks server-side (fresh content on read).
+    from app.services.synced_blocks import resolve_content_json
     return {
         "title": row["title"],
-        "content": row["content"],
+        "content": resolve_content_json(row["content"], row["content_format"]),
         "format": row["content_format"] or "blocks",
     }
 
@@ -2449,6 +2483,9 @@ async def api_rename_page(page_id: int, request: Request):
             "UPDATE pages SET title=?, updated_at=CURRENT_TIMESTAMP WHERE id=? AND deleted_at IS NULL",
             (title, page_id),
         )
+        # v6.5.0: renaming a database row's content page updates the row.
+        from app.services.row_pages import sync_page_title_to_row
+        sync_page_title_to_row(conn, page_id)
         conn.commit()
     return {"status": "ok", "title": title}