simple-module-pagebuilder 0.0.1__py3-none-any.whl

pagebuilder/endpoints/api/layout.py

@@ -0,0 +1,78 @@
+"""Site-wide layout and its revision history."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends
+from simple_module_db import get_db
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from pagebuilder.contracts.schemas import (
+    LayoutDetail,
+    LayoutRevisionDetail,
+    LayoutRevisionListResponse,
+    LayoutRevisionRead,
+    LayoutUpdate,
+)
+from pagebuilder.endpoints.api._deps import require_edit
+from pagebuilder.layout_service import LayoutService
+
+router = APIRouter()
+
+
+@router.get("/layout", response_model=LayoutDetail)
+async def get_layout(db: AsyncSession = Depends(get_db)) -> LayoutDetail:
+    """Return the site-wide layout. Created lazily on first read."""
+    layout = await LayoutService(db).get()
+    return LayoutDetail.model_validate(layout)
+
+
+@router.put(
+    "/layout",
+    response_model=LayoutDetail,
+    dependencies=[require_edit],
+)
+async def update_layout(
+    body: LayoutUpdate,
+    db: AsyncSession = Depends(get_db),
+) -> LayoutDetail:
+    layout = await LayoutService(db).update(
+        header_data=body.header_data,
+        footer_data=body.footer_data,
+        note=body.note,
+    )
+    return LayoutDetail.model_validate(layout)
+
+
+@router.get("/layout/revisions", response_model=LayoutRevisionListResponse)
+async def list_layout_revisions(
+    db: AsyncSession = Depends(get_db),
+) -> LayoutRevisionListResponse:
+    revisions = await LayoutService(db).list_revisions()
+    return LayoutRevisionListResponse(
+        items=[LayoutRevisionRead.model_validate(r) for r in revisions]
+    )
+
+
+@router.get(
+    "/layout/revisions/{revision_id}",
+    response_model=LayoutRevisionDetail,
+)
+async def get_layout_revision(
+    revision_id: int,
+    db: AsyncSession = Depends(get_db),
+) -> LayoutRevisionDetail:
+    revision = await LayoutService(db).get_revision(revision_id)
+    return LayoutRevisionDetail.model_validate(revision)
+
+
+@router.post(
+    "/layout/revisions/{revision_id}/restore",
+    response_model=LayoutDetail,
+    dependencies=[require_edit],
+)
+async def restore_layout_revision(
+    revision_id: int,
+    db: AsyncSession = Depends(get_db),
+) -> LayoutDetail:
+    layout = await LayoutService(db).restore(revision_id)
+    return LayoutDetail.model_validate(layout)

pagebuilder/endpoints/api/pages.py

@@ -0,0 +1,85 @@
+"""Page CRUD and listing endpoints."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, Request, status
+from simple_module_db import get_db
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from pagebuilder.contracts.schemas import (
+    PageCreate,
+    PageDetail,
+    PageListResponse,
+    PageRead,
+    PageUpdate,
+)
+from pagebuilder.endpoints.api._deps import require_approve, require_edit
+from pagebuilder.service import PagesService
+
+router = APIRouter()
+
+
+@router.get("/pages", response_model=PageListResponse)
+async def list_pages(db: AsyncSession = Depends(get_db)) -> PageListResponse:
+    pages = await PagesService(db).list_pages()
+    return PageListResponse(items=[PageRead.model_validate(p) for p in pages])
+
+
+# Declared before "/pages/{page_id}" so the literal path wins the match.
+# Keep these two adjacent — separating them across modules would make the
+# ordering depend on router include order instead of being visible here.
+@router.get(
+    "/pages/pending",
+    response_model=PageListResponse,
+    dependencies=[require_approve],
+)
+async def list_pending(db: AsyncSession = Depends(get_db)) -> PageListResponse:
+    """Approver queue — pages currently in ``submitted_for_review``."""
+    pages = await PagesService(db).list_pending()
+    return PageListResponse(items=[PageRead.model_validate(p) for p in pages])
+
+
+@router.post(
+    "/pages",
+    response_model=PageDetail,
+    status_code=status.HTTP_201_CREATED,
+    dependencies=[require_edit],
+)
+async def create_page(data: PageCreate, db: AsyncSession = Depends(get_db)) -> PageDetail:
+    page = await PagesService(db).create(data)
+    return PageDetail.model_validate(page)
+
+
+@router.get("/pages/{page_id}", response_model=PageDetail)
+async def get_page(page_id: int, db: AsyncSession = Depends(get_db)) -> PageDetail:
+    page = await PagesService(db).get_page(page_id)
+    return PageDetail.model_validate(page)
+
+
+@router.put(
+    "/pages/{page_id}",
+    response_model=PageDetail,
+    dependencies=[require_edit],
+)
+async def update_page(
+    page_id: int,
+    data: PageUpdate,
+    db: AsyncSession = Depends(get_db),
+) -> PageDetail:
+    page = await PagesService(db).update(page_id, data)
+    return PageDetail.model_validate(page)
+
+
+@router.delete(
+    "/pages/{page_id}",
+    status_code=status.HTTP_204_NO_CONTENT,
+    dependencies=[require_edit],
+)
+async def delete_page(
+    page_id: int, request: Request, db: AsyncSession = Depends(get_db)
+) -> None:
+    # The bus is passed only here: deleting a page is the one operation other
+    # modules must hear about, because nothing at the database level can tell
+    # them (no cross-module foreign keys, so no cascade).
+    bus = getattr(request.app.state.sm, "event_bus", None)
+    await PagesService(db, event_bus=bus).delete(page_id)

