from __future__ import annotations
import hashlib
from datetime import datetime
from pathlib import PurePosixPath
from typing import Any
from uuid import UUID
from sqlalchemy import func, select
from sqlalchemy.orm import Session
from ..config import Settings
from ..docs_repository import DocsRepository
from ..markdown import parse_frontmatter
from ..pending_changes import PendingChangeError, ProposedChangeRequest
from .db import Database
from .models import (
AuditLog,
Blob,
ChangeItem,
Changeset,
DocVersion,
Document,
InventoryItem,
InventoryItemVersion,
InventoryType,
utcnow,
)
from .validation import validate_session
def _iso(value: datetime | None) -> str | None:
if value is None:
return None
return value.isoformat().replace("+00:00", "Z")
def _content_hash(raw: str) -> str:
return hashlib.sha256(raw.encode("utf-8")).hexdigest()
def _serialize(changeset: Changeset, items: list[ChangeItem]) -> dict[str, Any]:
primary = items[0]
return {
"id": str(changeset.id),
"kind": primary.kind,
"target": primary.target,
"summary": changeset.summary,
"reason": changeset.reason,
"payload": dict(primary.payload or {}),
"status": changeset.status,
"created_at": _iso(changeset.created_at),
"updated_at": _iso(changeset.applied_at or changeset.created_at),
"applied_at": _iso(changeset.applied_at),
"validation": changeset.validation,
"items": [
{
"id": str(item.id),
"kind": item.kind,
"target": item.target,
"status": item.status,
"payload": dict(item.payload or {}),
}
for item in items
],
}
class PostgresPendingChangeRepository:
def __init__(self, database: Database, settings: Settings, via: str = "api") -> None:
self.database = database
self.settings = settings
self.via = via
def list(self) -> list[dict[str, Any]]:
with self.database.session() as session:
changesets = session.scalars(
select(Changeset).order_by(Changeset.created_at.desc())
).all()
result: list[dict[str, Any]] = []
for changeset in changesets:
items = self._items(session, changeset.id)
if items:
result.append(_serialize(changeset, items))
return result
def get(self, change_id: str) -> dict[str, Any]:
with self.database.session() as session:
changeset = self._changeset(session, change_id)
items = self._items(session, changeset.id)
if not items:
raise PendingChangeError("Pending change not found")
return _serialize(changeset, items)
def create(self, request: ProposedChangeRequest) -> dict[str, Any]:
with self.database.session() as session:
with session.begin():
changeset = Changeset(
summary=request.summary,
reason=request.reason,
status="draft",
)
session.add(changeset)
session.flush()
item = ChangeItem(
changeset_id=changeset.id,
kind=request.kind,
target=request.target,
payload=request.payload,
status="draft",
)
session.add(item)
session.flush()
session.add(
AuditLog(
actor_kind="agent",
actor_name=None,
via=self.via,
action="propose",
entity_type="changeset",
entity_id=str(changeset.id),
after={
"summary": request.summary,
"kind": request.kind,
"target": request.target,
},
)
)
return _serialize(changeset, [item])
def apply(self, change_id: str) -> dict[str, Any]:
with self.database.session() as session:
with session.begin():
changeset = self._changeset(session, change_id)
if changeset.status != "draft":
raise PendingChangeError("Only pending changes can be applied")
items = self._items(session, changeset.id)
if not items:
raise PendingChangeError("Pending change has no items")
for item in items:
if item.kind == "doc":
self._apply_doc(session, changeset, item)
elif item.kind == "inventory-item":
self._apply_inventory_item(session, changeset, item)
else:
raise PendingChangeError(
"Only doc and inventory-item changes can be applied in the current MVP"
)
item.status = "applied"
session.flush()
validation = validate_session(session)
if validation["status"] != "ok":
issues = validation.get("issues", [])
details = "\n".join(
f" - {issue['path']} ({issue['code']}): {issue['message']}"
for issue in issues[:10]
)
raise PendingChangeError(
"Applied change failed validation and was rolled back. Issues:\n"
+ details
)
changeset.status = "applied"
changeset.applied_at = utcnow()
changeset.validation = validation
session.add(
AuditLog(
actor_kind="agent",
actor_name=None,
via=self.via,
action="apply",
entity_type="changeset",
entity_id=str(changeset.id),
after={
"summary": changeset.summary,
"targets": [item.target for item in items],
"validation": validation,
},
)
)
return _serialize(changeset, items)
def _apply_doc(self, session: Session, changeset: Changeset, item: ChangeItem) -> None:
target = item.target
if not target.endswith(".md") or target.startswith("/") or "\\" in target:
raise PendingChangeError("Doc change target must be a Markdown file")
parts = PurePosixPath(target).parts
if not parts or ".." in parts:
raise PendingChangeError("Doc change target escapes repository root")
payload = item.payload or {}
content = payload.get("content")
if not isinstance(content, str) or not content.strip():
raise PendingChangeError("Doc change payload.content must be a non-empty string")
if not content.endswith("\n"):
content += "\n"
parsed = parse_frontmatter(target, content)
title = DocsRepository._extract_title(parsed.body) or PurePosixPath(target).stem
document = session.scalars(
select(Document).where(Document.slug == target).with_for_update()
).first()
if document is None:
document = Document(slug=target, title=title)
session.add(document)
session.flush()
version_no = 1
parent_version_id = None
else:
if document.deleted_at is not None:
raise PendingChangeError("Document is deleted")
document.title = title
latest = session.scalars(
select(DocVersion)
.where(DocVersion.document_id == document.id)
.order_by(DocVersion.version_no.desc())
.limit(1)
).first()
version_no = (latest.version_no + 1) if latest else 1
parent_version_id = latest.id if latest else None
content_hash = _content_hash(content)
if session.get(Blob, content_hash) is None:
session.add(Blob(hash=content_hash, content=content, size=len(content)))
session.add(
DocVersion(
document_id=document.id,
version_no=version_no,
parent_version_id=parent_version_id,
content_hash=content_hash,
raw=content,
body=parsed.body,
frontmatter=parsed.frontmatter,
actor_kind="agent",
actor_name=None,
via=self.via,
changeset_id=changeset.id,
)
)
def _apply_inventory_item(
self, session: Session, changeset: Changeset, item: ChangeItem
) -> None:
parts = item.target.split("/")
if len(parts) != 2 or not parts[0] or not parts[1]:
raise PendingChangeError("Inventory item target must use '<inventory-type>/<id>'")
inventory_type, item_id = parts
inventory_type_row = session.get(InventoryType, inventory_type)
if inventory_type_row is None:
raise PendingChangeError("Inventory type not found")
payload = item.payload or {}
mode = payload.get("mode", "update")
if mode not in {"update", "create"}:
raise PendingChangeError("Inventory change mode must be 'update' or 'create'")
if "patch" in payload:
patch = payload["patch"]
elif "mode" in payload:
raise PendingChangeError("Inventory change payload.patch is required")
else:
patch = payload
if not isinstance(patch, dict) or not patch:
raise PendingChangeError("Inventory change patch must be a non-empty object")
if "id" in patch:
raise PendingChangeError("Inventory item id cannot be changed")
row = session.scalars(
select(InventoryItem)
.where(
InventoryItem.type == inventory_type,
InventoryItem.item_id == item_id,
InventoryItem.deleted_at.is_(None),
)
.with_for_update()
).first()
if mode == "update":
if row is None:
raise PendingChangeError("Inventory item not found")
row.data = {**dict(row.data or {}), **patch}
latest = session.scalars(
select(InventoryItemVersion)
.where(InventoryItemVersion.inventory_item_id == row.id)
.order_by(InventoryItemVersion.version_no.desc())
.limit(1)
).first()
version_no = (latest.version_no + 1) if latest else 1
version_item = row
else:
if row is not None:
raise PendingChangeError("Inventory item already exists")
max_position = session.scalar(
select(func.max(InventoryItem.position)).where(
InventoryItem.type == inventory_type
)
)
row = InventoryItem(
type=inventory_type,
item_id=item_id,
position=(max_position or 0) + 1,
data=dict(patch),
)
session.add(row)
session.flush()
version_no = 1
version_item = row
session.add(
InventoryItemVersion(
inventory_item_id=version_item.id,
version_no=version_no,
data=dict(version_item.data or {}),
changeset_id=changeset.id,
)
)
@staticmethod
def _changeset(session: Session, change_id: str) -> Changeset:
try:
identifier = UUID(str(change_id))
except ValueError as exc:
raise PendingChangeError("Pending change not found") from exc
changeset = session.get(Changeset, identifier)
if changeset is None:
raise PendingChangeError("Pending change not found")
return changeset
@staticmethod
def _items(session: Session, changeset_id: UUID) -> list[ChangeItem]:
return list(
session.scalars(
select(ChangeItem)
.where(ChangeItem.changeset_id == changeset_id)
.order_by(ChangeItem.created_at, ChangeItem.id)
).all()
)