sync update from LAN repo (source master @ 6e3f02a2)

This commit is contained in:
gozeros committed 2026-11-17 11:28:22 +08:00
1 parent 66a443e915
commit 6c25c89d93
431 files changed
+68511 -2240

No files matched your search

@@ -0,0 +1,35 @@
"""GoView project and template persistence."""
from deerflow.persistence.goview.models import (
GoviewProjectContentRow,
GoviewProjectRow,
GoviewTemplateRow,
)
from deerflow.persistence.goview.project_store import (
GoviewProjectStore,
GoviewRejected,
MemoryGoviewProjectStore,
SqlGoviewProjectStore,
make_goview_project_store,
)
from deerflow.persistence.goview.template_store import (
GoviewTemplateStore,
MemoryGoviewTemplateStore,
SqlGoviewTemplateStore,
make_goview_template_store,
)
__all__ = [
"GoviewProjectContentRow",
"GoviewProjectRow",
"GoviewProjectStore",
"GoviewRejected",
"GoviewTemplateRow",
"GoviewTemplateStore",
"MemoryGoviewProjectStore",
"MemoryGoviewTemplateStore",
"SqlGoviewProjectStore",
"SqlGoviewTemplateStore",
"make_goview_project_store",
"make_goview_template_store",
]
@@ -0,0 +1,64 @@
"""ORM models for GoView projects, canvas content, and templates."""
from __future__ import annotations
from datetime import UTC, datetime
from sqlalchemy import Integer, String
from sqlalchemy.orm import Mapped, mapped_column
from deerflow.persistence.base import Base
from deerflow.persistence.types import BeijingDateTime, PortableLongText
class GoviewProjectRow(Base):
"""One GoView project card. Canvas JSON lives in ``goview_project_contents``."""
__tablename__ = "goview_projects"
id: Mapped[str] = mapped_column(String(64), primary_key=True)
project_name: Mapped[str] = mapped_column(String(255), nullable=False)
remarks: Mapped[str | None] = mapped_column(String(512), nullable=True)
state: Mapped[int] = mapped_column(Integer, nullable=False, default=-1)
index_image: Mapped[str | None] = mapped_column(String(1024), nullable=True)
owner_id: Mapped[str] = mapped_column(String(64), nullable=False, index=True)
created_at: Mapped[datetime] = mapped_column(BeijingDateTime(), nullable=False, default=lambda: datetime.now(UTC))
updated_at: Mapped[datetime] = mapped_column(
BeijingDateTime(),
nullable=False,
default=lambda: datetime.now(UTC),
onupdate=lambda: datetime.now(UTC),
)
class GoviewProjectContentRow(Base):
"""The ChartEditStorage document for one project. Listed projects do not load this row."""
__tablename__ = "goview_project_contents"
project_id: Mapped[str] = mapped_column(String(64), primary_key=True)
content_json: Mapped[str] = mapped_column(PortableLongText, nullable=False)
updated_at: Mapped[datetime] = mapped_column(BeijingDateTime(), nullable=False, default=lambda: datetime.now(UTC))
class GoviewTemplateRow(Base):
"""A personal template or a market template. Builtin rows are inserted only when missing."""
__tablename__ = "goview_templates"
id: Mapped[str] = mapped_column(String(64), primary_key=True)
name: Mapped[str] = mapped_column(String(255), nullable=False)
description: Mapped[str | None] = mapped_column(String(512), nullable=True)
cover_image: Mapped[str | None] = mapped_column(String(1024), nullable=True)
content_json: Mapped[str] = mapped_column(PortableLongText, nullable=False)
owner_id: Mapped[str | None] = mapped_column(String(64), nullable=True, index=True)
scope: Mapped[str] = mapped_column(String(16), nullable=False, default="personal")
is_builtin: Mapped[bool] = mapped_column(nullable=False, default=False)
sort_order: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
created_at: Mapped[datetime] = mapped_column(BeijingDateTime(), nullable=False, default=lambda: datetime.now(UTC))
updated_at: Mapped[datetime] = mapped_column(
BeijingDateTime(),
nullable=False,
default=lambda: datetime.now(UTC),
onupdate=lambda: datetime.now(UTC),
)
@@ -0,0 +1,426 @@
"""Project and canvas-content persistence for the GoView editor."""
from __future__ import annotations
import json
import uuid
from abc import ABC, abstractmethod
from datetime import UTC, datetime
from typing import Any
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from deerflow.persistence.goview.models import GoviewProjectContentRow, GoviewProjectRow
MAX_CONTENT_CHARS = 8_000_000
UNPUBLISHED = -1
PUBLISHED = 1
DEMO_OWNER = "goview-demo"
class GoviewRejected(ValueError):
"""A project write violated a size or state rule."""
def new_project_id() -> str:
return "id_" + uuid.uuid4().hex[:16]
def empty_canvas(project_name: str) -> str:
"""A ChartEditStorage document the editor can open before the first save."""
return json.dumps(
{
"editCanvasConfig": {
"projectName": project_name,
"width": 1920,
"height": 1080,
"filterShow": False,
"hueRotate": 0,
"saturate": 1,
"contrast": 1,
"brightness": 1,
"opacity": 1,
"rotateZ": 0,
"rotateX": 0,
"rotateY": 0,
"skewX": 0,
"skewY": 0,
"blendMode": "normal",
"background": None,
"backgroundImage": None,
"selectColor": True,
"chartThemeColor": "dark",
"chartCustomThemeColorInfo": None,
"chartThemeSetting": {},
"vChartThemeName": "vScreenVolcanoBlue",
"previewScaleType": "fit",
},
"componentList": [],
"requestGlobalConfig": {
"requestDataPond": [],
"requestOriginUrl": "",
"requestInterval": 30,
"requestIntervalUnit": "second",
"requestParams": {
"Body": {"form-data": {}, "x-www-form-urlencoded": {}, "json": "", "xml": ""},
"Header": {},
"Params": {},
},
},
},
ensure_ascii=False,
)
def _check_content(content: str) -> str:
if not isinstance(content, str) or len(content) > MAX_CONTENT_CHARS:
raise GoviewRejected("项目内容过大或无效")
return content
def _check_state(state: int) -> int:
if state not in (UNPUBLISHED, PUBLISHED):
raise GoviewRejected("发布状态只能是 1 或 -1")
return state
def _shared_or_owner(record_owner: str, caller: str) -> bool:
"""Shared demo canvases stay readable and editable for every logged-in user."""
return record_owner == caller or record_owner == DEMO_OWNER
def _meta(row: dict[str, Any] | GoviewProjectRow) -> dict[str, Any]:
if isinstance(row, dict):
return {
"id": row["id"],
"project_name": row["project_name"],
"remarks": row["remarks"],
"state": row["state"],
"index_image": row["index_image"],
"owner_id": row["owner_id"],
"created_at": row["created_at"],
"updated_at": row["updated_at"],
}
return {
"id": row.id,
"project_name": row.project_name,
"remarks": row.remarks,
"state": row.state,
"index_image": row.index_image,
"owner_id": row.owner_id,
"created_at": row.created_at,
"updated_at": row.updated_at,
}
class GoviewProjectStore(ABC):
@abstractmethod
async def list_projects(self, owner_id: str, *, page: int, limit: int) -> tuple[list[dict[str, Any]], int]:
raise NotImplementedError
@abstractmethod
async def create_project(
self,
*,
project_name: str,
remarks: str | None,
index_image: str | None,
owner_id: str,
content: str | None = None,
project_id: str | None = None,
) -> dict[str, Any]:
raise NotImplementedError
@abstractmethod
async def get_owned(self, project_id: str, owner_id: str, *, with_content: bool = True) -> dict[str, Any] | None:
raise NotImplementedError
@abstractmethod
async def get_published(self, project_id: str) -> dict[str, Any] | None:
raise NotImplementedError
@abstractmethod
async def save_content(self, project_id: str, owner_id: str, content: str) -> dict[str, Any] | None:
raise NotImplementedError
@abstractmethod
async def update_meta(
self,
project_id: str,
owner_id: str,
*,
project_name: str | None = None,
remarks: str | None = None,
index_image: str | None = None,
fields: set[str],
) -> dict[str, Any] | None:
raise NotImplementedError
@abstractmethod
async def set_state(self, project_id: str, owner_id: str, state: int) -> dict[str, Any] | None:
raise NotImplementedError
@abstractmethod
async def delete_owned(self, project_id: str, owner_id: str) -> bool:
raise NotImplementedError
class MemoryGoviewProjectStore(GoviewProjectStore):
def __init__(self) -> None:
self._projects: dict[str, dict[str, Any]] = {}
self._contents: dict[str, str] = {}
async def list_projects(self, owner_id: str, *, page: int, limit: int) -> tuple[list[dict[str, Any]], int]:
demos = [item for item in self._projects.values() if item["owner_id"] == DEMO_OWNER and owner_id != DEMO_OWNER]
demos.sort(key=lambda item: item["id"])
mine = [item for item in self._projects.values() if item["owner_id"] == owner_id]
mine.sort(key=lambda item: (item["updated_at"], item["id"]), reverse=True)
rows = [*demos, *mine]
start = (page - 1) * limit
return [_meta(item) for item in rows[start : start + limit]], len(rows)
async def create_project(
self,
*,
project_name: str,
remarks: str | None,
index_image: str | None,
owner_id: str,
content: str | None = None,
project_id: str | None = None,
) -> dict[str, Any]:
now = datetime.now(UTC)
project_id = project_id or new_project_id()
payload = _check_content(content if content is not None else empty_canvas(project_name))
record = {
"id": project_id,
"project_name": project_name,
"remarks": remarks,
"state": UNPUBLISHED,
"index_image": index_image,
"owner_id": owner_id,
"created_at": now,
"updated_at": now,
}
self._projects[project_id] = record
self._contents[project_id] = payload
data = _meta(record)
data["content"] = payload
return data
async def get_owned(self, project_id: str, owner_id: str, *, with_content: bool = True) -> dict[str, Any] | None:
record = self._projects.get(project_id)
if record is None or not _shared_or_owner(record["owner_id"], owner_id):
return None
data = _meta(record)
if with_content:
data["content"] = self._contents.get(project_id, "")
return data
async def get_published(self, project_id: str) -> dict[str, Any] | None:
record = self._projects.get(project_id)
if record is None or record["state"] != PUBLISHED:
return None
data = _meta(record)
data["content"] = self._contents.get(project_id, "")
return data
async def save_content(self, project_id: str, owner_id: str, content: str) -> dict[str, Any] | None:
record = self._projects.get(project_id)
if record is None or not _shared_or_owner(record["owner_id"], owner_id):
return None
self._contents[project_id] = _check_content(content)
record["updated_at"] = datetime.now(UTC)
return _meta(record)
async def update_meta(
self,
project_id: str,
owner_id: str,
*,
project_name: str | None = None,
remarks: str | None = None,
index_image: str | None = None,
fields: set[str],
) -> dict[str, Any] | None:
record = self._projects.get(project_id)
if record is None or not _shared_or_owner(record["owner_id"], owner_id):
return None
if "project_name" in fields and project_name is not None:
record["project_name"] = project_name
if "remarks" in fields:
record["remarks"] = remarks
if "index_image" in fields:
record["index_image"] = index_image
record["updated_at"] = datetime.now(UTC)
return _meta(record)
async def set_state(self, project_id: str, owner_id: str, state: int) -> dict[str, Any] | None:
record = self._projects.get(project_id)
if record is None or not _shared_or_owner(record["owner_id"], owner_id):
return None
record["state"] = _check_state(state)
record["updated_at"] = datetime.now(UTC)
return _meta(record)
async def delete_owned(self, project_id: str, owner_id: str) -> bool:
record = self._projects.get(project_id)
if record is None or record["owner_id"] != owner_id or record["owner_id"] == DEMO_OWNER:
return False
self._projects.pop(project_id, None)
self._contents.pop(project_id, None)
return True
class SqlGoviewProjectStore(GoviewProjectStore):
def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
self._session_factory = session_factory
async def list_projects(self, owner_id: str, *, page: int, limit: int) -> tuple[list[dict[str, Any]], int]:
async with self._session_factory() as session:
mine_stmt = (
select(GoviewProjectRow)
.where(GoviewProjectRow.owner_id == owner_id)
.order_by(GoviewProjectRow.updated_at.desc(), GoviewProjectRow.id.desc())
)
mine = list((await session.execute(mine_stmt)).scalars().all())
if owner_id == DEMO_OWNER:
rows = mine
else:
demo_stmt = (
select(GoviewProjectRow)
.where(GoviewProjectRow.owner_id == DEMO_OWNER)
.order_by(GoviewProjectRow.id.asc())
)
demos = list((await session.execute(demo_stmt)).scalars().all())
rows = [*demos, *mine]
start = (page - 1) * limit
return [_meta(row) for row in rows[start : start + limit]], len(rows)
async def create_project(
self,
*,
project_name: str,
remarks: str | None,
index_image: str | None,
owner_id: str,
content: str | None = None,
project_id: str | None = None,
) -> dict[str, Any]:
now = datetime.now(UTC)
project_id = project_id or new_project_id()
payload = _check_content(content if content is not None else empty_canvas(project_name))
async with self._session_factory() as session:
row = GoviewProjectRow(
id=project_id,
project_name=project_name,
remarks=remarks,
state=UNPUBLISHED,
index_image=index_image,
owner_id=owner_id,
created_at=now,
updated_at=now,
)
session.add(row)
session.add(GoviewProjectContentRow(project_id=project_id, content_json=payload, updated_at=now))
data = _meta(row)
data["content"] = payload
await session.commit()
return data
async def get_owned(self, project_id: str, owner_id: str, *, with_content: bool = True) -> dict[str, Any] | None:
async with self._session_factory() as session:
row = await session.get(GoviewProjectRow, project_id)
if row is None or not _shared_or_owner(row.owner_id, owner_id):
return None
data = _meta(row)
if with_content:
content_row = await session.get(GoviewProjectContentRow, project_id)
data["content"] = content_row.content_json if content_row is not None else ""
return data
async def get_published(self, project_id: str) -> dict[str, Any] | None:
async with self._session_factory() as session:
row = await session.get(GoviewProjectRow, project_id)
if row is None or row.state != PUBLISHED:
return None
content_row = await session.get(GoviewProjectContentRow, project_id)
data = _meta(row)
data["content"] = content_row.content_json if content_row is not None else ""
return data
async def save_content(self, project_id: str, owner_id: str, content: str) -> dict[str, Any] | None:
payload = _check_content(content)
async with self._session_factory() as session:
row = await session.get(GoviewProjectRow, project_id)
if row is None or not _shared_or_owner(row.owner_id, owner_id):
return None
now = datetime.now(UTC)
content_row = await session.get(GoviewProjectContentRow, project_id)
if content_row is None:
session.add(GoviewProjectContentRow(project_id=project_id, content_json=payload, updated_at=now))
else:
content_row.content_json = payload
content_row.updated_at = now
row.updated_at = now
data = _meta(row)
await session.commit()
return data
async def update_meta(
self,
project_id: str,
owner_id: str,
*,
project_name: str | None = None,
remarks: str | None = None,
index_image: str | None = None,
fields: set[str],
) -> dict[str, Any] | None:
async with self._session_factory() as session:
row = await session.get(GoviewProjectRow, project_id)
if row is None or not _shared_or_owner(row.owner_id, owner_id):
return None
if "project_name" in fields and project_name is not None:
row.project_name = project_name
if "remarks" in fields:
row.remarks = remarks
if "index_image" in fields:
row.index_image = index_image
row.updated_at = datetime.now(UTC)
data = _meta(row)
await session.commit()
return data
async def set_state(self, project_id: str, owner_id: str, state: int) -> dict[str, Any] | None:
checked = _check_state(state)
async with self._session_factory() as session:
row = await session.get(GoviewProjectRow, project_id)
if row is None or not _shared_or_owner(row.owner_id, owner_id):
return None
row.state = checked
row.updated_at = datetime.now(UTC)
data = _meta(row)
await session.commit()
return data
async def delete_owned(self, project_id: str, owner_id: str) -> bool:
async with self._session_factory() as session:
row = await session.get(GoviewProjectRow, project_id)
if row is None or row.owner_id != owner_id or row.owner_id == DEMO_OWNER:
return False
content_row = await session.get(GoviewProjectContentRow, project_id)
if content_row is not None:
await session.delete(content_row)
await session.delete(row)
await session.commit()
return True
def make_goview_project_store(session_factory: async_sessionmaker[AsyncSession] | None) -> GoviewProjectStore:
if session_factory is None:
return MemoryGoviewProjectStore()
return SqlGoviewProjectStore(session_factory)
@@ -0,0 +1,372 @@
"""Personal and market template persistence for GoView."""
from __future__ import annotations
import uuid
from abc import ABC, abstractmethod
from datetime import UTC, datetime
from typing import Any
from sqlalchemy import func, select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from deerflow.persistence.goview.models import GoviewTemplateRow
from deerflow.persistence.goview.project_store import MAX_CONTENT_CHARS, GoviewRejected
PERSONAL = "personal"
MARKET = "market"
def new_template_id() -> str:
return "tpl_" + uuid.uuid4().hex[:16]
def _check_content(content: str) -> str:
if not isinstance(content, str) or len(content) > MAX_CONTENT_CHARS:
raise GoviewRejected("模板内容过大或无效")
return content
def _meta_from_mapping(row: Any) -> dict[str, Any]:
return {
"id": row.id,
"name": row.name,
"description": row.description,
"cover_image": row.cover_image,
"owner_id": row.owner_id,
"scope": row.scope,
"is_builtin": bool(row.is_builtin),
"sort_order": row.sort_order,
"created_at": row.created_at,
"updated_at": row.updated_at,
}
_LIST_COLUMNS = (
GoviewTemplateRow.id,
GoviewTemplateRow.name,
GoviewTemplateRow.description,
GoviewTemplateRow.cover_image,
GoviewTemplateRow.owner_id,
GoviewTemplateRow.scope,
GoviewTemplateRow.is_builtin,
GoviewTemplateRow.sort_order,
GoviewTemplateRow.created_at,
GoviewTemplateRow.updated_at,
)
class GoviewTemplateStore(ABC):
@abstractmethod
async def list_personal(self, owner_id: str, *, page: int, limit: int) -> tuple[list[dict[str, Any]], int]:
raise NotImplementedError
@abstractmethod
async def list_market(self, *, page: int, limit: int) -> tuple[list[dict[str, Any]], int]:
raise NotImplementedError
@abstractmethod
async def get(self, template_id: str) -> dict[str, Any] | None:
raise NotImplementedError
@abstractmethod
async def create_personal(
self,
*,
name: str,
description: str | None,
cover_image: str | None,
content: str,
owner_id: str,
) -> dict[str, Any]:
raise NotImplementedError
@abstractmethod
async def update_meta(
self,
template_id: str,
*,
name: str | None = None,
description: str | None = None,
cover_image: str | None = None,
fields: set[str],
) -> dict[str, Any] | None:
raise NotImplementedError
@abstractmethod
async def delete(self, template_id: str) -> bool:
raise NotImplementedError
@abstractmethod
async def insert_if_absent(self, item: dict[str, Any]) -> bool:
raise NotImplementedError
@abstractmethod
async def refresh_builtin_content(self, template_id: str, content: str) -> bool:
"""Replace a builtin template canvas. Names and covers stay as stored."""
raise NotImplementedError
class MemoryGoviewTemplateStore(GoviewTemplateStore):
def __init__(self) -> None:
self._rows: dict[str, dict[str, Any]] = {}
def _visible(self, record: dict[str, Any]) -> dict[str, Any]:
data = dict(record)
data.pop("content", None)
return data
async def list_personal(self, owner_id: str, *, page: int, limit: int) -> tuple[list[dict[str, Any]], int]:
rows = [
item
for item in self._rows.values()
if item["owner_id"] == owner_id and item["scope"] == PERSONAL
]
rows.sort(key=lambda item: (item["updated_at"], item["id"]), reverse=True)
start = (page - 1) * limit
return [self._visible(item) for item in rows[start : start + limit]], len(rows)
async def list_market(self, *, page: int, limit: int) -> tuple[list[dict[str, Any]], int]:
rows = [item for item in self._rows.values() if item["scope"] == MARKET]
rows.sort(key=lambda item: (item["sort_order"], item["id"]))
start = (page - 1) * limit
return [self._visible(item) for item in rows[start : start + limit]], len(rows)
async def get(self, template_id: str) -> dict[str, Any] | None:
record = self._rows.get(template_id)
return dict(record) if record is not None else None
async def create_personal(
self,
*,
name: str,
description: str | None,
cover_image: str | None,
content: str,
owner_id: str,
) -> dict[str, Any]:
now = datetime.now(UTC)
template_id = new_template_id()
record = {
"id": template_id,
"name": name,
"description": description,
"cover_image": cover_image,
"content": _check_content(content),
"owner_id": owner_id,
"scope": PERSONAL,
"is_builtin": False,
"sort_order": 0,
"created_at": now,
"updated_at": now,
}
self._rows[template_id] = record
return dict(record)
async def update_meta(
self,
template_id: str,
*,
name: str | None = None,
description: str | None = None,
cover_image: str | None = None,
fields: set[str],
) -> dict[str, Any] | None:
record = self._rows.get(template_id)
if record is None:
return None
if "name" in fields and name is not None:
record["name"] = name
if "description" in fields:
record["description"] = description
if "cover_image" in fields:
record["cover_image"] = cover_image
record["updated_at"] = datetime.now(UTC)
return dict(record)
async def delete(self, template_id: str) -> bool:
return self._rows.pop(template_id, None) is not None
async def insert_if_absent(self, item: dict[str, Any]) -> bool:
template_id = item["id"]
if template_id in self._rows:
return False
now = datetime.now(UTC)
self._rows[template_id] = {
"id": template_id,
"name": item["name"],
"description": item.get("description"),
"cover_image": item.get("cover_image"),
"content": _check_content(item["content"]),
"owner_id": item.get("owner_id"),
"scope": item.get("scope") or MARKET,
"is_builtin": bool(item.get("is_builtin", True)),
"sort_order": int(item.get("sort_order") or 0),
"created_at": now,
"updated_at": now,
}
return True
async def refresh_builtin_content(self, template_id: str, content: str) -> bool:
record = self._rows.get(template_id)
if record is None or not record.get("is_builtin"):
return False
checked = _check_content(content)
if record.get("content") == checked:
return False
record["content"] = checked
return True
class SqlGoviewTemplateStore(GoviewTemplateStore):
def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
self._session_factory = session_factory
async def list_personal(self, owner_id: str, *, page: int, limit: int) -> tuple[list[dict[str, Any]], int]:
async with self._session_factory() as session:
where = (GoviewTemplateRow.owner_id == owner_id) & (GoviewTemplateRow.scope == PERSONAL)
total = await session.scalar(select(func.count()).select_from(GoviewTemplateRow).where(where))
stmt = (
select(*_LIST_COLUMNS)
.where(where)
.order_by(GoviewTemplateRow.updated_at.desc(), GoviewTemplateRow.id.desc())
.offset((page - 1) * limit)
.limit(limit)
)
rows = (await session.execute(stmt)).all()
return [_meta_from_mapping(row) for row in rows], int(total or 0)
async def list_market(self, *, page: int, limit: int) -> tuple[list[dict[str, Any]], int]:
async with self._session_factory() as session:
where = GoviewTemplateRow.scope == MARKET
total = await session.scalar(select(func.count()).select_from(GoviewTemplateRow).where(where))
stmt = (
select(*_LIST_COLUMNS)
.where(where)
.order_by(GoviewTemplateRow.sort_order.asc(), GoviewTemplateRow.id.asc())
.offset((page - 1) * limit)
.limit(limit)
)
rows = (await session.execute(stmt)).all()
return [_meta_from_mapping(row) for row in rows], int(total or 0)
async def get(self, template_id: str) -> dict[str, Any] | None:
async with self._session_factory() as session:
row = await session.get(GoviewTemplateRow, template_id)
if row is None:
return None
data = _meta_from_mapping(row)
data["content"] = row.content_json
return data
async def create_personal(
self,
*,
name: str,
description: str | None,
cover_image: str | None,
content: str,
owner_id: str,
) -> dict[str, Any]:
now = datetime.now(UTC)
row = GoviewTemplateRow(
id=new_template_id(),
name=name,
description=description,
cover_image=cover_image,
content_json=_check_content(content),
owner_id=owner_id,
scope=PERSONAL,
is_builtin=False,
sort_order=0,
created_at=now,
updated_at=now,
)
async with self._session_factory() as session:
session.add(row)
data = _meta_from_mapping(row)
data["content"] = row.content_json
await session.commit()
return data
async def update_meta(
self,
template_id: str,
*,
name: str | None = None,
description: str | None = None,
cover_image: str | None = None,
fields: set[str],
) -> dict[str, Any] | None:
async with self._session_factory() as session:
row = await session.get(GoviewTemplateRow, template_id)
if row is None:
return None
if "name" in fields and name is not None:
row.name = name
if "description" in fields:
row.description = description
if "cover_image" in fields:
row.cover_image = cover_image
row.updated_at = datetime.now(UTC)
data = _meta_from_mapping(row)
data["content"] = row.content_json
await session.commit()
return data
async def delete(self, template_id: str) -> bool:
async with self._session_factory() as session:
row = await session.get(GoviewTemplateRow, template_id)
if row is None:
return False
await session.delete(row)
await session.commit()
return True
async def insert_if_absent(self, item: dict[str, Any]) -> bool:
async with self._session_factory() as session:
existing = await session.get(GoviewTemplateRow, item["id"])
if existing is not None:
return False
now = datetime.now(UTC)
session.add(
GoviewTemplateRow(
id=item["id"],
name=item["name"],
description=item.get("description"),
cover_image=item.get("cover_image"),
content_json=_check_content(item["content"]),
owner_id=item.get("owner_id"),
scope=item.get("scope") or MARKET,
is_builtin=bool(item.get("is_builtin", True)),
sort_order=int(item.get("sort_order") or 0),
created_at=now,
updated_at=now,
)
)
try:
await session.commit()
except IntegrityError:
await session.rollback()
return False
return True
async def refresh_builtin_content(self, template_id: str, content: str) -> bool:
checked = _check_content(content)
async with self._session_factory() as session:
row = await session.get(GoviewTemplateRow, template_id)
if row is None or not row.is_builtin:
return False
if row.content_json == checked:
return False
row.content_json = checked
await session.commit()
return True
def make_goview_template_store(session_factory: async_sessionmaker[AsyncSession] | None) -> GoviewTemplateStore:
if session_factory is None:
return MemoryGoviewTemplateStore()
return SqlGoviewTemplateStore(session_factory)
@@ -0,0 +1,82 @@
"""Add configurable visual-dashboard projects and data snapshots.
Revision ID: 20261110_01
Revises: 20261102_02
Create Date: 2026-11-10
"""
from __future__ import annotations
import sqlalchemy as sa
from alembic import op
from deerflow.persistence.types import PortableLongText
revision = "20261110_01"
down_revision = "20261102_02"
branch_labels = None
depends_on = None
_PROJECTS = "visual_dashboard_projects"
_SNAPSHOTS = "visual_dashboard_snapshots"
def upgrade() -> None:
inspector = sa.inspect(op.get_bind())
if not inspector.has_table(_PROJECTS):
op.create_table(
_PROJECTS,
sa.Column("id", sa.String(length=64), primary_key=True),
sa.Column("slug", sa.String(length=64), nullable=False),
sa.Column("name", sa.String(length=191), nullable=False),
sa.Column("remarks", sa.String(length=512), nullable=True),
sa.Column("draft_canvas_json", PortableLongText(), nullable=False),
sa.Column("draft_bindings_json", PortableLongText(), nullable=False),
sa.Column("published_canvas_json", PortableLongText(), nullable=True),
sa.Column("published_bindings_json", PortableLongText(), nullable=True),
sa.Column("agent_id", sa.String(length=64), nullable=True),
sa.Column("chain_id", sa.String(length=64), nullable=True),
sa.Column("draft_revision", sa.Integer(), nullable=False),
sa.Column("published_revision", sa.Integer(), nullable=True),
sa.Column("created_by", sa.String(length=64), nullable=True),
sa.Column("updated_by", sa.String(length=64), nullable=True),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
sa.UniqueConstraint("slug", name="uq_visual_dashboard_projects_slug"),
)
if not inspector.has_table(_SNAPSHOTS):
op.create_table(
_SNAPSHOTS,
sa.Column("id", sa.String(length=64), primary_key=True),
sa.Column("dashboard_id", sa.String(length=64), nullable=False),
sa.Column("task_id", sa.String(length=128), nullable=False),
sa.Column("data_key", sa.String(length=96), nullable=False),
sa.Column("payload_json", PortableLongText(), nullable=False),
sa.Column("schema_version", sa.String(length=32), nullable=False),
sa.Column("source_type", sa.String(length=32), nullable=False),
sa.Column("source_ref", sa.String(length=128), nullable=True),
sa.Column("refresh_status", sa.String(length=24), nullable=False),
sa.Column("error_message", PortableLongText(), nullable=True),
sa.Column("updated_by", sa.String(length=64), nullable=True),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
sa.UniqueConstraint(
"dashboard_id",
"task_id",
"data_key",
name="uq_visual_dashboard_snapshots_key",
),
)
op.create_index(
"ix_visual_dashboard_snapshots_dashboard_id",
_SNAPSHOTS,
["dashboard_id"],
)
def downgrade() -> None:
inspector = sa.inspect(op.get_bind())
if inspector.has_table(_SNAPSHOTS):
op.drop_table(_SNAPSHOTS)
if inspector.has_table(_PROJECTS):
op.drop_table(_PROJECTS)
@@ -0,0 +1,79 @@
"""Replace the unused visual-dashboard tables with GoView projects and templates.
Revision ID: 20261110_02
Revises: 20261110_01
Create Date: 2026-11-10
"""
from __future__ import annotations
import sqlalchemy as sa
from alembic import op
from deerflow.persistence.types import PortableLongText
revision = "20261110_02"
down_revision = "20261110_01"
branch_labels = None
depends_on = None
_OLD_SNAPSHOTS = "visual_dashboard_snapshots"
_OLD_PROJECTS = "visual_dashboard_projects"
_PROJECTS = "goview_projects"
_CONTENTS = "goview_project_contents"
_TEMPLATES = "goview_templates"
def upgrade() -> None:
inspector = sa.inspect(op.get_bind())
if inspector.has_table(_OLD_SNAPSHOTS):
op.drop_table(_OLD_SNAPSHOTS)
if inspector.has_table(_OLD_PROJECTS):
op.drop_table(_OLD_PROJECTS)
inspector = sa.inspect(op.get_bind())
if not inspector.has_table(_PROJECTS):
op.create_table(
_PROJECTS,
sa.Column("id", sa.String(length=64), primary_key=True),
sa.Column("project_name", sa.String(length=255), nullable=False),
sa.Column("remarks", sa.String(length=512), nullable=True),
sa.Column("state", sa.Integer(), nullable=False),
sa.Column("index_image", sa.String(length=1024), nullable=True),
sa.Column("owner_id", sa.String(length=64), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
)
op.create_index("ix_goview_projects_owner_id", _PROJECTS, ["owner_id"])
if not inspector.has_table(_CONTENTS):
op.create_table(
_CONTENTS,
sa.Column("project_id", sa.String(length=64), primary_key=True),
sa.Column("content_json", PortableLongText(), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
)
if not inspector.has_table(_TEMPLATES):
op.create_table(
_TEMPLATES,
sa.Column("id", sa.String(length=64), primary_key=True),
sa.Column("name", sa.String(length=255), nullable=False),
sa.Column("description", sa.String(length=512), nullable=True),
sa.Column("cover_image", sa.String(length=1024), nullable=True),
sa.Column("content_json", PortableLongText(), nullable=False),
sa.Column("owner_id", sa.String(length=64), nullable=True),
sa.Column("scope", sa.String(length=16), nullable=False),
sa.Column("is_builtin", sa.Boolean(), nullable=False),
sa.Column("sort_order", sa.Integer(), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
)
op.create_index("ix_goview_templates_owner_id", _TEMPLATES, ["owner_id"])
def downgrade() -> None:
inspector = sa.inspect(op.get_bind())
if inspector.has_table(_TEMPLATES):
op.drop_table(_TEMPLATES)
if inspector.has_table(_CONTENTS):
op.drop_table(_CONTENTS)
if inspector.has_table(_PROJECTS):
op.drop_table(_PROJECTS)
@@ -0,0 +1,33 @@
"""Drop the unused visual-dashboard tables left behind by 20261110_02.
Revision ID: 20261110_03
Revises: 20261110_02
Create Date: 2026-11-10
``20261110_02`` already drops these tables. This revision repeats the drop so a
database that reached ``20261110_02`` while the tables were still registered on
``Base.metadata`` does not keep them after ``create_all``.
"""
from __future__ import annotations
import sqlalchemy as sa
from alembic import op
revision = "20261110_03"
down_revision = "20261110_02"
branch_labels = None
depends_on = None
def upgrade() -> None:
bind = op.get_bind()
inspector = sa.inspect(bind)
if inspector.has_table("visual_dashboard_snapshots"):
op.drop_table("visual_dashboard_snapshots")
if inspector.has_table("visual_dashboard_projects"):
op.drop_table("visual_dashboard_projects")
def downgrade() -> None:
return None
@@ -185,6 +185,11 @@ from deerflow.persistence.upload_policy.model import UploadPolicyRow
from deerflow.persistence.user.model import UserRow
from deerflow.persistence.user_preferences.model import UserPreferencesRow
from deerflow.persistence.user_prompts.model import UserCustomPromptRow
from deerflow.persistence.goview.models import (
GoviewProjectContentRow,
GoviewProjectRow,
GoviewTemplateRow,
)
from deerflow.persistence.workflow_data_sources.model import WorkflowDataSourceRow
from deerflow.persistence.workflow_events.model import WorkflowRunEventRow
from deerflow.persistence.workflow_planning.model import (
@@ -359,4 +364,7 @@ __all__ = [
"UserMemoryConfigRow",
"UserPreferencesRow",
"UserRow",
"GoviewProjectContentRow",
"GoviewProjectRow",
"GoviewTemplateRow",
]