pagebuilder/endpoints/api/revisions.py

@@ -0,0 +1,79 @@
+"""Page revision history, diffing, and restore."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends
+from simple_module_db import get_db
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from pagebuilder.contracts.schemas import (
+    PageDetail,
+    PageRevisionDetail,
+    PageRevisionListResponse,
+    PageRevisionRead,
+    RevisionDiffResponse,
+)
+from pagebuilder.endpoints.api._deps import require_edit
+from pagebuilder.service import PagesService
+
+router = APIRouter()
+
+
+@router.get("/pages/{page_id}/revisions", response_model=PageRevisionListResponse)
+async def list_revisions(
+    page_id: int,
+    db: AsyncSession = Depends(get_db),
+) -> PageRevisionListResponse:
+    service = PagesService(db)
+    await service.get_page(page_id)
+    revisions = await service.list_revisions(page_id)
+    return PageRevisionListResponse(items=[PageRevisionRead.model_validate(r) for r in revisions])
+
+
+@router.get(
+    "/pages/{page_id}/revisions/{revision_id}",
+    response_model=PageRevisionDetail,
+)
+async def get_revision(
+    page_id: int,
+    revision_id: int,
+    db: AsyncSession = Depends(get_db),
+) -> PageRevisionDetail:
+    revision = await PagesService(db).get_revision(page_id, revision_id)
+    return PageRevisionDetail.model_validate(revision)
+
+
+@router.get(
+    "/pages/{page_id}/revisions/{before_id}/diff/{after_id}",
+    response_model=RevisionDiffResponse,
+    response_model_exclude_none=True,
+)
+async def diff_revisions(
+    page_id: int,
+    before_id: int,
+    after_id: int,
+    db: AsyncSession = Depends(get_db),
+) -> RevisionDiffResponse:
+    """Block-level diff between two revisions.
+
+    The URL spells the direction explicitly (``before`` vs ``after``)
+    rather than relying on numeric ordering — restoring an older
+    revision can produce a higher id with older content, so id sort
+    isn't a reliable proxy for chronology.
+    """
+    result = await PagesService(db).diff_revisions(page_id, before_id, after_id)
+    return RevisionDiffResponse.model_validate(result)
+
+
+@router.post(
+    "/pages/{page_id}/revisions/{revision_id}/restore",
+    response_model=PageDetail,
+    dependencies=[require_edit],
+)
+async def restore_revision(
+    page_id: int,
+    revision_id: int,
+    db: AsyncSession = Depends(get_db),
+) -> PageDetail:
+    page = await PagesService(db).restore_revision(page_id, revision_id)
+    return PageDetail.model_validate(page)

pagebuilder/endpoints/api/uploads.py

@@ -0,0 +1,92 @@
+"""Media upload, listing, and deletion."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, Form, Query, UploadFile, status
+
+from pagebuilder.contracts.schemas import MediaAssetListResponse, MediaAssetRead
+from pagebuilder.deps import get_media_service
+from pagebuilder.endpoints.api._deps import require_edit
+from pagebuilder.media_service import MediaService
+
+router = APIRouter()
+
+
+@router.get("/uploads", response_model=MediaAssetListResponse)
+async def list_uploads(
+    media: MediaService = Depends(get_media_service),
+    search: str | None = Query(default=None, max_length=200),
+    content_type: str | None = Query(default=None, max_length=120),
+    folder: str | None = Query(default=None, max_length=300),
+    min_size_bytes: int | None = Query(default=None, ge=0),
+    max_size_bytes: int | None = Query(default=None, ge=0),
+    cursor: int | None = Query(default=None, ge=1),
+    offset: int | None = Query(
+        default=None,
+        ge=0,
+        description=(
+            'Offset paging, for callers that jump to an arbitrary page (the '
+            'image-picker gallery). Takes precedence over `cursor` and makes '
+            'the response carry `total`.'
+        ),
+    ),
+    limit: int = Query(default=60, ge=1, le=200),
+) -> MediaAssetListResponse:
+    # ``folder`` absent → no folder filter. ``folder=""`` (or whitespace)
+    # → the "Unfiled" sidebar bucket. Any other value → that exact path.
+    folder_filter: str | None = None
+    unfiled_only = False
+    if folder is not None:
+        trimmed = folder.strip().strip("/")
+        if trimmed:
+            folder_filter = trimmed
+        else:
+            unfiled_only = True
+    filters = {
+        "search": search,
+        "content_type": content_type,
+        "folder": folder_filter,
+        "unfiled_only": unfiled_only,
+        "min_size_bytes": min_size_bytes,
+        "max_size_bytes": max_size_bytes,
+    }
+    assets, next_cursor = await media.list_assets(
+        cursor=cursor, offset=offset, limit=limit, **filters
+    )
+    folders = await media.list_folders()
+    # The COUNT is only worth running for offset callers; cursor paging
+    # detects the end of the list from the row count it already fetched.
+    total = await media.count_assets(**filters) if offset is not None else None
+    return MediaAssetListResponse(
+        items=[media.to_read(a) for a in assets],
+        next_cursor=next_cursor,
+        folders=folders,
+        total=total,
+    )
+
+
+@router.post(
+    "/uploads",
+    response_model=MediaAssetRead,
+    status_code=status.HTTP_201_CREATED,
+    dependencies=[require_edit],
+)
+async def create_upload(
+    file: UploadFile,
+    folder: str | None = Form(default=None),
+    media: MediaService = Depends(get_media_service),
+) -> MediaAssetRead:
+    asset = await media.upload(file, folder=folder)
+    return media.to_read(asset)
+
+
+@router.delete(
+    "/uploads/{asset_id}",
+    status_code=status.HTTP_204_NO_CONTENT,
+    dependencies=[require_edit],
+)
+async def delete_upload(
+    asset_id: int,
+    media: MediaService = Depends(get_media_service),
+) -> None:
+    await media.delete(asset_id)

