Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

refactor(api): share conversation deletion and pin commands (#43992)

非法操作55b5265424b9
diff --git a/api/.importlinter b/api/.importlinter
index 9545ecbb7f9..9c3cdb6aa8e 100644
--- a/api/.importlinter
+++ b/api/.importlinter
@@ -1040,10 +1040,11 @@ forbidden_modules =
werkzeug
[importlinter:contract:conversation-name-boundary]
-name = Conversation naming policy is framework and persistence neutral
+name = Conversation naming and commands are framework and persistence neutral
type = forbidden
source_modules =
services.conversation_name_service
+ services.conversation_command_service
forbidden_modules =
controllers
extensions
diff --git a/api/controllers/service_api/app/conversation.py b/api/controllers/service_api/app/conversation.py
index 27d5a47c854..3f6cc2bd051 100644
--- a/api/controllers/service_api/app/conversation.py
+++ b/api/controllers/service_api/app/conversation.py
@@ -233,42 +233,41 @@ class ConversationApi(Resource):
@service_api_ns.route("/conversations/<uuid:conversation_id>")
class ConversationDetailApi(Resource):
- @error_responses(NotChatAppError)
+ @error_responses(NotChatAppError, ConversationNotFoundHTTPError)
@service_api_ns.doc(
summary="Delete Conversation",
description="Delete a conversation.",
tags=["Conversations"],
responses={
- 204: "Conversation deleted successfully.",
- 400: "`not_chat_app` : App mode does not match the API route.",
- 404: "`not_found` : Conversation does not exist.",
+ HTTPStatus.NO_CONTENT: "Conversation deleted successfully.",
+ HTTPStatus.BAD_REQUEST: "Invalid app selection or app mode does not match the API route.",
+ HTTPStatus.UNAUTHORIZED: "Invalid API credentials.",
+ HTTPStatus.FORBIDDEN: "API credential, app or workspace access is unavailable.",
+ HTTPStatus.NOT_FOUND: "`conversation_not_found`: Conversation does not exist for this user and app.",
},
)
@expect_user_json(service_api_ns)
@service_api_ns.doc("delete_conversation")
- @service_api_ns.doc(description="Delete a specific conversation")
@service_api_ns.doc(params={"conversation_id": "Conversation ID."})
- @service_api_ns.doc(
- responses={
- 204: "Conversation deleted successfully",
- 401: "Unauthorized - invalid API token",
- 404: "Conversation not found",
- }
- )
- @validate_app_token(fetch_user_arg=FetchUserArg(fetch_from=WhereisUserArg.JSON))
- def delete(self, app_model: App, end_user: EndUser, conversation_id: UUID):
+ @service_api_end_user_admission(fetch_user_arg=FetchUserArg(fetch_from=WhereisUserArg.JSON))
+ def delete(self, context: ServiceApiEndUserContext, conversation_id: UUID) -> tuple[str, HTTPStatus]:
"""Delete a specific conversation."""
- app_mode = AppMode.value_of(app_model.mode)
+ app_mode = AppMode.value_of(context.app_mode)
if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}:
raise NotChatAppError()
- conversation_id_str = str(conversation_id)
-
try:
- ConversationService.delete(app_model, conversation_id_str, end_user, session=db.session())
- except services.errors.conversation.ConversationNotExistsError as caught_error:
- raise NotFound("Conversation Not Exists.") from caught_error
- return "", 204
+ application_services().conversation_commands.delete(
+ ref=EndUserConversationRef(
+ app_id=context.app_id,
+ tenant_id=context.tenant_id,
+ end_user_id=context.end_user_id,
+ conversation_id=str(conversation_id),
+ )
+ )
+ except services.errors.conversation.ConversationNotExistsError as error:
+ raise ConversationNotFoundHTTPError() from error
+ return "", HTTPStatus.NO_CONTENT
@service_api_ns.route("/conversations/<uuid:conversation_id>/name")
diff --git a/api/controllers/web/conversation.py b/api/controllers/web/conversation.py
index f84b0782673..4e373ec4b42 100644
--- a/api/controllers/web/conversation.py
+++ b/api/controllers/web/conversation.py
@@ -26,7 +26,6 @@ from fields.conversation_fields import (
from libs.external_api import error_responses
from libs.helper import dump_response, uuid_value
from models.model import App, AppMode, EndUser
-from services.conversation_service import ConversationService
from services.entities.conversation_entities import EndUserConversationRef
from services.errors.conversation import ConversationNotExistsError, LastConversationNotExistsError
from services.errors.message import MessageNotExistsError
@@ -106,30 +105,37 @@ class ConversationListApi(WebApiResource):
@web_ns.route("/conversations/<uuid:c_id>")
class ConversationApi(WebApiResource):
- @error_responses(NotChatAppError)
+ @error_responses(NotChatAppError, ConversationNotFoundHTTPError)
@web_ns.doc("Delete Conversation")
@web_ns.doc(description="Delete a specific conversation.")
@web_ns.doc(params={"c_id": {"description": "Conversation UUID", "type": "string", "required": True}})
@web_ns.doc(
responses={
- 204: "Conversation deleted successfully",
- 400: "Bad Request",
- 401: "Unauthorized",
- 404: "Conversation Not Found or Not a Chat App",
- 500: "Internal Server Error",
+ HTTPStatus.NO_CONTENT: "Conversation deleted successfully",
+ HTTPStatus.BAD_REQUEST: "Bad Request",
+ HTTPStatus.UNAUTHORIZED: "Unauthorized",
+ HTTPStatus.NOT_FOUND: "`conversation_not_found`: Conversation does not exist for this user and app.",
+ HTTPStatus.INTERNAL_SERVER_ERROR: "Internal Server Error",
}
)
- def delete(self, app_model: App, end_user: EndUser, c_id: UUID):
+ def delete(self, app_model: App, end_user: EndUser, c_id: UUID) -> tuple[str, HTTPStatus]:
app_mode = AppMode.value_of(app_model.mode)
if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}:
raise NotChatAppError()
conversation_id = str(c_id)
try:
- ConversationService.delete(app_model, conversation_id, end_user, session=db.session())
- except ConversationNotExistsError as caught_error:
- raise NotFound("Conversation Not Exists.") from caught_error
- return "", 204
+ application_services().conversation_commands.delete(
+ ref=EndUserConversationRef(
+ app_id=app_model.id,
+ tenant_id=app_model.tenant_id,
+ end_user_id=end_user.id,
+ conversation_id=conversation_id,
+ )
+ )
+ except ConversationNotExistsError as error:
+ raise ConversationNotFoundHTTPError() from error
+ return "", HTTPStatus.NO_CONTENT
@web_ns.route("/conversations/<uuid:c_id>/name")
@@ -195,21 +201,21 @@ class ConversationRenameApi(WebApiResource):
@web_ns.route("/conversations/<uuid:c_id>/pin")
class ConversationPinApi(WebApiResource):
- @error_responses(NotChatAppError)
+ @error_responses(NotChatAppError, ConversationNotFoundHTTPError)
@web_ns.doc("Pin Conversation")
@web_ns.doc(description="Pin a specific conversation to keep it at the top of the list.")
@web_ns.doc(params={"c_id": {"description": "Conversation UUID", "type": "string", "required": True}})
@web_ns.doc(
responses={
- 200: "Conversation pinned successfully",
- 400: "Bad Request",
- 401: "Unauthorized",
- 404: "Conversation Not Found or Not a Chat App",
- 500: "Internal Server Error",
+ HTTPStatus.OK: "Conversation pinned successfully",
+ HTTPStatus.BAD_REQUEST: "Bad Request",
+ HTTPStatus.UNAUTHORIZED: "Unauthorized",
+ HTTPStatus.NOT_FOUND: "`conversation_not_found`: Conversation does not exist for this user and app.",
+ HTTPStatus.INTERNAL_SERVER_ERROR: "Internal Server Error",
}
)
- @web_ns.response(200, "Conversation pinned successfully", web_ns.models[ResultResponse.__name__])
- def patch(self, app_model: App, end_user: EndUser, c_id: UUID):
+ @web_ns.response(HTTPStatus.OK, "Conversation pinned successfully", web_ns.models[ResultResponse.__name__])
+ def patch(self, app_model: App, end_user: EndUser, c_id: UUID) -> dict[str, object]:
app_mode = AppMode.value_of(app_model.mode)
if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}:
raise NotChatAppError()
@@ -217,35 +223,54 @@ class ConversationPinApi(WebApiResource):
conversation_id = str(c_id)
try:
- WebConversationService.pin(app_model, conversation_id, end_user, db.session())
- except ConversationNotExistsError as caught_error:
- raise NotFound("Conversation Not Exists.") from caught_error
+ application_services().conversation_commands.set_pinned(
+ ref=EndUserConversationRef(
+ app_id=app_model.id,
+ tenant_id=app_model.tenant_id,
+ end_user_id=end_user.id,
+ conversation_id=conversation_id,
+ ),
+ is_pinned=True,
+ )
+ except ConversationNotExistsError as error:
+ raise ConversationNotFoundHTTPError() from error
return ResultResponse(result="success").model_dump(mode="json")
@web_ns.route("/conversations/<uuid:c_id>/unpin")
class ConversationUnPinApi(WebApiResource):
- @error_responses(NotChatAppError)
+ @error_responses(NotChatAppError, ConversationNotFoundHTTPError)
@web_ns.doc("Unpin Conversation")
- @web_ns.doc(description="Unpin a specific conversation to remove it from the top of the list.")
+ @web_ns.doc(description="Remove the current user's pin. Succeeds when the conversation is already unpinned.")
@web_ns.doc(params={"c_id": {"description": "Conversation UUID", "type": "string", "required": True}})
@web_ns.doc(
responses={
- 200: "Conversation unpinned successfully",
- 400: "Bad Request",
- 401: "Unauthorized",
- 404: "Conversation Not Found or Not a Chat App",
- 500: "Internal Server Error",
+ HTTPStatus.OK: "Conversation unpinned successfully",
+ HTTPStatus.BAD_REQUEST: "Bad Request",
+ HTTPStatus.UNAUTHORIZED: "Unauthorized",
+ HTTPStatus.NOT_FOUND: "`conversation_not_found`: The app or user is no longer available.",
+ HTTPStatus.INTERNAL_SERVER_ERROR: "Internal Server Error",
}
)
- @web_ns.response(200, "Conversation unpinned successfully", web_ns.models[ResultResponse.__name__])
- def patch(self, app_model: App, end_user: EndUser, c_id: UUID):
+ @web_ns.response(HTTPStatus.OK, "Conversation unpinned successfully", web_ns.models[ResultResponse.__name__])
+ def patch(self, app_model: App, end_user: EndUser, c_id: UUID) -> dict[str, object]:
app_mode = AppMode.value_of(app_model.mode)
if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}:
raise NotChatAppError()
conversation_id = str(c_id)
- WebConversationService.unpin(app_model, conversation_id, end_user, db.session())
+ try:
+ application_services().conversation_commands.set_pinned(
+ ref=EndUserConversationRef(
+ app_id=app_model.id,
+ tenant_id=app_model.tenant_id,
+ end_user_id=end_user.id,
+ conversation_id=conversation_id,
+ ),
+ is_pinned=False,
+ )
+ except ConversationNotExistsError as error:
+ raise ConversationNotFoundHTTPError() from error
return ResultResponse(result="success").model_dump(mode="json")
diff --git a/api/extensions/application_services/installed_app.py b/api/extensions/application_services/installed_app.py
index c729e676fbc..96a7e2ebf69 100644
--- a/api/extensions/application_services/installed_app.py
+++ b/api/extensions/application_services/installed_app.py
@@ -5,8 +5,8 @@ from dataclasses import dataclass
from sqlalchemy.orm import Session, sessionmaker
from repositories.installed_app_repository import SQLAlchemyInstalledAppRepository
+from services.conversation_command_service import ConversationCommandService
from services.conversation_name_service import ConversationNameService
-from services.conversation_service import ConversationService
from services.installed_app_access_service import InstalledAppAccessService
from services.installed_app_conversation_service import InstalledAppConversationService, InstalledAppConversationStore
from services.installed_app_generation_adapters import AppGenerateServiceRuntime
@@ -28,6 +28,7 @@ def build_installed_app_services(
database_client: sessionmaker[Session],
conversations: InstalledAppConversationStore,
conversation_names: ConversationNameService,
+ conversation_commands: ConversationCommandService,
webapp_access: WebAppAccessQueryService,
get_workspace_role: WorkspaceRoleLookup,
webapp_auth_enabled: bool,
@@ -53,6 +54,6 @@ def build_installed_app_services(
conversations=InstalledAppConversationService(
conversations=conversations,
names=conversation_names,
- enqueue_delete_cleanup=ConversationService.enqueue_delete_cleanup,
+ commands=conversation_commands,
),
)
diff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.py
index a31ccbe8da6..607de199039 100644
--- a/api/extensions/ext_application_services.py
+++ b/api/extensions/ext_application_services.py
@@ -136,8 +136,10 @@ from services.app_tracing_config_service import AppTracingConfigService
from services.billing_portal_service import BillingPortalService
from services.billing_service import BillingService
from services.compliance_download_service import ComplianceDownloadService
+from services.conversation_command_service import ConversationCommandService
from services.conversation_name_generator import generate_conversation_name
from services.conversation_name_service import ConversationNameService
+from services.conversation_service import ConversationService
from services.conversation_variable_query import ConversationVariableQuery
from services.credentials.query import CredentialQuery
from services.enterprise.enterprise_service import EnterpriseService
@@ -314,6 +316,7 @@ class ApplicationServices:
billing_portal: BillingPortalService
compliance_downloads: ComplianceDownloadService
conversation_names: ConversationNameService
+ conversation_commands: ConversationCommandService
data_sources: DataSourceServices
knowledge: KnowledgeServices
app_scoped_end_users: AppScopedEndUserServices
@@ -577,6 +580,9 @@ def build_application_services(
)
conversations = ConversationRepository(session_factory=database_client)
conversation_names = ConversationNameService(conversations=conversations, generate_name=generate_conversation_name)
+ conversation_commands = ConversationCommandService(
+ conversations=conversations, enqueue_delete_cleanup=ConversationService.enqueue_delete_cleanup
+ )
annotations = AnnotationRepository(session_factory=database_client)
messages = MessageRepository(session_factory=database_client)
suggested_questions = SuggestedQuestionsQuery(
@@ -613,6 +619,7 @@ def build_application_services(
),
rbac=rbac,
conversation_names=conversation_names,
+ conversation_commands=conversation_commands,
accounts=account_services,
apps=apps,
credential_queries=CredentialQueryRepository(session_factory=database_client),
@@ -688,6 +695,7 @@ def build_application_services(
installed_apps=build_installed_app_services(
conversations=conversations,
conversation_names=conversation_names,
+ conversation_commands=conversation_commands,
database_client=database_client,
webapp_access=webapp_access,
get_workspace_role=workspace_repository.get_account_role,
diff --git a/api/openapi/markdown/service-openapi.md b/api/openapi/markdown/service-openapi.md
index 5f5dc794428..d45868ada8e 100644
--- a/api/openapi/markdown/service-openapi.md
+++ b/api/openapi/markdown/service-openapi.md
@@ -2315,10 +2315,10 @@ Delete a conversation.
| Code | Description | Schema |
| ---- | ----------- | ------ |
| 204 | Conversation deleted successfully. | |
-| 400 | `not_chat_app` : App mode does not match the API route. | **application/json**: [NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> |
-| 401 | Unauthorized - invalid API token | **application/json**: [ErrorResponse](#errorresponse)<br> |
-| 403 | Forbidden - token scope, app, dataset, or workspace access denied | **application/json**: [ErrorResponse](#errorresponse)<br> |
-| 404 | `not_found` : Conversation does not exist. | **application/json**: [ErrorResponse](#errorresponse)<br> |
+| 400 | Invalid app selection or app mode does not match the API route. | **application/json**: [NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> |
+| 401 | Invalid API credentials. | **application/json**: [ErrorResponse](#errorresponse)<br> |
+| 403 | API credential, app or workspace access is unavailable. | **application/json**: [AppAbnormalStatusError](#appabnormalstatuserror)<br>[AppApiDisabledError](#appapidisablederror)<br>[AppNotFoundError](#appnotfounderror)<br>[ForbiddenError](#forbiddenerror)<br>[WorkspaceArchivedError](#workspacearchivederror)<br>[WorkspaceNotFoundError](#workspacenotfounderror)<br>[ErrorResponse](#errorresponse)<br> |
+| 404 | `conversation_not_found`: Conversation does not exist for this user and app. | **application/json**: [ConversationNotFoundError](#conversationnotfounderror)<br>[ErrorResponse](#errorresponse)<br> |
| default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |
### [POST] /conversations/{conversation_id}/name
diff --git a/api/openapi/markdown/web-openapi.md b/api/openapi/markdown/web-openapi.md
index e93ab4ff1a4..a83031fba6b 100644
--- a/api/openapi/markdown/web-openapi.md
+++ b/api/openapi/markdown/web-openapi.md
@@ -149,7 +149,7 @@ Delete a specific conversation.
| 204 | Conversation deleted successfully | |
| 400 | Bad Request | **application/json**: [NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> |
| 401 | Unauthorized | **application/json**: [ErrorResponse](#errorresponse)<br> |
-| 404 | Conversation Not Found or Not a Chat App | **application/json**: [ErrorResponse](#errorresponse)<br> |
+| 404 | `conversation_not_found`: Conversation does not exist for this user and app. | **application/json**: [ConversationNotFoundError](#conversationnotfounderror)<br>[ErrorResponse](#errorresponse)<br> |
| 500 | Internal Server Error | **application/json**: [ErrorResponse](#errorresponse)<br> |
| default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |
@@ -198,12 +198,12 @@ Pin a specific conversation to keep it at the top of the list.
| 200 | Conversation pinned successfully | **application/json**: [ResultResponse](#resultresponse)<br> |
| 400 | Bad Request | **application/json**: [NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> |
| 401 | Unauthorized | **application/json**: [ErrorResponse](#errorresponse)<br> |
-| 404 | Conversation Not Found or Not a Chat App | **application/json**: [ErrorResponse](#errorresponse)<br> |
+| 404 | `conversation_not_found`: Conversation does not exist for this user and app. | **application/json**: [ConversationNotFoundError](#conversationnotfounderror)<br>[ErrorResponse](#errorresponse)<br> |
| 500 | Internal Server Error | **application/json**: [ErrorResponse](#errorresponse)<br> |
| default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |
### [PATCH] /conversations/{c_id}/unpin
-Unpin a specific conversation to remove it from the top of the list.
+Remove the current user's pin. Succeeds when the conversation is already unpinned.
#### Parameters
@@ -218,7 +218,7 @@ Unpin a specific conversation to remove it from the top of the list.
| 200 | Conversation unpinned successfully | **application/json**: [ResultResponse](#resultresponse)<br> |
| 400 | Bad Request | **application/json**: [NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> |
| 401 | Unauthorized | **application/json**: [ErrorResponse](#errorresponse)<br> |
-| 404 | Conversation Not Found or Not a Chat App | **application/json**: [ErrorResponse](#errorresponse)<br> |
+| 404 | `conversation_not_found`: The app or user is no longer available. | **application/json**: [ConversationNotFoundError](#conversationnotfounderror)<br>[ErrorResponse](#errorresponse)<br> |
| 500 | Internal Server Error | **application/json**: [ErrorResponse](#errorresponse)<br> |
| default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |
diff --git a/api/repositories/conversation_repository.py b/api/repositories/conversation_repository.py
index a036d7c4394..b6c95ee836d 100644
--- a/api/repositories/conversation_repository.py
+++ b/api/repositories/conversation_repository.py
@@ -104,12 +104,9 @@ class ConversationRepository:
renamed = replace(record, name=conversation.name, updated_at=conversation.updated_at)
return renamed
- def delete(self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str) -> ConversationDeletion:
+ def delete(self, *, ref: ConversationRef) -> ConversationDeletion:
with self._session_factory.begin() as session:
- app = self._get_app(session=session, installed_app=installed_app)
- conversation = self._get_conversation(
- session=session, app_id=app.id, account_id=account_id, conversation_id=conversation_id
- )
+ app, conversation = self._resolve(session=session, ref=ref)
retired_workspace_ids = retire_conversation(app_model=app, conversation=conversation, session=session)
return ConversationDeletion(
tenant_id=app.tenant_id,
@@ -117,36 +114,53 @@ class ConversationRepository:
retired_workspace_ids=retired_workspace_ids,
)
- def set_pinned(
- self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str, is_pinned: bool
- ) -> None:
+ def set_pinned(self, *, ref: ConversationRef, is_pinned: bool) -> None:
with self._session_factory.begin() as session:
- app = self._get_app(session=session, installed_app=installed_app)
+ if isinstance(ref, InstalledAppConversationRef):
+ app = self._get_app(session=session, installed_app=ref.installed_app)
+ role = CreatorUserRole.ACCOUNT
+ actor_id = ref.account_id
+ else:
+ app = session.scalar(
+ select(App)
+ .join(EndUser, EndUser.app_id == App.id)
+ .where(
+ App.id == ref.app_id,
+ App.tenant_id == ref.tenant_id,
+ EndUser.id == ref.end_user_id,
+ EndUser.tenant_id == App.tenant_id,
+ )
+ )
+ if app is None:
+ raise ConversationNotExistsError(
+ f"Conversation {ref.conversation_id} is unavailable for this end user and app."
+ )
+ role = CreatorUserRole.END_USER
+ actor_id = ref.end_user_id
pin = session.scalar(
select(PinnedConversation)
.where(
PinnedConversation.app_id == app.id,
- PinnedConversation.conversation_id == conversation_id,
- PinnedConversation.created_by_role == CreatorUserRole.ACCOUNT,
- PinnedConversation.created_by == account_id,
+ PinnedConversation.conversation_id == ref.conversation_id,
+ PinnedConversation.created_by_role == role,
+ PinnedConversation.created_by == actor_id,
)
.limit(1)
)
if is_pinned:
if pin is not None:
return
- conversation = self._get_conversation(
- session=session, app_id=app.id, account_id=account_id, conversation_id=conversation_id
- )
+ _, conversation = self._resolve(session=session, ref=ref)
session.add(
PinnedConversation(
app_id=app.id,
conversation_id=conversation.id,
- created_by_role=CreatorUserRole.ACCOUNT,
- created_by=account_id,
+ created_by_role=role,
+ created_by=actor_id,
)
)
elif pin is not None:
+ # Unpin remains idempotent even after its conversation is deleted.
session.delete(pin)
@classmethod
diff --git a/api/services/conversation_command_service.py b/api/services/conversation_command_service.py
new file mode 100644
index 00000000000..e3f8f935183
--- /dev/null
+++ b/api/services/conversation_command_service.py
@@ -0,0 +1,37 @@
+"""Mutate owned conversations and dispatch cleanup after persistence commits."""
+
+from typing import Protocol
+
+from services.entities.conversation_entities import ConversationDeletion, ConversationRef
+
+
+class ConversationCommandStore(Protocol):
+ def delete(self, *, ref: ConversationRef) -> ConversationDeletion:
+ """Commit soft deletion and workspace retirement before returning cleanup data."""
+ ...
+
+ def set_pinned(self, *, ref: ConversationRef, is_pinned: bool) -> None:
+ """Set the caller's pin; removing an absent pin succeeds."""
+ ...
+
+
+class ConversationCleanup(Protocol):
+ def __call__(self, *, tenant_id: str, conversation_id: str, retired_workspace_ids: tuple[str, ...]) -> None: ...
+
+
+class ConversationCommandService:
+ def __init__(self, *, conversations: ConversationCommandStore, enqueue_delete_cleanup: ConversationCleanup) -> None:
+ self._conversations: ConversationCommandStore = conversations
+ self._enqueue_delete_cleanup: ConversationCleanup = enqueue_delete_cleanup
+
+ def delete(self, *, ref: ConversationRef) -> None:
+ deleted = self._conversations.delete(ref=ref)
+ # The retirement and soft-delete commit must precede physical cleanup.
+ self._enqueue_delete_cleanup(
+ tenant_id=deleted.tenant_id,
+ conversation_id=deleted.conversation_id,
+ retired_workspace_ids=deleted.retired_workspace_ids,
+ )
+
+ def set_pinned(self, *, ref: ConversationRef, is_pinned: bool) -> None:
+ self._conversations.set_pinned(ref=ref, is_pinned=is_pinned)
diff --git a/api/services/installed_app_conversation_service.py b/api/services/installed_app_conversation_service.py
index 10fd969f038..cd741185b3b 100644
--- a/api/services/installed_app_conversation_service.py
+++ b/api/services/installed_app_conversation_service.py
@@ -2,9 +2,9 @@
from typing import Protocol
+from services.conversation_command_service import ConversationCommandService
from services.conversation_name_service import ConversationNameService
from services.entities.conversation_entities import (
- ConversationDeletion,
ConversationPage,
ConversationRecord,
InstalledAppConversationRef,
@@ -21,18 +21,6 @@ class InstalledAppConversationStore(Protocol):
self, *, installed_app: InstalledAppRef, account_id: str, last_id: str | None, limit: int, pinned: bool | None
) -> ConversationPage: ...
- def delete(
- self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str
- ) -> ConversationDeletion: ...
-
- def set_pinned(
- self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str, is_pinned: bool
- ) -> None: ...
-
-
-class ConversationCleanup(Protocol):
- def __call__(self, *, tenant_id: str, conversation_id: str, retired_workspace_ids: tuple[str, ...]) -> None: ...
-
class InstalledAppConversationService:
def __init__(
@@ -40,11 +28,11 @@ class InstalledAppConversationService:
*,
conversations: InstalledAppConversationStore,
names: ConversationNameService,
- enqueue_delete_cleanup: ConversationCleanup,
+ commands: ConversationCommandService,
) -> None:
self._conversations: InstalledAppConversationStore = conversations
self._names = names
- self._enqueue_delete_cleanup: ConversationCleanup = enqueue_delete_cleanup
+ self._commands = commands
def get_page(
self, *, installed_app: InstalledAppRef, account_id: str, last_id: str | None, limit: int, pinned: bool | None
@@ -80,22 +68,21 @@ class InstalledAppConversationService:
def delete(self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str) -> None:
self._get_chat_mode(installed_app)
- deleted = self._conversations.delete(
- installed_app=installed_app, account_id=account_id, conversation_id=conversation_id
- )
- # The retirement and soft-delete commit must precede physical cleanup.
- self._enqueue_delete_cleanup(
- tenant_id=deleted.tenant_id,
- conversation_id=deleted.conversation_id,
- retired_workspace_ids=deleted.retired_workspace_ids,
+ self._commands.delete(
+ ref=InstalledAppConversationRef(
+ installed_app=installed_app, account_id=account_id, conversation_id=conversation_id
+ )
)
def set_pinned(
self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str, is_pinned: bool
) -> None:
self._get_chat_mode(installed_app)
- self._conversations.set_pinned(
- installed_app=installed_app, account_id=account_id, conversation_id=conversation_id, is_pinned=is_pinned
+ self._commands.set_pinned(
+ ref=InstalledAppConversationRef(
+ installed_app=installed_app, account_id=account_id, conversation_id=conversation_id
+ ),
+ is_pinned=is_pinned,
)
@staticmethod
diff --git a/api/services/web_conversation_service.py b/api/services/web_conversation_service.py
index 96d95d5f5ac..d6d5cda594c 100644
--- a/api/services/web_conversation_service.py
+++ b/api/services/web_conversation_service.py
@@ -4,7 +4,6 @@ from sqlalchemy.orm import Session
from core.app.entities.app_invoke_entities import InvokeFrom
from libs.infinite_scroll_pagination import InfiniteScrollPagination
from models import Account
-from models.enums import CreatorUserRole
from models.model import App, EndUser
from models.web import PinnedConversation
from services.conversation_service import ConversationService
@@ -56,56 +55,3 @@ class WebConversationService:
exclude_ids=exclude_ids,
sort_by=sort_by,
)
-
- @classmethod
- def pin(cls, app_model: App, conversation_id: str, user: Account | EndUser | None, session: Session):
- if not user:
- return
- pinned_conversation = session.scalar(
- select(PinnedConversation)
- .where(
- PinnedConversation.app_id == app_model.id,
- PinnedConversation.conversation_id == conversation_id,
- PinnedConversation.created_by_role == ("account" if isinstance(user, Account) else "end_user"),
- PinnedConversation.created_by == user.id,
- )
- .limit(1)
- )
-
- if pinned_conversation:
- return
-
- conversation = ConversationService.get_conversation(
- app_model=app_model, conversation_id=conversation_id, user=user, session=session
- )
-
- pinned_conversation = PinnedConversation(
- app_id=app_model.id,
- conversation_id=conversation.id,
- created_by_role=CreatorUserRole.ACCOUNT if isinstance(user, Account) else CreatorUserRole.END_USER,
- created_by=user.id,
- )
-
- session.add(pinned_conversation)
- session.commit()
-
- @classmethod
- def unpin(cls, app_model: App, conversation_id: str, user: Account | EndUser | None, session: Session):
- if not user:
- return
- pinned_conversation = session.scalar(
- select(PinnedConversation)
- .where(
- PinnedConversation.app_id == app_model.id,
- PinnedConversation.conversation_id == conversation_id,
- PinnedConversation.created_by_role == ("account" if isinstance(user, Account) else "end_user"),
- PinnedConversation.created_by == user.id,
- )
- .limit(1)
- )
-
- if not pinned_conversation:
- return
-
- session.delete(pinned_conversation)
- session.commit()
diff --git a/api/tests/e2e_tests/containers/controllers/web/test_conversation.py b/api/tests/e2e_tests/containers/controllers/web/test_conversation.py
index 177b29aa50b..aa199e179ff 100644
--- a/api/tests/e2e_tests/containers/controllers/web/test_conversation.py
+++ b/api/tests/e2e_tests/containers/controllers/web/test_conversation.py
@@ -8,16 +8,9 @@ from uuid import uuid4
import pytest
from flask import Flask
-from werkzeug.exceptions import NotFound
-
-from controllers.web.conversation import (
- ConversationApi,
- ConversationListApi,
- ConversationPinApi,
- ConversationUnPinApi,
-)
+
+from controllers.web.conversation import ConversationListApi
from controllers.web.error import NotChatAppError
-from services.errors.conversation import ConversationNotExistsError
def _chat_app() -> SimpleNamespace:
@@ -61,75 +54,3 @@ class TestConversationListApi:
assert result["limit"] == 20
assert result["has_more"] is False
-
-
-class TestConversationApi:
- @pytest.fixture
- def app(self, flask_app_with_containers: Flask):
- return flask_app_with_containers
-
- def test_non_chat_mode_raises(self, app: Flask) -> None:
- with app.test_request_context(f"/conversations/{uuid4()}"):
- with pytest.raises(NotChatAppError):
- ConversationApi().delete(_completion_app(), _end_user(), uuid4())
-
- @patch("controllers.web.conversation.ConversationService.delete")
- def test_delete_success(self, mock_delete: MagicMock, app: Flask) -> None:
- c_id = uuid4()
- with app.test_request_context(f"/conversations/{c_id}"):
- result, status = ConversationApi().delete(_chat_app(), _end_user(), c_id)
-
- assert status == 204
- assert result == ""
-
- @patch("controllers.web.conversation.ConversationService.delete", side_effect=ConversationNotExistsError())
- def test_delete_not_found(self, mock_delete: MagicMock, app: Flask) -> None:
- c_id = uuid4()
- with app.test_request_context(f"/conversations/{c_id}"):
- with pytest.raises(NotFound, match="Conversation Not Exists"):
- ConversationApi().delete(_chat_app(), _end_user(), c_id)
-
-
-class TestConversationPinApi:
- @pytest.fixture
- def app(self, flask_app_with_containers: Flask):
- return flask_app_with_containers
-
- def test_non_chat_mode_raises(self, app: Flask) -> None:
- with app.test_request_context(f"/conversations/{uuid4()}/pin", method="PATCH"):
- with pytest.raises(NotChatAppError):
- ConversationPinApi().patch(_completion_app(), _end_user(), uuid4())
-
- @patch("controllers.web.conversation.WebConversationService.pin")
- def test_pin_success(self, mock_pin: MagicMock, app: Flask) -> None:
- c_id = uuid4()
- with app.test_request_context(f"/conversations/{c_id}/pin", method="PATCH"):
- result = ConversationPinApi().patch(_chat_app(), _end_user(), c_id)
-
- assert result["result"] == "success"
-
- @patch("controllers.web.conversation.WebConversationService.pin", side_effect=ConversationNotExistsError())
- def test_pin_not_found(self, mock_pin: MagicMock, app: Flask) -> None:
- c_id = uuid4()
- with app.test_request_context(f"/conversations/{c_id}/pin", method="PATCH"):
- with pytest.raises(NotFound):
- ConversationPinApi().patch(_chat_app(), _end_user(), c_id)
-
-
-class TestConversationUnPinApi:
- @pytest.fixture
- def app(self, flask_app_with_containers: Flask):
- return flask_app_with_containers
-
- def test_non_chat_mode_raises(self, app: Flask) -> None:
- with app.test_request_context(f"/conversations/{uuid4()}/unpin", method="PATCH"):
- with pytest.raises(NotChatAppError):
- ConversationUnPinApi().patch(_completion_app(), _end_user(), uuid4())
-
- @patch("controllers.web.conversation.WebConversationService.unpin")
- def test_unpin_success(self, mock_unpin: MagicMock, app: Flask) -> None:
- c_id = uuid4()
- with app.test_request_context(f"/conversations/{c_id}/unpin", method="PATCH"):
- result = ConversationUnPinApi().patch(_chat_app(), _end_user(), c_id)
-
- assert result["result"] == "success"
diff --git a/api/tests/e2e_tests/containers/services/test_web_conversation_service.py b/api/tests/e2e_tests/containers/services/test_web_conversation_service.py
index 928fa6344d0..28aa37324a6 100644
--- a/api/tests/e2e_tests/containers/services/test_web_conversation_service.py
+++ b/api/tests/e2e_tests/containers/services/test_web_conversation_service.py
@@ -2,7 +2,6 @@ from unittest.mock import patch
import pytest
from faker import Faker
-from sqlalchemy import select
from sqlalchemy.orm import Session
from core.app.entities.app_invoke_entities import InvokeFrom
@@ -299,181 +298,6 @@ class TestWebConversationService:
expected_unpinned_ids = [conv.id for conv in conversations[1:]]
assert set(returned_ids) == set(expected_unpinned_ids)
- def test_pin_conversation_success(self, db_session_with_containers: Session, mock_external_service_dependencies):
- """
- Test successful pinning of a conversation.
- """
- fake = Faker()
- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
-
- # Create a conversation
- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)
-
- # Pin the conversation
- WebConversationService.pin(app, conversation.id, account, db_session_with_containers)
-
- # Verify the conversation was pinned
-
- pinned_conversation = (
- db_session_with_containers.query(PinnedConversation)
- .where(
- PinnedConversation.app_id == app.id,
- PinnedConversation.conversation_id == conversation.id,
- PinnedConversation.created_by_role == "account",
- PinnedConversation.created_by == account.id,
- )
- .first()
- )
-
- assert pinned_conversation is not None
- assert pinned_conversation.app_id == app.id
- assert pinned_conversation.conversation_id == conversation.id
- assert pinned_conversation.created_by_role == "account"
- assert pinned_conversation.created_by == account.id
-
- def test_pin_conversation_already_pinned(
- self, db_session_with_containers: Session, mock_external_service_dependencies
- ):
- """
- Test pinning a conversation that is already pinned (should not create duplicate).
- """
- fake = Faker()
- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
-
- # Create a conversation
- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)
-
- # Pin the conversation first time
- WebConversationService.pin(app, conversation.id, account, db_session_with_containers)
-
- # Pin the conversation again
- WebConversationService.pin(app, conversation.id, account, db_session_with_containers)
-
- # Verify only one pinned conversation record exists
-
- pinned_conversations = db_session_with_containers.scalars(
- select(PinnedConversation).where(
- PinnedConversation.app_id == app.id,
- PinnedConversation.conversation_id == conversation.id,
- PinnedConversation.created_by_role == "account",
- PinnedConversation.created_by == account.id,
- )
- ).all()
-
- assert len(pinned_conversations) == 1
-
- def test_pin_conversation_with_end_user(
- self, db_session_with_containers: Session, mock_external_service_dependencies
- ):
- """
- Test pinning a conversation with an end user.
- """
- fake = Faker()
- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
-
- # Create an end user
- end_user = self._create_test_end_user(db_session_with_containers, app)
-
- # Create a conversation for the end user
- conversation = self._create_test_conversation(db_session_with_containers, app, end_user, fake)
-
- # Pin the conversation
- WebConversationService.pin(app, conversation.id, end_user, db_session_with_containers)
-
- # Verify the conversation was pinned
-
- pinned_conversation = (
- db_session_with_containers.query(PinnedConversation)
- .where(
- PinnedConversation.app_id == app.id,
- PinnedConversation.conversation_id == conversation.id,
- PinnedConversation.created_by_role == "end_user",
- PinnedConversation.created_by == end_user.id,
- )
- .first()
- )
-
- assert pinned_conversation is not None
- assert pinned_conversation.app_id == app.id
- assert pinned_conversation.conversation_id == conversation.id
- assert pinned_conversation.created_by_role == "end_user"
- assert pinned_conversation.created_by == end_user.id
-
- def test_unpin_conversation_success(self, db_session_with_containers: Session, mock_external_service_dependencies):
- """
- Test successful unpinning of a conversation.
- """
- fake = Faker()
- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
-
- # Create a conversation
- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)
-
- # Pin the conversation first
- WebConversationService.pin(app, conversation.id, account, db_session_with_containers)
-
- # Verify it was pinned
-
- pinned_conversation = (
- db_session_with_containers.query(PinnedConversation)
- .where(
- PinnedConversation.app_id == app.id,
- PinnedConversation.conversation_id == conversation.id,
- PinnedConversation.created_by_role == "account",
- PinnedConversation.created_by == account.id,
- )
- .first()
- )
-
- assert pinned_conversation is not None
-
- # Unpin the conversation
- WebConversationService.unpin(app, conversation.id, account, db_session_with_containers)
-
- # Verify it was unpinned
- pinned_conversation = (
- db_session_with_containers.query(PinnedConversation)
- .where(
- PinnedConversation.app_id == app.id,
- PinnedConversation.conversation_id == conversation.id,
- PinnedConversation.created_by_role == "account",
- PinnedConversation.created_by == account.id,
- )
- .first()
- )
-
- assert pinned_conversation is None
-
- def test_unpin_conversation_not_pinned(
- self, db_session_with_containers: Session, mock_external_service_dependencies
- ):
- """
- Test unpinning a conversation that is not pinned (should not cause error).
- """
- fake = Faker()
- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
-
- # Create a conversation
- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)
-
- # Try to unpin a conversation that was never pinned
- WebConversationService.unpin(app, conversation.id, account, db_session_with_containers)
-
- # Verify no pinned conversation record exists
-
- pinned_conversation = (
- db_session_with_containers.query(PinnedConversation)
- .where(
- PinnedConversation.app_id == app.id,
- PinnedConversation.conversation_id == conversation.id,
- PinnedConversation.created_by_role == "account",
- PinnedConversation.created_by == account.id,
- )
- .first()
- )
-
- assert pinned_conversation is None
-
def test_pagination_by_last_id_user_required_error(
self, db_session_with_containers: Session, mock_external_service_dependencies
):
@@ -495,76 +319,3 @@ class TestWebConversationService:
pinned=None,
sort_by="-updated_at",
)
-
- def test_pin_conversation_user_none(self, db_session_with_containers: Session, mock_external_service_dependencies):
- """
- Test that pin method returns early when user is None.
- """
- fake = Faker()
- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
-
- # Create a conversation
- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)
-
- # Try to pin with None user
- WebConversationService.pin(app, conversation.id, None, db_session_with_containers)
-
- # Verify no pinned conversation was created
-
- pinned_conversation = (
- db_session_with_containers.query(PinnedConversation)
- .where(
- PinnedConversation.app_id == app.id,
- PinnedConversation.conversation_id == conversation.id,
- )
- .first()
- )
-
- assert pinned_conversation is None
-
- def test_unpin_conversation_user_none(
- self, db_session_with_containers: Session, mock_external_service_dependencies
- ):
- """
- Test that unpin method returns early when user is None.
- """
- fake = Faker()
- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)
-
- # Create a conversation
- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)
-
- # Pin the conversation first
- WebConversationService.pin(app, conversation.id, account, db_session_with_containers)
-
- # Verify it was pinned
-
- pinned_conversation = (
- db_session_with_containers.query(PinnedConversation)
- .where(
- PinnedConversation.app_id == app.id,
- PinnedConversation.conversation_id == conversation.id,
- PinnedConversation.created_by_role == "account",
- PinnedConversation.created_by == account.id,
- )
- .first()
- )
-
- assert pinned_conversation is not None
-
- # Try to unpin with None user
- WebConversationService.unpin(app, conversation.id, None, db_session_with_containers)
-
- # Verify the conversation is still pinned
- pinned_conversation = (
- db_session_with_containers.query(PinnedConversation)
- .where(
- PinnedConversation.app_id == app.id,
- PinnedConversation.conversation_id == conversation.id,
- PinnedConversation.created_by_role == "account",
- PinnedConversation.created_by == account.id,
- )
- .first()
- )
-
- assert pinned_conversation is not None
diff --git a/api/tests/e2e_tests/contracts/controllers/service_api/app/test_conversation_commands.py b/api/tests/e2e_tests/contracts/controllers/service_api/app/test_conversation_commands.py
new file mode 100644
index 00000000000..bc1a86b73b3
--- /dev/null
+++ b/api/tests/e2e_tests/contracts/controllers/service_api/app/test_conversation_commands.py
@@ -0,0 +1,298 @@
+"""Delete contracts using real API tokens, EndUser admission, and SQLite writes."""
+
+from dataclasses import dataclass
+from http import HTTPStatus
+from uuid import uuid4
+
+import pytest
+from sqlalchemy import event, select, update
+from sqlalchemy.orm import Session, SessionTransaction
+from werkzeug.test import TestResponse
+
+from constants.resource_access_token import ResourceAccessTokenResourceType
+from controllers.service_api.app.conversation import ConversationDetailApi
+from machinery.context import RequestContext
+from models import Tenant, TenantStatus
+from models.enums import ConversationFromSource
+from models.model import App, AppMode, Conversation, EndUser
+from models.resource_access_token import ResourceAccessToken
+from repositories.conversation_repository import ConversationRepository
+from services.auth.resource_access_token_contracts import ResourceAccessTokenResource
+from services.conversation_command_service import ConversationCommandService
+from tests.e2e_tests.contracts.controllers.service_api.app import test_conversation_rename as rename_tests
+from tests.e2e_tests.contracts.controllers.service_api.app.test_conversation_rename import _Harness as RenameHarness
+from tests.e2e_tests.contracts.controllers.service_api.app.test_conversation_rename import _Services as RenameServices
+from tests.helpers.unit.model_factories import make_app
+
+rename_harness = rename_tests.harness
+
+
+@dataclass(frozen=True)
+class _Services(RenameServices):
+ conversation_commands: ConversationCommandService
+
+
+@dataclass(frozen=True)
+class _Harness:
+ source: RenameHarness
+ cleanups: list[tuple[str, str, tuple[str, ...]]]
+
+ def delete(
+ self,
+ *,
+ conversation_id: str | None = None,
+ user: str | None = "alice",
+ authorization: str | None = "Bearer rename-token",
+ requested_app_id: str | None = None,
+ ) -> TestResponse:
+ headers = {"Authorization": authorization} if authorization is not None else {}
+ if requested_app_id is not None:
+ headers["X-Dify-App-ID"] = requested_app_id
+ return self.source.app.test_client().delete(
+ f"/conversations/{conversation_id or self.source.conversation.id}",
+ json={"user": user} if user is not None else {},
+ headers=headers,
+ )
+
+ def assert_not_deleted(self) -> None:
+ with self.source.factory() as session:
+ stored = session.get(Conversation, self.source.conversation.id)
+ assert stored is not None
+ assert not stored.is_deleted
+ assert self.cleanups == []
+
+
+def harness(rename_harness: RenameHarness) -> _Harness:
+ cleanups: list[tuple[str, str, tuple[str, ...]]] = []
+
+ def enqueue_cleanup(*, tenant_id: str, conversation_id: str, retired_workspace_ids: tuple[str, ...]) -> None:
+ rename_harness.assert_closed()
+ with rename_harness.factory() as session:
+ stored = session.get(Conversation, conversation_id)
+ assert stored is not None
+ assert stored.is_deleted
+ cleanups.append((tenant_id, conversation_id, retired_workspace_ids))
+
+ original = rename_harness.app.extensions["application_services"]
+ assert isinstance(original, RenameServices)
+ rename_harness.app.extensions["application_services"] = _Services(
+ app_definitions=original.app_definitions,
+ app_scoped_end_users=original.app_scoped_end_users,
+ conversation_names=original.conversation_names,
+ resource_access_tokens=original.resource_access_tokens,
+ conversation_commands=ConversationCommandService(
+ conversations=ConversationRepository(session_factory=rename_harness.repository_factory),
+ enqueue_delete_cleanup=enqueue_cleanup,
+ ),
+ )
+ rename_harness.api.add_resource(ConversationDetailApi, "/conversations/<uuid:conversation_id>")
+ return _Harness(rename_harness, cleanups)
+
+
[email protected]("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT])
+def test_delete_commits_before_cleanup_after_admission_connections_close(harness: _Harness, mode: AppMode) -> None:
+ source = harness.source
+ with source.factory.begin() as session:
+ session.execute(update(App).where(App.id == source.target.id).values(mode=mode))
+
+ response = harness.delete()
+
+ assert response.status_code == HTTPStatus.NO_CONTENT
+ assert response.data == b""
+ assert response.headers["Content-Type"] == "application/json"
+ assert harness.cleanups == [(source.tenant.id, source.conversation.id, ())]
+ assert source.admissions
+ assert source.provisions
+ assert source.queries
+ assert source.scoped_sessions == []
+ source.assert_closed()
+
+ repeated = harness.delete()
+ assert repeated.status_code == HTTPStatus.NOT_FOUND
+ assert repeated.json is not None
+ assert repeated.json["code"] == "conversation_not_found"
+ assert len(harness.cleanups) == 1
+ source.assert_closed()
+
+
[email protected]("field", ["app_id", "from_end_user_id", "from_source", "from_account_id", "is_deleted"])
+def test_delete_rejects_conversation_outside_end_user_scope(harness: _Harness, field: str) -> None:
+ source = harness.source
+ value: str | bool
+ if field == "is_deleted":
+ value = True
+ elif field == "from_source":
+ value = ConversationFromSource.CONSOLE
+ elif field == "from_account_id":
+ value = source.end_user.id
+ else:
+ value = str(uuid4())
+ with source.factory.begin() as session:
+ session.execute(update(Conversation).where(Conversation.id == source.conversation.id).values({field: value}))
+
+ response = harness.delete()
+
+ assert response.status_code == HTTPStatus.NOT_FOUND
+ assert response.json is not None
+ assert response.json == {
+ "code": "conversation_not_found",
+ "message": "The conversation was not found for this user and app.",
+ "status": HTTPStatus.NOT_FOUND,
+ }
+ assert harness.cleanups == []
+ with source.factory() as session:
+ stored = session.get(Conversation, source.conversation.id)
+ assert stored is not None
+ assert stored.is_deleted is (field == "is_deleted")
+ source.assert_closed()
+
+
[email protected]("change_app_too", [False, True], ids=["end-user-workspace", "app-workspace"])
+def test_workspace_change_after_admission_prevents_delete(harness: _Harness, change_app_too: bool) -> None:
+ source = harness.source
+
+ def change_owner(_session: Session, _transaction: SessionTransaction) -> None:
+ with source.factory.begin() as session:
+ end_user = session.get(EndUser, source.end_user.id)
+ assert end_user is not None
+ end_user.tenant_id = str(uuid4())
+ if change_app_too:
+ target = session.get(App, source.target.id)
+ assert target is not None
+ target.tenant_id = end_user.tenant_id
+
+ event.listen(source.provision_factory, "after_transaction_end", change_owner, once=True)
+ try:
+ response = harness.delete()
+ finally:
+ event.remove(source.provision_factory, "after_transaction_end", change_owner)
+ assert response.status_code == HTTPStatus.NOT_FOUND
+ assert response.json is not None
+ assert response.json["code"] == "conversation_not_found"
+ harness.assert_not_deleted()
+ source.assert_closed()
+
+
+def test_unknown_conversation_cannot_delete_existing_decoy(harness: _Harness) -> None:
+ response = harness.delete(conversation_id=str(uuid4()))
+ assert response.status_code == HTTPStatus.NOT_FOUND
+ assert response.json is not None
+ assert response.json["code"] == "conversation_not_found"
+ harness.assert_not_deleted()
+ harness.source.assert_closed()
+
+
[email protected]("user", [None, ""])
+def test_anonymous_user_cannot_delete_identified_users_conversation(harness: _Harness, user: str | None) -> None:
+ response = harness.delete(user=user)
+ assert response.status_code == HTTPStatus.NOT_FOUND
+ assert response.json is not None
+ assert response.json["code"] == "conversation_not_found"
+ with harness.source.factory() as session:
+ end_users = session.scalars(select(EndUser)).all()
+ assert len(end_users) == 2
+ assert len([user for user in end_users if user.id != harness.source.end_user.id]) == 1
+ harness.assert_not_deleted()
+ harness.source.assert_closed()
+
+
[email protected]("authorization", [None, "Basic rename-token", "Bearer invalid-token"])
+def test_invalid_token_is_rejected_before_admission(harness: _Harness, authorization: str | None) -> None:
+ source = harness.source
+ response = harness.delete(authorization=authorization)
+ assert response.status_code == HTTPStatus.UNAUTHORIZED
+ assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'
+ assert response.json is not None
+ assert response.json["code"] == "unauthorized"
+ assert source.admissions == source.provisions == source.queries == []
+ harness.assert_not_deleted()
+ source.assert_closed()
+
+
[email protected]("mode", [AppMode.COMPLETION, AppMode.WORKFLOW])
+def test_non_chat_mode_is_rejected_before_delete(harness: _Harness, mode: AppMode) -> None:
+ source = harness.source
+ with source.factory.begin() as session:
+ session.execute(update(App).where(App.id == source.target.id).values(mode=mode))
+ response = harness.delete()
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ assert response.json is not None
+ assert response.json["code"] == "not_chat_app"
+ assert source.queries == []
+ harness.assert_not_deleted()
+ source.assert_closed()
+
+
+ ("failure", "code"), [("disabled_api", "app_api_disabled"), ("archived_workspace", "workspace_archived")]
+)
+def test_disabled_app_or_workspace_is_rejected_before_provisioning(harness: _Harness, failure: str, code: str) -> None:
+ source = harness.source
+ with source.factory.begin() as session:
+ if failure == "disabled_api":
+ session.execute(update(App).where(App.id == source.target.id).values(enable_api=False))
+ else:
+ session.execute(update(Tenant).where(Tenant.id == source.tenant.id).values(status=TenantStatus.ARCHIVE))
+ response = harness.delete(user="new-user")
+ assert response.status_code == HTTPStatus.FORBIDDEN
+ assert response.json is not None
+ assert response.json["code"] == code
+ assert source.provisions == source.queries == []
+ with source.factory() as session:
+ assert session.scalars(select(EndUser.id)).all() == [source.end_user.id]
+ harness.assert_not_deleted()
+ source.assert_closed()
+
+
[email protected]("multiple_apps", [False, True], ids=["implicit-single-app", "explicit-multiple-apps"])
+def test_resource_token_deletes_bound_app_and_records_usage(harness: _Harness, multiple_apps: bool) -> None:
+ source = harness.source
+ app_ids = (source.target.id,)
+ if multiple_apps:
+ other = make_app(app_id=str(uuid4()), tenant_id=source.tenant.id)
+ with source.factory.begin() as session:
+ session.add(other)
+ app_ids = (other.id, source.target.id)
+ services = source.app.extensions["application_services"]
+ assert isinstance(services, _Services)
+ token = services.resource_access_tokens.create(
+ RequestContext(
+ request_id="delete-resource-token",
+ trace_id=None,
+ account_id=str(uuid4()),
+ active_workspace_id=source.tenant.id,
+ ),
+ name="Delete app token",
+ resources=tuple(ResourceAccessTokenResource(ResourceAccessTokenResourceType.APP, app_id) for app_id in app_ids),
+ )
+
+ response = harness.delete(
+ authorization=f"Bearer {token.token}",
+ requested_app_id=source.target.id if multiple_apps else None,
+ )
+
+ assert response.status_code == HTTPStatus.NO_CONTENT
+ assert response.data == b""
+ assert harness.cleanups == [(source.tenant.id, source.conversation.id, ())]
+ source.assert_closed()
+ with source.factory() as session:
+ stored_token = session.get(ResourceAccessToken, token.token_id)
+ assert stored_token is not None
+ assert stored_token.last_used_at is not None
+ assert session.scalars(select(EndUser.id)).all() == [source.end_user.id]
+
+
+def test_failed_delete_commit_rolls_back_without_publishing_cleanup(harness: _Harness) -> None:
+ def reject_commit(_session: Session) -> None:
+ raise RuntimeError("Database commit failed")
+
+ source = harness.source
+ event.listen(source.repository_factory, "before_commit", reject_commit)
+ try:
+ response = harness.delete()
+ finally:
+ event.remove(source.repository_factory, "before_commit", reject_commit)
+ assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
+ harness.assert_not_deleted()
+ source.assert_closed()
diff --git a/api/tests/e2e_tests/contracts/controllers/service_api/app/test_conversation_rename.py b/api/tests/e2e_tests/contracts/controllers/service_api/app/test_conversation_rename.py
index 9aeb6c83968..e38470ef8c5 100644
--- a/api/tests/e2e_tests/contracts/controllers/service_api/app/test_conversation_rename.py
+++ b/api/tests/e2e_tests/contracts/controllers/service_api/app/test_conversation_rename.py
@@ -62,6 +62,8 @@ class _Harness:
end_user: EndUser
conversation: Conversation
factory: sessionmaker[Session]
+ repository_factory: sessionmaker[Session]
+ api: ExternalApi
provision_factory: sessionmaker[Session]
admissions: list[Session]
provisions: list[Session]
@@ -185,6 +187,8 @@ def harness(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]
end_user,
conversation,
sqlite_session_factory,
+ query_factory,
+ api,
provision_factory,
admissions,
provisions,
diff --git a/api/tests/e2e_tests/contracts/controllers/web/test_conversation_commands.py b/api/tests/e2e_tests/contracts/controllers/web/test_conversation_commands.py
new file mode 100644
index 00000000000..419f467045f
--- /dev/null
+++ b/api/tests/e2e_tests/contracts/controllers/web/test_conversation_commands.py
@@ -0,0 +1,257 @@
+"""Conversation commands through real Web admission and SQLite transactions."""
+
+from dataclasses import dataclass
+from http import HTTPStatus
+from typing import Literal
+from uuid import uuid4
+
+import pytest
+from sqlalchemy import event, select, update
+from sqlalchemy.orm import Session
+from werkzeug.test import TestResponse
+
+from constants import HEADER_NAME_APP_CODE, HEADER_NAME_PASSPORT
+from controllers.web.conversation import ConversationApi, ConversationPinApi, ConversationUnPinApi
+from models.agent import AgentWorkingResourceStatus, AgentWorkspace, AgentWorkspaceOwnerType
+from models.enums import ConversationFromSource, CreatorUserRole
+from models.model import AppMode, Conversation, EndUser
+from models.web import PinnedConversation
+from repositories.conversation_repository import ConversationRepository
+from services.conversation_command_service import ConversationCommandService
+from tests.e2e_tests.contracts.controllers.web import test_conversation_rename as rename_tests
+from tests.e2e_tests.contracts.controllers.web.test_conversation_rename import _Harness as RenameHarness
+
+rename_harness = rename_tests.harness
+
+
+@dataclass(frozen=True)
+class _Services:
+ conversation_commands: ConversationCommandService
+
+
+@dataclass(frozen=True)
+class _Harness:
+ source: RenameHarness
+ cleanups: list[tuple[str, str, tuple[str, ...]]]
+
+ def request(self, action: str, *, conversation_id: str | None = None) -> TestResponse:
+ path = f"/conversations/{conversation_id or self.source.conversation.id}"
+ return self.source.app.test_client().open(
+ path if action == "delete" else f"{path}/{action}",
+ method="DELETE" if action == "delete" else "PATCH",
+ headers={HEADER_NAME_APP_CODE: "public-app", HEADER_NAME_PASSPORT: self.source.passport},
+ )
+
+ def assert_not_deleted(self) -> None:
+ with self.source.factory() as session:
+ stored = session.get(Conversation, self.source.conversation.id)
+ assert stored is not None
+ assert not stored.is_deleted
+ assert self.cleanups == []
+
+
+def harness(rename_harness: RenameHarness) -> _Harness:
+ cleanups: list[tuple[str, str, tuple[str, ...]]] = []
+
+ def enqueue_cleanup(*, tenant_id: str, conversation_id: str, retired_workspace_ids: tuple[str, ...]) -> None:
+ # Observe the real external boundary: committed state must be visible on
+ # another connection, with neither admission nor command transactions open.
+ rename_harness.assert_closed()
+ with rename_harness.factory() as session:
+ stored = session.get(Conversation, conversation_id)
+ assert stored is not None
+ assert stored.is_deleted
+ for workspace_id in retired_workspace_ids:
+ workspace = session.get(AgentWorkspace, workspace_id)
+ assert workspace is not None
+ assert workspace.status == AgentWorkingResourceStatus.RETIRED
+ assert workspace.active_guard is None
+ assert workspace.retired_at is not None
+ cleanups.append((tenant_id, conversation_id, retired_workspace_ids))
+
+ rename_harness.app.extensions["application_services"] = _Services(
+ conversation_commands=ConversationCommandService(
+ conversations=ConversationRepository(session_factory=rename_harness.repository_factory),
+ enqueue_delete_cleanup=enqueue_cleanup,
+ )
+ )
+ rename_harness.api.add_resource(ConversationApi, "/conversations/<uuid:c_id>")
+ rename_harness.api.add_resource(ConversationPinApi, "/conversations/<uuid:c_id>/pin")
+ rename_harness.api.add_resource(ConversationUnPinApi, "/conversations/<uuid:c_id>/unpin")
+ return _Harness(rename_harness, cleanups)
+
+
[email protected]("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT])
+def test_delete_commits_retirement_before_cleanup_and_returns_empty_204(harness: _Harness, mode: AppMode) -> None:
+ source = harness.source
+ rename_tests._publish_mode(source, mode)
+ with source.factory.begin() as session:
+ workspace = AgentWorkspace(
+ id=str(uuid4()),
+ tenant_id=source.target.tenant_id,
+ app_id=source.target.id,
+ owner_type=AgentWorkspaceOwnerType.CONVERSATION,
+ owner_id=source.conversation.id,
+ owner_scope_key="chatflow-node",
+ backend_workspace_ref="backend-workspace",
+ status=AgentWorkingResourceStatus.ACTIVE,
+ active_guard=1,
+ )
+ session.add(workspace)
+
+ response = harness.request("delete")
+
+ assert response.status_code == HTTPStatus.NO_CONTENT
+ assert response.data == b""
+ assert response.headers["Content-Type"] == "application/json"
+ assert harness.cleanups == [(source.target.tenant_id, source.conversation.id, (workspace.id,))]
+ assert source.repository_sessions
+ source.assert_closed()
+
+ repeated = harness.request("delete")
+ assert repeated.status_code == HTTPStatus.NOT_FOUND
+ assert repeated.json is not None
+ assert repeated.json["code"] == "conversation_not_found"
+ assert len(harness.cleanups) == 1
+ source.assert_closed()
+
+
[email protected]("action", ["delete", "pin"])
[email protected]("field", ["app_id", "from_end_user_id", "from_source", "from_account_id", "is_deleted"])
+def test_commands_cannot_target_conversations_outside_end_user_scope(
+ harness: _Harness, action: str, field: str
+) -> None:
+ source = harness.source
+ value: str | bool
+ if field == "is_deleted":
+ value = True
+ elif field == "from_source":
+ value = ConversationFromSource.CONSOLE
+ elif field == "from_account_id":
+ # Account and EndUser IDs are independent namespaces, even if equal.
+ value = source.end_user.id
+ else:
+ value = str(uuid4())
+ with source.factory.begin() as session:
+ session.execute(update(Conversation).where(Conversation.id == source.conversation.id).values({field: value}))
+
+ response = harness.request(action)
+
+ assert response.status_code == HTTPStatus.NOT_FOUND
+ assert response.json is not None
+ assert response.json["code"] == "conversation_not_found"
+ assert harness.cleanups == []
+ with source.factory() as session:
+ stored = session.get(Conversation, source.conversation.id)
+ assert stored is not None
+ assert stored.is_deleted is (field == "is_deleted")
+ assert session.scalars(select(PinnedConversation)).all() == []
+ source.assert_closed()
+
+
[email protected]("action", ["delete", "pin", "unpin"])
[email protected]("field", ["tenant_id", "app_id"])
+def test_commands_reject_end_user_outside_app_owner_scope(
+ harness: _Harness, action: str, field: Literal["tenant_id", "app_id"]
+) -> None:
+ source = harness.source
+ with source.factory.begin() as session:
+ session.execute(update(EndUser).where(EndUser.id == source.end_user.id).values({field: str(uuid4())}))
+ response = harness.request(action)
+ assert response.status_code == HTTPStatus.NOT_FOUND
+ assert response.json is not None
+ assert response.json["code"] == "not_found"
+ harness.assert_not_deleted()
+ source.assert_closed()
+
+
+def test_pin_and_unpin_are_idempotent_and_isolate_actor_role(harness: _Harness) -> None:
+ source = harness.source
+ with source.factory.begin() as session:
+ other_pins = [
+ PinnedConversation(
+ app_id=source.target.id,
+ conversation_id=source.conversation.id,
+ created_by_role=role,
+ created_by=actor_id,
+ )
+ for role, actor_id in [
+ (CreatorUserRole.ACCOUNT, source.end_user.id),
+ (CreatorUserRole.END_USER, str(uuid4())),
+ ]
+ ]
+ session.add_all(other_pins)
+
+ for _ in range(2):
+ response = harness.request("pin")
+ assert response.status_code == HTTPStatus.OK
+ assert response.headers["Content-Type"] == "application/json"
+ assert response.json is not None
+ assert response.json == {"result": "success"}
+ source.assert_closed()
+ with source.factory() as session:
+ pins = session.scalars(select(PinnedConversation)).all()
+ own_pins = [
+ pin
+ for pin in pins
+ if pin.created_by_role == CreatorUserRole.END_USER and pin.created_by == source.end_user.id
+ ]
+ assert len(pins) == 3
+ assert len(own_pins) == 1
+ assert own_pins[0].app_id == source.target.id
+ assert own_pins[0].conversation_id == source.conversation.id
+
+ for _ in range(2):
+ response = harness.request("unpin")
+ assert response.status_code == HTTPStatus.OK
+ assert response.json is not None
+ assert response.json == {"result": "success"}
+ source.assert_closed()
+ with source.factory() as session:
+ assert set(session.scalars(select(PinnedConversation.id))) == {pin.id for pin in other_pins}
+ harness.assert_not_deleted()
+
+
[email protected]("action", ["delete", "pin", "unpin"])
+def test_unknown_conversation_preserves_existing_decoy(harness: _Harness, action: str) -> None:
+ response = harness.request(action, conversation_id=str(uuid4()))
+ if action == "unpin":
+ assert response.status_code == HTTPStatus.OK
+ assert response.json is not None
+ assert response.json == {"result": "success"}
+ else:
+ assert response.status_code == HTTPStatus.NOT_FOUND
+ assert response.json is not None
+ assert response.json["code"] == "conversation_not_found"
+ harness.assert_not_deleted()
+ harness.source.assert_closed()
+
+
[email protected]("action", ["delete", "pin", "unpin"])
[email protected]("mode", [AppMode.COMPLETION, AppMode.WORKFLOW])
+def test_non_chat_mode_is_rejected_before_command_transaction(harness: _Harness, action: str, mode: AppMode) -> None:
+ source = harness.source
+ rename_tests._publish_mode(source, mode)
+ response = harness.request(action)
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ assert response.json is not None
+ assert response.json["code"] == "not_chat_app"
+ assert source.repository_sessions == []
+ harness.assert_not_deleted()
+ source.assert_closed()
+
+
+def test_failed_delete_commit_rolls_back_without_publishing_cleanup(harness: _Harness) -> None:
+ def reject_commit(_session: Session) -> None:
+ raise RuntimeError("Database commit failed")
+
+ source = harness.source
+ event.listen(source.repository_factory, "before_commit", reject_commit)
+ try:
+ response = harness.request("delete")
+ finally:
+ event.remove(source.repository_factory, "before_commit", reject_commit)
+ assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
+ harness.assert_not_deleted()
+ source.assert_closed()
diff --git a/api/tests/e2e_tests/contracts/controllers/web/test_conversation_rename.py b/api/tests/e2e_tests/contracts/controllers/web/test_conversation_rename.py
index b8c01d6f258..fd097de70d0 100644
--- a/api/tests/e2e_tests/contracts/controllers/web/test_conversation_rename.py
+++ b/api/tests/e2e_tests/contracts/controllers/web/test_conversation_rename.py
@@ -57,6 +57,8 @@ class _Harness:
end_user: EndUser
conversation: Conversation
factory: sessionmaker[Session]
+ repository_factory: sessionmaker[Session]
+ api: ExternalApi
passport: str
admission_sessions: list[Session]
repository_sessions: list[Session]
@@ -166,6 +168,8 @@ def harness(
end_user,
conversation,
sqlite_session_factory,
+ repository_factory,
+ api,
passport,
admission_sessions,
repository_sessions,
diff --git a/api/tests/unit_tests/controllers/console/explore/test_conversation.py b/api/tests/unit_tests/controllers/console/explore/test_conversation.py
index 5f2f5802183..948bcc984ec 100644
--- a/api/tests/unit_tests/controllers/console/explore/test_conversation.py
+++ b/api/tests/unit_tests/controllers/console/explore/test_conversation.py
@@ -19,6 +19,7 @@ from models.enums import InvokeFrom as ModelInvokeFrom
from models.model import App, AppMode, Conversation, Message
from models.web import PinnedConversation
from repositories.conversation_repository import ConversationRepository
+from services.conversation_command_service import ConversationCommandService
from services.conversation_name_service import ConversationNameService
from services.installed_app_conversation_service import InstalledAppConversationService
from tests.unit_tests.controllers.console.explore.test_installed_app_admission import (
@@ -122,7 +123,10 @@ def conversations(
names=ConversationNameService(
conversations=ConversationRepository(session_factory=factory), generate_name=state.generate_name
),
- enqueue_delete_cleanup=state.enqueue_cleanup,
+ commands=ConversationCommandService(
+ conversations=ConversationRepository(session_factory=factory),
+ enqueue_delete_cleanup=state.enqueue_cleanup,
+ ),
)
)
)
diff --git a/api/tests/unit_tests/controllers/service_api/app/test_conversation.py b/api/tests/unit_tests/controllers/service_api/app/test_conversation.py
index 3f767872a02..08825d53d45 100644
--- a/api/tests/unit_tests/controllers/service_api/app/test_conversation.py
+++ b/api/tests/unit_tests/controllers/service_api/app/test_conversation.py
@@ -16,7 +16,6 @@ import services
from controllers.console.explore.conversation import ConversationRenamePayload as ConsolePayload
from controllers.service_api.app.conversation import (
ConversationApi,
- ConversationDetailApi,
ConversationListQuery,
ConversationRenamePayload,
ConversationVariableDetailApi,
@@ -595,43 +594,6 @@ class TestConversationCases:
end_user=end_user,
)
- class TestConversationDetailApiController:
- def test_delete_not_chat(self, app: Flask) -> None:
- api = ConversationDetailApi()
- handler = unwrap(api.delete)
- app_model = _app(mode=AppMode.COMPLETION)
- end_user = _end_user()
-
- with app.test_request_context("/conversations/1", method="DELETE"):
- with pytest.raises(NotChatAppError):
- handler(
- api,
- app_model=app_model,
- end_user=end_user,
- conversation_id="00000000-0000-0000-0000-000000000001",
- )
-
- def test_delete_not_found(self, app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
- monkeypatch.setattr(
- ConversationService,
- "delete",
- lambda *_args, **_kwargs: (_ for _ in ()).throw(ConversationNotExistsError()),
- )
-
- api = ConversationDetailApi()
- handler = unwrap(api.delete)
- app_model = _app()
- end_user = _end_user()
-
- with app.test_request_context("/conversations/1", method="DELETE"):
- with pytest.raises(NotFound):
- handler(
- api,
- app_model=app_model,
- end_user=end_user,
- conversation_id="00000000-0000-0000-0000-000000000001",
- )
-
class TestConversationVariablesApiController:
def test_not_chat(self, app: Flask) -> None:
api = ConversationVariablesApi()
diff --git a/api/tests/unit_tests/repositories/test_conversation_repository.py b/api/tests/unit_tests/repositories/test_conversation_repository.py
index 734635e6545..80c4be6f6e5 100644
--- a/api/tests/unit_tests/repositories/test_conversation_repository.py
+++ b/api/tests/unit_tests/repositories/test_conversation_repository.py
@@ -246,10 +246,17 @@ def test_every_conversation_ownership_predicate_protects_reads_and_mutations(
updated_at=_TIME,
)
with pytest.raises(ConversationNotExistsError):
- repository.delete(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation_id)
+ repository.delete(
+ ref=InstalledAppConversationRef(
+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation_id
+ )
+ )
with pytest.raises(ConversationNotExistsError):
repository.set_pinned(
- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation_id, is_pinned=True
+ ref=InstalledAppConversationRef(
+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation_id
+ ),
+ is_pinned=True,
)
with sqlite_session_factory() as session:
stored = session.get(Conversation, conversation_id)
@@ -294,11 +301,18 @@ def test_all_operations_revalidate_complete_installation_and_actual_app(
updated_at=_TIME,
)
with pytest.raises(InstalledAppNotFoundError):
- repository.delete(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id)
+ repository.delete(
+ ref=InstalledAppConversationRef(
+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id
+ )
+ )
for is_pinned in (True, False):
with pytest.raises(InstalledAppNotFoundError):
repository.set_pinned(
- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id, is_pinned=is_pinned
+ ref=InstalledAppConversationRef(
+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id
+ ),
+ is_pinned=is_pinned,
)
@@ -394,17 +408,26 @@ def test_pin_and_unpin_are_idempotent_and_preserve_other_owners(
repository = ConversationRepository(session_factory=sqlite_session_factory)
for _ in range(2):
repository.set_pinned(
- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id, is_pinned=True
+ ref=InstalledAppConversationRef(
+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id
+ ),
+ is_pinned=True,
)
with sqlite_session_factory() as session:
assert len(session.scalars(select(PinnedConversation)).all()) == 4
for _ in range(2):
repository.set_pinned(
- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id, is_pinned=False
+ ref=InstalledAppConversationRef(
+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id
+ ),
+ is_pinned=False,
)
repository.set_pinned(
- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=str(uuid4()), is_pinned=False
+ ref=InstalledAppConversationRef(
+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=str(uuid4())
+ ),
+ is_pinned=False,
)
with sqlite_session_factory() as session:
remaining = session.scalars(select(PinnedConversation)).all()
@@ -425,10 +448,12 @@ def test_existing_pin_and_unpin_do_not_require_live_conversation(
_pin(session, installation, missing_id)
repository = ConversationRepository(session_factory=sqlite_session_factory)
repository.set_pinned(
- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=missing_id, is_pinned=True
+ ref=InstalledAppConversationRef(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=missing_id),
+ is_pinned=True,
)
repository.set_pinned(
- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=missing_id, is_pinned=False
+ ref=InstalledAppConversationRef(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=missing_id),
+ is_pinned=False,
)
with sqlite_session_factory() as session:
assert session.scalars(select(PinnedConversation)).all() == []
@@ -456,7 +481,11 @@ def test_delete_commits_soft_deletion_and_returns_owner_tenant_for_cleanup(
]
session.add_all(workspaces)
repository = ConversationRepository(session_factory=sqlite_session_factory)
- deleted = repository.delete(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id)
+ deleted = repository.delete(
+ ref=InstalledAppConversationRef(
+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id
+ )
+ )
assert deleted.tenant_id == _OWNER_TENANT_ID
assert deleted.conversation_id == conversation.id
@@ -472,7 +501,11 @@ def test_delete_commits_soft_deletion_and_returns_owner_tenant_for_cleanup(
assert stored_workspace.retired_at is not None
assert stored_workspace.active_guard is None
with pytest.raises(ConversationNotExistsError):
- repository.delete(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id)
+ repository.delete(
+ ref=InstalledAppConversationRef(
+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id
+ )
+ )
@pytest.mark.parametrize("operation", ["rename", "delete", "pin"])
@@ -503,10 +536,17 @@ def test_failed_commit_rolls_back_mutations_and_propagates_original_error(
updated_at=_TIME + timedelta(hours=1),
)
elif operation == "delete":
- repository.delete(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id)
+ repository.delete(
+ ref=InstalledAppConversationRef(
+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id
+ )
+ )
else:
repository.set_pinned(
- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id, is_pinned=True
+ ref=InstalledAppConversationRef(
+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id
+ ),
+ is_pinned=True,
)
with pytest.raises(RuntimeError) as error:
@@ -574,5 +614,9 @@ def test_end_user_and_installed_account_refs_never_cross_owner_domains(
repository.get_name_source(ref=foreign_ref)
with pytest.raises(ConversationNotExistsError):
repository.rename(ref=foreign_ref, name="Forbidden", updated_at=_TIME)
+ with pytest.raises(ConversationNotExistsError):
+ repository.delete(ref=foreign_ref)
+ with pytest.raises(ConversationNotExistsError):
+ repository.set_pinned(ref=foreign_ref, is_pinned=True)
assert repository.get(ref=account_ref).name == "Original name"
assert repository.get(ref=end_user_ref).name == "End-user conversation"
diff --git a/api/tests/unit_tests/services/test_conversation_command_service.py b/api/tests/unit_tests/services/test_conversation_command_service.py
new file mode 100644
index 00000000000..0c0bd3cf393
--- /dev/null
+++ b/api/tests/unit_tests/services/test_conversation_command_service.py
@@ -0,0 +1,287 @@
+"""Conversation commands exercise persistence, ownership and cleanup ordering."""
+
+from dataclasses import replace
+from uuid import uuid4
+
+import pytest
+from sqlalchemy import Engine, delete, event, select, update
+from sqlalchemy.orm import Session, sessionmaker
+
+from models.agent import AgentWorkingResourceStatus, AgentWorkspace, AgentWorkspaceOwnerType
+from models.enums import ConversationFromSource, CreatorUserRole, EndUserType
+from models.model import App, AppMode, Conversation, EndUser
+from models.web import PinnedConversation
+from repositories.conversation_repository import ConversationRepository
+from services.conversation_command_service import ConversationCleanup, ConversationCommandService
+from services.entities.conversation_entities import EndUserConversationRef
+from services.errors.conversation import ConversationNotExistsError
+
+
+def end_user_ref(sqlite_session_factory: sessionmaker[Session]) -> EndUserConversationRef:
+ with sqlite_session_factory.begin() as session:
+ app = App(tenant_id=str(uuid4()), name="Chat", mode=AppMode.CHAT, enable_site=True, enable_api=True)
+ session.add(app)
+ session.flush()
+ end_user = EndUser(
+ tenant_id=app.tenant_id,
+ app_id=app.id,
+ type=EndUserType.BROWSER,
+ session_id=str(uuid4()),
+ )
+ session.add(end_user)
+ session.flush()
+ conversation = Conversation(
+ app_id=app.id,
+ mode=AppMode.CHAT,
+ name="Original",
+ _inputs={},
+ from_source=ConversationFromSource.API,
+ from_end_user_id=end_user.id,
+ from_account_id=None,
+ is_deleted=False,
+ )
+ session.add(conversation)
+ session.flush()
+ return EndUserConversationRef(
+ app_id=app.id,
+ tenant_id=app.tenant_id,
+ end_user_id=end_user.id,
+ conversation_id=conversation.id,
+ )
+
+
+def _unexpected_cleanup(**_kwargs: object) -> None:
+ raise AssertionError("No cleanup should be dispatched")
+
+
+def _service(
+ factory: sessionmaker[Session], *, cleanup: ConversationCleanup = _unexpected_cleanup
+) -> ConversationCommandService:
+ return ConversationCommandService(
+ conversations=ConversationRepository(session_factory=factory), enqueue_delete_cleanup=cleanup
+ )
+
+
+def test_delete_commits_and_returns_connection_before_dispatching_workspace_cleanup(
+ sqlite_session_factory: sessionmaker[Session], sqlite_engine: Engine, end_user_ref: EndUserConversationRef
+) -> None:
+ with sqlite_session_factory.begin() as session:
+ workspace = AgentWorkspace(
+ id=str(uuid4()),
+ tenant_id=end_user_ref.tenant_id,
+ app_id=end_user_ref.app_id,
+ owner_type=AgentWorkspaceOwnerType.CONVERSATION,
+ owner_id=end_user_ref.conversation_id,
+ owner_scope_key="conversation-binding",
+ backend_workspace_ref="backend-workspace",
+ status=AgentWorkingResourceStatus.ACTIVE,
+ active_guard=1,
+ )
+ session.add(workspace)
+ events: list[str] = []
+
+ @event.listens_for(sqlite_engine, "checkout")
+ def checkout(_connection: object, _record: object, _proxy: object) -> None:
+ events.append("checkout")
+
+ @event.listens_for(sqlite_engine, "checkin")
+ def checkin(_connection: object, _record: object) -> None:
+ events.append("checkin")
+
+ def cleanup(*, tenant_id: str, conversation_id: str, retired_workspace_ids: tuple[str, ...]) -> None:
+ assert events == ["checkout", "checkin"]
+ assert (tenant_id, conversation_id) == (end_user_ref.tenant_id, end_user_ref.conversation_id)
+ assert retired_workspace_ids == (workspace.id,)
+ events.append("cleanup")
+ with sqlite_session_factory() as session:
+ assert session.scalar(select(Conversation.is_deleted).where(Conversation.id == conversation_id)) is True
+ stored_workspace = session.get(AgentWorkspace, workspace.id)
+ assert stored_workspace is not None
+ assert stored_workspace.status == AgentWorkingResourceStatus.RETIRED
+ assert stored_workspace.active_guard is None
+ assert stored_workspace.retired_at is not None
+
+ service = _service(sqlite_session_factory, cleanup=cleanup)
+ service.delete(ref=end_user_ref)
+ assert events == ["checkout", "checkin", "cleanup", "checkout", "checkin"]
+ with pytest.raises(ConversationNotExistsError):
+ service.delete(ref=end_user_ref)
+ assert events.count("cleanup") == 1
+
+
+def test_failed_delete_commit_preserves_conversation_and_workspace_without_cleanup(
+ sqlite_session_factory: sessionmaker[Session], sqlite_engine: Engine, end_user_ref: EndUserConversationRef
+) -> None:
+ with sqlite_session_factory.begin() as session:
+ workspace = AgentWorkspace(
+ id=str(uuid4()),
+ tenant_id=end_user_ref.tenant_id,
+ app_id=end_user_ref.app_id,
+ owner_type=AgentWorkspaceOwnerType.CONVERSATION,
+ owner_id=end_user_ref.conversation_id,
+ owner_scope_key="conversation-binding",
+ backend_workspace_ref="backend-workspace",
+ status=AgentWorkingResourceStatus.ACTIVE,
+ active_guard=1,
+ )
+ session.add(workspace)
+ factory = sessionmaker(bind=sqlite_engine)
+ failure = RuntimeError("Database commit failed")
+
+ @event.listens_for(factory, "before_commit")
+ def fail_commit(_session: Session) -> None:
+ raise failure
+
+ with pytest.raises(RuntimeError) as error:
+ _service(factory).delete(ref=end_user_ref)
+ assert error.value is failure
+ with sqlite_session_factory() as session:
+ assert (
+ session.scalar(select(Conversation.is_deleted).where(Conversation.id == end_user_ref.conversation_id))
+ is False
+ )
+ stored_workspace = session.get(AgentWorkspace, workspace.id)
+ assert stored_workspace is not None
+ assert stored_workspace.status == AgentWorkingResourceStatus.ACTIVE
+ assert stored_workspace.active_guard == 1
+ assert stored_workspace.retired_at is None
+
+
[email protected]("operation", ["delete", "pin"])
+ "mismatch", ["app_id", "from_source", "from_account_id", "from_end_user_id", "is_deleted", "missing"]
+)
+def test_end_user_commands_reject_every_conversation_owner_mismatch(
+ sqlite_session_factory: sessionmaker[Session],
+ end_user_ref: EndUserConversationRef,
+ operation: str,
+ mismatch: str,
+) -> None:
+ with sqlite_session_factory.begin() as session:
+ if mismatch == "missing":
+ session.execute(delete(Conversation).where(Conversation.id == end_user_ref.conversation_id))
+ else:
+ value: str | bool = True if mismatch == "is_deleted" else str(uuid4())
+ if mismatch == "from_source":
+ value = ConversationFromSource.CONSOLE
+ session.execute(
+ update(Conversation).where(Conversation.id == end_user_ref.conversation_id).values({mismatch: value})
+ )
+ service = _service(sqlite_session_factory)
+ if operation == "delete":
+ with pytest.raises(ConversationNotExistsError):
+ service.delete(ref=end_user_ref)
+ else:
+ with pytest.raises(ConversationNotExistsError):
+ service.set_pinned(ref=end_user_ref, is_pinned=True)
+ with sqlite_session_factory() as session:
+ assert session.scalars(select(PinnedConversation)).all() == []
+ stored = session.get(Conversation, end_user_ref.conversation_id)
+ if mismatch == "missing":
+ assert stored is None
+ else:
+ assert stored is not None
+ assert stored.is_deleted is (mismatch == "is_deleted")
+
+
[email protected]("operation", ["delete", "pin", "unpin"])
+ "mismatch", ["app_tenant", "end_user_tenant", "end_user_app", "app_missing", "end_user_missing"]
+)
+def test_end_user_commands_revalidate_app_and_end_user_owner_chain(
+ sqlite_session_factory: sessionmaker[Session],
+ end_user_ref: EndUserConversationRef,
+ operation: str,
+ mismatch: str,
+) -> None:
+ with sqlite_session_factory.begin() as session:
+ pin = PinnedConversation(
+ app_id=end_user_ref.app_id,
+ conversation_id=end_user_ref.conversation_id,
+ created_by_role=CreatorUserRole.END_USER,
+ created_by=end_user_ref.end_user_id,
+ )
+ session.add(pin)
+ if mismatch == "app_tenant":
+ session.execute(update(App).where(App.id == end_user_ref.app_id).values(tenant_id=str(uuid4())))
+ elif mismatch == "end_user_tenant":
+ session.execute(
+ update(EndUser).where(EndUser.id == end_user_ref.end_user_id).values(tenant_id=str(uuid4()))
+ )
+ elif mismatch == "end_user_app":
+ session.execute(update(EndUser).where(EndUser.id == end_user_ref.end_user_id).values(app_id=str(uuid4())))
+ elif mismatch == "app_missing":
+ session.execute(delete(App).where(App.id == end_user_ref.app_id))
+ else:
+ session.execute(delete(EndUser).where(EndUser.id == end_user_ref.end_user_id))
+ service = _service(sqlite_session_factory)
+ if operation == "delete":
+ with pytest.raises(ConversationNotExistsError):
+ service.delete(ref=end_user_ref)
+ else:
+ with pytest.raises(ConversationNotExistsError):
+ service.set_pinned(ref=end_user_ref, is_pinned=operation == "pin")
+ with sqlite_session_factory() as session:
+ assert (
+ session.scalar(select(Conversation.is_deleted).where(Conversation.id == end_user_ref.conversation_id))
+ is False
+ )
+ assert session.get(PinnedConversation, pin.id) is not None
+
+
+def test_end_user_pin_and_unpin_are_idempotent_and_preserve_other_roles_and_owners(
+ sqlite_session_factory: sessionmaker[Session], end_user_ref: EndUserConversationRef
+) -> None:
+ with sqlite_session_factory.begin() as session:
+ other_pins = [
+ PinnedConversation(
+ app_id=app_id,
+ conversation_id=end_user_ref.conversation_id,
+ created_by_role=role,
+ created_by=actor_id,
+ )
+ for app_id, role, actor_id in [
+ (end_user_ref.app_id, CreatorUserRole.ACCOUNT, end_user_ref.end_user_id),
+ (end_user_ref.app_id, CreatorUserRole.END_USER, str(uuid4())),
+ (str(uuid4()), CreatorUserRole.END_USER, end_user_ref.end_user_id),
+ ]
+ ]
+ session.add_all(other_pins)
+ service = _service(sqlite_session_factory)
+ for _ in range(2):
+ service.set_pinned(ref=end_user_ref, is_pinned=True)
+ with sqlite_session_factory() as session:
+ assert len(session.scalars(select(PinnedConversation)).all()) == 4
+ for _ in range(2):
+ service.set_pinned(ref=end_user_ref, is_pinned=False)
+ service.set_pinned(ref=replace(end_user_ref, conversation_id=str(uuid4())), is_pinned=False)
+ with sqlite_session_factory() as session:
+ assert {pin.id for pin in session.scalars(select(PinnedConversation))} == {pin.id for pin in other_pins}
+
+
[email protected]("state", ["deleted", "missing"])
+def test_end_user_existing_pin_and_unpin_do_not_require_live_conversation(
+ sqlite_session_factory: sessionmaker[Session], end_user_ref: EndUserConversationRef, state: str
+) -> None:
+ with sqlite_session_factory.begin() as session:
+ session.add(
+ PinnedConversation(
+ app_id=end_user_ref.app_id,
+ conversation_id=end_user_ref.conversation_id,
+ created_by_role=CreatorUserRole.END_USER,
+ created_by=end_user_ref.end_user_id,
+ )
+ )
+ if state == "deleted":
+ session.execute(
+ update(Conversation).where(Conversation.id == end_user_ref.conversation_id).values(is_deleted=True)
+ )
+ else:
+ session.execute(delete(Conversation).where(Conversation.id == end_user_ref.conversation_id))
+ service = _service(sqlite_session_factory)
+ service.set_pinned(ref=end_user_ref, is_pinned=True)
+ service.set_pinned(ref=end_user_ref, is_pinned=False)
+ service.set_pinned(ref=end_user_ref, is_pinned=False)
+ with sqlite_session_factory() as session:
+ assert session.scalars(select(PinnedConversation)).all() == []
diff --git a/api/tests/unit_tests/services/test_installed_app_conversation_service.py b/api/tests/unit_tests/services/test_installed_app_conversation_service.py
index 7b91472f902..f5010633dad 100644
--- a/api/tests/unit_tests/services/test_installed_app_conversation_service.py
+++ b/api/tests/unit_tests/services/test_installed_app_conversation_service.py
@@ -12,6 +12,7 @@ from sqlalchemy.orm import Session, sessionmaker
from models.enums import ConversationFromSource
from models.model import App, AppMode, Conversation, InstalledApp, Message
from repositories.conversation_repository import ConversationRepository
+from services.conversation_command_service import ConversationCleanup, ConversationCommandService
from services.conversation_name_service import (
ConversationNameGenerator,
ConversationNameRequiredError,
@@ -21,7 +22,6 @@ from services.entities.conversation_entities import InstalledAppConversationRef
from services.errors.conversation import ConversationNotExistsError
from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppRef
from services.installed_app_conversation_service import (
- ConversationCleanup,
ConversationNotChatAppError,
InstalledAppConversationService,
)
@@ -97,7 +97,7 @@ def _service(
return InstalledAppConversationService(
conversations=repository,
names=ConversationNameService(conversations=repository, generate_name=generate_name),
- enqueue_delete_cleanup=cleanup,
+ commands=ConversationCommandService(conversations=repository, enqueue_delete_cleanup=cleanup),
)
diff --git a/packages/contracts/generated/api/service/errors.gen.ts b/packages/contracts/generated/api/service/errors.gen.ts
index ef467e76f6f..6a63831bf55 100644
--- a/packages/contracts/generated/api/service/errors.gen.ts
+++ b/packages/contracts/generated/api/service/errors.gen.ts
@@ -565,7 +565,16 @@ export const put2Errors = { not_chat_app: { status: 400, data: zNotChatAppError
export const get5Errors = { not_chat_app: { status: 400, data: zNotChatAppError } }
-export const delete2Errors = { not_chat_app: { status: 400, data: zNotChatAppError } }
+export const delete2Errors = {
+ app_abnormal_status: { status: 403, data: zAppAbnormalStatusError },
+ app_api_disabled: { status: 403, data: zAppApiDisabledError },
+ app_not_found: { status: 403, data: zAppNotFoundError },
+ conversation_not_found: { status: 404, data: zConversationNotFoundError },
+ forbidden: { status: 403, data: zForbiddenError },
+ not_chat_app: { status: 400, data: zNotChatAppError },
+ workspace_archived: { status: 403, data: zWorkspaceArchivedError },
+ workspace_not_found: { status: 403, data: zWorkspaceNotFoundError },
+}
export const get6Errors = { not_chat_app: { status: 400, data: zNotChatAppError } }
diff --git a/packages/contracts/generated/api/service/orpc.gen.ts b/packages/contracts/generated/api/service/orpc.gen.ts
index 512754c6fa6..aaf85135abb 100644
--- a/packages/contracts/generated/api/service/orpc.gen.ts
+++ b/packages/contracts/generated/api/service/orpc.gen.ts
@@ -1016,7 +1016,16 @@ export const delete2 = oc
}),
)
.output(zDeleteConversationsByConversationIdResponse)
- .errors({ not_chat_app: { status: 400, data: zNotChatAppError } })
+ .errors({
+ app_abnormal_status: { status: 403, data: zAppAbnormalStatusError },
+ app_api_disabled: { status: 403, data: zAppApiDisabledError },
+ app_not_found: { status: 403, data: zAppNotFoundError },
+ conversation_not_found: { status: 404, data: zConversationNotFoundError },
+ forbidden: { status: 403, data: zForbiddenError },
+ not_chat_app: { status: 400, data: zNotChatAppError },
+ workspace_archived: { status: 403, data: zWorkspaceArchivedError },
+ workspace_not_found: { status: 403, data: zWorkspaceNotFoundError },
+ })
export const byConversationId = {
delete: delete2,
diff --git a/packages/contracts/generated/api/service/types.gen.ts b/packages/contracts/generated/api/service/types.gen.ts
index f9c583dee3f..d375781fdc9 100644
--- a/packages/contracts/generated/api/service/types.gen.ts
+++ b/packages/contracts/generated/api/service/types.gen.ts
@@ -5008,8 +5008,15 @@ export type DeleteConversationsByConversationIdData = {
export type DeleteConversationsByConversationIdErrors = {
400: NotChatAppError | ErrorResponse
401: ErrorResponse
- 403: ErrorResponse
- 404: ErrorResponse
+ 403:
+ | AppAbnormalStatusError
+ | AppApiDisabledError
+ | AppNotFoundError
+ | ForbiddenError
+ | WorkspaceArchivedError
+ | WorkspaceNotFoundError
+ | ErrorResponse
+ 404: ConversationNotFoundError | ErrorResponse
default: ErrorResponse
}
diff --git a/packages/contracts/generated/api/web/errors.gen.ts b/packages/contracts/generated/api/web/errors.gen.ts
index 1b4ffd442d8..7648c520cd0 100644
--- a/packages/contracts/generated/api/web/errors.gen.ts
+++ b/packages/contracts/generated/api/web/errors.gen.ts
@@ -464,11 +464,20 @@ export const post6Errors = {
not_chat_app: { status: 400, data: zNotChatAppError },
}
-export const patchErrors = { not_chat_app: { status: 400, data: zNotChatAppError } }
+export const patchErrors = {
+ conversation_not_found: { status: 404, data: zConversationNotFoundError },
+ not_chat_app: { status: 400, data: zNotChatAppError },
+}
-export const patch2Errors = { not_chat_app: { status: 400, data: zNotChatAppError } }
+export const patch2Errors = {
+ conversation_not_found: { status: 404, data: zConversationNotFoundError },
+ not_chat_app: { status: 400, data: zNotChatAppError },
+}
-export const delete_Errors = { not_chat_app: { status: 400, data: zNotChatAppError } }
+export const delete_Errors = {
+ conversation_not_found: { status: 404, data: zConversationNotFoundError },
+ not_chat_app: { status: 400, data: zNotChatAppError },
+}
export const getErrors = { not_chat_app: { status: 400, data: zNotChatAppError } }
diff --git a/packages/contracts/generated/api/web/orpc.gen.ts b/packages/contracts/generated/api/web/orpc.gen.ts
index e2f99672747..be955cc6272 100644
--- a/packages/contracts/generated/api/web/orpc.gen.ts
+++ b/packages/contracts/generated/api/web/orpc.gen.ts
@@ -332,18 +332,22 @@ export const patch = oc
})
.input(z.object({ params: zPatchConversationsByCIdPinPath }))
.output(zPatchConversationsByCIdPinResponse)
- .errors({ not_chat_app: { status: 400, data: zNotChatAppError } })
+ .errors({
+ conversation_not_found: { status: 404, data: zConversationNotFoundError },
+ not_chat_app: { status: 400, data: zNotChatAppError },
+ })
export const pin = {
patch,
}
/**
- * Unpin a specific conversation to remove it from the top of the list.
+ * Remove the current user's pin. Succeeds when the conversation is already unpinned.
*/
export const patch2 = oc
.route({
- description: 'Unpin a specific conversation to remove it from the top of the list.',
+ description:
+ "Remove the current user's pin. Succeeds when the conversation is already unpinned.",
inputStructure: 'detailed',
method: 'PATCH',
operationId: 'patchConversationsByCIdUnpin',
@@ -352,7 +356,10 @@ export const patch2 = oc
})
.input(z.object({ params: zPatchConversationsByCIdUnpinPath }))
.output(zPatchConversationsByCIdUnpinResponse)
- .errors({ not_chat_app: { status: 400, data: zNotChatAppError } })
+ .errors({
+ conversation_not_found: { status: 404, data: zConversationNotFoundError },
+ not_chat_app: { status: 400, data: zNotChatAppError },
+ })
export const unpin = {
patch: patch2,
@@ -373,7 +380,10 @@ export const delete_ = oc
})
.input(z.object({ params: zDeleteConversationsByCIdPath }))
.output(zDeleteConversationsByCIdResponse)
- .errors({ not_chat_app: { status: 400, data: zNotChatAppError } })
+ .errors({
+ conversation_not_found: { status: 404, data: zConversationNotFoundError },
+ not_chat_app: { status: 400, data: zNotChatAppError },
+ })
export const byCId = {
delete: delete_,
diff --git a/packages/contracts/generated/api/web/types.gen.ts b/packages/contracts/generated/api/web/types.gen.ts
index 365b170ae5f..bd8492280c7 100644
--- a/packages/contracts/generated/api/web/types.gen.ts
+++ b/packages/contracts/generated/api/web/types.gen.ts
@@ -1519,7 +1519,7 @@ export type DeleteConversationsByCIdData = {
export type DeleteConversationsByCIdErrors = {
400: NotChatAppError | ErrorResponse
401: ErrorResponse
- 404: ErrorResponse
+ 404: ConversationNotFoundError | ErrorResponse
500: ErrorResponse
default: ErrorResponse
}
@@ -1577,7 +1577,7 @@ export type PatchConversationsByCIdPinData = {
export type PatchConversationsByCIdPinErrors = {
400: NotChatAppError | ErrorResponse
401: ErrorResponse
- 404: ErrorResponse
+ 404: ConversationNotFoundError | ErrorResponse
500: ErrorResponse
default: ErrorResponse
}
@@ -1604,7 +1604,7 @@ export type PatchConversationsByCIdUnpinData = {
export type PatchConversationsByCIdUnpinErrors = {
400: NotChatAppError | ErrorResponse
401: ErrorResponse
- 404: ErrorResponse
+ 404: ConversationNotFoundError | ErrorResponse
500: ErrorResponse
default: ErrorResponse
}