feat: 简介模式菜单按类型 A/B 分套,兼容未配置的旧部署

两套网页可通过 runtime-config.js 的 VITE_COMPACT_MENU_TYPE 加载各自左侧菜单;缺省或旧页面不传参数时仍读取原来的类型 A 数据。

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
董宏凯andCursor committed 2026-08-19 16:59:34 +08:00
1 parent 5e1765d889
commit acf538ac01
21 files changed
+610 -103

No files matched your search

@@ -3,16 +3,24 @@
from __future__ import annotations
from deerflow.persistence.compact_menu_overrides.base import CompactMenuOverrideStore
from deerflow.persistence.compact_menu_overrides.keys import (
ALLOWED_COMPACT_MENU_TYPES,
DEFAULT_COMPACT_MENU_TYPE,
normalize_compact_menu_type,
)
from deerflow.persistence.compact_menu_overrides.memory import MemoryCompactMenuOverrideStore
from deerflow.persistence.compact_menu_overrides.model import CompactMenuOverrideRow
from deerflow.persistence.compact_menu_overrides.sql import CompactMenuOverrideRepository
__all__ = [
"ALLOWED_COMPACT_MENU_TYPES",
"CompactMenuOverrideRepository",
"CompactMenuOverrideRow",
"CompactMenuOverrideStore",
"DEFAULT_COMPACT_MENU_TYPE",
"MemoryCompactMenuOverrideStore",
"make_compact_menu_override_store",
"normalize_compact_menu_type",
]
@@ -8,11 +8,17 @@ from typing import Any
class CompactMenuOverrideStore(ABC):
@abstractmethod
async def list_overrides(self) -> list[dict[str, Any]]:
"""Return every stored compact-menu override row."""
async def list_overrides(self, menu_type: str | None = None) -> list[dict[str, Any]]:
"""Return compact-menu override rows for one type (default A)."""
raise NotImplementedError
@abstractmethod
async def replace_all(self, rows: list[dict[str, Any]], *, updated_by: str | None = None) -> list[dict[str, Any]]:
"""Atomically replace the entire compact-menu override set."""
async def replace_all(
self,
rows: list[dict[str, Any]],
*,
menu_type: str | None = None,
updated_by: str | None = None,
) -> list[dict[str, Any]]:
"""Atomically replace the compact-menu override set for one type."""
raise NotImplementedError
@@ -0,0 +1,47 @@
"""Compact-menu type helpers.
Two website deployments can keep independent compact-sidebar layouts.
Type ``A`` is the historical default (existing rows stay as-is). Type ``B``
is stored under a prefixed primary key so it never collides with type A on
databases that still use ``node_id`` as the sole PK.
"""
from __future__ import annotations
DEFAULT_COMPACT_MENU_TYPE = "A"
ALLOWED_COMPACT_MENU_TYPES = ("A", "B")
_STORAGE_SEP = "::"
_TYPE_ALIASES = {
"A": "A",
"1": "A",
"DEFAULT": "A",
"B": "B",
"2": "B",
"ALT": "B",
}
def normalize_compact_menu_type(value: str | None) -> str:
raw = (value or "").strip().upper()
return _TYPE_ALIASES.get(raw, DEFAULT_COMPACT_MENU_TYPE)
def storage_node_id(menu_type: str, node_id: str) -> str:
"""PK value that stays unique across types on a node_id-only primary key."""
t = normalize_compact_menu_type(menu_type)
nid = str(node_id)
if t == DEFAULT_COMPACT_MENU_TYPE:
prefix = f"{t}{_STORAGE_SEP}"
return nid[len(prefix) :] if nid.startswith(prefix) else nid
prefix = f"{t}{_STORAGE_SEP}"
return nid if nid.startswith(prefix) else f"{prefix}{nid}"
def public_node_id(stored: str, menu_type: str | None = None) -> str:
"""Strip the type prefix so API callers always see the real menu node id."""
t = normalize_compact_menu_type(menu_type)
nid = str(stored)
prefix = f"{t}{_STORAGE_SEP}"
if nid.startswith(prefix):
return nid[len(prefix) :]
return nid
@@ -6,12 +6,19 @@ from datetime import UTC, datetime
from typing import Any
from deerflow.persistence.compact_menu_overrides.base import CompactMenuOverrideStore
from deerflow.persistence.compact_menu_overrides.keys import (
normalize_compact_menu_type,
public_node_id,
storage_node_id,
)
def _normalize(data: dict[str, Any], updated_by: str | None) -> dict[str, Any]:
def _normalize(data: dict[str, Any], menu_type: str, updated_by: str | None) -> dict[str, Any]:
placement = str(data.get("placement") or "sidebar")
node_id = public_node_id(str(data["node_id"]), menu_type)
return {
"node_id": str(data["node_id"]),
"node_id": storage_node_id(menu_type, node_id),
"menu_type": menu_type,
"placement": placement if placement in {"sidebar", "settings"} else "sidebar",
"sort_order": int(data.get("sort_order", 0)),
"label": (data.get("label") or None),
@@ -20,18 +27,38 @@ def _normalize(data: dict[str, Any], updated_by: str | None) -> dict[str, Any]:
}
def _public(row: dict[str, Any]) -> dict[str, Any]:
menu_type = normalize_compact_menu_type(row.get("menu_type"))
out = dict(row)
out["menu_type"] = menu_type
out["node_id"] = public_node_id(str(row.get("node_id") or ""), menu_type)
return out
class MemoryCompactMenuOverrideStore(CompactMenuOverrideStore):
def __init__(self) -> None:
self._rows: dict[str, dict[str, Any]] = {}
async def list_overrides(self) -> list[dict[str, Any]]:
return [dict(r) for r in sorted(self._rows.values(), key=lambda r: r.get("sort_order", 0))]
async def list_overrides(self, menu_type: str | None = None) -> list[dict[str, Any]]:
t = normalize_compact_menu_type(menu_type)
rows = [r for r in self._rows.values() if normalize_compact_menu_type(r.get("menu_type")) == t]
return [_public(r) for r in sorted(rows, key=lambda r: r.get("sort_order", 0))]
async def replace_all(self, rows: list[dict[str, Any]], *, updated_by: str | None = None) -> list[dict[str, Any]]:
self._rows = {}
async def replace_all(
self,
rows: list[dict[str, Any]],
*,
menu_type: str | None = None,
updated_by: str | None = None,
) -> list[dict[str, Any]]:
t = normalize_compact_menu_type(menu_type)
self._rows = {
k: v for k, v in self._rows.items() if normalize_compact_menu_type(v.get("menu_type")) != t
}
for r in rows:
node_id = r.get("node_id")
if not node_id:
continue
self._rows[str(node_id)] = _normalize(r, updated_by)
return [dict(r) for r in self._rows.values()]
stored = _normalize(r, t, updated_by)
self._rows[str(stored["node_id"])] = stored
return await self.list_overrides(t)
@@ -8,7 +8,7 @@ from __future__ import annotations
from datetime import UTC, datetime
from sqlalchemy import Integer, String
from sqlalchemy import Index, Integer, String
from sqlalchemy.orm import Mapped, mapped_column
from deerflow.persistence.base import Base
@@ -17,8 +17,10 @@ from deerflow.persistence.types import BeijingDateTime
class CompactMenuOverrideRow(Base):
__tablename__ = "compact_menu_overrides"
__table_args__ = (Index("ix_compact_menu_overrides_menu_type", "menu_type"),)
node_id: Mapped[str] = mapped_column(String(128), primary_key=True)
menu_type: Mapped[str] = mapped_column(String(32), default="A", server_default="A")
placement: Mapped[str] = mapped_column(String(32), default="sidebar")
sort_order: Mapped[int] = mapped_column(Integer, default=0)
label: Mapped[str | None] = mapped_column(String(255))
@@ -5,25 +5,36 @@ from __future__ import annotations
from datetime import datetime
from typing import Any
from sqlalchemy import delete, select
from sqlalchemy import delete, or_, select
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from deerflow.persistence.compact_menu_overrides.base import CompactMenuOverrideStore
from deerflow.persistence.compact_menu_overrides.keys import (
DEFAULT_COMPACT_MENU_TYPE,
normalize_compact_menu_type,
public_node_id,
storage_node_id,
)
from deerflow.persistence.compact_menu_overrides.model import CompactMenuOverrideRow
def _to_dict(row: CompactMenuOverrideRow) -> dict[str, Any]:
data = row.to_dict()
menu_type = normalize_compact_menu_type(data.get("menu_type"))
data["menu_type"] = menu_type
data["node_id"] = public_node_id(str(data.get("node_id") or ""), menu_type)
value = data.get("updated_at")
if isinstance(value, datetime):
data["updated_at"] = value.isoformat()
return data
def _row_from(data: dict[str, Any], updated_by: str | None) -> CompactMenuOverrideRow:
def _row_from(data: dict[str, Any], menu_type: str, updated_by: str | None) -> CompactMenuOverrideRow:
placement = str(data.get("placement") or "sidebar")
node_id = str(data["node_id"])
return CompactMenuOverrideRow(
node_id=str(data["node_id"]),
node_id=storage_node_id(menu_type, node_id),
menu_type=menu_type,
placement=placement if placement in {"sidebar", "settings"} else "sidebar",
sort_order=int(data.get("sort_order", 0)),
label=(data.get("label") or None),
@@ -35,23 +46,42 @@ class CompactMenuOverrideRepository(CompactMenuOverrideStore):
def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
self._sf = session_factory
async def list_overrides(self) -> list[dict[str, Any]]:
async def list_overrides(self, menu_type: str | None = None) -> list[dict[str, Any]]:
t = normalize_compact_menu_type(menu_type)
stmt = select(CompactMenuOverrideRow).order_by(CompactMenuOverrideRow.sort_order.asc())
stmt = stmt.where(_menu_type_filter(t))
async with self._sf() as session:
result = await session.execute(stmt)
return [_to_dict(row) for row in result.scalars()]
async def replace_all(self, rows: list[dict[str, Any]], *, updated_by: str | None = None) -> list[dict[str, Any]]:
async def replace_all(
self,
rows: list[dict[str, Any]],
*,
menu_type: str | None = None,
updated_by: str | None = None,
) -> list[dict[str, Any]]:
t = normalize_compact_menu_type(menu_type)
by_id: dict[str, dict[str, Any]] = {}
for r in rows:
node_id = r.get("node_id")
if node_id:
by_id[str(node_id)] = r
by_id[public_node_id(str(node_id), t)] = r
async with self._sf() as session:
await session.execute(delete(CompactMenuOverrideRow))
new_rows = [_row_from(r, updated_by) for r in by_id.values()]
await session.execute(delete(CompactMenuOverrideRow).where(_menu_type_filter(t)))
new_rows = [_row_from(r, t, updated_by) for r in by_id.values()]
session.add_all(new_rows)
await session.commit()
for row in new_rows:
await session.refresh(row)
return [_to_dict(row) for row in new_rows]
def _menu_type_filter(menu_type: str):
if menu_type == DEFAULT_COMPACT_MENU_TYPE:
return or_(
CompactMenuOverrideRow.menu_type == menu_type,
CompactMenuOverrideRow.menu_type.is_(None),
CompactMenuOverrideRow.menu_type == "",
)
return CompactMenuOverrideRow.menu_type == menu_type
@@ -0,0 +1,52 @@
"""Add compact_menu_overrides.menu_type (简介模式菜单分套).
Two website deployments keep independent compact/sidebar-summary left menus.
Type ``A`` is the historical default; type ``B`` is stored under a prefixed
``node_id`` so it never collides on databases that still use ``node_id`` as
the sole primary key.
ORM: ``CompactMenuOverrideRow.menu_type = String(32), NOT NULL, default A``.
``create_all`` gives new DBs the column; existing DBs are patched by this
revision and by startup ``_ensure_orm_columns_sync``.
Revision ID: 20260819_01
Revises: 20260816_01
Create Date: 2026-08-19
"""
from __future__ import annotations
import sqlalchemy as sa
from alembic import op
from sqlalchemy import inspect
revision = "20260819_01"
down_revision = "20260816_01"
branch_labels = None
depends_on = None
def _has_table(table_name: str) -> bool:
inspector = inspect(op.get_bind())
return table_name in inspector.get_table_names()
def _has_column(table_name: str, column_name: str) -> bool:
if not _has_table(table_name):
return False
inspector = inspect(op.get_bind())
return any(col["name"] == column_name for col in inspector.get_columns(table_name))
def upgrade() -> None:
if _has_table("compact_menu_overrides") and not _has_column("compact_menu_overrides", "menu_type"):
op.add_column(
"compact_menu_overrides",
sa.Column("menu_type", sa.String(length=32), nullable=False, server_default="A"),
)
def downgrade() -> None:
if _has_column("compact_menu_overrides", "menu_type"):
op.drop_column("compact_menu_overrides", "menu_type")