代码提交

This commit is contained in:
董宏凯 committed 2026-08-16 19:17:45 +08:00
1 parent 70da7c5649
commit 178572bc7f
79 files changed
+13456 -798

No files matched your search

@@ -0,0 +1,17 @@
"""Document rewrite version persistence factory."""
from deerflow.persistence.document_rewrite_versions.model import DocumentRewriteVersionRow
from deerflow.persistence.document_rewrite_versions.sql import DocumentRewriteVersionRepository
def make_document_rewrite_version_store(session_factory) -> DocumentRewriteVersionRepository | None:
if session_factory is None:
return None
return DocumentRewriteVersionRepository(session_factory)
__all__ = [
"DocumentRewriteVersionRepository",
"DocumentRewriteVersionRow",
"make_document_rewrite_version_store",
]
@@ -0,0 +1,34 @@
"""Persistent, undoable snapshots for whole-document AI rewrites."""
from __future__ import annotations
from datetime import UTC, datetime
from sqlalchemy import String
from sqlalchemy.orm import Mapped, mapped_column
from deerflow.persistence.base import Base
from deerflow.persistence.types import BeijingDateTime, PortableLongText
class DocumentRewriteVersionRow(Base):
"""The immutable pre-rewrite document retained for one safe undo action."""
__tablename__ = "document_rewrite_versions"
id: Mapped[str] = mapped_column(String(64), primary_key=True)
user_id: Mapped[str | None] = mapped_column(String(64), nullable=True, index=True)
# ``artifact`` uses ``source_id=thread_id`` and a virtual sandbox path;
# ``deep_research_report`` uses ``source_id=deep-research session id``.
source_type: Mapped[str] = mapped_column(String(32), nullable=False, index=True)
source_id: Mapped[str] = mapped_column(String(128), nullable=False, index=True)
source_path: Mapped[str | None] = mapped_column(String(1024), nullable=True)
original_content: Mapped[str] = mapped_column(PortableLongText, nullable=False)
original_hash: Mapped[str] = mapped_column(String(64), nullable=False)
committed_hash: Mapped[str] = mapped_column(String(64), nullable=False)
instruction: Mapped[str | None] = mapped_column(PortableLongText, nullable=True)
model_name: Mapped[str | None] = mapped_column(String(256), nullable=True)
reverted_at: Mapped[datetime | None] = mapped_column(BeijingDateTime(), nullable=True)
created_at: Mapped[datetime] = mapped_column(
BeijingDateTime(), nullable=False, default=lambda: datetime.now(UTC)
)
@@ -0,0 +1,145 @@
"""Repository for document-rewrite snapshots.
The caller performs the actual content compare-and-swap. This repository keeps
the retained original version owner-scoped and marks a snapshot consumed after a
successful undo, preventing an older undo from silently overwriting newer work.
"""
from __future__ import annotations
from datetime import UTC, datetime
from typing import Any
from sqlalchemy import delete, select, update
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from deerflow.persistence.document_rewrite_versions.model import DocumentRewriteVersionRow
from deerflow.runtime.user_context import AUTO, _AutoSentinel, resolve_user_id
class DocumentRewriteVersionRepository:
def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
self._sf = session_factory
@staticmethod
def _row_to_dict(row: DocumentRewriteVersionRow) -> dict[str, Any]:
return row.to_dict()
async def create(
self,
*,
id: str,
source_type: str,
source_id: str,
source_path: str | None,
original_content: str,
original_hash: str,
committed_hash: str,
instruction: str | None = None,
model_name: str | None = None,
user_id: str | _AutoSentinel = AUTO,
) -> dict[str, Any]:
resolved = resolve_user_id(user_id, method_name="DocumentRewriteVersionRepository.create")
async with self._sf() as session:
row = DocumentRewriteVersionRow(
id=id,
user_id=resolved,
source_type=source_type,
source_id=source_id,
source_path=source_path,
original_content=original_content,
original_hash=original_hash,
committed_hash=committed_hash,
instruction=instruction,
model_name=model_name,
)
session.add(row)
await session.commit()
await session.refresh(row)
return self._row_to_dict(row)
async def get(
self,
version_id: str,
*,
user_id: str | _AutoSentinel = AUTO,
source_type: str | None = None,
) -> dict[str, Any] | None:
resolved = resolve_user_id(user_id, method_name="DocumentRewriteVersionRepository.get")
async with self._sf() as session:
clauses = [DocumentRewriteVersionRow.id == version_id]
if resolved is not None:
clauses.append(DocumentRewriteVersionRow.user_id == resolved)
if source_type:
clauses.append(DocumentRewriteVersionRow.source_type == source_type)
row = (await session.execute(select(DocumentRewriteVersionRow).where(*clauses))).scalar_one_or_none()
return self._row_to_dict(row) if row else None
async def mark_reverted(
self,
version_id: str,
*,
user_id: str | _AutoSentinel = AUTO,
) -> bool:
resolved = resolve_user_id(user_id, method_name="DocumentRewriteVersionRepository.mark_reverted")
async with self._sf() as session:
clauses = [
DocumentRewriteVersionRow.id == version_id,
DocumentRewriteVersionRow.reverted_at.is_(None),
]
if resolved is not None:
clauses.append(DocumentRewriteVersionRow.user_id == resolved)
result = await session.execute(
update(DocumentRewriteVersionRow)
.where(*clauses)
.values(reverted_at=datetime.now(UTC))
)
await session.commit()
return result.rowcount > 0
async def prune_source(
self,
*,
source_type: str,
source_id: str,
source_path: str | None,
keep: int = 20,
user_id: str | _AutoSentinel = AUTO,
) -> int:
"""Retain the newest snapshots for one document without crossing owners.
Old rewrite snapshots contain complete document bodies, so this is both a
storage guardrail and an explicit product boundary: users can undo the
recent history, not retain an unbounded hidden copy of every document.
"""
if keep < 1:
raise ValueError("keep must be at least one")
resolved = resolve_user_id(user_id, method_name="DocumentRewriteVersionRepository.prune_source")
async with self._sf() as session:
clauses = [
DocumentRewriteVersionRow.source_type == source_type,
DocumentRewriteVersionRow.source_id == source_id,
DocumentRewriteVersionRow.source_path == source_path,
]
if resolved is not None:
clauses.append(DocumentRewriteVersionRow.user_id == resolved)
stale_ids = list(
(
await session.scalars(
select(DocumentRewriteVersionRow.id)
.where(*clauses)
.order_by(
DocumentRewriteVersionRow.created_at.desc(),
DocumentRewriteVersionRow.id.desc(),
)
.offset(keep)
)
).all()
)
if not stale_ids:
return 0
result = await session.execute(
delete(DocumentRewriteVersionRow).where(DocumentRewriteVersionRow.id.in_(stale_ids))
)
await session.commit()
return int(result.rowcount or 0)