feat: initialize blog app with blueprints and templates

Extract blog-specific code from the coop monolith into a standalone
repository. Includes auth, blog, post, admin, menu_items, snippets
blueprints, associated templates, Dockerfile (APP_MODULE=app:app),
entrypoint, and Gitea CI workflow.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

bp/menu_items/services/menu_items.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func
+from models.menu_item import MenuItem
+from models.ghost_content import Post
+
+
+class MenuItemError(ValueError):
+    """Base error for menu item service operations."""
+
+
+async def get_all_menu_items(session: AsyncSession) -> list[MenuItem]:
+    """
+    Get all menu items (excluding deleted), ordered by sort_order.
+    Eagerly loads the post relationship.
+    """
+    from sqlalchemy.orm import selectinload
+
+    result = await session.execute(
+        select(MenuItem)
+        .where(MenuItem.deleted_at.is_(None))
+        .options(selectinload(MenuItem.post))
+        .order_by(MenuItem.sort_order.asc(), MenuItem.id.asc())
+    )
+    return list(result.scalars().all())
+
+
+async def get_menu_item_by_id(session: AsyncSession, item_id: int) -> MenuItem | None:
+    """Get a menu item by ID (excluding deleted)."""
+    from sqlalchemy.orm import selectinload
+
+    result = await session.execute(
+        select(MenuItem)
+        .where(MenuItem.id == item_id, MenuItem.deleted_at.is_(None))
+        .options(selectinload(MenuItem.post))
+    )
+    return result.scalar_one_or_none()
+
+
+async def create_menu_item(
+    session: AsyncSession,
+    post_id: int,
+    sort_order: int | None = None
+) -> MenuItem:
+    """
+    Create a new menu item.
+    If sort_order is not provided, adds to end of list.
+    """
+    # Verify post exists and is a page
+    post = await session.scalar(
+        select(Post).where(Post.id == post_id)
+    )
+    if not post:
+        raise MenuItemError(f"Post {post_id} does not exist.")
+
+    if not post.is_page:
+        raise MenuItemError("Only pages can be added as menu items, not posts.")
+
+    # If no sort_order provided, add to end
+    if sort_order is None:
+        max_order = await session.scalar(
+            select(func.max(MenuItem.sort_order))
+            .where(MenuItem.deleted_at.is_(None))
+        )
+        sort_order = (max_order or 0) + 1
+
+    # Check for duplicate (same post, not deleted)
+    existing = await session.scalar(
+        select(MenuItem).where(
+            MenuItem.post_id == post_id,
+            MenuItem.deleted_at.is_(None)
+        )
+    )
+    if existing:
+        raise MenuItemError(f"Menu item for this page already exists.")
+
+    menu_item = MenuItem(
+        post_id=post_id,
+        sort_order=sort_order
+    )
+    session.add(menu_item)
+    await session.flush()
+
+    # Reload with post relationship
+    await session.refresh(menu_item, ["post"])
+
+    return menu_item
+
+
+async def update_menu_item(
+    session: AsyncSession,
+    item_id: int,
+    post_id: int | None = None,
+    sort_order: int | None = None
+) -> MenuItem:
+    """Update an existing menu item."""
+    menu_item = await get_menu_item_by_id(session, item_id)
+    if not menu_item:
+        raise MenuItemError(f"Menu item {item_id} not found.")
+
+    if post_id is not None:
+        # Verify post exists and is a page
+        post = await session.scalar(
+            select(Post).where(Post.id == post_id)
+        )
+        if not post:
+            raise MenuItemError(f"Post {post_id} does not exist.")
+
+        if not post.is_page:
+            raise MenuItemError("Only pages can be added as menu items, not posts.")
+
+        # Check for duplicate (same post, different menu item)
+        existing = await session.scalar(
+            select(MenuItem).where(
+                MenuItem.post_id == post_id,
+                MenuItem.id != item_id,
+                MenuItem.deleted_at.is_(None)
+            )
+        )
+        if existing:
+            raise MenuItemError(f"Menu item for this page already exists.")
+
+        menu_item.post_id = post_id
+
+    if sort_order is not None:
+        menu_item.sort_order = sort_order
+
+    await session.flush()
+    await session.refresh(menu_item, ["post"])
+
+    return menu_item
+
+
+async def delete_menu_item(session: AsyncSession, item_id: int) -> bool:
+    """Soft delete a menu item."""
+    menu_item = await get_menu_item_by_id(session, item_id)
+    if not menu_item:
+        return False
+
+    menu_item.deleted_at = func.now()
+    await session.flush()
+
+    return True
+
+
+async def reorder_menu_items(
+    session: AsyncSession,
+    item_ids: list[int]
+) -> list[MenuItem]:
+    """
+    Reorder menu items by providing a list of IDs in desired order.
+    Updates sort_order for each item.
+    """
+    items = []
+    for index, item_id in enumerate(item_ids):
+        menu_item = await get_menu_item_by_id(session, item_id)
+        if menu_item:
+            menu_item.sort_order = index
+            items.append(menu_item)
+
+    await session.flush()
+
+    return items
+
+
+async def search_pages(
+    session: AsyncSession,
+    query: str,
+    page: int = 1,
+    per_page: int = 10
+) -> tuple[list[Post], int]:
+    """
+    Search for pages (not posts) by title.
+    Returns (pages, total_count).
+    """
+    # Build search filter
+    filters = [
+        Post.is_page == True,  # noqa: E712
+        Post.status == "published",
+        Post.deleted_at.is_(None)
+    ]
+
+    if query:
+        filters.append(Post.title.ilike(f"%{query}%"))
+
+    # Get total count
+    count_result = await session.execute(
+        select(func.count(Post.id)).where(*filters)
+    )
+    total = count_result.scalar() or 0
+
+    # Get paginated results
+    offset = (page - 1) * per_page
+    result = await session.execute(
+        select(Post)
+        .where(*filters)
+        .order_by(Post.title.asc())
+        .limit(per_page)
+        .offset(offset)
+    )
+    pages = list(result.scalars().all())
+
+    return pages, total