MetaList 0.9.0__tar.gz → 0.10.0__tar.gz

{metalist-0.9.0 → metalist-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metalist
-Version: 0.9.0
+Version: 0.10.0
 Summary: A minimalist single-user note-taking app with SSR, fast in-memory tree operations, and efficient sync.
 Project-URL: Homepage, https://github.com/evolvingstuff/metalist
 Project-URL: Repository, https://github.com/evolvingstuff/metalist
@@ -49,6 +49,14 @@ A minimalist single-user note-taking app focused on server-side rendering (SSR),
 - Multi-tab search contexts with server-persisted scroll/search state (survives browser restarts)
 - Manual namespace backups/restores to a user-selected backup folder with retention controls
 
+## Changes in 0.10.0
+
+- Excalidraw diagrams: add one from the note's right-click menu or the command palette, and double-click a diagram to edit it full screen. Diagrams autosave, show light and dark previews, resize like images, and each editing session is one undo step. The editor is bundled locally and needs no Node server.
+- The dark theme uses neutral greys with a brighter accent, the light theme header is darker, and Note Layout & Appearance adds note corner and tag style settings.
+- References to a note that starts with an image or diagram show its thumbnail. Collapsed notes, reference titles, and backlink previews show only the first line.
+- Fixed a command palette crash on queries with no matches.
+- The database schema moves to version 10. Password-protected namespaces migrate after unlock, with the usual automatic backup first.
+
 ## Changes in 0.9.0
 
 - AI chat can browse the web in disabled, contextual, or unrestricted mode, fetch multiple pages concurrently, and cite the specific pages used as evidence.

{metalist-0.9.0 → metalist-0.10.0}/README.md

@@ -12,6 +12,14 @@ A minimalist single-user note-taking app focused on server-side rendering (SSR),
 - Multi-tab search contexts with server-persisted scroll/search state (survives browser restarts)
 - Manual namespace backups/restores to a user-selected backup folder with retention controls
 
+## Changes in 0.10.0
+
+- Excalidraw diagrams: add one from the note's right-click menu or the command palette, and double-click a diagram to edit it full screen. Diagrams autosave, show light and dark previews, resize like images, and each editing session is one undo step. The editor is bundled locally and needs no Node server.
+- The dark theme uses neutral greys with a brighter accent, the light theme header is darker, and Note Layout & Appearance adds note corner and tag style settings.
+- References to a note that starts with an image or diagram show its thumbnail. Collapsed notes, reference titles, and backlink previews show only the first line.
+- Fixed a command palette crash on queries with no matches.
+- The database schema moves to version 10. Password-protected namespaces migrate after unlock, with the usual automatic backup first.
+
 ## Changes in 0.9.0
 
 - AI chat can browse the web in disabled, contextual, or unrestricted mode, fetch multiple pages concurrently, and cite the specific pages used as evidence.

{metalist-0.9.0 → metalist-0.10.0}/app/api/note_requests.py

@@ -206,6 +206,19 @@ class ResizeNoteImageRequest(TypedDict):
     undoContext: UndoContext
     viewport: Viewport
 
+@with_config(ConfigDict(strict=True))
+class FinishFileEditSessionRequest(TypedDict):
+    clientId: Identifier
+    hostNoteId: Identifier
+    contentRevision: Annotated[int, Field(ge=1)]
+    isNewDiagram: bool
+    undoContext: UndoContext
+    viewport: Viewport
+
+@with_config(ConfigDict(strict=True))
+class DiscardFileEditSessionRequest(TypedDict):
+    contentRevision: Annotated[int, Field(ge=1)]
+
 @with_config(ConfigDict(strict=True))
 class RunShellEndpointRequest(TypedDict):
     timeoutSeconds: Annotated[int, Field(ge=0, le=SHELL_SECONDS)]

metalist-0.10.0/app/api/routes/files.py

@@ -0,0 +1,244 @@
+from __future__ import annotations
+
+from io import BytesIO
+from typing import Annotated
+from urllib.parse import quote
+
+from fastapi import APIRouter, File, Form, HTTPException, Request, UploadFile
+from fastapi.responses import Response, StreamingResponse
+from pydantic import BaseModel
+
+from app.api.note_requests import DiscardFileEditSessionRequest, FinishFileEditSessionRequest
+from app.api.transactions import transactional_route
+from app.api.upload_limits import read_attachment
+from app.api.request_auth import require_request_auth_token
+from app.services.file_registry import file_registry
+from app.services.note_store import store as note_store
+from app.db.file_schema import FILE_PREVIEW_VARIANTS
+from app.services.file_storage import (
+    create_file,
+    download_file,
+    get_file_preview,
+    replace_file_content,
+    store_file_previews,
+    trim_unused_files,
+)
+from app.usecases.file_edit_session import (
+    CmdDiscardFileEditSession,
+    CmdFinishFileEditSession,
+    CmdStartFileEditSession,
+)
+
+router = APIRouter(prefix="/files", tags=["files"])
+
+FILE_REVISION_HEADER = "X-MetaList-File-Revision"
+
+
+class UploadedFileResponse(BaseModel):
+    file_id: str
+    reference_token: str
+    title: str
+    original_filename: str
+    mime_type: str
+    size_bytes: int
+    thumbnail_kind: str
+
+
+class FileContentUpdatedResponse(BaseModel):
+    file_id: str
+    content_revision: int
+    size_bytes: int
+
+
+class FilePreviewsStoredResponse(BaseModel):
+    file_id: str
+    content_revision: int
+
+
+class TrimUnusedFilesResponse(BaseModel):
+    deleted_count: int
+    deleted_file_ids: list[str]
+
+
+def _require_bearer_token(request: Request) -> str:
+    return require_request_auth_token(request)
+
+
+def _require_known_file(file_id: str) -> None:
+    if not file_registry.has_file(file_id):
+        raise HTTPException(status_code=404, detail=f"File not found: {file_id}")
+
+
+@router.post("/upload", response_model=UploadedFileResponse)
+@transactional_route
+async def upload_file_endpoint(
+    request: Request,
+    file: Annotated[UploadFile, File()],
+):
+    token = _require_bearer_token(request)
+    if not isinstance(file.filename, str) or file.filename == "":
+        raise HTTPException(status_code=400, detail="Uploaded file must include a filename")
+    if not isinstance(file.content_type, str) or file.content_type == "":
+        raise HTTPException(status_code=400, detail="Uploaded file must include a non-empty MIME type")
+
+    content_bytes = await read_attachment(file)
+
+    record = create_file(
+        original_filename=file.filename,
+        mime_type=file.content_type,
+        content_bytes=content_bytes,
+        token=token,
+    )
+    return UploadedFileResponse(
+        file_id=record.id,
+        reference_token=f"![[{record.id}]]",
+        title=record.title,
+        original_filename=record.original_filename,
+        mime_type=record.mime_type,
+        size_bytes=record.size_bytes,
+        thumbnail_kind=record.thumbnail_kind,
+    )
+
+
+@router.get("/{file_id}/download")
+def download_file_endpoint(request: Request, file_id: str):
+    token = _require_bearer_token(request)
+    if not file_registry.has_file(file_id):
+        raise HTTPException(status_code=404, detail=f"File not found: {file_id}")
+
+    downloaded = download_file(file_id, token)
+    quoted_filename = quote(downloaded.record.original_filename, safe="")
+    return StreamingResponse(
+        BytesIO(downloaded.content_bytes),
+        media_type=downloaded.record.mime_type,
+        headers={
+            "Content-Disposition": f"attachment; filename*=UTF-8''{quoted_filename}",
+            FILE_REVISION_HEADER: str(downloaded.record.content_revision),
+        },
+    )
+
+
+@router.put("/{file_id}/content", response_model=FileContentUpdatedResponse)
+@transactional_route
+async def replace_file_content_endpoint(
+    request: Request,
+    file_id: str,
+    file: Annotated[UploadFile, File()],
+    expected_revision: Annotated[int, Form()],
+):
+    token = _require_bearer_token(request)
+    _require_known_file(file_id)
+    content_bytes = await read_attachment(file)
+    record = replace_file_content(
+        file_id=file_id,
+        content_bytes=content_bytes,
+        expected_revision=expected_revision,
+        token=token,
+    )
+    return FileContentUpdatedResponse(
+        file_id=record.id,
+        content_revision=record.content_revision,
+        size_bytes=record.size_bytes,
+    )
+
+
+@router.put("/{file_id}/previews", response_model=FilePreviewsStoredResponse)
+@transactional_route
+async def store_file_previews_endpoint(
+    request: Request,
+    file_id: str,
+    light: Annotated[UploadFile, File()],
+    dark: Annotated[UploadFile, File()],
+    content_revision: Annotated[int, Form()],
+):
+    token = _require_bearer_token(request)
+    _require_known_file(file_id)
+    previews_by_variant = {
+        "light": await read_attachment(light),
+        "dark": await read_attachment(dark),
+    }
+    record = store_file_previews(
+        file_id=file_id,
+        previews_by_variant=previews_by_variant,
+        content_revision=content_revision,
+        token=token,
+    )
+    return FilePreviewsStoredResponse(file_id=record.id, content_revision=record.content_revision)
+
+
+@router.get("/{file_id}/previews/{variant}")
+def download_file_preview_endpoint(request: Request, file_id: str, variant: str):
+    token = _require_bearer_token(request)
+    _require_known_file(file_id)
+    if variant not in FILE_PREVIEW_VARIANTS:
+        raise HTTPException(status_code=404, detail=f"Unknown preview variant: {variant}")
+    preview = get_file_preview(file_id=file_id, variant=variant, token=token)
+    return Response(
+        content=preview.content_bytes,
+        media_type=preview.mime_type,
+        headers={FILE_REVISION_HEADER: str(preview.content_revision)},
+    )
+
+
+# A diagram editing session: opened with the editor, finished by Done (one undo step), or discarded.
+@router.post("/{file_id}/edit-sessions")
+@transactional_route
+def start_file_edit_session_endpoint(request: Request, file_id: str) -> dict[str, object]:
+    token = _require_bearer_token(request)
+    _require_known_file(file_id)
+    return CmdStartFileEditSession(file_id=file_id, token=token).execute()
+
+
+@router.post("/{file_id}/edit-sessions/{session_id}/finish")
+@transactional_route
+def finish_file_edit_session_endpoint(
+    request: Request,
+    file_id: str,
+    session_id: str,
+    body: FinishFileEditSessionRequest,
+) -> dict[str, object]:
+    token = _require_bearer_token(request)
+    _require_known_file(file_id)
+    host_note_id = body["hostNoteId"]
+    if not note_store.has_note(host_note_id):
+        raise HTTPException(status_code=404, detail=f"Note not found: {host_note_id}")
+    return CmdFinishFileEditSession(
+        file_id=file_id,
+        session_id=session_id,
+        host_note_id=host_note_id,
+        content_revision=body["contentRevision"],
+        is_new_diagram=body["isNewDiagram"],
+        token=token,
+        client_id=body["clientId"],
+        undo_context=body["undoContext"],
+        viewport=body["viewport"],
+    ).execute()
+
+
+@router.post("/{file_id}/edit-sessions/{session_id}/discard")
+@transactional_route
+def discard_file_edit_session_endpoint(
+    request: Request,
+    file_id: str,
+    session_id: str,
+    body: DiscardFileEditSessionRequest,
+) -> dict[str, object]:
+    token = _require_bearer_token(request)
+    _require_known_file(file_id)
+    return CmdDiscardFileEditSession(
+        file_id=file_id,
+        session_id=session_id,
+        content_revision=body["contentRevision"],
+        token=token,
+    ).execute()
+
+
+@router.post("/trim-unused", response_model=TrimUnusedFilesResponse)
+@transactional_route
+def trim_unused_files_endpoint(request: Request):
+    _require_bearer_token(request)
+    result = trim_unused_files()
+    return TrimUnusedFilesResponse(
+        deleted_count=result.deleted_count,
+        deleted_file_ids=result.deleted_file_ids,
+    )

{metalist-0.9.0 → metalist-0.10.0}/app/api/upload_limits.py

@@ -23,6 +23,18 @@ async def read_attachment(file: UploadFile) -> bytes:
         await file.close()
 
 
+def _is_upload_request(scope) -> bool:
+    path = scope['path']
+    if path.endswith('/files/upload'):
+        return True
+    # In-place updates of MetaList-edited files (Excalidraw scenes and their previews) are uploads too.
+    if '/files/' not in path:
+        return False
+    if not path.endswith('/content') and not path.endswith('/previews'):
+        return False
+    return scope['method'] == 'PUT'
+
+
 class UploadLimitMiddleware:
     def __init__(self, app):
         self.app = app
@@ -32,7 +44,7 @@ class UploadLimitMiddleware:
         if scope['type'] != 'http':
             await self.app(scope, receive, send)
             return
-        is_upload = scope['path'].endswith('/files/upload')
+        is_upload = _is_upload_request(scope)
         is_download = '/files/' in scope['path'] and scope['path'].endswith('/download')
         if not (is_upload or is_download):
             await self.app(scope, receive, send)

metalist-0.10.0/app/db/editable_files_migration.py

@@ -0,0 +1,50 @@
+"""Migration 9→10: let MetaList edit some attachments in place (Excalidraw diagrams).
+
+The sibling files database gains `files.content_revision` and the encrypted `file_previews`
+table. Opening a files database also adds them (see `initialize_file_schema`), so this step is
+idempotent; it exists so the upgrade is recorded in the namespace version like every other
+schema change, and so the encryption audit can require the new schema from version 10 on.
+"""
+
+from contextlib import closing
+from pathlib import Path
+import sqlite3
+
+from app.db.file_schema import FILE_PREVIEWS_TABLE, FILES_TABLE, initialize_file_schema
+
+# Same shared in-memory database FileSession uses when the notes database is in memory.
+_FILE_MEMORY_URI = "file:metalist_files_memory?mode=memory&cache=shared"
+
+
+def _upgrade(files: sqlite3.Connection) -> None:
+    initialize_file_schema(files)
+    files.commit()
+    columns = {row[1] for row in files.execute(f"PRAGMA table_info({FILES_TABLE})").fetchall()}
+    if "content_revision" not in columns:
+        raise RuntimeError("Database migration 9→10 did not add files.content_revision")
+    preview_table = files.execute(
+        "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?", (FILE_PREVIEWS_TABLE,)
+    ).fetchone()
+    if preview_table is None:
+        raise RuntimeError(f"Database migration 9→10 did not create {FILE_PREVIEWS_TABLE}")
+
+
+def add_editable_file_schema(
+    *,
+    connection: sqlite3.Connection,
+    encryption_enabled: bool,  # noqa: ARG001
+    encryption_service: object,  # noqa: ARG001
+) -> int:
+    database = connection.execute("PRAGMA database_list").fetchone()[2]
+    if not database:
+        with closing(sqlite3.connect(_FILE_MEMORY_URI, uri=True)) as files:
+            _upgrade(files)
+        return 0
+    notes = Path(database)
+    target = notes.with_name(f"{notes.stem}.files{notes.suffix}")
+    # A namespace without attachments gets the current schema when its files database is created.
+    if not target.exists():
+        return 0
+    with closing(sqlite3.connect(target)) as files:
+        _upgrade(files)
+    return 0

metalist-0.10.0/app/db/file_schema.py

@@ -0,0 +1,58 @@
+"""SQLite schema helpers for encrypted file storage."""
+
+from __future__ import annotations
+
+from sqlite3 import Connection
+
+FILES_TABLE = "files"
+FILE_PREVIEWS_TABLE = "file_previews"
+FILE_PREVIEW_VARIANTS = ("light", "dark")
+
+_CREATE_FILES_TABLE = f"""
+CREATE TABLE IF NOT EXISTS {FILES_TABLE} (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL,
+    title_encryption_nonce BLOB,
+    title_encryption_tag BLOB,
+    metadata_json TEXT NOT NULL,
+    metadata_encryption_nonce BLOB,
+    metadata_encryption_tag BLOB,
+    blob_data BLOB NOT NULL,
+    blob_encryption_nonce BLOB,
+    blob_encryption_tag BLOB,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    content_revision INTEGER NOT NULL DEFAULT 1
+);
+"""
+
+# Rendered previews for files edited inside MetaList (Excalidraw diagrams).
+# One row per theme variant; content_revision records which file revision was rendered.
+_CREATE_FILE_PREVIEWS_TABLE = f"""
+CREATE TABLE IF NOT EXISTS {FILE_PREVIEWS_TABLE} (
+    file_id TEXT NOT NULL REFERENCES {FILES_TABLE}(id) ON DELETE CASCADE,
+    variant TEXT NOT NULL CHECK (variant IN ('light', 'dark')),
+    mime_type TEXT NOT NULL,
+    preview_data BLOB NOT NULL,
+    preview_encryption_nonce BLOB,
+    preview_encryption_tag BLOB,
+    content_revision INTEGER NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (file_id, variant)
+);
+"""
+
+
+def _add_content_revision_column_if_missing(connection: Connection) -> None:
+    """Upgrade live file databases created before in-place file updates existed."""
+    column_names = {row[1] for row in connection.execute(f"PRAGMA table_info({FILES_TABLE})").fetchall()}
+    assert "id" in column_names, "files table must exist before its columns are upgraded"
+    if "content_revision" in column_names:
+        return
+    connection.execute(f"ALTER TABLE {FILES_TABLE} ADD COLUMN content_revision INTEGER NOT NULL DEFAULT 1")
+
+
+def initialize_file_schema(connection: Connection) -> None:
+    connection.execute(_CREATE_FILES_TABLE)
+    _add_content_revision_column_if_missing(connection)
+    connection.execute(_CREATE_FILE_PREVIEWS_TABLE)

{metalist-0.9.0 → metalist-0.10.0}/app/db/files_sql.py

@@ -6,7 +6,7 @@ import sqlite3
 from datetime import datetime
 from typing import Iterable, Optional
 
-from app.db.file_schema import FILES_TABLE
+from app.db.file_schema import FILE_PREVIEW_VARIANTS, FILE_PREVIEWS_TABLE, FILES_TABLE
 
 
 def _serialize_datetime(value: datetime) -> str:
@@ -24,6 +24,10 @@ def _deserialize_row(row: sqlite3.Row) -> dict[str, object]:
             raise TypeError(f"files.{field} must be a string | file_id={file_id} value={raw!r}")
         return datetime.fromisoformat(raw)
 
+    content_revision = row["content_revision"]
+    if not isinstance(content_revision, int) or content_revision < 1:
+        raise TypeError(f"files.content_revision must be a positive integer | file_id={file_id} value={content_revision!r}")
+
     return {
         "id": file_id,
         "title": row["title"],
@@ -37,6 +41,7 @@ def _deserialize_row(row: sqlite3.Row) -> dict[str, object]:
         "blob_encryption_tag": row["blob_encryption_tag"],
         "created_at": _parse_datetime("created_at"),
         "updated_at": _parse_datetime("updated_at"),
+        "content_revision": content_revision,
     }
 
 
@@ -90,7 +95,7 @@ def insert_file(
     )
 
 
-_METADATA_COLUMNS = "id, title, title_encryption_nonce, title_encryption_tag, metadata_json, metadata_encryption_nonce, metadata_encryption_tag, created_at, updated_at, X'' AS blob_data, blob_encryption_nonce, blob_encryption_tag"
+_METADATA_COLUMNS = "id, title, title_encryption_nonce, title_encryption_tag, metadata_json, metadata_encryption_nonce, metadata_encryption_tag, created_at, updated_at, content_revision, X'' AS blob_data, blob_encryption_nonce, blob_encryption_tag"
 
 
 class AttachmentSizeExceeded(ValueError):
@@ -200,3 +205,157 @@ def delete_files(connection: sqlite3.Connection, file_ids: Iterable[str]) -> int
         tuple(identifiers),
     )
     return int(cursor.rowcount)
