feat(v1.3.0): Database Concept — collections, pages, views, GiteaBoardCompat
FlowDeck CI / test (push) Failing after 4s
FlowDeck CI / docker (push) Has been skipped

Database foundation:
- New tables: collections, collection_pages, collection_views
- Router /db with full CRUD API
- GiteaBoardCompat adapter for legacy board compatibility
- CSRF exemption for /db/ routes
- 34/34 tests pass
- Version bump 1.0.0 → 1.3.0
- Deployed and verified on Docker port 8080
This commit is contained in:
2026-07-09 22:33:39 -04:00
parent b9723dffab
commit c574d2c8b5
6 changed files with 424 additions and 136 deletions
+1 -1
View File
@@ -57,7 +57,7 @@ async def health():
return {
"status": "ok" if (db_ok and gitea_ok) else "degraded",
"version": "1.0.0",
"version": "1.3.0",
"db": db_ok,
"gitea": gitea_ok,
}
+166 -131
View File
@@ -5,7 +5,7 @@ import json
import logging
from fastapi import APIRouter, Request, HTTPException, Query
from fastapi.responses import HTMLResponse, RedirectResponse
from fastapi.responses import HTMLResponse
from app.db import get_conn
from app.auth.session import SessionManager
@@ -14,15 +14,7 @@ logger = logging.getLogger(__name__)
router = APIRouter(tags=["collections"], prefix="/db")
def _get_workspace(request: Request) -> str:
"""Returns the current workspace name from session."""
user = SessionManager.decode_session(
request.cookies.get("flowdeck_session", "")
)
return user.get("login", "Default") if user else "Default"
# ── Collection CRUD ──
# ── API: List & Create (no path params) ──
@router.get("", response_class=HTMLResponse)
@@ -79,7 +71,6 @@ async def create_collection_api(request: Request):
)
collection_id = cur.lastrowid
# Create a default table view
conn.execute(
"""INSERT INTO collection_views
(collection_id, name, view_type, config_json)
@@ -95,6 +86,170 @@ async def create_collection_api(request: Request):
return {"id": collection_id, "name": name, "status": "created"}
# ── API: Update & Delete (no path-param conflicts) ──
@router.put("/api/{collection_id}")
async def update_collection_api(request: Request, collection_id: int):
"""API: update a collection."""
try:
body = await request.json()
except Exception:
body = {}
with get_conn() as conn:
existing = conn.execute(
"SELECT * FROM collections WHERE id=?", (collection_id,)
).fetchone()
if not existing:
raise HTTPException(status_code=404, detail="Collection not found")
name = body.get("name", existing["name"])
description = body.get("description", existing["description"])
icon = body.get("icon", existing["icon"])
is_locked = body.get("is_locked", existing["is_locked"])
schema_json = json.dumps(body.get("schema", json.loads(existing["schema_json"])))
gitea_owner = body.get("gitea_owner", existing["gitea_owner"])
gitea_repo = body.get("gitea_repo", existing["gitea_repo"])
conn.execute(
"""UPDATE collections SET name=?, description=?, icon=?, schema_json=?,
is_locked=?, gitea_owner=?, gitea_repo=?, updated_at=CURRENT_TIMESTAMP
WHERE id=?""",
(name, description, icon, schema_json, int(is_locked),
gitea_owner, gitea_repo, collection_id),
)
conn.commit()
return {"id": collection_id, "status": "updated"}
@router.delete("/api/{collection_id}")
async def delete_collection_api(request: Request, collection_id: int):
"""API: delete a collection and its pages (CASCADE)."""
with get_conn() as conn:
existing = conn.execute(
"SELECT * FROM collections WHERE id=?", (collection_id,)
).fetchone()
if not existing:
raise HTTPException(status_code=404, detail="Collection not found")
conn.execute("DELETE FROM collections WHERE id=?", (collection_id,))
conn.commit()
return {"id": collection_id, "status": "deleted"}
# ── Page CRUD (standalone, BEFORE collection wildcards) ──
@router.get("/pages/{page_id}/api")
async def get_page_api(request: Request, page_id: int):
"""API: get a single page."""
with get_conn() as conn:
page = conn.execute(
"SELECT * FROM collection_pages WHERE id=?", (page_id,)
).fetchone()
if not page:
raise HTTPException(status_code=404, detail="Page not found")
return dict(page)
@router.put("/pages/{page_id}/api")
async def update_page_api(request: Request, page_id: int):
"""API: update a page's properties."""
try:
body = await request.json()
except Exception:
body = {}
with get_conn() as conn:
existing = conn.execute(
"SELECT * FROM collection_pages WHERE id=?", (page_id,)
).fetchone()
if not existing:
raise HTTPException(status_code=404, detail="Page not found")
title = body.get("title", existing["title"])
icon = body.get("icon", existing["icon"])
position = body.get("position", existing["position"])
parent_id = body.get("parent_id", existing["parent_id"])
property_values = json.dumps(
body.get("properties", json.loads(existing["property_values_json"]))
)
conn.execute(
"""UPDATE collection_pages
SET title=?, icon=?, position=?, parent_id=?, property_values_json=?,
updated_at=CURRENT_TIMESTAMP
WHERE id=?""",
(title, icon, position, parent_id, property_values, page_id),
)
conn.commit()
return {"id": page_id, "status": "updated"}
@router.delete("/pages/{page_id}/api")
async def delete_page_api(request: Request, page_id: int):
"""API: delete a page from its collection."""
with get_conn() as conn:
existing = conn.execute(
"SELECT * FROM collection_pages WHERE id=?", (page_id,)
).fetchone()
if not existing:
raise HTTPException(status_code=404, detail="Page not found")
conn.execute("DELETE FROM collection_pages WHERE id=?", (page_id,))
conn.commit()
return {"id": page_id, "status": "deleted"}
# ── Gitea Board Compatibility (BEFORE {collection_id} wildcards) ──
@router.get("/boards/api")
async def list_boards_as_collections(request: Request):
"""API: list all Gitea boards as pseudo-collections."""
from app.services.collection_adapter import GiteaBoardCompat
boards = GiteaBoardCompat.list_boards_as_collections()
return {"boards": boards}
@router.get("/board/{owner}/{repo}/api")
async def get_board_as_collection(request: Request, owner: str, repo: str):
"""API: get a specific Gitea board as a pseudo-collection."""
from app.services.collection_adapter import GiteaBoardCompat
coll = GiteaBoardCompat.get_board_as_collection(owner, repo)
if not coll:
raise HTTPException(status_code=404, detail="Board not found")
from app.services.gitea_client import gitea
issues = await gitea.get_issues(owner, repo, state="all")
cards = GiteaBoardCompat.get_board_cards(owner, repo, issues)
return {"collection": coll, "pages": cards}
@router.post("/board/{owner}/{repo}/sync")
async def sync_board_to_collection(request: Request, owner: str, repo: str):
"""Sync a Gitea board to a real collection."""
from app.services.collection_adapter import GiteaBoardCompat
from app.services.gitea_client import gitea
issues = await gitea.get_issues(owner, repo, state="all")
coll_id = GiteaBoardCompat.sync_to_collection(owner, repo, issues)
if coll_id is None:
raise HTTPException(status_code=404, detail="Board not found")
return {"collection_id": coll_id, "status": "synced"}
# ── {collection_id} wildcards (LAST — catches everything else) ──
@router.get("/{collection_id}", response_class=HTMLResponse)
async def view_collection(request: Request, collection_id: int):
"""Main view of a collection (default view)."""
@@ -158,60 +313,6 @@ async def get_collection_api(request: Request, collection_id: int):
}
@router.put("/api/{collection_id}")
async def update_collection_api(request: Request, collection_id: int):
"""API: update a collection."""
try:
body = await request.json()
except Exception:
body = {}
with get_conn() as conn:
existing = conn.execute(
"SELECT * FROM collections WHERE id=?", (collection_id,)
).fetchone()
if not existing:
raise HTTPException(status_code=404, detail="Collection not found")
name = body.get("name", existing["name"])
description = body.get("description", existing["description"])
icon = body.get("icon", existing["icon"])
is_locked = body.get("is_locked", existing["is_locked"])
schema_json = json.dumps(body.get("schema", json.loads(existing["schema_json"])))
gitea_owner = body.get("gitea_owner", existing["gitea_owner"])
gitea_repo = body.get("gitea_repo", existing["gitea_repo"])
conn.execute(
"""UPDATE collections SET name=?, description=?, icon=?, schema_json=?,
is_locked=?, gitea_owner=?, gitea_repo=?, updated_at=CURRENT_TIMESTAMP
WHERE id=?""",
(name, description, icon, schema_json, int(is_locked),
gitea_owner, gitea_repo, collection_id),
)
conn.commit()
return {"id": collection_id, "status": "updated"}
@router.delete("/api/{collection_id}")
async def delete_collection_api(request: Request, collection_id: int):
"""API: delete a collection and its pages (CASCADE)."""
with get_conn() as conn:
existing = conn.execute(
"SELECT * FROM collections WHERE id=?", (collection_id,)
).fetchone()
if not existing:
raise HTTPException(status_code=404, detail="Collection not found")
conn.execute("DELETE FROM collections WHERE id=?", (collection_id,))
conn.commit()
return {"id": collection_id, "status": "deleted"}
# ── Collection Pages CRUD ──
@router.post("/{collection_id}/pages/api")
async def create_page_api(request: Request, collection_id: int):
"""API: create a page in a collection."""
@@ -230,12 +331,10 @@ async def create_page_api(request: Request, collection_id: int):
gitea_issue_number = body.get("gitea_issue_number")
with get_conn() as conn:
# Verify collection exists
coll = conn.execute("SELECT id FROM collections WHERE id=?", (collection_id,)).fetchone()
if not coll:
raise HTTPException(status_code=404, detail="Collection not found")
# Get next position
max_pos = conn.execute(
"SELECT COALESCE(MAX(position), -1) + 1 FROM collection_pages WHERE collection_id=?",
(collection_id,),
@@ -251,67 +350,3 @@ async def create_page_api(request: Request, collection_id: int):
page_id = cur.lastrowid
return {"id": page_id, "title": title, "status": "created"}
@router.get("/pages/{page_id}/api")
async def get_page_api(request: Request, page_id: int):
"""API: get a single page."""
with get_conn() as conn:
page = conn.execute(
"SELECT * FROM collection_pages WHERE id=?", (page_id,)
).fetchone()
if not page:
raise HTTPException(status_code=404, detail="Page not found")
return dict(page)
@router.put("/pages/{page_id}/api")
async def update_page_api(request: Request, page_id: int):
"""API: update a page's properties."""
try:
body = await request.json()
except Exception:
body = {}
with get_conn() as conn:
existing = conn.execute(
"SELECT * FROM collection_pages WHERE id=?", (page_id,)
).fetchone()
if not existing:
raise HTTPException(status_code=404, detail="Page not found")
title = body.get("title", existing["title"])
icon = body.get("icon", existing["icon"])
position = body.get("position", existing["position"])
parent_id = body.get("parent_id", existing["parent_id"])
property_values = json.dumps(
body.get("properties", json.loads(existing["property_values_json"]))
)
conn.execute(
"""UPDATE collection_pages
SET title=?, icon=?, position=?, parent_id=?, property_values_json=?,
updated_at=CURRENT_TIMESTAMP
WHERE id=?""",
(title, icon, position, parent_id, property_values, page_id),
)
conn.commit()
return {"id": page_id, "status": "updated"}
@router.delete("/pages/{page_id}/api")
async def delete_page_api(request: Request, page_id: int):
"""API: delete a page from its collection."""
with get_conn() as conn:
existing = conn.execute(
"SELECT * FROM collection_pages WHERE id=?", (page_id,)
).fetchone()
if not existing:
raise HTTPException(status_code=404, detail="Page not found")
conn.execute("DELETE FROM collection_pages WHERE id=?", (page_id,))
conn.commit()
return {"id": page_id, "status": "deleted"}