skrift 0.1.0a1__py3-none-any.whl

skrift/db/services/page_service.py

@@ -0,0 +1,217 @@
+"""Page service for CRUD operations on pages."""
+
+from datetime import datetime
+from uuid import UUID
+
+from sqlalchemy import select, and_
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from skrift.db.models import Page
+
+
+async def list_pages(
+    db_session: AsyncSession,
+    published_only: bool = False,
+    user_id: UUID | None = None,
+    limit: int | None = None,
+    offset: int = 0,
+) -> list[Page]:
+    """List pages with optional filtering.
+
+    Args:
+        db_session: Database session
+        published_only: Only return published pages
+        user_id: Filter by user ID (author)
+        limit: Maximum number of results
+        offset: Number of results to skip
+
+    Returns:
+        List of Page objects
+    """
+    query = select(Page)
+
+    # Build filters
+    filters = []
+    if published_only:
+        filters.append(Page.is_published == True)
+    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 pagination
+    if offset:
+        query = query.offset(offset)
+    if limit:
+        query = query.limit(limit)
+
+    result = await db_session.execute(query)
+    return list(result.scalars().all())
+
+
+async def get_page_by_slug(
+    db_session: AsyncSession,
+    slug: str,
+    published_only: bool = False,
+) -> Page | None:
+    """Get a single page by slug.
+
+    Args:
+        db_session: Database session
+        slug: Page slug
+        published_only: Only return if published
+
+    Returns:
+        Page object or None if not found
+    """
+    query = select(Page).where(Page.slug == slug)
+
+    if published_only:
+        query = query.where(Page.is_published == True)
+
+    result = await db_session.execute(query)
+    return result.scalar_one_or_none()
+
+
+async def get_page_by_id(
+    db_session: AsyncSession,
+    page_id: UUID,
+) -> Page | None:
+    """Get a single page by ID.
+
+    Args:
+        db_session: Database session
+        page_id: Page UUID
+
+    Returns:
+        Page object or None if not found
+    """
+    result = await db_session.execute(select(Page).where(Page.id == page_id))
+    return result.scalar_one_or_none()
+
+
+async def create_page(
+    db_session: AsyncSession,
+    slug: str,
+    title: str,
+    content: str = "",
+    is_published: bool = False,
+    published_at: datetime | None = None,
+    user_id: UUID | None = None,
+) -> Page:
+    """Create a new page.
+
+    Args:
+        db_session: Database session
+        slug: Unique page slug
+        title: Page title
+        content: Page content (HTML or markdown)
+        is_published: Whether page is published
+        published_at: Publication timestamp
+        user_id: Author user ID (optional)
+
+    Returns:
+        Created Page object
+    """
+    page = Page(
+        slug=slug,
+        title=title,
+        content=content,
+        is_published=is_published,
+        published_at=published_at,
+        user_id=user_id,
+    )
+    db_session.add(page)
+    await db_session.commit()
+    await db_session.refresh(page)
+    return page
+
+
+async def update_page(
+    db_session: AsyncSession,
+    page_id: UUID,
+    slug: str | None = None,
+    title: str | None = None,
+    content: str | None = None,
+    is_published: bool | None = None,
+    published_at: datetime | None = None,
+) -> Page | None:
+    """Update an existing page.
+
+    Args:
+        db_session: Database session
+        page_id: Page UUID to update
+        slug: New slug (optional)
+        title: New title (optional)
+        content: New content (optional)
+        is_published: New published status (optional)
+        published_at: New publication timestamp (optional)
+
+    Returns:
+        Updated Page object or None if not found
+    """
+    page = await get_page_by_id(db_session, page_id)
+    if not page:
+        return None
+
+    if slug is not None:
+        page.slug = slug
+    if title is not None:
+        page.title = title
+    if content is not None:
+        page.content = content
+    if is_published is not None:
+        page.is_published = is_published
+    if published_at is not None:
+        page.published_at = published_at
+
+    await db_session.commit()
+    await db_session.refresh(page)
+    return page
+
+
+async def delete_page(
+    db_session: AsyncSession,
+    page_id: UUID,
+) -> bool:
+    """Delete a page.
+
+    Args:
+        db_session: Database session
+        page_id: Page UUID to delete
+
+    Returns:
+        True if deleted, False if not found
+    """
+    page = await get_page_by_id(db_session, page_id)
+    if not page:
+        return False
+
+    await db_session.delete(page)
+    await db_session.commit()
+    return True
+
+
+async def check_page_ownership(
+    db_session: AsyncSession,
+    page_id: UUID,
+    user_id: UUID,
+) -> bool:
+    """Check if a user owns a page.
+
+    Args:
+        db_session: Database session
+        page_id: Page UUID to check
+        user_id: User UUID to check ownership
+
+    Returns:
+        True if user owns the page, False otherwise
+    """
+    page = await get_page_by_id(db_session, page_id)
+    if not page:
+        return False
+    return page.user_id == user_id

