from __future__ import annotations
import difflib
from datetime import datetime
from typing import Any
from sqlalchemy import select
from sqlalchemy.orm import Session
from ..config import Settings
from ..pending_changes import ProposedChangeRequest
from .db import Database
from .models import Changeset, DocVersion, Document
from .pending_changes_db import PostgresPendingChangeRepository
class DocumentError(ValueError):
pass
def _iso(value: datetime | None) -> str | None:
if value is None:
return None
return value.isoformat().replace("+00:00", "Z")
def _find_document(session: Session, path: str) -> Document:
document = session.scalars(select(Document).where(Document.slug == path)).first()
if document is None or document.deleted_at is not None:
raise DocumentError("Document not found")
return document
def _find_version(session: Session, document_id, version_no: int) -> DocVersion:
version = session.scalars(
select(DocVersion).where(
DocVersion.document_id == document_id,
DocVersion.version_no == version_no,
)
).first()
if version is None:
raise DocumentError("Document version not found")
return version
def list_document_versions(database: Database, path: str) -> list[dict[str, Any]]:
with database.session() as session:
document = _find_document(session, path)
versions = session.scalars(
select(DocVersion)
.where(DocVersion.document_id == document.id)
.order_by(DocVersion.version_no)
).all()
result: list[dict[str, Any]] = []
for version in versions:
changeset = (
session.get(Changeset, version.changeset_id)
if version.changeset_id
else None
)
result.append(
{
"path": document.slug,
"version_no": version.version_no,
"content_hash": version.content_hash,
"created_at": _iso(version.created_at),
"actor_kind": version.actor_kind,
"actor_name": version.actor_name,
"via": version.via,
"changeset_id": str(version.changeset_id) if version.changeset_id else None,
"summary": changeset.summary if changeset else None,
}
)
return result
def get_document_version(database: Database, path: str, version_no: int) -> dict[str, Any]:
with database.session() as session:
document = _find_document(session, path)
version = _find_version(session, document.id, version_no)
changeset = (
session.get(Changeset, version.changeset_id) if version.changeset_id else None
)
return {
"path": document.slug,
"version_no": version.version_no,
"raw": version.raw,
"body": version.body,
"frontmatter": dict(version.frontmatter or {}),
"content_hash": version.content_hash,
"created_at": _iso(version.created_at),
"actor_kind": version.actor_kind,
"actor_name": version.actor_name,
"via": version.via,
"changeset_id": str(version.changeset_id) if version.changeset_id else None,
"summary": changeset.summary if changeset else None,
}
def diff_document_versions(
database: Database,
path: str,
from_version: int | None = None,
to_version: int | None = None,
) -> dict[str, Any]:
with database.session() as session:
document = _find_document(session, path)
versions = session.scalars(
select(DocVersion)
.where(DocVersion.document_id == document.id)
.order_by(DocVersion.version_no)
).all()
if not versions:
raise DocumentError("Document has no versions")
latest_no = versions[-1].version_no
target_no = latest_no if to_version is None else to_version
if from_version is None:
source_no = max(1, target_no - 1)
else:
source_no = from_version
if source_no < 1 or target_no < 1:
raise DocumentError("Version numbers must be positive")
source = _find_version(session, document.id, source_no)
target = _find_version(session, document.id, target_no)
diff_lines = difflib.unified_diff(
source.raw.splitlines(),
target.raw.splitlines(),
fromfile=f"{path}@v{source_no}",
tofile=f"{path}@v{target_no}",
lineterm="",
)
return {
"path": path,
"from_version": source_no,
"to_version": target_no,
"diff": "\n".join(diff_lines),
}
def restore_document_version(
database: Database,
settings: Settings,
path: str,
version_no: int,
summary: str | None = None,
via: str = "api",
) -> dict[str, Any]:
with database.session() as session:
document = _find_document(session, path)
version = _find_version(session, document.id, version_no)
raw = version.raw
repository = PostgresPendingChangeRepository(database, settings, via=via)
change = repository.create(
ProposedChangeRequest(
kind="doc",
target=path,
summary=summary or f"Restore {path} to version {version_no}",
reason=f"Restore version {version_no}",
payload={"content": raw},
)
)
return repository.apply(change["id"])