pagebuilder/endpoints/api/workflow.py

@@ -0,0 +1,124 @@
+"""Status-transition endpoints: publish, unpublish, submit, approve, reject, schedule."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends
+from simple_module_db import get_db
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from pagebuilder.contracts.schemas import (
+    PageNoteRequest,
+    PageRead,
+    PageRejectRequest,
+    PageScheduleRequest,
+)
+from pagebuilder.endpoints.api._deps import require_approve, require_edit, require_publish
+from pagebuilder.service import _UNSET, PagesService
+
+router = APIRouter()
+
+
+def _note(body: PageNoteRequest | None) -> str | None:
+    return body.note if body else None
+
+
+@router.post(
+    "/pages/{page_id}/publish",
+    response_model=PageRead,
+    dependencies=[require_publish],
+)
+async def publish_page(
+    page_id: int,
+    db: AsyncSession = Depends(get_db),
+    body: PageNoteRequest | None = None,
+) -> PageRead:
+    """Publish the current draft. The optional ``note`` is captured on
+    the revision row so the history panel can label the publish."""
+    page = await PagesService(db).publish(page_id, note=_note(body))
+    return PageRead.model_validate(page)
+
+
+@router.post(
+    "/pages/{page_id}/unpublish",
+    response_model=PageRead,
+    dependencies=[require_publish],
+)
+async def unpublish_page(
+    page_id: int,
+    db: AsyncSession = Depends(get_db),
+    body: PageNoteRequest | None = None,
+) -> PageRead:
+    page = await PagesService(db).unpublish(page_id, note=_note(body))
+    return PageRead.model_validate(page)
+
+
+@router.post(
+    "/pages/{page_id}/submit",
+    response_model=PageRead,
+    dependencies=[require_edit],
+)
+async def submit_page(
+    page_id: int,
+    db: AsyncSession = Depends(get_db),
+    body: PageNoteRequest | None = None,
+) -> PageRead:
+    """Editor action: hand a draft off to the approver queue."""
+    page = await PagesService(db).submit_for_review(page_id, note=_note(body))
+    return PageRead.model_validate(page)
+
+
+@router.post(
+    "/pages/{page_id}/approve",
+    response_model=PageRead,
+    dependencies=[require_approve],
+)
+async def approve_page(
+    page_id: int,
+    db: AsyncSession = Depends(get_db),
+    body: PageNoteRequest | None = None,
+) -> PageRead:
+    """Approver action: take a submission live (also publishes)."""
+    page = await PagesService(db).approve(page_id, note=_note(body))
+    return PageRead.model_validate(page)
+
+
+@router.post(
+    "/pages/{page_id}/schedule",
+    response_model=PageRead,
+    dependencies=[require_publish],
+)
+async def schedule_page(
+    page_id: int,
+    body: PageScheduleRequest,
+    db: AsyncSession = Depends(get_db),
+) -> PageRead:
+    """Set or clear scheduled flip timestamps.
+
+    Each field uses ``model_fields_set`` to distinguish "field absent"
+    (leave the existing value alone) from ``"field": null`` (clear). So
+    ``POST {"publish_at": "..."}`` only touches ``publish_at`` and leaves
+    ``unpublish_at`` as-is.
+    """
+    publish_at = body.publish_at if "publish_at" in body.model_fields_set else _UNSET
+    unpublish_at = body.unpublish_at if "unpublish_at" in body.model_fields_set else _UNSET
+    page = await PagesService(db).schedule(
+        page_id,
+        publish_at=publish_at,
+        unpublish_at=unpublish_at,
+    )
+    return PageRead.model_validate(page)
+
+
+@router.post(
+    "/pages/{page_id}/reject",
+    response_model=PageRead,
+    dependencies=[require_approve],
+)
+async def reject_page(
+    page_id: int,
+    body: PageRejectRequest,
+    db: AsyncSession = Depends(get_db),
+) -> PageRead:
+    """Approver action: send a submission back to draft with feedback."""
+    page = await PagesService(db).reject(page_id, body.note)
+    return PageRead.model_validate(page)

pagebuilder/endpoints/seo.py

@@ -0,0 +1,95 @@
+"""Public ``/sitemap.xml`` and ``/robots.txt`` routes (issue #24).
+
+Mounted directly on the host app from ``on_startup`` (alongside
+``/p/{slug}``) so the URLs sit at the site root, not under the admin
+prefix. Both routes are short-cached so a busy crawler doesn't hammer
+the page-list query, and both honour per-page ``index_in_search`` so a
+``noindex`` page is also kept out of discovery.
+"""
+
+from __future__ import annotations
+
+from xml.sax.saxutils import escape as xml_escape
+
+from fastapi import APIRouter, Depends, Request, Response
+from simple_module_db import get_db
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from pagebuilder.deps import get_settings
+from pagebuilder.service import PagesService
+from pagebuilder.settings import PagebuilderSettings
+
+seo_router = APIRouter()
+
+
+def _public_origin(request: Request, settings: PagebuilderSettings) -> str:
+    """Same fallback as the public viewer: explicit setting wins, else inferred."""
+    if settings.public_base_url:
+        return settings.public_base_url.rstrip("/")
+    return f"{request.url.scheme}://{request.url.netloc}".rstrip("/")
+
+
+def _sitemap_url_for(origin: str, prefix: str, slug: str) -> str:
+    return f"{origin}{prefix.rstrip('/')}/{slug}"
+
+
+@seo_router.get("/sitemap.xml", response_class=Response)
+async def sitemap(
+    request: Request,
+    db: AsyncSession = Depends(get_db),
+    settings: PagebuilderSettings = Depends(get_settings),
+) -> Response:
+    if not settings.sitemap_enabled:
+        return Response(status_code=404)
+
+    pages = await PagesService(db).list_indexable_published()
+    origin = _public_origin(request, settings)
+    prefix = settings.public_route_prefix
+
+    entries: list[str] = []
+    for page in pages:
+        loc = xml_escape(_sitemap_url_for(origin, prefix, page.slug))
+        lastmod = page.updated_at.isoformat() if page.updated_at else None
+        if lastmod is not None:
+            entries.append(
+                f"  <url><loc>{loc}</loc><lastmod>{xml_escape(lastmod)}</lastmod></url>"
+            )
+        else:
+            entries.append(f"  <url><loc>{loc}</loc></url>")
+
+    body = (
+        '<?xml version="1.0" encoding="UTF-8"?>\n'
+        '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n'
+        + "\n".join(entries)
+        + ("\n" if entries else "")
+        + "</urlset>\n"
+    )
+    return Response(
+        content=body,
+        media_type="application/xml",
+        headers={"Cache-Control": f"public, max-age={settings.seo_cache_max_age}"},
+    )
+
+
+@seo_router.get("/robots.txt", response_class=Response)
+async def robots(
+    request: Request,
+    settings: PagebuilderSettings = Depends(get_settings),
+) -> Response:
+    if not settings.robots_enabled:
+        return Response(status_code=404)
+
+    if settings.robots_body is not None:
+        body = settings.robots_body
+    else:
+        lines = ["User-agent: *", "Allow: /"]
+        if settings.sitemap_enabled:
+            origin = _public_origin(request, settings)
+            lines.append(f"Sitemap: {origin}/sitemap.xml")
+        body = "\n".join(lines) + "\n"
+
+    return Response(
+        content=body,
+        media_type="text/plain",
+        headers={"Cache-Control": f"public, max-age={settings.seo_cache_max_age}"},
+    )