skrift/db/services/setting_service.py

@@ -0,0 +1,206 @@
+"""Setting service for CRUD operations on site settings."""
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from skrift.db.models import Setting
+
+# In-memory cache for site settings (avoids DB queries on every page render)
+_site_settings_cache: dict[str, str] = {}
+
+
+async def get_setting(
+    db_session: AsyncSession,
+    key: str,
+) -> str | None:
+    """Get a setting value by key.
+
+    Args:
+        db_session: Database session
+        key: Setting key
+
+    Returns:
+        Setting value or None if not found
+    """
+    result = await db_session.execute(select(Setting).where(Setting.key == key))
+    setting = result.scalar_one_or_none()
+    return setting.value if setting else None
+
+
+async def get_setting_with_default(
+    db_session: AsyncSession,
+    key: str,
+    default: str,
+) -> str:
+    """Get a setting value by key, returning a default if not found.
+
+    Args:
+        db_session: Database session
+        key: Setting key
+        default: Default value if setting doesn't exist
+
+    Returns:
+        Setting value or default
+    """
+    value = await get_setting(db_session, key)
+    return value if value is not None else default
+
+
+async def get_settings(
+    db_session: AsyncSession,
+    keys: list[str] | None = None,
+) -> dict[str, str | None]:
+    """Get multiple settings as a dictionary.
+
+    Args:
+        db_session: Database session
+        keys: Optional list of keys to retrieve. If None, returns all settings.
+
+    Returns:
+        Dictionary of key-value pairs
+    """
+    query = select(Setting)
+    if keys:
+        query = query.where(Setting.key.in_(keys))
+
+    result = await db_session.execute(query)
+    settings = result.scalars().all()
+    return {s.key: s.value for s in settings}
+
+
+async def set_setting(
+    db_session: AsyncSession,
+    key: str,
+    value: str | None,
+) -> Setting:
+    """Set a setting value, creating or updating as needed.
+
+    Args:
+        db_session: Database session
+        key: Setting key
+        value: Setting value (can be None)
+
+    Returns:
+        The created or updated Setting object
+    """
+    result = await db_session.execute(select(Setting).where(Setting.key == key))
+    setting = result.scalar_one_or_none()
+
+    if setting:
+        setting.value = value
+    else:
+        setting = Setting(key=key, value=value)
+        db_session.add(setting)
+
+    await db_session.commit()
+    await db_session.refresh(setting)
+    return setting
+
+
+async def delete_setting(
+    db_session: AsyncSession,
+    key: str,
+) -> bool:
+    """Delete a setting by key.
+
+    Args:
+        db_session: Database session
+        key: Setting key to delete
+
+    Returns:
+        True if deleted, False if not found
+    """
+    result = await db_session.execute(select(Setting).where(Setting.key == key))
+    setting = result.scalar_one_or_none()
+
+    if not setting:
+        return False
+
+    await db_session.delete(setting)
+    await db_session.commit()
+    return True
+
+
+# Site setting keys
+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"
+
+# Setup wizard key
+SETUP_COMPLETED_AT_KEY = "setup_completed_at"
+
+# Default values
+SITE_DEFAULTS = {
+    SITE_NAME_KEY: "My Site",
+    SITE_TAGLINE_KEY: "Welcome to my site",
+    SITE_COPYRIGHT_HOLDER_KEY: "",
+    SITE_COPYRIGHT_START_YEAR_KEY: "",
+}
+
+
+async def get_site_settings(db_session: AsyncSession) -> dict[str, str]:
+    """Get all site settings with defaults applied.
+
+    Args:
+        db_session: Database session
+
+    Returns:
+        Dictionary with site settings, using defaults for missing values
+    """
+    keys = list(SITE_DEFAULTS.keys())
+    settings = await get_settings(db_session, keys)
+
+    return {
+        key: settings.get(key) or default
+        for key, default in SITE_DEFAULTS.items()
+    }
+
+
+async def load_site_settings_cache(db_session: AsyncSession) -> None:
+    """Load site settings into the in-memory cache.
+
+    Call this on application startup to populate the cache.
+    If the settings table doesn't exist yet (before migration), uses defaults.
+
+    Args:
+        db_session: Database session
+    """
+    global _site_settings_cache
+    try:
+        _site_settings_cache = await get_site_settings(db_session)
+    except Exception:
+        # Table might not exist yet (before migration), use defaults
+        _site_settings_cache = SITE_DEFAULTS.copy()
+
+
+def invalidate_site_settings_cache() -> None:
+    """Clear the site settings cache.
+
+    Call this when settings are modified to ensure fresh values are loaded.
+    """
+    global _site_settings_cache
+    _site_settings_cache.clear()
+
+
+def get_cached_site_name() -> str:
+    """Get the cached site name for use in templates."""
+    return _site_settings_cache.get(SITE_NAME_KEY, SITE_DEFAULTS[SITE_NAME_KEY])
+
+
+def get_cached_site_tagline() -> str:
+    """Get the cached site tagline for use in templates."""
+    return _site_settings_cache.get(SITE_TAGLINE_KEY, SITE_DEFAULTS[SITE_TAGLINE_KEY])
+
+
+def get_cached_site_copyright_holder() -> str:
+    """Get the cached site copyright holder for use in templates."""
+    return _site_settings_cache.get(SITE_COPYRIGHT_HOLDER_KEY, SITE_DEFAULTS[SITE_COPYRIGHT_HOLDER_KEY])
+
+
+def get_cached_site_copyright_start_year() -> str | int | None:
+    """Get the cached site copyright start year for use in templates."""
+    value = _site_settings_cache.get(SITE_COPYRIGHT_START_YEAR_KEY, SITE_DEFAULTS[SITE_COPYRIGHT_START_YEAR_KEY])
+    if value and value.isdigit():
+        return int(value)
+    return None

