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

pagebuilder/hooks/usePageWorkflow.ts

@@ -0,0 +1,173 @@
+/** Save, publish, and approval-workflow actions for the page editor. */
+
+import { router } from '@inertiajs/react';
+import type { Data } from '@puckeditor/core';
+
+import {
+  approvePage,
+  createPage,
+  promptAndReject,
+  publishPage,
+  savePage,
+  submitPage,
+  unpublishPage,
+} from '../utils/api';
+import type { EditorSnapshot } from '../utils/editorSnapshot';
+import type { EditorForm } from './useEditorForm';
+
+interface Params {
+  form: EditorForm;
+  setBusy: (v: boolean) => void;
+  setMessage: (v: string | null) => void;
+  markSaved: (payload: EditorSnapshot) => void;
+}
+
+export interface PageWorkflow {
+  handleSave: (newData: Data) => Promise<void>;
+  handlePublish: () => Promise<void>;
+  handleUnpublish: () => Promise<void>;
+  handleSubmitForReview: () => Promise<void>;
+  handleApprove: () => Promise<void>;
+  handleReject: () => Promise<void>;
+}
+
+export function usePageWorkflow({ form, setBusy, setMessage, markSaved }: Params): PageWorkflow {
+  const snapshotWith = (newData: Data): EditorSnapshot => ({
+    ...form.snapshotPayload,
+    data: newData,
+  });
+
+  const draftPayload = (newData: Data) => ({
+    ...form.writePayload(),
+    draft_data: newData as unknown as Record<string, unknown>,
+  });
+
+  const handleSave = async (newData: Data) => {
+    setBusy(true);
+    setMessage(null);
+    try {
+      if (form.pageId === null) {
+        const created = await createPage(draftPayload(newData) as Parameters<typeof createPage>[0]);
+        form.setPageId(created.id);
+        form.setSlug(created.slug);
+        form.setSlugTouched(true);
+        form.setStatus(created.status);
+        router.visit(`/pagebuilder/${created.id}/edit`, { preserveState: false });
+      } else {
+        const updated = await savePage(form.pageId, draftPayload(newData));
+        form.setStatus(updated.status);
+        markSaved(snapshotWith(newData));
+        setMessage('Draft saved.');
+      }
+    } catch (e) {
+      setMessage(e instanceof Error ? e.message : 'Save failed');
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const handlePublish = async () => {
+    if (form.pageId === null) {
+      await handleSave(form.data);
+      return;
+    }
+    // Prompt returns `null` on Cancel, `''` on bare-press Enter — only
+    // ``null`` should abort. An empty string means "publish, no note".
+    const noteInput = window.prompt(
+      'Optional message describing this publish (leave blank to skip):',
+      '',
+    );
+    if (noteInput === null) return;
+    const note = noteInput.trim() || null;
+    setBusy(true);
+    setMessage(null);
+    try {
+      await savePage(form.pageId, draftPayload(form.data));
+      markSaved(snapshotWith(form.data));
+      const result = await publishPage(form.pageId, note);
+      form.setStatus(result.status);
+      setMessage('Published.');
+      router.reload({ only: ['revisions'] });
+    } catch (e) {
+      setMessage(e instanceof Error ? e.message : 'Publish failed');
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const handleUnpublish = async () => {
+    if (form.pageId === null) return;
+    setBusy(true);
+    setMessage(null);
+    try {
+      const result = await unpublishPage(form.pageId);
+      form.setStatus(result.status);
+      setMessage('Unpublished.');
+    } catch (e) {
+      setMessage(e instanceof Error ? e.message : 'Unpublish failed');
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const handleSubmitForReview = async () => {
+    if (form.pageId === null) {
+      setMessage('Save a draft first.');
+      return;
+    }
+    setBusy(true);
+    setMessage(null);
+    try {
+      await savePage(form.pageId, draftPayload(form.data));
+      markSaved(snapshotWith(form.data));
+      const result = await submitPage(form.pageId);
+      form.setStatus(result.status);
+      setMessage('Submitted for review.');
+      router.reload({ only: ['revisions', 'page'] });
+    } catch (e) {
+      setMessage(e instanceof Error ? e.message : 'Submit failed');
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const handleApprove = async () => {
+    if (form.pageId === null) return;
+    setBusy(true);
+    setMessage(null);
+    try {
+      const result = await approvePage(form.pageId);
+      form.setStatus(result.status);
+      setMessage('Approved and published.');
+      router.reload({ only: ['revisions', 'page'] });
+    } catch (e) {
+      setMessage(e instanceof Error ? e.message : 'Approve failed');
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const handleReject = async () => {
+    if (form.pageId === null) return;
+    setBusy(true);
+    setMessage(null);
+    const result = await promptAndReject(form.pageId);
+    setBusy(false);
+    if ('skipped' in result) {
+      if (result.skipped !== 'cancelled') setMessage(result.skipped);
+      return;
+    }
+    form.setStatus(result.status);
+    setMessage('Sent back to draft.');
+    router.reload({ only: ['revisions', 'page'] });
+  };
+
+  return {
+    handleSave,
+    handlePublish,
+    handleUnpublish,
+    handleSubmitForReview,
+    handleApprove,
+    handleReject,
+  };
+}

pagebuilder/layout_service.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from fastapi import HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlmodel import select
+
+from pagebuilder.models import Layout, LayoutRevision
+
+
+def _has_content(data: dict | None) -> bool:
+    if not isinstance(data, dict):
+        return False
+    content = data.get("content")
+    return isinstance(content, list) and len(content) > 0
+
+
+class LayoutService:
+    def __init__(self, db: AsyncSession) -> None:
+        self.db = db
+
+    async def get(self) -> Layout:
+        result = await self.db.execute(
+            select(Layout).order_by(Layout.id.asc()).limit(1)
+        )
+        layout = result.scalars().first()
+        if layout is None:
+            layout = Layout(header_data={}, footer_data={})
+            self.db.add(layout)
+            await self.db.flush()
+            await self.db.refresh(layout)
+        return layout
+
+    async def update(
+        self,
+        *,
+        header_data: dict | None = None,
+        footer_data: dict | None = None,
+        note: str | None = None,
+    ) -> Layout:
+        layout = await self.get()
+        header_changed = header_data is not None and header_data != layout.header_data
+        footer_changed = footer_data is not None and footer_data != layout.footer_data
+        # No-op save: skip the revision row so save-button-spam doesn't
+        # pollute history. The layout row itself is also untouched.
+        if not header_changed and not footer_changed:
+            return layout
+
+        if header_changed:
+            layout.header_data = header_data  # type: ignore[assignment]
+        if footer_changed:
+            layout.footer_data = footer_data  # type: ignore[assignment]
+        self.db.add(layout)
+
+        assert layout.id is not None
+        revision = LayoutRevision(
+            layout_id=layout.id,
+            header_data=layout.header_data,
+            footer_data=layout.footer_data,
+            note=note,
+        )
+        self.db.add(revision)
+
+        await self.db.flush()
+        await self.db.refresh(layout)
+        return layout
+
+    async def list_revisions(self) -> list[LayoutRevision]:
+        layout = await self.get()
+        result = await self.db.execute(
+            select(LayoutRevision)
+            .where(LayoutRevision.layout_id == layout.id)
+            .order_by(LayoutRevision.id.desc())
+        )
+        return list(result.scalars().all())
+
+    async def get_revision(self, revision_id: int) -> LayoutRevision:
+        revision = await self.db.get(LayoutRevision, revision_id)
+        if revision is None:
+            raise HTTPException(status_code=404, detail="Revision not found")
+        return revision
+
+    async def restore(self, revision_id: int) -> Layout:
+        revision = await self.get_revision(revision_id)
+        return await self.update(
+            header_data=revision.header_data,
+            footer_data=revision.footer_data,
+            note=f"Restored from revision #{revision.id}",
+        )
+
+
+def public_layout_props(layout: Layout) -> dict[str, dict | None]:
+    # Empty slots surface as None so PublicPage can drop the wrapper —
+    # an empty <header> is worse than no header.
+    return {
+        "layout_header": layout.header_data
+        if _has_content(layout.header_data)
+        else None,
+        "layout_footer": layout.footer_data
+        if _has_content(layout.footer_data)
+        else None,
+    }

pagebuilder/media_images.py

@@ -0,0 +1,185 @@
+"""Filename, content-sniffing, and image-processing helpers for uploads.
+
+Extracted from :mod:`pagebuilder.media_service` so that module stays focused
+on storage + DB operations. These are pure functions — they take everything
+they need as arguments rather than reading service state — which also makes
+them directly testable.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from pathlib import Path
+from typing import Any
+
+from fastapi import HTTPException
+from PIL import Image, UnidentifiedImageError
+
+logger = logging.getLogger(__name__)
+
+_EXT_RE = re.compile(r"\.[A-Za-z0-9]{1,8}$")
+
+# Folders are user-supplied path-like strings, so we constrain the
+# alphabet and reject traversal segments before they reach the DB.
+_FOLDER_SEGMENT_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]*$")
+_FOLDER_MAX_LENGTH = 300
+
+# Header signatures for the formats this module accepts. We sniff the
+# first bytes of every upload so a malicious client can't claim
+# `image/png` while shipping HTML/JS/PHP that StaticFiles would later
+# serve back under a same-origin URL. Pure-Python so no native dep.
+SNIFF_BYTES = 64
+
+_MAGIC_SIGNATURES: tuple[tuple[bytes, str], ...] = (
+    (b"\xff\xd8\xff", "image/jpeg"),
+    (b"\x89PNG\r\n\x1a\n", "image/png"),
+    (b"GIF87a", "image/gif"),
+    (b"GIF89a", "image/gif"),
+)
+
+# WebP needs a two-part check (RIFF + WEBP at offset 8); handled inline.
+CONTENT_TYPE_EXTENSIONS: dict[str, str] = {
+    "image/jpeg": ".jpg",
+    "image/png": ".png",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+}
+
+
+def normalize_folder(raw: str | None) -> str | None:
+    """Canonicalize a folder path or raise 422.
+
+    Strips surrounding slashes/whitespace, collapses double slashes,
+    and validates each segment against ``_FOLDER_SEGMENT_RE``. An empty
+    or ``None`` input becomes ``None`` (the asset is unfiled).
+    """
+    if raw is None:
+        return None
+    cleaned = raw.strip().strip("/")
+    if not cleaned:
+        return None
+    if len(cleaned) > _FOLDER_MAX_LENGTH:
+        raise HTTPException(status_code=422, detail="Folder path is too long")
+    segments = [seg for seg in cleaned.split("/") if seg]
+    for segment in segments:
+        if segment in {".", ".."} or not _FOLDER_SEGMENT_RE.match(segment):
+            raise HTTPException(
+                status_code=422,
+                detail=(
+                    "Folder segments must start with an alphanumeric and "
+                    "contain only letters, digits, '.', '_' or '-'"
+                ),
+            )
+    return "/".join(segments)
+
+
+def sniff_content_type(head: bytes) -> str | None:
+    for sig, ctype in _MAGIC_SIGNATURES:
+        if head.startswith(sig):
+            return ctype
+    if len(head) >= 12 and head[0:4] == b"RIFF" and head[8:12] == b"WEBP":
+        return "image/webp"
+    return None
+
+
+def safe_extension(name: str) -> str:
+    match = _EXT_RE.search(name or "")
+    return match.group(0).lower() if match else ""
+
+
+def is_animated(image: Image.Image) -> bool:
+    """Detect multi-frame images we should leave alone.
+
+    Pillow can downscale individual frames of animated GIF/WEBP but
+    re-encoding the animation into webp is a different code path and
+    the issue's acceptance criteria explicitly say animated GIFs skip
+    transcoding. ``getattr`` defends against formats where Pillow
+    doesn't set ``is_animated`` at all.
+    """
+    return bool(getattr(image, "is_animated", False))
+
+
+def process_image(
+    source: Path,
+    *,
+    thumbnail_widths: tuple[int, ...],
+    webp_quality: int,
+) -> tuple[int | None, int | None, dict[str, Any]]:
+    """Extract dimensions and generate webp thumbnails for a raster image.
+
+    Returns ``(width, height, variants)``. On any failure (corrupt
+    file, format Pillow can't decode, animated image) returns
+    ``(None, None, {})`` so the upload still completes — the original
+    is served as-is and the Image block falls back to a plain
+    ``<img src>``.
+    """
+    try:
+        with Image.open(source) as image:
+            src_w, src_h = image.size
+            if src_w <= 0 or src_h <= 0:
+                return src_w or None, src_h or None, {}
+            # Capture dimensions even for animated images — the
+            # original is still served, and a known intrinsic size
+            # lets the Image block emit width/height to avoid CLS.
+            if is_animated(image):
+                return src_w, src_h, {}
+            image.load()
+            variants = generate_thumbnails(
+                image,
+                source,
+                src_w,
+                src_h,
+                thumbnail_widths=thumbnail_widths,
+                webp_quality=webp_quality,
+            )
+    except (UnidentifiedImageError, OSError, ValueError) as exc:
+        # Logged at INFO because this is expected for corrupt or
+        # exotic-but-valid uploads — not a code bug.
+        logger.info("Skipping image processing for %s: %s", source.name, exc)
+        return None, None, {}
+    return src_w, src_h, variants
+
+
+def generate_thumbnails(
+    image: Image.Image,
+    source: Path,
+    src_w: int,
+    src_h: int,
+    *,
+    thumbnail_widths: tuple[int, ...],
+    webp_quality: int,
+) -> dict[str, Any]:
+    widths = sorted({w for w in thumbnail_widths if w > 0})
+    if not widths:
+        return {}
+    # Webp doesn't support paletted/CMYK directly the same way; convert
+    # once up front so each resize doesn't re-do the work.
+    if image.mode not in ("RGB", "RGBA"):
+        base = image.convert("RGBA" if "A" in image.mode else "RGB")
+    else:
+        base = image
+    stem = source.stem
+    out_dir = source.parent
+    variants: dict[str, Any] = {}
+    for width in widths:
+        if width >= src_w:
+            # No upscaling — skip widths at or above the source. The
+            # original file already covers visitors at full size.
+            continue
+        ratio = width / src_w
+        height = max(1, round(src_h * ratio))
+        resized = base.resize((width, height), Image.Resampling.LANCZOS)
+        out_name = f"{stem}_w{width}.webp"
+        out_path = out_dir / out_name
+        # method=4 is Google's recommended encoder default — method=6
+        # is ~5x slower for marginal byte-size gains at q=82.
+        resized.save(out_path, format="WEBP", quality=webp_quality, method=4)
+        variants[f"w{width}"] = {
+            "filename": out_name,
+            "content_type": "image/webp",
+            "width": width,
+            "height": height,
+            "size_bytes": out_path.stat().st_size,
+        }
+    return variants

pagebuilder/media_queries.py

@@ -0,0 +1,92 @@
+"""Listing and counting queries for media assets.
+
+Split from :mod:`pagebuilder.media_service` so that module stays focused on
+storage and uploads, and both files stay under the 300-line cap.
+"""
+
+from __future__ import annotations
+
+from sqlalchemy import func
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlmodel import select
+
+from pagebuilder.models import MediaAsset
+
+DEFAULT_PAGE_SIZE = 60
+MAX_PAGE_SIZE = 200
+
+
+def filtered_stmt(
+    *,
+    search: str | None = None,
+    content_type: str | None = None,
+    folder: str | None = None,
+    unfiled_only: bool = False,
+    min_size_bytes: int | None = None,
+    max_size_bytes: int | None = None,
+):
+    """Build the SELECT shared by listing and counting."""
+    stmt = select(MediaAsset)
+    if search:
+        # SQLite LIKE is case-insensitive for ASCII by default; this matches
+        # what users expect ("hero" finds "Hero.jpg").
+        stmt = stmt.where(MediaAsset.original_filename.like(f"%{search}%"))
+    if content_type:
+        if content_type.endswith("/*"):
+            stmt = stmt.where(MediaAsset.content_type.like(f"{content_type[:-1]}%"))
+        else:
+            stmt = stmt.where(MediaAsset.content_type == content_type)
+    if unfiled_only:
+        stmt = stmt.where(MediaAsset.folder.is_(None))
+    elif folder is not None:
+        stmt = stmt.where(MediaAsset.folder == folder)
+    if min_size_bytes is not None:
+        stmt = stmt.where(MediaAsset.size_bytes >= min_size_bytes)
+    if max_size_bytes is not None:
+        stmt = stmt.where(MediaAsset.size_bytes <= max_size_bytes)
+    return stmt
+
+
+async def count_assets(db: AsyncSession, **filters) -> int:
+    """Total rows matching *filters* — for offset-paginated callers."""
+    inner = filtered_stmt(**filters).subquery()
+    result = await db.execute(select(func.count()).select_from(inner))
+    return int(result.scalar_one())
+
+
+async def list_assets(
+    db: AsyncSession,
+    *,
+    cursor: int | None = None,
+    offset: int | None = None,
+    limit: int = DEFAULT_PAGE_SIZE,
+    **filters,
+) -> tuple[list[MediaAsset], int | None]:
+    """Return one page of assets newest-first, plus the next cursor.
+
+    Two paging modes. The default is cursor-based: the cursor is the smallest
+    ``id`` on the previous page, and the query asks for ``limit + 1`` rows so
+    the end of the list is detectable without a separate count.
+
+    Passing ``offset`` switches to offset paging, which the image-picker
+    gallery needs because it jumps to arbitrary pages. ``next_cursor`` is then
+    always ``None`` and callers pair it with :func:`count_assets`.
+    """
+    page_size = max(1, min(limit, MAX_PAGE_SIZE))
+    stmt = filtered_stmt(**filters)
+
+    if offset is not None:
+        stmt = stmt.order_by(MediaAsset.id.desc()).offset(max(0, offset)).limit(page_size)
+        result = await db.execute(stmt)
+        return list(result.scalars().all()), None
+
+    if cursor is not None:
+        stmt = stmt.where(MediaAsset.id < cursor)
+    stmt = stmt.order_by(MediaAsset.id.desc()).limit(page_size + 1)
+    result = await db.execute(stmt)
+    rows = list(result.scalars().all())
+    next_cursor: int | None = None
+    if len(rows) > page_size:
+        rows = rows[:page_size]
+        next_cursor = rows[-1].id
+    return rows, next_cursor