+
+
+def replace_file_content_fields(
+    connection: sqlite3.Connection,
+    *,
+    file_id: str,
+    metadata_json: str,
+    metadata_encryption_nonce: Optional[bytes],
+    metadata_encryption_tag: Optional[bytes],
+    blob_data: bytes,
+    blob_encryption_nonce: Optional[bytes],
+    blob_encryption_tag: Optional[bytes],
+    expected_revision: int,
+    updated_at: datetime,
+) -> int:
+    """Replace a file's content when it is still at expected_revision; returns the updated row count."""
+    if not isinstance(expected_revision, int) or expected_revision < 1:
+        raise TypeError(f"expected_revision must be a positive integer, got {expected_revision!r}")
+    cursor = connection.execute(
+        f"""
+        UPDATE {FILES_TABLE}
+        SET
+            metadata_json = ?,
+            metadata_encryption_nonce = ?,
+            metadata_encryption_tag = ?,
+            blob_data = ?,
+            blob_encryption_nonce = ?,
+            blob_encryption_tag = ?,
+            updated_at = ?,
+            content_revision = content_revision + 1
+        WHERE id = ? AND content_revision = ?
+        """,
+        (
+            metadata_json,
+            metadata_encryption_nonce,
+            metadata_encryption_tag,
+            blob_data,
+            blob_encryption_nonce,
+            blob_encryption_tag,
+            _serialize_datetime(updated_at),
+            file_id,
+            expected_revision,
+        ),
+    )
+    return int(cursor.rowcount)
+
+
+def _require_preview_variant(variant: str) -> None:
+    if variant not in FILE_PREVIEW_VARIANTS:
+        raise ValueError(f"file preview variant must be one of {FILE_PREVIEW_VARIANTS}, got {variant!r}")
+
+
+def _deserialize_preview_row(row: sqlite3.Row) -> dict[str, object]:
+    file_id = row["file_id"]
+    content_revision = row["content_revision"]
+    if not isinstance(content_revision, int) or content_revision < 1:
+        raise TypeError(f"file_previews.content_revision invalid | file_id={file_id} value={content_revision!r}")
+    updated_at = row["updated_at"]
+    if not isinstance(updated_at, str):
+        raise TypeError(f"file_previews.updated_at must be a string | file_id={file_id}")
+    return {
+        "file_id": file_id,
+        "variant": row["variant"],
+        "mime_type": row["mime_type"],
+        "preview_data": row["preview_data"],
+        "preview_encryption_nonce": row["preview_encryption_nonce"],
+        "preview_encryption_tag": row["preview_encryption_tag"],
+        "content_revision": content_revision,
+        "updated_at": datetime.fromisoformat(updated_at),
+    }
+
+
+def upsert_file_preview(
+    connection: sqlite3.Connection,
+    *,
+    file_id: str,
+    variant: str,
+    mime_type: str,
+    preview_data: bytes,
+    preview_encryption_nonce: Optional[bytes],
+    preview_encryption_tag: Optional[bytes],
+    content_revision: int,
+    updated_at: datetime,
+) -> None:
+    _require_preview_variant(variant)
+    connection.execute(
+        f"""
+        INSERT INTO {FILE_PREVIEWS_TABLE} (
+            file_id, variant, mime_type, preview_data, preview_encryption_nonce,
+            preview_encryption_tag, content_revision, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(file_id, variant) DO UPDATE SET
+            mime_type = excluded.mime_type,
+            preview_data = excluded.preview_data,
+            preview_encryption_nonce = excluded.preview_encryption_nonce,
+            preview_encryption_tag = excluded.preview_encryption_tag,
+            content_revision = excluded.content_revision,
+            updated_at = excluded.updated_at
+        """,
+        (
+            file_id,
+            variant,
+            mime_type,
+            preview_data,
+            preview_encryption_nonce,
+            preview_encryption_tag,
+            content_revision,
+            _serialize_datetime(updated_at),
+        ),
+    )
+
+
+def delete_file_previews(connection: sqlite3.Connection, file_id: str) -> int:
+    cursor = connection.execute(f"DELETE FROM {FILE_PREVIEWS_TABLE} WHERE file_id = ?", (file_id,))
+    return cursor.rowcount
+
+
+def fetch_file_preview(connection: sqlite3.Connection, file_id: str, variant: str) -> Optional[dict[str, object]]:
+    _require_preview_variant(variant)
+    row = connection.execute(
+        f"SELECT * FROM {FILE_PREVIEWS_TABLE} WHERE file_id = ? AND variant = ?",
+        (file_id, variant),
+    ).fetchone()
+    if row is None:
+        return None
+    return _deserialize_preview_row(row)
+
+
+def fetch_all_file_previews(connection: sqlite3.Connection) -> list[dict[str, object]]:
+    rows = connection.execute(f"SELECT * FROM {FILE_PREVIEWS_TABLE} ORDER BY file_id ASC, variant ASC").fetchall()
+    return [_deserialize_preview_row(row) for row in rows]
+
+
+def update_file_preview_storage_fields(
+    connection: sqlite3.Connection,
+    *,
+    file_id: str,
+    variant: str,
+    preview_data: bytes,
+    preview_encryption_nonce: Optional[bytes],
+    preview_encryption_tag: Optional[bytes],
+) -> None:
+    """Rewrite preview ciphertext during encryption migrations without changing its revision."""
+    _require_preview_variant(variant)
+    cursor = connection.execute(
+        f"""
+        UPDATE {FILE_PREVIEWS_TABLE}
+        SET preview_data = ?, preview_encryption_nonce = ?, preview_encryption_tag = ?
+        WHERE file_id = ? AND variant = ?
+        """,
+        (preview_data, preview_encryption_nonce, preview_encryption_tag, file_id, variant),
+    )
+    if cursor.rowcount != 1:
+        raise RuntimeError(f"file preview rewrite expected one row | file_id={file_id} variant={variant}")

{metalist-0.9.0 → metalist-0.10.0}/app/db/migrations.py

@@ -8,6 +8,7 @@ import sqlite3
 import re
 
 from app.db.version import CURRENT_DATABASE_VERSION
+from app.db.editable_files_migration import add_editable_file_schema
 from app.db.retire_sounds import retire_sounds
 from app.db.schema import create_namespace_content_migrations_table
 from app.services.encryption import EncryptionService
@@ -382,6 +383,7 @@ _MIGRATIONS: dict[
     6: _migration_6_to_7,
     7: _migration_7_to_8,
     8: retire_sounds,
+    9: add_editable_file_schema,
 }
 
 

{metalist-0.9.0 → metalist-0.10.0}/app/db/version.py

@@ -1,3 +1,3 @@
 """Database schema version constants without runtime configuration imports."""
 
-CURRENT_DATABASE_VERSION = 9
+CURRENT_DATABASE_VERSION = 10