skrift/lib/__init__.py

@@ -0,0 +1,3 @@
+from skrift.lib.template import Template
+
+__all__ = ["Template"]

skrift/lib/exceptions.py

@@ -0,0 +1,168 @@
+import hashlib
+from pathlib import Path
+
+from litestar import Request, Response
+from litestar.exceptions import HTTPException
+from litestar.status_codes import HTTP_500_INTERNAL_SERVER_ERROR
+
+from skrift.config import get_settings
+from skrift.db.services.setting_service import get_cached_site_name
+
+TEMPLATE_DIR = Path(__file__).parent.parent.parent / "templates"
+
+
+def _accepts_html(request: Request) -> bool:
+    """Check if the request accepts HTML responses (browser request)."""
+    accept = request.headers.get("accept", "")
+    return "text/html" in accept
+
+
+def _resolve_error_template(status_code: int) -> str:
+    """Resolve error template with fallback, WP-style."""
+    specific_template = f"error-{status_code}.html"
+    if (TEMPLATE_DIR / specific_template).exists():
+        return specific_template
+    return "error.html"
+
+
+def _get_session_from_cookie(request: Request) -> dict | None:
+    """Manually decode session from cookie when middleware hasn't run.
+
+    This replicates Litestar's ClientSideSessionBackend decryption logic synchronously.
+    """
+    try:
+        import time
+        from base64 import b64decode
+        from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+        from litestar.middleware.session.client_side import decode_json, NONCE_SIZE, AAD
+
+        # Get the session cookie
+        cookie_value = request.cookies.get("session")
+        if not cookie_value:
+            return None
+
+        # Get the secret key and hash it the same way asgi.py does
+        settings = get_settings()
+        secret = hashlib.sha256(settings.secret_key.encode()).digest()
+
+        # Decode the base64 cookie value
+        decoded = b64decode(cookie_value)
+
+        # Extract nonce (first 12 bytes)
+        nonce = decoded[:NONCE_SIZE]
+
+        # Find where AAD marker starts
+        aad_starts_from = decoded.find(AAD)
+        if aad_starts_from == -1:
+            return None
+
+        # Associated data is the JSON part only (after removing the AAD prefix)
+        associated_data = decoded[aad_starts_from:].replace(AAD, b"")
+
+        # Check expiration
+        if decode_json(value=associated_data)["expires_at"] <= round(time.time()):
+            return None
+
+        # Extract encrypted session (between nonce and AAD marker)
+        encrypted_session = decoded[NONCE_SIZE:aad_starts_from]
+
+        # Decrypt using AES-GCM with the JSON part as associated_data
+        aesgcm = AESGCM(secret)
+        decrypted = aesgcm.decrypt(nonce, encrypted_session, associated_data=associated_data)
+
+        # Deserialize JSON
+        session_data = decode_json(decrypted)
+        return session_data
+    except Exception:
+        return None
+
+
+def _get_user_context_from_session(session: dict | None) -> dict | None:
+    """Get user display info from session if available."""
+    if not session:
+        return None
+    try:
+        user_id = session.get("user_id")
+        if not user_id:
+            return None
+        return {
+            "id": user_id,
+            "name": session.get("user_name"),
+            "email": session.get("user_email"),
+            "picture_url": session.get("user_picture_url"),
+        }
+    except Exception:
+        return None
+
+
+class SessionUser:
+    """Lightweight user object for templates, populated from session data."""
+
+    def __init__(self, data: dict):
+        self.id = data.get("id")
+        self.name = data.get("name")
+        self.email = data.get("email")
+        self.picture_url = data.get("picture_url")
+
+
+def http_exception_handler(request: Request, exc: HTTPException) -> Response:
+    """Handle HTTP exceptions with HTML for browsers, JSON for APIs."""
+    status_code = exc.status_code
+    detail = exc.detail if isinstance(exc.detail, str) else str(exc.detail)
+
+    if _accepts_html(request):
+        session = _get_session_from_cookie(request)
+        user_data = _get_user_context_from_session(session)
+        user = SessionUser(user_data) if user_data else None
+        template_name = _resolve_error_template(status_code)
+        template_engine = request.app.template_engine
+        template = template_engine.get_template(template_name)
+        content = template.render(
+            status_code=status_code,
+            message=detail,
+            user=user,
+            site_name=get_cached_site_name,
+        )
+        return Response(
+            content=content,
+            status_code=status_code,
+            media_type="text/html",
+        )
+
+    # JSON response for API clients
+    return Response(
+        content={"status_code": status_code, "detail": detail},
+        status_code=status_code,
+        media_type="application/json",
+    )
+
+
+def internal_server_error_handler(request: Request, exc: Exception) -> Response:
+    """Handle unexpected exceptions with HTML for browsers, JSON for APIs."""
+    status_code = HTTP_500_INTERNAL_SERVER_ERROR
+
+    if _accepts_html(request):
+        session = _get_session_from_cookie(request)
+        user_data = _get_user_context_from_session(session)
+        user = SessionUser(user_data) if user_data else None
+        template_name = _resolve_error_template(status_code)
+        template_engine = request.app.template_engine
+        template = template_engine.get_template(template_name)
+        content = template.render(
+            status_code=status_code,
+            message="An unexpected error occurred.",
+            user=user,
+            site_name=get_cached_site_name,
+        )
+        return Response(
+            content=content,
+            status_code=status_code,
+            media_type="text/html",
+        )
+
+    # JSON response for API clients
+    return Response(
+        content={"status_code": status_code, "detail": "Internal Server Error"},
+        status_code=status_code,
+        media_type="application/json",
+    )

