Files
gsfdc/demo-dify/dify/api/repositories/conversation_variable_repository.py
T
wuzilongandCursor 6519682885 chore: 纳入本地 Dify 1.19.0 源码及品牌与免登改动
演示目录只保留可重建的源码。运行密钥、数据卷、依赖和带口令的本地配置不进入仓库。

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-18 13:59:25 +08:00

173 lines
7.2 KiB
Python

"""Conversation-variable persistence with fully scoped, bounded sessions."""
from collections.abc import Callable
from typing import override
from sqlalchemy import JSON, ColumnElement, Select, cast, func, select
from sqlalchemy.orm import Session, sessionmaker
from graphon.variables import VariableBase
from libs.datetime_utils import naive_utc_now
from libs.helper import escape_like_pattern
from machinery.context import RequestContext
from models import App, AppMode, ConversationVariable
from models.enums import AppStatus, ConversationFromSource
from models.model import Conversation, EndUser
from repositories.app.console_repository import find_console_app
from services.conversation_variable_query import (
CONVERSATION_VARIABLE_LIMIT,
ConversationVariableAppNotFoundError,
ConversationVariablePage,
ConversationVariableQuery,
ConversationVariableRecord,
)
from services.entities.conversation_entities import EndUserConversationRef
from services.errors.conversation import ConversationNotExistsError, ConversationVariableNotExistsError
class ConversationVariableRepository(ConversationVariableQuery):
def __init__(self, *, session_factory: sessionmaker[Session]) -> None:
self._session_factory = session_factory
@override
def require_app(self, context: RequestContext, app_id: str) -> None:
with self._session_factory() as session:
app = find_console_app(session, workspace_id=context.active_workspace_id, app_id=app_id)
if app is None:
raise ConversationVariableAppNotFoundError("App not found.")
if AppMode.value_of(app.mode) != AppMode.ADVANCED_CHAT:
modes = {AppMode.ADVANCED_CHAT.value}
raise ConversationVariableAppNotFoundError(f"App mode is not in the supported list: {modes}")
@override
def list_variables(
self, context: RequestContext, app_id: str, conversation_id: str
) -> list[ConversationVariableRecord]:
with self._session_factory() as session:
rows = session.scalars(
select(ConversationVariable)
.join(App, App.id == ConversationVariable.app_id)
.where(
App.id == app_id,
App.tenant_id == context.active_workspace_id,
App.status == AppStatus.NORMAL,
App.mode == AppMode.ADVANCED_CHAT,
ConversationVariable.conversation_id == conversation_id,
)
.order_by(ConversationVariable.created_at)
.limit(CONVERSATION_VARIABLE_LIMIT)
)
# Decode inside the owned session; neither rows nor lazy loads escape.
return [
ConversationVariableRecord(
id=row.id,
variable=row.to_variable(),
created_at=row.created_at,
updated_at=row.updated_at,
)
for row in rows
]
@override
def get_page(
self,
*,
ref: EndUserConversationRef,
last_id: str | None,
limit: int,
variable_name: str | None,
) -> ConversationVariablePage:
with self._session_factory() as session:
stmt = self._variables(session=session, ref=ref)
if variable_name:
stmt = stmt.where(
self._name_filter(variable_name=variable_name, dialect_name=session.get_bind().dialect.name)
)
if last_id:
cursor = session.scalar(stmt.where(ConversationVariable.id == last_id))
if cursor is None:
raise ConversationVariableNotExistsError()
stmt = stmt.where(
(ConversationVariable.created_at > cursor.created_at)
| ((ConversationVariable.created_at == cursor.created_at) & (ConversationVariable.id > cursor.id))
)
rows = session.scalars(
stmt.order_by(ConversationVariable.created_at, ConversationVariable.id).limit(limit + 1)
).all()
return ConversationVariablePage(
limit=limit,
has_more=len(rows) > limit,
data=tuple(self._record(row) for row in rows[:limit]),
)
def update(
self,
*,
ref: EndUserConversationRef,
variable_id: str,
transform: Callable[[VariableBase], VariableBase],
) -> ConversationVariableRecord:
"""Apply a pure transformation in the write transaction; it must perform no external I/O."""
with self._session_factory.begin() as session:
stmt = self._variables(session=session, ref=ref)
row = session.scalar(stmt.where(ConversationVariable.id == variable_id).with_for_update())
if row is None:
raise ConversationVariableNotExistsError()
variable = transform(row.to_variable())
row.data = variable.model_dump_json()
row.updated_at = naive_utc_now()
record = ConversationVariableRecord(
id=row.id,
variable=variable,
created_at=row.created_at,
updated_at=row.updated_at,
)
return record
@staticmethod
def _name_filter(*, variable_name: str, dialect_name: str) -> ColumnElement[bool]:
# The stored payload is TEXT, while PostgreSQL's extractor requires JSON.
name = (
func.json_extract_path_text(cast(ConversationVariable.data, JSON), "name")
if dialect_name == "postgresql"
else func.json_extract(ConversationVariable.data, "$.name")
)
return name.ilike(f"%{escape_like_pattern(variable_name)}%", escape="\\")
@staticmethod
def _variables(*, session: Session, ref: EndUserConversationRef) -> Select[tuple[ConversationVariable]]:
owner = (
select(Conversation.id)
.join(App, App.id == Conversation.app_id)
.join(
EndUser,
(EndUser.id == ref.end_user_id) & (EndUser.app_id == App.id) & (EndUser.tenant_id == App.tenant_id),
)
.where(
App.id == ref.app_id,
App.tenant_id == ref.tenant_id,
Conversation.id == ref.conversation_id,
Conversation.from_source == ConversationFromSource.API,
Conversation.from_end_user_id == ref.end_user_id,
Conversation.from_account_id.is_(None),
Conversation.is_deleted.is_(False),
)
)
if session.scalar(owner) is None:
raise ConversationNotExistsError(
f"Conversation {ref.conversation_id} does not belong to this end user and app."
)
return select(ConversationVariable).where(
ConversationVariable.app_id == ref.app_id,
ConversationVariable.conversation_id.in_(owner),
)
@staticmethod
def _record(row: ConversationVariable) -> ConversationVariableRecord:
return ConversationVariableRecord(
id=row.id,
variable=row.to_variable(),
created_at=row.created_at,
updated_at=row.updated_at,
)