skrift 0.1.0a14__py3-none-any.whl → 0.1.0a15__py3-none-any.whl

skrift/db/services/page_service.py

@@ -1,12 +1,18 @@
 """Page service for CRUD operations on pages."""
 
-from datetime import datetime
+from datetime import datetime, UTC
+from typing import Literal
 from uuid import UUID
 
-from sqlalchemy import select, and_
+from sqlalchemy import select, and_, or_
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from skrift.db.models import Page
+from skrift.db.services import revision_service
+from skrift.lib.hooks import hooks, BEFORE_PAGE_SAVE, AFTER_PAGE_SAVE, BEFORE_PAGE_DELETE, AFTER_PAGE_DELETE
+
+
+OrderBy = Literal["order", "created", "published", "title"]
 
 
 async def list_pages(
@@ -15,15 +21,17 @@ async def list_pages(
     user_id: UUID | None = None,
     limit: int | None = None,
     offset: int = 0,
+    order_by: OrderBy = "order",
 ) -> list[Page]:
     """List pages with optional filtering.
 
     Args:
         db_session: Database session
-        published_only: Only return published pages
+        published_only: Only return published pages (respects scheduling)
         user_id: Filter by user ID (author)
         limit: Maximum number of results
         offset: Number of results to skip
+        order_by: Sort order - "order" (default), "created", "published", "title"
 
     Returns:
         List of Page objects
@@ -33,15 +41,25 @@ async def list_pages(
     # Build filters
     filters = []
     if published_only:
+        now = datetime.now(UTC)
         filters.append(Page.is_published == True)
+        # Respect scheduling: either no publish_at set, or publish_at is in the past
+        filters.append(or_(Page.publish_at.is_(None), Page.publish_at <= now))
     if user_id:
         filters.append(Page.user_id == user_id)
 
     if filters:
         query = query.where(and_(*filters))
 
-    # Order by published date (newest first), then created date
-    query = query.order_by(Page.published_at.desc().nullslast(), Page.created_at.desc())
+    # Apply ordering
+    if order_by == "order":
+        query = query.order_by(Page.order.asc(), Page.created_at.desc())
+    elif order_by == "created":
+        query = query.order_by(Page.created_at.desc())
+    elif order_by == "published":
+        query = query.order_by(Page.published_at.desc().nullslast(), Page.created_at.desc())
+    elif order_by == "title":
+        query = query.order_by(Page.title.asc())
 
     # Apply pagination
     if offset:
@@ -63,7 +81,7 @@ async def get_page_by_slug(
     Args:
         db_session: Database session
         slug: Page slug
-        published_only: Only return if published
+        published_only: Only return if published (respects scheduling)
 
     Returns:
         Page object or None if not found
@@ -71,7 +89,10 @@ async def get_page_by_slug(
     query = select(Page).where(Page.slug == slug)
 
     if published_only:
+        now = datetime.now(UTC)
         query = query.where(Page.is_published == True)
+        # Respect scheduling: either no publish_at set, or publish_at is in the past
+        query = query.where(or_(Page.publish_at.is_(None), Page.publish_at <= now))
 
     result = await db_session.execute(query)
     return result.scalar_one_or_none()
@@ -102,6 +123,13 @@ async def create_page(
     is_published: bool = False,
     published_at: datetime | None = None,
     user_id: UUID | None = None,
+    order: int = 0,
+    publish_at: datetime | None = None,
+    meta_description: str | None = None,
+    og_title: str | None = None,
+    og_description: str | None = None,
+    og_image: str | None = None,
+    meta_robots: str | None = None,
 ) -> Page:
     """Create a new page.
 
@@ -113,6 +141,13 @@ async def create_page(
         is_published: Whether page is published
         published_at: Publication timestamp
         user_id: Author user ID (optional)
+        order: Display order (lower numbers first)
+        publish_at: Scheduled publish datetime
+        meta_description: SEO meta description
+        og_title: OpenGraph title override
+        og_description: OpenGraph description override
+        og_image: OpenGraph image URL
+        meta_robots: Meta robots directive
 
     Returns:
         Created Page object
@@ -124,13 +159,31 @@ async def create_page(
         is_published=is_published,
         published_at=published_at,
         user_id=user_id,
+        order=order,
+        publish_at=publish_at,
+        meta_description=meta_description,
+        og_title=og_title,
+        og_description=og_description,
+        og_image=og_image,
+        meta_robots=meta_robots,
     )
+
+    # Fire before_page_save action (is_new=True for creates)
+    await hooks.do_action(BEFORE_PAGE_SAVE, page, is_new=True)
+
     db_session.add(page)
     await db_session.commit()
     await db_session.refresh(page)
+
+    # Fire after_page_save action
+    await hooks.do_action(AFTER_PAGE_SAVE, page, is_new=True)
+
     return page
 
 
+_UNSET = object()  # Sentinel for distinguishing None from "not provided"
+
+
 async def update_page(
     db_session: AsyncSession,
     page_id: UUID,
@@ -139,6 +192,15 @@ async def update_page(
     content: str | None = None,
     is_published: bool | None = None,
     published_at: datetime | None = None,
+    order: int | None = None,
+    publish_at: datetime | None | object = _UNSET,
+    meta_description: str | None | object = _UNSET,
+    og_title: str | None | object = _UNSET,
+    og_description: str | None | object = _UNSET,
+    og_image: str | None | object = _UNSET,
+    meta_robots: str | None | object = _UNSET,
+    create_revision: bool = True,
+    user_id: UUID | None = None,
 ) -> Page | None:
     """Update an existing page.
 
@@ -150,6 +212,15 @@ async def update_page(
         content: New content (optional)
         is_published: New published status (optional)
         published_at: New publication timestamp (optional)
+        order: New display order (optional)
+        publish_at: New scheduled publish datetime (optional, use None to clear)
+        meta_description: New SEO meta description (optional, use None to clear)
+        og_title: New OpenGraph title (optional, use None to clear)
+        og_description: New OpenGraph description (optional, use None to clear)
+        og_image: New OpenGraph image URL (optional, use None to clear)
+        meta_robots: New meta robots directive (optional, use None to clear)
+        create_revision: Whether to create a revision before updating (default True)
+        user_id: ID of user making the change (for revision tracking)
 
     Returns:
         Updated Page object or None if not found
@@ -158,6 +229,17 @@ async def update_page(
     if not page:
         return None
 
+    # Create revision before making changes (if title or content is changing)
+    if create_revision and (title is not None or content is not None):
+        # Only create revision if title or content actually differs
+        title_changed = title is not None and title != page.title
+        content_changed = content is not None and content != page.content
+        if title_changed or content_changed:
+            await revision_service.create_revision(db_session, page, user_id)
+
+    # Fire before_page_save action (is_new=False for updates)
+    await hooks.do_action(BEFORE_PAGE_SAVE, page, is_new=False)
+
     if slug is not None:
         page.slug = slug
     if title is not None:
@@ -168,9 +250,27 @@ async def update_page(
         page.is_published = is_published
     if published_at is not None:
         page.published_at = published_at
+    if order is not None:
+        page.order = order
+    if publish_at is not _UNSET:
+        page.publish_at = publish_at
+    if meta_description is not _UNSET:
+        page.meta_description = meta_description
+    if og_title is not _UNSET:
+        page.og_title = og_title
+    if og_description is not _UNSET:
+        page.og_description = og_description
+    if og_image is not _UNSET:
+        page.og_image = og_image
+    if meta_robots is not _UNSET:
+        page.meta_robots = meta_robots
 
     await db_session.commit()
     await db_session.refresh(page)
+
+    # Fire after_page_save action
+    await hooks.do_action(AFTER_PAGE_SAVE, page, is_new=False)
+
     return page
 
 
@@ -191,8 +291,15 @@ async def delete_page(
     if not page:
         return False
 
+    # Fire before_page_delete action
+    await hooks.do_action(BEFORE_PAGE_DELETE, page)
+
     await db_session.delete(page)
     await db_session.commit()
+
+    # Fire after_page_delete action
+    await hooks.do_action(AFTER_PAGE_DELETE, page)
+
     return True
 
 

skrift/db/services/revision_service.py

@@ -0,0 +1,146 @@
+"""Revision service for page history management."""
+
+from uuid import UUID
+
+from sqlalchemy import select, func
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from skrift.db.models import Page, PageRevision
+
+
+async def create_revision(
+    db_session: AsyncSession,
+    page: Page,
+    user_id: UUID | None = None,
+) -> PageRevision:
+    """Create a revision snapshot of the current page state.
+
+    Args:
+        db_session: Database session
+        page: The page to snapshot
+        user_id: ID of user making the change (optional)
+
+    Returns:
+        The created PageRevision object
+    """
+    # Get the next revision number for this page
+    result = await db_session.execute(
+        select(func.coalesce(func.max(PageRevision.revision_number), 0))
+        .where(PageRevision.page_id == page.id)
+    )
+    max_revision = result.scalar()
+    next_revision = (max_revision or 0) + 1
+
+    revision = PageRevision(
+        page_id=page.id,
+        user_id=user_id,
+        revision_number=next_revision,
+        title=page.title,
+        content=page.content,
+    )
+
+    db_session.add(revision)
+    await db_session.commit()
+    await db_session.refresh(revision)
+
+    return revision
+
+
+async def list_revisions(
+    db_session: AsyncSession,
+    page_id: UUID,
+    limit: int | None = None,
+) -> list[PageRevision]:
+    """List revisions for a page, newest first.
+
+    Args:
+        db_session: Database session
+        page_id: The page ID to get revisions for
+        limit: Maximum number of revisions to return (None for all)
+
+    Returns:
+        List of PageRevision objects ordered by revision_number descending
+    """
+    query = (
+        select(PageRevision)
+        .where(PageRevision.page_id == page_id)
+        .order_by(PageRevision.revision_number.desc())
+    )
+
+    if limit:
+        query = query.limit(limit)
+
+    result = await db_session.execute(query)
+    return list(result.scalars().all())
+
+
+async def get_revision(
+    db_session: AsyncSession,
+    revision_id: UUID,
+) -> PageRevision | None:
+    """Get a specific revision by ID.
+
+    Args:
+        db_session: Database session
+        revision_id: The revision ID
+
+    Returns:
+        PageRevision object or None if not found
+    """
+    result = await db_session.execute(
+        select(PageRevision).where(PageRevision.id == revision_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def restore_revision(
+    db_session: AsyncSession,
+    page: Page,
+    revision: PageRevision,
+    user_id: UUID | None = None,
+) -> Page:
+    """Restore a page to a previous revision state.
+
+    This creates a new revision first (to preserve current state),
+    then updates the page content to match the target revision.
+
+    Args:
+        db_session: Database session
+        page: The page to restore
+        revision: The revision to restore to
+        user_id: ID of user performing the restore (optional)
+
+    Returns:
+        The updated Page object
+    """
+    # Create a revision of the current state before restoring
+    await create_revision(db_session, page, user_id)
+
+    # Update the page to match the revision
+    page.title = revision.title
+    page.content = revision.content
+
+    await db_session.commit()
+    await db_session.refresh(page)
+
+    return page
+
+
+async def get_revision_count(
+    db_session: AsyncSession,
+    page_id: UUID,
+) -> int:
+    """Get the total number of revisions for a page.
+
+    Args:
+        db_session: Database session
+        page_id: The page ID
+
+    Returns:
+        Number of revisions
+    """
+    result = await db_session.execute(
+        select(func.count(PageRevision.id))
+        .where(PageRevision.page_id == page_id)
+    )
+    return result.scalar() or 0

skrift/db/services/setting_service.py

@@ -126,6 +126,7 @@ SITE_NAME_KEY = "site_name"
 SITE_TAGLINE_KEY = "site_tagline"
 SITE_COPYRIGHT_HOLDER_KEY = "site_copyright_holder"
 SITE_COPYRIGHT_START_YEAR_KEY = "site_copyright_start_year"
+SITE_BASE_URL_KEY = "site_base_url"
 
 # Setup wizard key
 SETUP_COMPLETED_AT_KEY = "setup_completed_at"
@@ -136,6 +137,7 @@ SITE_DEFAULTS = {
     SITE_TAGLINE_KEY: "Welcome to my site",
     SITE_COPYRIGHT_HOLDER_KEY: "",
     SITE_COPYRIGHT_START_YEAR_KEY: "",
+    SITE_BASE_URL_KEY: "",
 }
 
 
@@ -204,3 +206,8 @@ def get_cached_site_copyright_start_year() -> str | int | None:
     if value and value.isdigit():
         return int(value)
     return None
+
+
+def get_cached_site_base_url() -> str:
+    """Get the cached site base URL for use in SEO/sitemap."""
+    return _site_settings_cache.get(SITE_BASE_URL_KEY, SITE_DEFAULTS[SITE_BASE_URL_KEY])

skrift/lib/__init__.py

@@ -1,4 +1,15 @@
+from skrift.lib.hooks import hooks, action, filter, add_action, add_filter, do_action, apply_filters
 from skrift.lib.markdown import render_markdown
 from skrift.lib.template import Template
 
-__all__ = ["Template", "render_markdown"]
+__all__ = [
+    "Template",
+    "render_markdown",
+    "hooks",
+    "action",
+    "filter",
+    "add_action",
+    "add_filter",
+    "do_action",
+    "apply_filters",
+]

skrift/lib/flash.py

@@ -0,0 +1,103 @@
+"""Enhanced flash message system with types and multiple messages support."""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from litestar import Request
+
+
+class FlashType(str, Enum):
+    """Types of flash messages with corresponding CSS classes."""
+
+    SUCCESS = "success"
+    ERROR = "error"
+    WARNING = "warning"
+    INFO = "info"
+
+
+@dataclass
+class FlashMessage:
+    """A flash message with type and dismissibility."""
+
+    message: str
+    type: FlashType = FlashType.INFO
+    dismissible: bool = True
+
+
+def add_flash(
+    request: "Request",
+    message: str,
+    flash_type: FlashType = FlashType.INFO,
+    dismissible: bool = True,
+) -> None:
+    """Add a flash message to the session queue.
+
+    Args:
+        request: The Litestar request object
+        message: The message text to display
+        flash_type: Type of message (success, error, warning, info)
+        dismissible: Whether the message can be dismissed by the user
+    """
+    if "flash_messages" not in request.session:
+        request.session["flash_messages"] = []
+
+    request.session["flash_messages"].append({
+        "message": message,
+        "type": flash_type.value,
+        "dismissible": dismissible,
+    })
+
+
+def get_flash_messages(request: "Request") -> list[FlashMessage]:
+    """Get and clear all flash messages from the session.
+
+    Also handles backwards compatibility with old single-string flash.
+
+    Args:
+        request: The Litestar request object
+
+    Returns:
+        List of FlashMessage objects
+    """
+    messages = request.session.pop("flash_messages", [])
+
+    # Backwards compatibility: convert old single-string flash
+    old_flash = request.session.pop("flash", None)
+    if old_flash:
+        messages.insert(0, {
+            "message": old_flash,
+            "type": FlashType.INFO.value,
+            "dismissible": True,
+        })
+
+    return [
+        FlashMessage(
+            message=m["message"],
+            type=FlashType(m["type"]),
+            dismissible=m.get("dismissible", True),
+        )
+        for m in messages
+    ]
+
+
+# Convenience functions for common flash types
+def flash_success(request: "Request", message: str, dismissible: bool = True) -> None:
+    """Add a success flash message."""
+    add_flash(request, message, FlashType.SUCCESS, dismissible)
+
+
+def flash_error(request: "Request", message: str, dismissible: bool = True) -> None:
+    """Add an error flash message."""
+    add_flash(request, message, FlashType.ERROR, dismissible)
+
+
+def flash_warning(request: "Request", message: str, dismissible: bool = True) -> None:
+    """Add a warning flash message."""
+    add_flash(request, message, FlashType.WARNING, dismissible)
+
+
+def flash_info(request: "Request", message: str, dismissible: bool = True) -> None:
+    """Add an info flash message."""
+    add_flash(request, message, FlashType.INFO, dismissible)