skrift/lib/template.py

@@ -0,0 +1,108 @@
+import os
+from pathlib import Path
+from typing import Any
+
+from litestar.contrib.jinja import JinjaTemplateEngine
+from litestar.response import Template as TemplateResponse
+from litestar.template import TemplateConfig
+
+
+class Template:
+    """WordPress-like template resolver with fallback support.
+
+    Resolves templates in order of specificity:
+    - Template("post", "about") → tries post-about.html, falls back to post.html
+    - Template("page", "services", "web") → tries page-services-web.html → page-services.html → page.html
+
+    Template Directory Hierarchy:
+    Templates are searched in the following order:
+    1. ./templates/ (working directory) - User overrides
+    2. skrift/templates/ (package directory) - Default templates
+
+    Available Templates for Override:
+    - base.html - Base layout template
+    - index.html - Homepage template
+    - page.html - Default page template
+    - post.html - Default post template
+    - error.html - Generic error page
+    - error-404.html - Not found error page
+    - error-500.html - Server error page
+
+    Users can override any template by creating a file with the same name
+    in their project's ./templates/ directory.
+    """
+
+    def __init__(self, template_type: str, *slugs: str, context: dict[str, Any] | None = None):
+        self.template_type = template_type
+        self.slugs = slugs
+        self.context = context or {}
+        self._resolved_template: str | None = None
+
+    def resolve(self, template_dir: Path) -> str:
+        """Resolve the most specific template that exists.
+
+        Searches for templates in order:
+        1. Working directory's ./templates/
+        2. Package's templates directory
+
+        Within each directory, searches from most to least specific template name.
+        """
+        if self._resolved_template:
+            return self._resolved_template
+
+        # Define search paths: working directory first, then package directory
+        working_dir_templates = Path(os.getcwd()) / "templates"
+        search_dirs = [working_dir_templates, template_dir]
+
+        # Build list of templates to try, from most to least specific
+        templates_to_try = []
+
+        if self.slugs:
+            # Add progressively less specific templates
+            for i in range(len(self.slugs), 0, -1):
+                slug_part = "-".join(self.slugs[:i])
+                templates_to_try.append(f"{self.template_type}-{slug_part}.html")
+
+        # Always fall back to the base template type
+        templates_to_try.append(f"{self.template_type}.html")
+
+        # Search for templates in each directory
+        for template_name in templates_to_try:
+            for search_dir in search_dirs:
+                template_path = search_dir / template_name
+                if template_path.exists():
+                    self._resolved_template = template_name
+                    return template_name
+
+        # Default to base template even if it doesn't exist (let Jinja handle the error)
+        self._resolved_template = f"{self.template_type}.html"
+        return self._resolved_template
+
+    def render(self, template_dir: Path, **extra_context: Any) -> TemplateResponse:
+        """Resolve template and return TemplateResponse with merged context.
+
+        Context passed to __init__ is merged with extra_context, with extra_context
+        taking precedence for duplicate keys.
+        """
+        template_name = self.resolve(template_dir)
+        merged_context = {**self.context, **extra_context}
+        return TemplateResponse(template_name, context=merged_context)
+
+    def __repr__(self) -> str:
+        return f"Template({self.template_type!r}, {', '.join(repr(s) for s in self.slugs)})"
+
+
+def get_template_config(template_dir: Path) -> TemplateConfig:
+    """Get the Jinja template configuration.
+
+    Configures Jinja to search for templates in multiple directories:
+    1. ./templates/ (working directory) - for user overrides
+    2. package templates directory - for default templates
+    """
+    working_dir_templates = Path(os.getcwd()) / "templates"
+    directories = [working_dir_templates, template_dir]
+
+    return TemplateConfig(
+        directory=directories,
+        engine=JinjaTemplateEngine,
+    )