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.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
refactor(api): isolate trigger subscription management (#44541)
非法操作803f5d3d9cc9
diff --git a/api/.importlinter b/api/.importlinterindex 90df3674e1f..7a75529eb9b 100644--- a/api/.importlinter+++ b/api/.importlinter@@ -1436,6 +1436,7 @@ source_modules =services.trigger.oauth_serviceservices.trigger.provider_queryservices.trigger.subscription_query_service+ services.trigger.subscription_serviceforbidden_modules =controllersextensions@@ -1457,3 +1458,27 @@ forbidden_modules =sqlalchemyservices.trigger.trigger_provider_serviceallow_indirect_imports = True++[importlinter:contract:trigger-subscription-encryption-boundary]+name = Trigger subscription commands depend on the encryption port+type = forbidden+source_modules =+ services.trigger.subscription_service+forbidden_modules =+ core.helper.provider_cache+ core.helper.provider_encryption+ core.helper.encrypter+ services.trigger.subscription_codec+allow_indirect_imports = True++[importlinter:contract:trigger-subscription-controller-persistence-boundary]+name = Trigger subscription controllers reach persistence through application services+type = forbidden+source_modules =+ controllers.console.workspace.trigger_providers+forbidden_modules =+ repositories+ sqlalchemy+ core.db+ models.engine+allow_indirect_imports = Truediff --git a/api/controllers/console/workspace/error.py b/api/controllers/console/workspace/error.pyindex fd7e777ff11..84bfc64a652 100644--- a/api/controllers/console/workspace/error.py+++ b/api/controllers/console/workspace/error.py@@ -27,6 +27,42 @@ class TriggerOAuthClientChangedError(BaseHTTPException):description = "The trigger OAuth client configuration changed. Reload it before saving again."+class TriggerSubscriptionNotFoundError(BaseHTTPException):+ error_code = "trigger_subscription_not_found"+ code = HTTPStatus.NOT_FOUND+ description = "The trigger subscription does not exist in this workspace and provider."+++class TriggerSubscriptionNameConflictError(BaseHTTPException):+ error_code = "trigger_subscription_name_conflict"+ code = HTTPStatus.CONFLICT+ description = "A trigger subscription with this name already exists for the provider."+++class TriggerSubscriptionChangedError(BaseHTTPException):+ error_code = "trigger_subscription_changed"+ code = HTTPStatus.CONFLICT+ description = "The trigger subscription changed. Reload it before trying again."+++class TriggerSubscriptionLimitError(BaseHTTPException):+ error_code = "trigger_subscription_limit_reached"+ code = HTTPStatus.BAD_REQUEST+ description = "The maximum number of trigger subscriptions for this provider has been reached."+++class TriggerSubscriptionProviderError(BaseHTTPException):+ error_code = "trigger_subscription_provider_error"+ code = HTTPStatus.BAD_GATEWAY+ description = "The trigger provider could not complete the subscription operation."+++class TriggerSubscriptionInvalidError(BaseHTTPException):+ error_code = "trigger_subscription_invalid"+ code = HTTPStatus.BAD_REQUEST+ description = "The trigger subscription configuration or credentials are invalid."++class CurrentWorkspaceArchivedError(BaseHTTPException):error_code = "current_workspace_archived"description = "The current workspace has been archived."diff --git a/api/controllers/console/workspace/trigger_providers.py b/api/controllers/console/workspace/trigger_providers.pyindex 15db2094adf..10f5909e6d7 100644--- a/api/controllers/console/workspace/trigger_providers.py+++ b/api/controllers/console/workspace/trigger_providers.py@@ -1,13 +1,11 @@import loggingfrom http import HTTPStatus-from typing import Any+from typing import Any, NoReturn, Selffrom flask import make_response, redirect, requestfrom flask_restx import Resourcefrom pydantic import BaseModel, RootModel, model_validator-from sqlalchemy.orm import sessionmakerfrom werkzeug import Response-from werkzeug.exceptions import BadRequestfrom configs import dify_configfrom controllers.common.errors import ForbiddenError, NotFoundError@@ -21,17 +19,17 @@ from controllers.console.workspace.error import (TriggerOAuthClientConfigInvalidError,TriggerOAuthContextInvalidError,TriggerOAuthProviderRequestError,+ TriggerSubscriptionChangedError,+ TriggerSubscriptionInvalidError,+ TriggerSubscriptionLimitError,+ TriggerSubscriptionNameConflictError,+ TriggerSubscriptionNotFoundError,+ TriggerSubscriptionProviderError,)from controllers.console.wraps import (RBACPermission,- account_initialization_required,- edit_permission_required,- is_admin_or_owner_required,model_validate,- rbac_permission_required,setup_required,- with_current_tenant_id,- with_current_user,)from core.entities.provider_entities import ProviderConfigfrom core.plugin.entities.plugin_daemon import CredentialType@@ -43,13 +41,10 @@ from core.trigger.entities.api_entities import (from core.trigger.entities.entities import RequestLog, SubscriptionBuilderUpdaterfrom enums.account import TenantAccountRolefrom extensions.ext_application_services import application_services-from extensions.ext_database import dbfrom fields.base import ResponseModelfrom libs.external_api import error_responsesfrom libs.helper import dump_response-from libs.login import login_requiredfrom machinery.context import RequestContext-from models.account import Accountfrom models.provider_ids import TriggerProviderIDfrom services.trigger.oauth_client_service import TriggerOAuthClientChangedError as TriggerOAuthClientChangedfrom services.trigger.oauth_client_service import TriggerOAuthClientConfigError@@ -59,12 +54,33 @@ from services.trigger.oauth_service import (TriggerOAuthContextError,TriggerOAuthProviderError,)-from services.trigger.trigger_provider_service import TriggerProviderService-from services.trigger.trigger_subscription_operator_service import TriggerSubscriptionOperatorService+from services.trigger.subscription_service import TriggerSubscriptionChangedError as SubscriptionChanged+from services.trigger.subscription_service import TriggerSubscriptionError+from services.trigger.subscription_service import TriggerSubscriptionInvalidError as SubscriptionInvalid+from services.trigger.subscription_service import TriggerSubscriptionLimitError as SubscriptionLimit+from services.trigger.subscription_service import TriggerSubscriptionNameConflictError as SubscriptionNameConflict+from services.trigger.subscription_service import TriggerSubscriptionNotFoundError as SubscriptionNotFound+from services.trigger.subscription_service import TriggerSubscriptionProviderError as SubscriptionProviderErrorlogger = logging.getLogger(__name__)+def _raise_subscription_error(error: TriggerSubscriptionError) -> NoReturn:+ if isinstance(error, SubscriptionNotFound):+ raise TriggerSubscriptionNotFoundError(str(error)) from error+ if isinstance(error, SubscriptionNameConflict):+ raise TriggerSubscriptionNameConflictError(str(error)) from error+ if isinstance(error, SubscriptionChanged):+ raise TriggerSubscriptionChangedError(str(error)) from error+ if isinstance(error, SubscriptionLimit):+ raise TriggerSubscriptionLimitError(str(error)) from error+ if isinstance(error, SubscriptionInvalid):+ raise TriggerSubscriptionInvalidError(str(error)) from error+ if isinstance(error, SubscriptionProviderError):+ raise TriggerSubscriptionProviderError(str(error)) from error+ raise error++class TriggerSubscriptionBuilderCreatePayload(BaseModel):credential_type: str = CredentialType.UNAUTHORIZED@@ -84,7 +100,7 @@ class TriggerSubscriptionBuilderUpdatePayload(BaseModel):credentials: dict[str, Any] | None = None@model_validator(mode="after")- def check_at_least_one_field(self):+ def check_at_least_one_field(self) -> Self:if all(v is None for v in self.model_dump().values()):raise ValueError("At least one of name, credentials, parameters, or properties must be provided")return self@@ -417,6 +433,9 @@ class TriggerSubscriptionBuilderLogsApi(Resource):"/workspaces/current/trigger-provider/<path:provider>/subscriptions/builder/build/<path:subscription_builder_id>",)class TriggerSubscriptionBuilderBuildApi(Resource):+ @error_responses(+ TriggerSubscriptionNameConflictError, TriggerSubscriptionLimitError, TriggerSubscriptionProviderError+ )@console_ns.expect(console_ns.models[TriggerSubscriptionBuilderUpdatePayload.__name__])@console_ns.response(HTTPStatus.OK,@@ -450,6 +469,8 @@ class TriggerSubscriptionBuilderBuildApi(Resource):),)return SimpleResultResponse(result="success").model_dump(mode="json")+ except TriggerSubscriptionError as error:+ _raise_subscription_error(error)except Exception as e:logger.exception("Error building provider credential", exc_info=e)raise ValueError(str(e)) from e@@ -459,99 +480,61 @@ class TriggerSubscriptionBuilderBuildApi(Resource):"/workspaces/current/trigger-provider/<path:subscription_id>/subscriptions/update",)class TriggerSubscriptionUpdateApi(Resource):+ @error_responses(+ TriggerSubscriptionNotFoundError,+ TriggerSubscriptionNameConflictError,+ TriggerSubscriptionChangedError,+ TriggerSubscriptionProviderError,+ )@console_ns.expect(console_ns.models[TriggerSubscriptionBuilderUpdatePayload.__name__])@console_ns.response(- 200, "Trigger subscription updated successfully", console_ns.models[SimpleResultResponse.__name__]+ HTTPStatus.OK, "Trigger subscription updated successfully", console_ns.models[SimpleResultResponse.__name__]+ )+ @console_account_admission(+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR}),+ rbac_checks=[RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace())],)- @setup_required- @login_required- @edit_permission_required- @rbac_permission_required(RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace()))- @account_initialization_required- @with_current_tenant_id@model_validate(TriggerSubscriptionBuilderUpdatePayload)- def post(self, req_data: TriggerSubscriptionBuilderUpdatePayload, tenant_id: str, subscription_id: str):- """Update a subscription instance"""-- subscription = TriggerProviderService.get_subscription_by_id(- tenant_id=tenant_id,- subscription_id=subscription_id,- )- if not subscription:- raise NotFoundError(f"Subscription {subscription_id} not found")-- provider_id = TriggerProviderID(subscription.provider_id)-+ def post(+ self, req_data: TriggerSubscriptionBuilderUpdatePayload, context: RequestContext, subscription_id: str+ ) -> dict[str, Any]:+ """Rename a subscription or rebuild its provider configuration."""try:- # For rename only, just update the name- rename = req_data.name is not None and not any(- (req_data.credentials, req_data.parameters, req_data.properties)- )- # When credential type is UNAUTHORIZED, it indicates the subscription was manually created- # For Manually created subscription, they dont have credentials, parameters- # They only have name and properties(which is input by user)- manually_created = subscription.credential_type == CredentialType.UNAUTHORIZED- if rename or manually_created:- TriggerProviderService.update_trigger_subscription(- tenant_id=tenant_id,- subscription_id=subscription_id,- name=req_data.name,- properties=req_data.properties,- )- return SimpleResultResponse(result="success").model_dump(mode="json")-- # For the rest cases(API_KEY, OAUTH2)- # we need to call third party provider(e.g. GitHub) to rebuild the subscription- TriggerProviderService.rebuild_trigger_subscription(- tenant_id=tenant_id,- name=req_data.name,- provider_id=provider_id,+ application_services().workspaces.trigger_subscription_management.update(+ tenant_id=context.active_workspace_id,subscription_id=subscription_id,- credentials=req_data.credentials or subscription.credentials,- parameters=req_data.parameters or subscription.parameters,+ name=req_data.name,+ properties=req_data.properties,+ parameters=req_data.parameters,+ credentials=req_data.credentials,)- return SimpleResultResponse(result="success").model_dump(mode="json")- except ValueError as e:- raise BadRequest(str(e)) from e- except Exception as e:- logger.exception("Error updating subscription", exc_info=e)- raise+ except TriggerSubscriptionError as error:+ _raise_subscription_error(error)+ return SimpleResultResponse(result="success").model_dump(mode="json")@console_ns.route("/workspaces/current/trigger-provider/<path:subscription_id>/subscriptions/delete",)class TriggerSubscriptionDeleteApi(Resource):- @console_ns.response(200, "Success", console_ns.models[SimpleResultResponse.__name__])- @setup_required- @login_required- @is_admin_or_owner_required- @rbac_permission_required(RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace()))- @account_initialization_required- @with_current_tenant_id- def post(self, tenant_id: str, subscription_id: str):- """Delete a subscription instance"""-+ @error_responses(+ TriggerSubscriptionNotFoundError, TriggerSubscriptionChangedError, TriggerSubscriptionProviderError+ )+ @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[SimpleResultResponse.__name__])+ @console_account_admission(+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN}),+ rbac_checks=[RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace())],+ )+ def post(self, context: RequestContext, subscription_id: str) -> dict[str, Any]:+ """Delete the subscription and its workflow trigger bindings."""try:- with sessionmaker(db.engine).begin() as session:- # Delete trigger provider subscription- TriggerProviderService.delete_trigger_provider(- session=session,- tenant_id=tenant_id,- subscription_id=subscription_id,- )- # Delete plugin triggers- TriggerSubscriptionOperatorService.delete_plugin_trigger_by_subscription(- session=session,- tenant_id=tenant_id,- subscription_id=subscription_id,- )- return SimpleResultResponse(result="success").model_dump(mode="json")- except ValueError as e:- raise BadRequest(str(e)) from e- except Exception as e:- logger.exception("Error deleting provider credential", exc_info=e)- raise+ application_services().workspaces.trigger_subscription_management.delete(+ tenant_id=context.active_workspace_id,+ subscription_id=subscription_id,+ )+ except TriggerSubscriptionError as error:+ _raise_subscription_error(error)+ return SimpleResultResponse(result="success").model_dump(mode="json")@console_ns.route("/workspaces/current/trigger-provider/<path:provider>/subscriptions/oauth/authorize")@@ -715,42 +698,36 @@ class TriggerOAuthClientManageApi(Resource):"/workspaces/current/trigger-provider/<path:provider>/subscriptions/verify/<path:subscription_id>",)class TriggerSubscriptionVerifyApi(Resource):+ @error_responses(+ TriggerSubscriptionNotFoundError, TriggerSubscriptionInvalidError, TriggerSubscriptionProviderError+ )@console_ns.expect(console_ns.models[TriggerSubscriptionVerifyPayload.__name__])@console_ns.response(- 200,+ HTTPStatus.OK,"Trigger subscription verified successfully",console_ns.models[TriggerVerificationResponse.__name__],)- @setup_required- @login_required- @edit_permission_required- @rbac_permission_required(RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace()))- @account_initialization_required- @with_current_user- @with_current_tenant_id+ @console_account_admission(+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR}),+ rbac_checks=[RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace())],+ )@model_validate(TriggerSubscriptionVerifyPayload)def post(self,req_data: TriggerSubscriptionVerifyPayload,- tenant_id: str,- user: Account,+ context: RequestContext,provider: str,subscription_id: str,- ):- """Verify credentials for an existing subscription (edit mode only)"""-+ ) -> dict[str, Any]:+ """Verify credentials against the subscription's own provider without updating it."""try:- result = TriggerProviderService.verify_subscription_credentials(- tenant_id=tenant_id,- user_id=user.id,+ result = application_services().workspaces.trigger_subscription_management.verify(+ tenant_id=context.active_workspace_id,+ user_id=context.account_id,provider_id=TriggerProviderID(provider),subscription_id=subscription_id,credentials=req_data.credentials,)- return dump_response(TriggerVerificationResponse, result)- except ValueError as e:- logger.warning("Credential verification failed", exc_info=e)- raise BadRequest(str(e)) from e- except Exception as e:- logger.exception("Error verifying subscription credentials", exc_info=e)- raise BadRequest(str(e)) from e+ except TriggerSubscriptionError as error:+ _raise_subscription_error(error)+ return dump_response(TriggerVerificationResponse, result)diff --git a/api/extensions/application_services/workspace.py b/api/extensions/application_services/workspace.pyindex f3d106d9f73..14255576b0d 100644--- a/api/extensions/application_services/workspace.py+++ b/api/extensions/application_services/workspace.py@@ -6,12 +6,14 @@ from sqlalchemy.orm import Session, sessionmakerfrom core.plugin.impl.oauth import OAuthHandlerfrom core.trigger.trigger_manager import TriggerManager+from core.trigger.utils.encryption import delete_cache_for_subscriptionfrom extensions.ext_redis import RedisClientWrapperfrom repositories.account.repository import SQLAlchemyAccountRepositoryfrom repositories.app.console_repository import ConsoleAppRepositoryfrom repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepositoryfrom repositories.trigger.oauth_client_repository import TriggerOAuthClientRepositoryfrom repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepository+from repositories.trigger.subscription_repository import RedisTriggerSubscriptionLocks, TriggerSubscriptionRepositoryfrom repositories.workspace.resource_cleanup_repository import WorkspaceResourceCleanupRepositoryfrom repositories.workspace.workspace_repository import WorkspaceRepositoryfrom services.account.adapters import RedisInvitationTokenStore@@ -26,8 +28,10 @@ from services.trigger.oauth_gateway import (from services.trigger.oauth_service import TriggerOAuthServicefrom services.trigger.provider_gateway import PluginTriggerProviderQueryfrom services.trigger.provider_query import TriggerProviderQuery+from services.trigger.subscription_codec import ProviderTriggerSubscriptionCodec+from services.trigger.subscription_gateway import PluginTriggerSubscriptionGatewayfrom services.trigger.subscription_query_service import TriggerSubscriptionQueryService-from services.trigger.trigger_provider_service import TriggerProviderService+from services.trigger.subscription_service import TriggerSubscriptionServicefrom services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderServicefrom services.workspace.gateways import (DeploymentWorkspaceCreationPolicy,@@ -66,6 +70,7 @@ class WorkspaceServices:resource_cleanup: WorkspaceResourceCleanupServicetrigger_providers: TriggerProviderQuerytrigger_subscriptions: TriggerSubscriptionQueryService+ trigger_subscription_management: TriggerSubscriptionServicetrigger_builders: TriggerSubscriptionBuilderServicetrigger_oauth_clients: TriggerOAuthClientServicetrigger_oauth: TriggerOAuthService@@ -107,12 +112,18 @@ def build_workspace_services(credentials: CredentialQuery,) -> WorkspaceServices:trigger_providers = PluginTriggerProviderQuery()+ trigger_subscription_management = TriggerSubscriptionService(+ subscriptions=TriggerSubscriptionRepository(session_factory=database_client),+ providers=PluginTriggerSubscriptionGateway(),+ locks=RedisTriggerSubscriptionLocks(redis=redis),+ codec=ProviderTriggerSubscriptionCodec(),+ invalidate_cache=delete_cache_for_subscription,+ )trigger_builders = TriggerSubscriptionBuilderService(builders=RedisTriggerSubscriptionBuilderRepository(redis=redis),get_provider=TriggerManager.get_trigger_provider,subscribe=TriggerManager.subscribe_trigger,- # Keep the shared subscription writer until subscription management migrates.- create_subscription=TriggerProviderService.add_trigger_subscription,+ create_subscription=trigger_subscription_management.create,)trigger_oauth_provider = PluginTriggerOAuthGateway(oauth=OAuthHandler())trigger_oauth_clients = TriggerOAuthClientService(@@ -153,6 +164,7 @@ def build_workspace_services(),trigger_providers=trigger_providers,trigger_subscriptions=TriggerSubscriptionQueryService(credentials=credentials, schemas=trigger_providers),+ trigger_subscription_management=trigger_subscription_management,trigger_builders=trigger_builders,trigger_oauth_clients=trigger_oauth_clients,trigger_oauth=TriggerOAuthService(diff --git a/api/openapi/markdown/console-openapi.md b/api/openapi/markdown/console-openapi.mdindex 556f4b4310a..097a7abf431 100644--- a/api/openapi/markdown/console-openapi.md+++ b/api/openapi/markdown/console-openapi.md@@ -18501,6 +18501,9 @@ Import a Skill zip package from multipart form field `file`.| Code | Description | Schema || ---- | ----------- | ------ || 200 | Trigger subscription builder built successfully | **application/json**: [SimpleResultResponse](#simpleresultresponse)<br> |+| 400 | Bad Request | **application/json**: [TriggerSubscriptionLimitReachedError](#triggersubscriptionlimitreachederror)<br>[ErrorResponse](#errorresponse)<br> |+| 409 | Conflict | **application/json**: [TriggerSubscriptionNameConflictError](#triggersubscriptionnameconflicterror)<br>[ErrorResponse](#errorresponse)<br> |+| 502 | Bad Gateway | **application/json**: [TriggerSubscriptionProviderError](#triggersubscriptionprovidererror)<br>[ErrorResponse](#errorresponse)<br> || default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |### [POST] /workspaces/current/trigger-provider/{provider}/subscriptions/builder/create@@ -18641,7 +18644,7 @@ Import a Skill zip package from multipart form field `file`.| default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |### [POST] /workspaces/current/trigger-provider/{provider}/subscriptions/verify/{subscription_id}-**Verify credentials for an existing subscription (edit mode only)**+**Verify credentials against the subscription's own provider without updating it**#### Parameters@@ -18661,10 +18664,13 @@ Import a Skill zip package from multipart form field `file`.| Code | Description | Schema || ---- | ----------- | ------ || 200 | Trigger subscription verified successfully | **application/json**: [TriggerVerificationResponse](#triggerverificationresponse)<br> |+| 400 | Bad Request | **application/json**: [TriggerSubscriptionInvalidError](#triggersubscriptioninvaliderror)<br>[ErrorResponse](#errorresponse)<br> |+| 404 | Not Found | **application/json**: [TriggerSubscriptionNotFoundError](#triggersubscriptionnotfounderror)<br>[ErrorResponse](#errorresponse)<br> |+| 502 | Bad Gateway | **application/json**: [TriggerSubscriptionProviderError](#triggersubscriptionprovidererror)<br>[ErrorResponse](#errorresponse)<br> || default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |### [POST] /workspaces/current/trigger-provider/{subscription_id}/subscriptions/delete-**Delete a subscription instance**+**Delete the subscription and its workflow trigger bindings**#### Parameters@@ -18677,10 +18683,13 @@ Import a Skill zip package from multipart form field `file`.| Code | Description | Schema || ---- | ----------- | ------ || 200 | Success | **application/json**: [SimpleResultResponse](#simpleresultresponse)<br> |+| 404 | Not Found | **application/json**: [TriggerSubscriptionNotFoundError](#triggersubscriptionnotfounderror)<br>[ErrorResponse](#errorresponse)<br> |+| 409 | Conflict | **application/json**: [TriggerSubscriptionChangedError](#triggersubscriptionchangederror)<br>[ErrorResponse](#errorresponse)<br> |+| 502 | Bad Gateway | **application/json**: [TriggerSubscriptionProviderError](#triggersubscriptionprovidererror)<br>[ErrorResponse](#errorresponse)<br> || default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |### [POST] /workspaces/current/trigger-provider/{subscription_id}/subscriptions/update-**Update a subscription instance**+**Rename a subscription or rebuild its provider configuration**#### Parameters@@ -18699,6 +18708,9 @@ Import a Skill zip package from multipart form field `file`.| Code | Description | Schema || ---- | ----------- | ------ || 200 | Trigger subscription updated successfully | **application/json**: [SimpleResultResponse](#simpleresultresponse)<br> |+| 404 | Not Found | **application/json**: [TriggerSubscriptionNotFoundError](#triggersubscriptionnotfounderror)<br>[ErrorResponse](#errorresponse)<br> |+| 409 | Conflict | **application/json**: [TriggerSubscriptionChangedError](#triggersubscriptionchangederror)<br>[TriggerSubscriptionNameConflictError](#triggersubscriptionnameconflicterror)<br>[ErrorResponse](#errorresponse)<br> |+| 502 | Bad Gateway | **application/json**: [TriggerSubscriptionProviderError](#triggersubscriptionprovidererror)<br>[ErrorResponse](#errorresponse)<br> || default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |### [GET] /workspaces/current/triggers@@ -36659,6 +36671,54 @@ The identity of the trigger provider| ---- | ---- | ----------- | -------- || credentials | object | | No |+#### TriggerSubscriptionChangedError++The trigger subscription changed. Reload it before trying again.++| Name | Type | Description | Required |+| ---- | ---- | ----------- | -------- |+| TriggerSubscriptionChangedError | | The trigger subscription changed. Reload it before trying again. | |++#### TriggerSubscriptionInvalidError++The trigger subscription configuration or credentials are invalid.++| Name | Type | Description | Required |+| ---- | ---- | ----------- | -------- |+| TriggerSubscriptionInvalidError | | The trigger subscription configuration or credentials are invalid. | |++#### TriggerSubscriptionLimitReachedError++The maximum number of trigger subscriptions for this provider has been reached.++| Name | Type | Description | Required |+| ---- | ---- | ----------- | -------- |+| TriggerSubscriptionLimitReachedError | | The maximum number of trigger subscriptions for this provider has been reached. | |++#### TriggerSubscriptionNameConflictError++A trigger subscription with this name already exists for the provider.++| Name | Type | Description | Required |+| ---- | ---- | ----------- | -------- |+| TriggerSubscriptionNameConflictError | | A trigger subscription with this name already exists for the provider. | |++#### TriggerSubscriptionNotFoundError++The trigger subscription does not exist in this workspace and provider.++| Name | Type | Description | Required |+| ---- | ---- | ----------- | -------- |+| TriggerSubscriptionNotFoundError | | The trigger subscription does not exist in this workspace and provider. | |++#### TriggerSubscriptionProviderError++The trigger provider could not complete the subscription operation.++| Name | Type | Description | Required |+| ---- | ---- | ----------- | -------- |+| TriggerSubscriptionProviderError | | The trigger provider could not complete the subscription operation. | |+#### TriggerSubscriptionVerifyPayload| Name | Type | Description | Required |diff --git a/api/repositories/trigger/subscription_repository.py b/api/repositories/trigger/subscription_repository.pynew file mode 100644index 00000000000..aedf8ac98a5--- /dev/null+++ b/api/repositories/trigger/subscription_repository.py@@ -0,0 +1,271 @@+"""Short SQL transactions and Redis serialization for trigger subscription commands."""++import logging+import sqlite3+from collections.abc import Generator+from contextlib import AbstractContextManager, contextmanager+from copy import deepcopy+from threading import Event, Thread+from typing import override++from psycopg2.errors import UniqueViolation+from pymysql.err import IntegrityError as MySQLIntegrityError+from redis.exceptions import LockError, RedisError+from redis.lock import Lock+from sqlalchemy import delete, func, select+from sqlalchemy.exc import IntegrityError+from sqlalchemy.orm import Session, sessionmaker++from extensions.ext_redis import RedisClientWrapper+from models.provider_ids import TriggerProviderID+from models.trigger import TriggerSubscription, WorkflowPluginTrigger+from services.trigger.subscription_service import (+ TriggerSubscriptionChangedError,+ TriggerSubscriptionLease,+ TriggerSubscriptionLeaseLostError,+ TriggerSubscriptionLimitError,+ TriggerSubscriptionLocks,+ TriggerSubscriptionNameConflictError,+ TriggerSubscriptionSnapshot,+ TriggerSubscriptionStore,+)++logger = logging.getLogger(__name__)+++def _is_name_conflict(error: IntegrityError) -> bool:+ original = error.orig+ constraint = "unique_trigger_provider"+ if isinstance(original, UniqueViolation):+ return original.diag.constraint_name == constraint+ if isinstance(original, MySQLIntegrityError):+ if len(original.args) != 2 or original.args[0] != 1062 or not isinstance(original.args[1], str):+ return False+ key = original.args[1].rsplit(" for key ", 1)[-1]+ return key in (+ f"'{constraint}'",+ f"'trigger_subscriptions.{constraint}'",+ f"`{constraint}`",+ f"`trigger_subscriptions.{constraint}`",+ )+ if isinstance(original, sqlite3.IntegrityError):+ return original.sqlite_errorcode == sqlite3.SQLITE_CONSTRAINT_UNIQUE and str(original) == (+ "UNIQUE constraint failed: trigger_subscriptions.tenant_id, "+ "trigger_subscriptions.provider_id, trigger_subscriptions.name"+ )+ return False+++class TriggerSubscriptionRepository(TriggerSubscriptionStore):+ def __init__(self, *, session_factory: sessionmaker[Session]) -> None:+ self._session_factory = session_factory++ @override+ def get(self, *, tenant_id: str, subscription_id: str) -> TriggerSubscriptionSnapshot | None:+ with self._session_factory() as session:+ row = session.scalar(+ select(TriggerSubscription).where(+ TriggerSubscription.tenant_id == tenant_id, TriggerSubscription.id == subscription_id+ )+ )+ return self._snapshot(row) if row is not None else None++ @override+ def create(self, *, subscription: TriggerSubscriptionSnapshot, max_count: int) -> None:+ try:+ with self._session_factory.begin() as session:+ owner = (+ TriggerSubscription.tenant_id == subscription.tenant_id,+ TriggerSubscription.provider_id == subscription.provider_id,+ )+ count = session.scalar(select(func.count(TriggerSubscription.id)).where(*owner)) or 0+ if count >= max_count:+ raise TriggerSubscriptionLimitError(+ f"Maximum number of subscriptions ({max_count}) reached "+ f"for provider {subscription.provider_id}."+ )+ self._require_available_name(session, subscription)+ row = TriggerSubscription(+ name=subscription.name,+ tenant_id=subscription.tenant_id,+ user_id=subscription.user_id,+ provider_id=subscription.provider_id,+ endpoint_id=subscription.endpoint_id,+ credential_type=subscription.credential_type,+ parameters=deepcopy(dict(subscription.parameters)),+ properties=deepcopy(dict(subscription.properties)),+ credentials=deepcopy(dict(subscription.credentials)),+ credential_expires_at=subscription.credential_expires_at,+ expires_at=subscription.expires_at,+ visibility=subscription.visibility,+ )+ row.id = subscription.id+ session.add(row)+ except IntegrityError as error:+ if not _is_name_conflict(error):+ raise+ raise self._name_conflict(subscription) from error++ @override+ def update(self, *, expected: TriggerSubscriptionSnapshot, replacement: TriggerSubscriptionSnapshot) -> None:+ try:+ with self._session_factory.begin() as session:+ row = self._require_unchanged(session, expected)+ if replacement.name != expected.name:+ self._require_available_name(session, replacement)+ row.name = replacement.name+ row.parameters = deepcopy(dict(replacement.parameters))+ row.properties = deepcopy(dict(replacement.properties))+ row.credentials = deepcopy(dict(replacement.credentials))+ row.credential_expires_at = replacement.credential_expires_at+ row.expires_at = replacement.expires_at+ except IntegrityError as error:+ if not _is_name_conflict(error):+ raise+ raise self._name_conflict(replacement) from error++ @override+ def delete(self, *, expected: TriggerSubscriptionSnapshot) -> None:+ with self._session_factory.begin() as session:+ row = self._require_unchanged(session, expected)+ session.execute(+ delete(WorkflowPluginTrigger).where(+ WorkflowPluginTrigger.tenant_id == expected.tenant_id,+ WorkflowPluginTrigger.subscription_id == expected.id,+ )+ )+ session.delete(row)++ @classmethod+ def _require_unchanged(cls, session: Session, expected: TriggerSubscriptionSnapshot) -> TriggerSubscription:+ row = session.scalar(+ select(TriggerSubscription)+ .where(TriggerSubscription.tenant_id == expected.tenant_id, TriggerSubscription.id == expected.id)+ .with_for_update()+ )+ # Compare in Python so database JSON/text collations cannot consider+ # different ciphertext or nested configuration values equivalent.+ if row is None or cls._snapshot(row) != expected:+ raise TriggerSubscriptionChangedError(f"Trigger subscription {expected.id} changed. Reload and retry.")+ return row++ @classmethod+ def _require_available_name(cls, session: Session, subscription: TriggerSubscriptionSnapshot) -> None:+ exists = session.scalar(+ select(TriggerSubscription.id)+ .where(+ TriggerSubscription.tenant_id == subscription.tenant_id,+ TriggerSubscription.provider_id == subscription.provider_id,+ TriggerSubscription.name == subscription.name,+ TriggerSubscription.id != subscription.id,+ )+ .limit(1)+ )+ if exists is not None:+ raise cls._name_conflict(subscription)++ @staticmethod+ def _name_conflict(subscription: TriggerSubscriptionSnapshot) -> TriggerSubscriptionNameConflictError:+ return TriggerSubscriptionNameConflictError(+ f"Subscription name '{subscription.name}' already exists for provider {subscription.provider_id}."+ )++ @staticmethod+ def _snapshot(row: TriggerSubscription) -> TriggerSubscriptionSnapshot:+ return TriggerSubscriptionSnapshot(+ id=row.id,+ name=row.name,+ tenant_id=row.tenant_id,+ user_id=row.user_id,+ provider_id=row.provider_id,+ endpoint_id=row.endpoint_id,+ credential_type=row.credential_type,+ parameters=deepcopy(row.parameters),+ properties=deepcopy(row.properties),+ credentials=deepcopy(row.credentials),+ credential_expires_at=row.credential_expires_at,+ expires_at=row.expires_at,+ visibility=row.visibility,+ )+++class _SubscriptionLease:+ """Renew a Redis lease, failing closed when ownership can no longer be confirmed."""++ def __init__(self, lock: Lock, lost: Event) -> None:+ self._lock = lock+ self._lost = lost++ def ensure_owned(self) -> None:+ """Reset the lease TTL if owned; raise before further work if ownership is lost."""+ if self._lost.is_set():+ raise TriggerSubscriptionLeaseLostError(+ "Trigger subscription lock was lost; check the provider state before retrying."+ )+ try:+ self._lock.reacquire()+ except RedisError as error:+ self._lost.set()+ raise TriggerSubscriptionLeaseLostError(+ "Trigger subscription lock was lost; check the provider state before retrying."+ ) from error+++class RedisTriggerSubscriptionLocks(TriggerSubscriptionLocks):+ def __init__(self, *, redis: RedisClientWrapper) -> None:+ self._redis = redis++ @override+ def for_provider(self, *, tenant_id: str, provider_id: TriggerProviderID) -> AbstractContextManager[None]:+ return self._hold(f"trigger_provider_create_lock:{tenant_id}_{provider_id}")++ @override+ @contextmanager+ def for_subscription(self, *, tenant_id: str, subscription_id: str) -> Generator[TriggerSubscriptionLease]:+ """Serialize the subscription mutation and renew its lease during provider I/O.++ The caller must check ownership between remote operations and before the SQL write.+ Release errors cannot replace the outcome of a completed or failed mutation.+ """+ key = f"trigger_subscription_update_lock:{tenant_id}_{subscription_id}"+ lock: Lock = self._redis.lock(key, timeout=60, thread_local=False)+ if not lock.acquire():+ raise LockError(f"Unable to acquire trigger subscription lock {key}")+ stopped, lost = Event(), Event()+ lease = _SubscriptionLease(lock, lost)++ def renew() -> None:+ while not stopped.wait(20):+ try:+ lease.ensure_owned()+ except Exception:+ lost.set()+ logger.warning("Lost trigger subscription lock %s", key, exc_info=True)+ return++ heartbeat = Thread(target=renew, name=f"TriggerSubscriptionLock({subscription_id})", daemon=True)+ try:+ heartbeat.start()+ yield lease+ finally:+ stopped.set()+ if heartbeat.ident is not None:+ heartbeat.join(timeout=2)+ try:+ lock.release()+ except RedisError:+ logger.exception("Failed to release trigger subscription lock %s", key)++ @contextmanager+ def _hold(self, key: str) -> Generator[None]:+ lock = self._redis.lock(key, timeout=20)+ if not lock.acquire():+ raise LockError(f"Unable to acquire trigger subscription lock {key}")+ try:+ yield+ finally:+ # SQL may already be committed; cleanup must not replace its outcome.+ try:+ lock.release()+ except RedisError:+ logger.exception("Failed to release trigger subscription lock %s", key)diff --git a/api/services/trigger/subscription_codec.py b/api/services/trigger/subscription_codec.pynew file mode 100644index 00000000000..c3fe51b3808--- /dev/null+++ b/api/services/trigger/subscription_codec.py@@ -0,0 +1,17 @@+"""Adapt existing provider encryption to the subscription service's codec port."""++from core.entities.provider_entities import BasicProviderConfig+from core.helper.provider_cache import NoOpProviderCredentialCache+from core.helper.provider_encryption import create_provider_encrypter+from services.trigger.subscription_service import TriggerSubscriptionCipher+++class ProviderTriggerSubscriptionCodec:+ """Use the existing workspace key provider for schema-defined secret fields."""++ def for_schema(self, *, tenant_id: str, schema: list[BasicProviderConfig]) -> TriggerSubscriptionCipher:+ """Create an uncached provider cipher scoped to the workspace and schema."""+ encrypter, _ = create_provider_encrypter(+ tenant_id=tenant_id, config=schema, cache=NoOpProviderCredentialCache()+ )+ return encrypterdiff --git a/api/services/trigger/subscription_gateway.py b/api/services/trigger/subscription_gateway.pynew file mode 100644index 00000000000..f648fba1db1--- /dev/null+++ b/api/services/trigger/subscription_gateway.py@@ -0,0 +1,89 @@+"""Adapt plugin provider discovery and dispatch for subscription management."""++from collections.abc import Mapping+from typing import Any++from core.plugin.entities.plugin_daemon import CredentialType+from core.trigger.entities.entities import Subscription, UnsubscribeResult+from core.trigger.errors import TriggerProviderCredentialValidationError+from core.trigger.provider import PluginTriggerProviderController+from core.trigger.trigger_manager import TriggerManager+from models.provider_ids import TriggerProviderID+from services.trigger.subscription_query_service import TriggerSubscriptionSchemas+from services.trigger.subscription_service import (+ TriggerSubscriptionInvalidError,+ TriggerSubscriptionProviderError,+)+++class PluginTriggerSubscriptionGateway:+ """Reuse TriggerManager's context cache for one synchronous management operation."""++ def get_schemas(+ self, *, tenant_id: str, provider_id: TriggerProviderID, credential_type: CredentialType+ ) -> TriggerSubscriptionSchemas:+ provider = self._provider(tenant_id=tenant_id, provider_id=provider_id)+ return TriggerSubscriptionSchemas(+ credentials={credential_type: provider.get_credential_schema_config(credential_type)},+ properties=provider.get_properties_schema(),+ )++ def validate_credentials(+ self, *, tenant_id: str, provider_id: TriggerProviderID, user_id: str, credentials: Mapping[str, Any]+ ) -> None:+ provider = self._provider(tenant_id=tenant_id, provider_id=provider_id)+ try:+ provider.validate_credentials(user_id=user_id, credentials=credentials)+ except TriggerProviderCredentialValidationError as error:+ raise TriggerSubscriptionInvalidError(+ f"Invalid credentials for trigger provider {provider_id}: {error}"+ ) from error+ except Exception as error:+ raise TriggerSubscriptionProviderError(+ f"Failed to verify credentials for trigger provider {provider_id}."+ ) from error++ def subscribe(+ self,+ *,+ tenant_id: str,+ provider_id: TriggerProviderID,+ user_id: str,+ endpoint: str,+ parameters: Mapping[str, Any],+ credentials: Mapping[str, str],+ credential_type: CredentialType,+ ) -> Subscription:+ provider = self._provider(tenant_id=tenant_id, provider_id=provider_id)+ return provider.subscribe_trigger(+ user_id=user_id,+ endpoint=endpoint,+ parameters=parameters,+ credentials=credentials,+ credential_type=credential_type,+ )++ def unsubscribe(+ self,+ *,+ tenant_id: str,+ provider_id: TriggerProviderID,+ user_id: str,+ subscription: Subscription,+ credentials: Mapping[str, str],+ credential_type: CredentialType,+ ) -> UnsubscribeResult:+ provider = self._provider(tenant_id=tenant_id, provider_id=provider_id)+ return provider.unsubscribe_trigger(+ user_id=user_id,+ subscription=subscription,+ credentials=credentials,+ credential_type=credential_type,+ )++ @staticmethod+ def _provider(*, tenant_id: str, provider_id: TriggerProviderID) -> PluginTriggerProviderController:+ try:+ return TriggerManager.get_trigger_provider(tenant_id=tenant_id, provider_id=provider_id)+ except Exception as error:+ raise TriggerSubscriptionProviderError(f"Failed to load trigger provider {provider_id}.") from errordiff --git a/api/services/trigger/subscription_service.py b/api/services/trigger/subscription_service.pynew file mode 100644index 00000000000..76c6908f57f--- /dev/null+++ b/api/services/trigger/subscription_service.py@@ -0,0 +1,417 @@+"""Manage persisted trigger subscriptions outside repository transactions."""++import logging+from collections.abc import Mapping+from contextlib import AbstractContextManager+from dataclasses import dataclass, replace+from typing import Any, Protocol, overload++from constants import HIDDEN_VALUE, UNKNOWN_VALUE+from core.entities.provider_entities import BasicProviderConfig+from core.plugin.entities.plugin_daemon import CredentialType+from core.trigger.entities.entities import Subscription, UnsubscribeResult+from core.trigger.utils.endpoint import generate_plugin_trigger_endpoint_url+from models.enums import PermissionEnum+from models.provider_ids import TriggerProviderID+from services.trigger.subscription_query_service import TriggerSubscriptionSchemas++logger = logging.getLogger(__name__)+++class TriggerSubscriptionError(Exception):+ """A trigger subscription operation could not be completed."""+++class TriggerSubscriptionNotFoundError(TriggerSubscriptionError):+ """The subscription does not belong to the requested workspace and provider."""+++class TriggerSubscriptionNameConflictError(TriggerSubscriptionError):+ """The provider already has a subscription with the requested name."""+++class TriggerSubscriptionChangedError(TriggerSubscriptionError):+ """The persisted subscription changed while an operation was being prepared."""+++class TriggerSubscriptionLeaseLostError(TriggerSubscriptionChangedError):+ """The mutation lease was lost before its next side effect or database write."""+++class TriggerSubscriptionLimitError(TriggerSubscriptionError):+ """The provider has reached its subscription limit."""+++class TriggerSubscriptionProviderError(TriggerSubscriptionError):+ """The plugin provider could not complete the requested operation."""+++class TriggerSubscriptionInvalidError(TriggerSubscriptionError):+ """The requested operation or credentials are invalid for this subscription."""+++@dataclass(frozen=True, slots=True)+class TriggerSubscriptionSnapshot:+ id: str+ name: str+ tenant_id: str+ user_id: str+ provider_id: str+ endpoint_id: str+ credential_type: CredentialType+ parameters: Mapping[str, Any]+ properties: Mapping[str, Any]+ credentials: Mapping[str, str]+ credential_expires_at: int+ expires_at: int+ visibility: PermissionEnum+++class TriggerSubscriptionStore(Protocol):+ """Return detached records and complete each write in one bounded transaction."""++ def get(self, *, tenant_id: str, subscription_id: str) -> TriggerSubscriptionSnapshot | None: ...++ def create(self, *, subscription: TriggerSubscriptionSnapshot, max_count: int) -> None: ...++ def update(self, *, expected: TriggerSubscriptionSnapshot, replacement: TriggerSubscriptionSnapshot) -> None: ...++ def delete(self, *, expected: TriggerSubscriptionSnapshot) -> None: ...+++class TriggerSubscriptionLease(Protocol):+ def ensure_owned(self) -> None:+ """Renew the lease or raise if ownership cannot be confirmed."""+ ...+++class TriggerSubscriptionLocks(Protocol):+ """Serialize mutations; release errors do not replace the mutation outcome."""++ def for_provider(self, *, tenant_id: str, provider_id: TriggerProviderID) -> AbstractContextManager[None]: ...++ def for_subscription(+ self, *, tenant_id: str, subscription_id: str+ ) -> AbstractContextManager[TriggerSubscriptionLease]:+ """Hold a renewable lease until the provider operation and SQL write finish."""+ ...+++class TriggerSubscriptionProviderGateway(Protocol):+ def get_schemas(+ self, *, tenant_id: str, provider_id: TriggerProviderID, credential_type: CredentialType+ ) -> TriggerSubscriptionSchemas: ...++ def validate_credentials(+ self, *, tenant_id: str, provider_id: TriggerProviderID, user_id: str, credentials: Mapping[str, Any]+ ) -> None: ...++ def subscribe(+ self,+ *,+ tenant_id: str,+ provider_id: TriggerProviderID,+ user_id: str,+ endpoint: str,+ parameters: Mapping[str, Any],+ credentials: Mapping[str, str],+ credential_type: CredentialType,+ ) -> Subscription: ...++ def unsubscribe(+ self,+ *,+ tenant_id: str,+ provider_id: TriggerProviderID,+ user_id: str,+ subscription: Subscription,+ credentials: Mapping[str, str],+ credential_type: CredentialType,+ ) -> UnsubscribeResult: ...+++class TriggerSubscriptionCipher(Protocol):+ """Transform values according to a provider schema without changing their shape."""++ @overload+ def encrypt(self, data: Mapping[str, str]) -> Mapping[str, str]: ...++ @overload+ def encrypt(self, data: Mapping[str, object]) -> Mapping[str, object]: ...++ @overload+ def decrypt(self, data: Mapping[str, str]) -> Mapping[str, str]: ...++ @overload+ def decrypt(self, data: Mapping[str, object]) -> Mapping[str, object]: ...+++class TriggerSubscriptionCodec(Protocol):+ def for_schema(self, *, tenant_id: str, schema: list[BasicProviderConfig]) -> TriggerSubscriptionCipher:+ """Create a cipher scoped to the workspace and provider schema."""+ ...+++class TriggerSubscriptionCacheInvalidator(Protocol):+ def __call__(self, *, tenant_id: str, provider_id: str, subscription_id: str) -> None: ...+++class TriggerSubscriptionService:+ """Keep provider calls, credential processing and Redis outside repository transactions.++ TODO: The shared RSA key provider still owns a scoped DB session for encryption;+ remove that dependency when its tenant key reads return detached values.+ TODO: Coordinate the legacy subscription renewal task with this same lease.+ """++ def __init__(+ self,+ *,+ subscriptions: TriggerSubscriptionStore,+ providers: TriggerSubscriptionProviderGateway,+ locks: TriggerSubscriptionLocks,+ codec: TriggerSubscriptionCodec,+ invalidate_cache: TriggerSubscriptionCacheInvalidator,+ ) -> None:+ self._subscriptions = subscriptions+ self._providers = providers+ self._locks = locks+ self._codec = codec+ self._invalidate_cache = invalidate_cache++ def create(+ self,+ *,+ tenant_id: str,+ user_id: str,+ name: str,+ provider_id: TriggerProviderID,+ endpoint_id: str,+ credential_type: CredentialType,+ parameters: Mapping[str, Any],+ properties: Mapping[str, Any],+ credentials: Mapping[str, str],+ subscription_id: str,+ credential_expires_at: int,+ expires_at: int,+ ) -> Mapping[str, str]:+ schemas = self._providers.get_schemas(+ tenant_id=tenant_id, provider_id=provider_id, credential_type=credential_type+ )+ encrypted_credentials = (+ dict(+ self._codec.for_schema(tenant_id=tenant_id, schema=schemas.credentials[credential_type]).encrypt(+ credentials+ )+ )+ if credential_type != CredentialType.UNAUTHORIZED+ else {}+ )+ subscription = TriggerSubscriptionSnapshot(+ id=subscription_id,+ name=name,+ tenant_id=tenant_id,+ user_id=user_id,+ provider_id=str(provider_id),+ endpoint_id=endpoint_id,+ credential_type=credential_type,+ parameters=dict(parameters),+ properties=dict(self._codec.for_schema(tenant_id=tenant_id, schema=schemas.properties).encrypt(properties)),+ credentials=encrypted_credentials,+ credential_expires_at=credential_expires_at,+ expires_at=expires_at,+ visibility=PermissionEnum.ALL_TEAM,+ )+ with self._locks.for_provider(tenant_id=tenant_id, provider_id=provider_id):+ self._subscriptions.create(subscription=subscription, max_count=10)+ return {"result": "success", "id": subscription_id}++ def update(+ self,+ *,+ tenant_id: str,+ subscription_id: str,+ name: str | None,+ credentials: Mapping[str, Any] | None,+ parameters: Mapping[str, Any] | None,+ properties: Mapping[str, Any] | None,+ ) -> None:+ """Serialize the remote rebuild and conditional write for an owned subscription.++ A lease is required through the write; on lease loss no further provider call+ or database write is attempted. Already completed remote effects cannot be undone.+ """+ # Preserve not-found behavior when Redis is unavailable; reload under the+ # lease so the mutation never relies on this preliminary snapshot.+ self._require(tenant_id=tenant_id, subscription_id=subscription_id)+ with self._locks.for_subscription(tenant_id=tenant_id, subscription_id=subscription_id) as lease:+ snapshot = self._require(tenant_id=tenant_id, subscription_id=subscription_id)+ provider_id = TriggerProviderID(snapshot.provider_id)+ schemas = self._providers.get_schemas(+ tenant_id=tenant_id, provider_id=provider_id, credential_type=snapshot.credential_type+ )+ replacement = replace(snapshot, name=name if name is not None else snapshot.name)+ rename = name is not None and not any((credentials, parameters, properties))+ property_encrypter = self._codec.for_schema(tenant_id=tenant_id, schema=schemas.properties)+ if rename or snapshot.credential_type == CredentialType.UNAUTHORIZED:+ # Manual subscriptions only support name and properties. Empty+ # mappings retain the original rename/partial-update semantics.+ if properties is not None:+ replacement = replace(+ replacement,+ properties=dict(+ property_encrypter.encrypt(+ self._restore_hidden(properties, property_encrypter.decrypt(snapshot.properties))+ )+ ),+ )+ else:+ credential_encrypter = self._codec.for_schema(+ tenant_id=tenant_id, schema=schemas.credentials[snapshot.credential_type]+ )+ original_credentials = credential_encrypter.decrypt(snapshot.credentials)+ original_properties = property_encrypter.decrypt(snapshot.properties)+ lease.ensure_owned()+ try:+ removed = self._providers.unsubscribe(+ tenant_id=tenant_id,+ provider_id=provider_id,+ user_id=snapshot.user_id,+ subscription=self._entity(snapshot, original_properties),+ credentials=original_credentials,+ credential_type=snapshot.credential_type,+ )+ except Exception as error:+ raise TriggerSubscriptionProviderError(+ f"Failed to remove trigger subscription {subscription_id} from provider {provider_id}."+ ) from error+ if not removed.success:+ raise TriggerSubscriptionProviderError(+ f"Provider {provider_id} rejected removal of trigger subscription {subscription_id}: "+ f"{removed.message}"+ )+ restored_credentials = self._restore_hidden(credentials or original_credentials, original_credentials)+ new_parameters = parameters or snapshot.parameters+ lease.ensure_owned()+ try:+ created = self._providers.subscribe(+ tenant_id=tenant_id,+ provider_id=provider_id,+ user_id=snapshot.user_id,+ endpoint=generate_plugin_trigger_endpoint_url(snapshot.endpoint_id),+ parameters=new_parameters,+ credentials=restored_credentials,+ credential_type=snapshot.credential_type,+ )+ except Exception as error:+ raise TriggerSubscriptionProviderError(+ f"Failed to rebuild trigger subscription {subscription_id} with provider {provider_id}."+ ) from error+ replacement = replace(+ replacement,+ credentials=dict(credential_encrypter.encrypt(restored_credentials)),+ parameters=dict(new_parameters),+ properties=dict(+ property_encrypter.encrypt(self._restore_hidden(created.properties, original_properties))+ ),+ expires_at=created.expires_at,+ )+ lease.ensure_owned()+ self._subscriptions.update(expected=snapshot, replacement=replacement)+ self._invalidate(snapshot)++ def delete(self, *, tenant_id: str, subscription_id: str) -> None:+ """Serialize remote removal and the scoped SQL delete under a renewable lease.++ On lost ownership, no further SQL write is attempted; a prior remote removal+ cannot be undone. Provider failures retain the existing best-effort behavior.+ """+ # Preserve not-found behavior when Redis is unavailable; reload under the+ # lease so the mutation never relies on this preliminary snapshot.+ self._require(tenant_id=tenant_id, subscription_id=subscription_id)+ with self._locks.for_subscription(tenant_id=tenant_id, subscription_id=subscription_id) as lease:+ snapshot = self._require(tenant_id=tenant_id, subscription_id=subscription_id)+ provider_id = TriggerProviderID(snapshot.provider_id)+ schemas = self._providers.get_schemas(+ tenant_id=tenant_id, provider_id=provider_id, credential_type=snapshot.credential_type+ )+ if snapshot.credential_type in {CredentialType.API_KEY, CredentialType.OAUTH2}:+ lease.ensure_owned()+ try:+ self._providers.unsubscribe(+ tenant_id=tenant_id,+ provider_id=provider_id,+ user_id=snapshot.user_id,+ subscription=self._entity(snapshot, snapshot.properties),+ credentials=self._codec.for_schema(+ tenant_id=tenant_id, schema=schemas.credentials[snapshot.credential_type]+ ).decrypt(snapshot.credentials),+ credential_type=snapshot.credential_type,+ )+ except Exception:+ logger.exception("Failed to unsubscribe trigger subscription %s before deletion", subscription_id)+ lease.ensure_owned()+ self._subscriptions.delete(expected=snapshot)+ self._invalidate(snapshot)++ def verify(+ self,+ *,+ tenant_id: str,+ user_id: str,+ provider_id: TriggerProviderID,+ subscription_id: str,+ credentials: Mapping[str, Any],+ ) -> Mapping[str, bool]:+ snapshot = self._require(tenant_id=tenant_id, subscription_id=subscription_id)+ if snapshot.provider_id != str(provider_id):+ raise TriggerSubscriptionNotFoundError(f"Trigger subscription {subscription_id} not found.")+ if snapshot.credential_type != CredentialType.API_KEY:+ return {"verified": True}+ schemas = self._providers.get_schemas(+ tenant_id=tenant_id, provider_id=provider_id, credential_type=snapshot.credential_type+ )+ original_credentials = self._codec.for_schema(+ tenant_id=tenant_id, schema=schemas.credentials[snapshot.credential_type]+ ).decrypt(snapshot.credentials)+ self._providers.validate_credentials(+ tenant_id=tenant_id,+ provider_id=provider_id,+ user_id=user_id,+ credentials=self._restore_hidden(credentials, original_credentials),+ )+ return {"verified": True}++ def _require(self, *, tenant_id: str, subscription_id: str) -> TriggerSubscriptionSnapshot:+ snapshot = self._subscriptions.get(tenant_id=tenant_id, subscription_id=subscription_id)+ if snapshot is None:+ raise TriggerSubscriptionNotFoundError(f"Trigger subscription {subscription_id} not found.")+ return snapshot++ def _invalidate(self, snapshot: TriggerSubscriptionSnapshot) -> None:+ try:+ self._invalidate_cache(+ tenant_id=snapshot.tenant_id, provider_id=snapshot.provider_id, subscription_id=snapshot.id+ )+ except Exception:+ # The write is committed; reporting failure would invite unsafe retries.+ logger.exception(+ "Failed to invalidate cache for trigger subscription %s in workspace %s",+ snapshot.id,+ snapshot.tenant_id,+ )++ @staticmethod+ def _restore_hidden(values: Mapping[str, Any], original: Mapping[str, Any]) -> dict[str, Any]:+ return {+ key: original.get(key, UNKNOWN_VALUE) if value == HIDDEN_VALUE else value for key, value in values.items()+ }++ @staticmethod+ def _entity(snapshot: TriggerSubscriptionSnapshot, properties: Mapping[str, Any]) -> Subscription:+ return Subscription(+ expires_at=snapshot.expires_at,+ endpoint=generate_plugin_trigger_endpoint_url(snapshot.endpoint_id),+ parameters=snapshot.parameters,+ properties=properties,+ )diff --git a/api/services/trigger/trigger_provider_service.py b/api/services/trigger/trigger_provider_service.pyindex 97180dd5e03..c0587a86271 100644--- a/api/services/trigger/trigger_provider_service.py+++ b/api/services/trigger/trigger_provider_service.py@@ -1,16 +1,14 @@import loggingimport time as _time-import uuidfrom collections.abc import Mapping-from typing import Any, TypedDict+from typing import Any-from sqlalchemy import func, select+from sqlalchemy import selectfrom sqlalchemy.orm import Session, sessionmakerfrom configs import dify_config-from constants import HIDDEN_VALUE, UNKNOWN_VALUEfrom core.helper.provider_cache import NoOpProviderCredentialCache-from core.helper.provider_encryption import ProviderConfigEncrypter, create_provider_encrypter+from core.helper.provider_encryption import create_provider_encrypterfrom core.plugin.entities.plugin_daemon import CredentialTypefrom core.plugin.impl.oauth import OAuthHandlerfrom core.plugin.plugin_service import PluginService@@ -25,7 +23,6 @@ from core.trigger.utils.encryption import ()from core.trigger.utils.endpoint import generate_plugin_trigger_endpoint_urlfrom extensions.ext_database import db-from extensions.ext_redis import redis_clientfrom models.provider_ids import TriggerProviderIDfrom models.trigger import (TriggerOAuthSystemClient,@@ -37,224 +34,13 @@ from services.plugin.dispatch_identity import PluginOAuthClientConfiglogger = logging.getLogger(__name__)-class VerifyCredentialsResult(TypedDict):- verified: bool--class TriggerProviderService:- """Service for managing trigger providers and credentials"""-- ##########################- # Trigger provider- ##########################- __MAX_TRIGGER_PROVIDER_COUNT__ = 10-- @classmethod- def add_trigger_subscription(- cls,- tenant_id: str,- user_id: str,- name: str,- provider_id: TriggerProviderID,- endpoint_id: str,- credential_type: CredentialType,- parameters: Mapping[str, Any],- properties: Mapping[str, Any],- credentials: Mapping[str, str],- subscription_id: str | None = None,- credential_expires_at: int = -1,- expires_at: int = -1,- ) -> Mapping[str, Any]:- """- Add a new trigger provider with credentials.- Supports multiple credential instances per provider.+ """Legacy subscription reads and renewal tasks.- :param tenant_id: Tenant ID- :param provider_id: Provider identifier (e.g., "plugin_id/provider_name")- :param credential_type: Type of credential (oauth or api_key)- :param credentials: Credential data to encrypt and store- :param name: Optional name for this credential instance- :param expires_at: OAuth token expiration timestamp- :return: Success response- """- try:- provider_controller = TriggerManager.get_trigger_provider(tenant_id, provider_id)- with sessionmaker(bind=db.engine, expire_on_commit=False).begin() as session:- # Use distributed lock to prevent race conditions- lock_key = f"trigger_provider_create_lock:{tenant_id}_{provider_id}"- with redis_client.lock(lock_key, timeout=20):- # Check provider count limit- provider_count = (- session.scalar(- select(func.count(TriggerSubscription.id)).where(- TriggerSubscription.tenant_id == tenant_id,- TriggerSubscription.provider_id == str(provider_id),- )- )- or 0- )-- if provider_count >= cls.__MAX_TRIGGER_PROVIDER_COUNT__:- raise ValueError(- f"Maximum number of providers ({cls.__MAX_TRIGGER_PROVIDER_COUNT__}) "- f"reached for {provider_id}"- )-- # Check if name already exists- existing = session.scalar(- select(TriggerSubscription)- .where(- TriggerSubscription.tenant_id == tenant_id,- TriggerSubscription.provider_id == str(provider_id),- TriggerSubscription.name == name,- )- .limit(1)- )- if existing:- raise ValueError(f"Credential name '{name}' already exists for this provider")-- credential_encrypter: ProviderConfigEncrypter | None = None- if credential_type != CredentialType.UNAUTHORIZED:- credential_encrypter, _ = create_provider_encrypter(- tenant_id=tenant_id,- config=provider_controller.get_credential_schema_config(credential_type),- cache=NoOpProviderCredentialCache(),- )-- properties_encrypter, _ = create_provider_encrypter(- tenant_id=tenant_id,- config=provider_controller.get_properties_schema(),- cache=NoOpProviderCredentialCache(),- )-- # Create provider record- subscription = TriggerSubscription(- tenant_id=tenant_id,- user_id=user_id,- name=name,- endpoint_id=endpoint_id,- provider_id=str(provider_id),- parameters=dict(parameters),- properties=dict(properties_encrypter.encrypt(dict(properties))),- credentials=dict(credential_encrypter.encrypt(dict(credentials)))- if credential_encrypter- else {},- credential_type=credential_type,- credential_expires_at=credential_expires_at,- expires_at=expires_at,- )- subscription.id = subscription_id or str(uuid.uuid4())-- session.add(subscription)-- return {- "result": "success",- "id": str(subscription.id),- }-- except Exception as e:- logger.exception("Failed to add trigger provider")- raise ValueError(str(e)) from e-- @classmethod- def update_trigger_subscription(- cls,- tenant_id: str,- subscription_id: str,- name: str | None = None,- properties: Mapping[str, Any] | None = None,- parameters: Mapping[str, Any] | None = None,- credentials: Mapping[str, Any] | None = None,- credential_expires_at: int | None = None,- expires_at: int | None = None,- ) -> None:- """- Update an existing trigger subscription.-- :param tenant_id: Tenant ID- :param subscription_id: Subscription instance ID- :param name: Optional new name for this subscription- :param properties: Optional new properties- :param parameters: Optional new parameters- :param credentials: Optional new credentials- :param credential_expires_at: Optional new credential expiration timestamp- :param expires_at: Optional new expiration timestamp- :return: Success response with updated subscription info- """- with sessionmaker(bind=db.engine, expire_on_commit=False).begin() as session:- # Use distributed lock to prevent race conditions on the same subscription- lock_key = f"trigger_subscription_update_lock:{tenant_id}_{subscription_id}"- with redis_client.lock(lock_key, timeout=20):- subscription = session.scalar(- select(TriggerSubscription)- .where(- TriggerSubscription.tenant_id == tenant_id,- TriggerSubscription.id == subscription_id,- )- .limit(1)- )- if not subscription:- raise ValueError(f"Trigger subscription {subscription_id} not found")-- provider_id = TriggerProviderID(subscription.provider_id)- provider_controller = TriggerManager.get_trigger_provider(tenant_id, provider_id)-- # Check for name uniqueness if name is being updated- if name is not None and name != subscription.name:- existing = session.scalar(- select(TriggerSubscription)- .where(- TriggerSubscription.tenant_id == tenant_id,- TriggerSubscription.provider_id == str(provider_id),- TriggerSubscription.name == name,- )- .limit(1)- )- if existing:- raise ValueError(f"Subscription name '{name}' already exists for this provider")- subscription.name = name-- # Update properties if provided- if properties is not None:- properties_encrypter, _ = create_provider_encrypter(- tenant_id=tenant_id,- config=provider_controller.get_properties_schema(),- cache=NoOpProviderCredentialCache(),- )- # Handle hidden values - preserve original encrypted values- original_properties = properties_encrypter.decrypt(subscription.properties)- new_properties: dict[str, Any] = {- key: value if value != HIDDEN_VALUE else original_properties.get(key, UNKNOWN_VALUE)- for key, value in properties.items()- }- subscription.properties = dict(properties_encrypter.encrypt(new_properties))-- # Update parameters if provided- if parameters is not None:- subscription.parameters = dict(parameters)-- # Update credentials if provided- if credentials is not None:- credential_type = CredentialType.of(subscription.credential_type)- credential_encrypter, _ = create_provider_encrypter(- tenant_id=tenant_id,- config=provider_controller.get_credential_schema_config(credential_type),- cache=NoOpProviderCredentialCache(),- )- subscription.credentials = dict(credential_encrypter.encrypt(dict(credentials)))-- # Update credential expiration timestamp if provided- if credential_expires_at is not None:- subscription.credential_expires_at = credential_expires_at-- # Update expiration timestamp if provided- if expires_at is not None:- subscription.expires_at = expires_at-- # Invalidate after commit so a cache miss observes committed credentials.- delete_cache_for_subscription(- tenant_id=tenant_id, provider_id=subscription.provider_id, subscription_id=subscription.id- )+ Console management and builder writes use the injected TriggerSubscriptionService.+ TODO: Retire these ORM-returning reads when webhook dispatch, dynamic options and+ renewal tasks migrate to detached subscription queries and explicit dependencies.+ """@classmethoddef get_subscription_by_id(@@ -288,60 +74,6 @@ class TriggerProviderService:subscription.properties = dict(properties_encrypter.decrypt(subscription.properties))return subscription- @classmethod- def delete_trigger_provider(cls, tenant_id: str, subscription_id: str, *, session: Session):- """- Delete a trigger provider subscription within an existing session.-- :param session: Database session- :param tenant_id: Tenant ID- :param subscription_id: Subscription instance ID- :return: Success response- """- subscription = session.scalar(- select(TriggerSubscription)- .where(- TriggerSubscription.tenant_id == tenant_id,- TriggerSubscription.id == subscription_id,- )- .limit(1)- )- if not subscription:- raise ValueError(f"Trigger provider subscription {subscription_id} not found")-- credential_type: CredentialType = CredentialType.of(subscription.credential_type)- provider_id = TriggerProviderID(subscription.provider_id)- provider_controller: PluginTriggerProviderController = TriggerManager.get_trigger_provider(- tenant_id=tenant_id, provider_id=provider_id- )- encrypter, _ = create_trigger_provider_encrypter_for_subscription(- tenant_id=tenant_id,- controller=provider_controller,- subscription=subscription,- )-- is_auto_created: bool = credential_type in [CredentialType.OAUTH2, CredentialType.API_KEY]- if is_auto_created:- try:- TriggerManager.unsubscribe_trigger(- tenant_id=tenant_id,- user_id=subscription.user_id,- provider_id=provider_id,- subscription=subscription.to_entity(),- credentials=encrypter.decrypt(subscription.credentials),- credential_type=credential_type,- )- except Exception as e:- logger.exception("Error unsubscribing trigger", exc_info=e)-- session.delete(subscription)- # Clear cache- delete_cache_for_subscription(- tenant_id=tenant_id,- provider_id=subscription.provider_id,- subscription_id=subscription.id,- )-@classmethoddef refresh_oauth_token(cls,@@ -614,127 +346,3 @@ class TriggerProviderService:)subscription.properties = dict(properties_encrypter.decrypt(subscription.properties))return subscription-- @classmethod- def verify_subscription_credentials(- cls,- tenant_id: str,- user_id: str,- provider_id: TriggerProviderID,- subscription_id: str,- credentials: dict[str, Any],- ) -> VerifyCredentialsResult:- """- Verify credentials for an existing subscription without updating it.-- This is used in edit mode to validate new credentials before rebuild.-- :param tenant_id: Tenant ID- :param user_id: User ID- :param provider_id: Provider identifier- :param subscription_id: Subscription ID- :param credentials: New credentials to verify- :return: dict with 'verified' boolean- """- provider_controller = TriggerManager.get_trigger_provider(tenant_id, provider_id)- if not provider_controller:- raise ValueError(f"Provider {provider_id} not found")-- subscription = cls.get_subscription_by_id(- tenant_id=tenant_id,- subscription_id=subscription_id,- )- if not subscription:- raise ValueError(f"Subscription {subscription_id} not found")-- credential_type = CredentialType.of(subscription.credential_type)-- # For API Key, validate the new credentials- if credential_type == CredentialType.API_KEY:- new_credentials: dict[str, Any] = {- key: value if value != HIDDEN_VALUE else subscription.credentials.get(key, UNKNOWN_VALUE)- for key, value in credentials.items()- }- try:- provider_controller.validate_credentials(user_id, credentials=new_credentials)- return {"verified": True}- except Exception as e:- raise ValueError(f"Invalid credentials: {e}") from e-- return {"verified": True}-- @classmethod- def rebuild_trigger_subscription(- cls,- tenant_id: str,- provider_id: TriggerProviderID,- subscription_id: str,- credentials: Mapping[str, Any],- parameters: Mapping[str, Any],- name: str | None = None,- ) -> None:- """- Create a subscription builder for rebuilding an existing subscription.-- This method rebuild the subscription by call DELETE and CREATE API of the third party provider(e.g. GitHub)- keeping the same subscription_id and endpoint_id so the webhook URL remains unchanged.-- :param tenant_id: Tenant ID- :param name: Name for the subscription- :param subscription_id: Subscription ID- :param provider_id: Provider identifier- :param credentials: Credentials for the subscription- :param parameters: Parameters for the subscription- :return: SubscriptionBuilderApiEntity- """- provider_controller = TriggerManager.get_trigger_provider(tenant_id, provider_id)- if not provider_controller:- raise ValueError(f"Provider {provider_id} not found")-- subscription = TriggerProviderService.get_subscription_by_id(- tenant_id=tenant_id,- subscription_id=subscription_id,- )- if not subscription:- raise ValueError(f"Subscription {subscription_id} not found")-- credential_type = CredentialType.of(subscription.credential_type)- if credential_type not in {CredentialType.OAUTH2, CredentialType.API_KEY}:- raise ValueError(f"Credential type {credential_type} not supported for auto creation")-- # Delete the previous subscription- user_id = subscription.user_id- unsubscribe_result = TriggerManager.unsubscribe_trigger(- tenant_id=tenant_id,- user_id=user_id,- provider_id=provider_id,- subscription=subscription.to_entity(),- credentials=subscription.credentials,- credential_type=credential_type,- )- if not unsubscribe_result.success:- raise ValueError(f"Failed to delete previous subscription: {unsubscribe_result.message}")-- # Create a new subscription with the same subscription_id and endpoint_id- new_credentials: dict[str, Any] = {- key: value if value != HIDDEN_VALUE else subscription.credentials.get(key, UNKNOWN_VALUE)- for key, value in credentials.items()- }- new_subscription: TriggerSubscriptionEntity = TriggerManager.subscribe_trigger(- tenant_id=tenant_id,- user_id=user_id,- provider_id=provider_id,- endpoint=generate_plugin_trigger_endpoint_url(subscription.endpoint_id),- parameters=parameters,- credentials=new_credentials,- credential_type=credential_type,- )- TriggerProviderService.update_trigger_subscription(- tenant_id=tenant_id,- subscription_id=subscription.id,- name=name,- parameters=parameters,- credentials=new_credentials,- properties=new_subscription.properties,- expires_at=new_subscription.expires_at,- )diff --git a/api/services/trigger/trigger_subscription_operator_service.py b/api/services/trigger/trigger_subscription_operator_service.pyindex 491723c6ec2..24a9e5ce378 100644--- a/api/services/trigger/trigger_subscription_operator_service.py+++ b/api/services/trigger/trigger_subscription_operator_service.py@@ -38,28 +38,3 @@ class TriggerSubscriptionOperatorService:)).all()return list(subscribers)-- @classmethod- def delete_plugin_trigger_by_subscription(cls, tenant_id: str, subscription_id: str, *, session: Session) -> None:- """Delete a plugin trigger by tenant_id and subscription_id within an existing session-- Args:- session: Database session- tenant_id: The tenant ID- subscription_id: The subscription ID-- Raises:- NotFound: If plugin trigger not found- """- # Find plugin trigger using indexed columns- plugin_trigger = session.scalar(- select(WorkflowPluginTrigger).where(- WorkflowPluginTrigger.tenant_id == tenant_id,- WorkflowPluginTrigger.subscription_id == subscription_id,- )- )-- if not plugin_trigger:- return-- session.delete(plugin_trigger)diff --git a/api/tests/e2e_tests/containers/repositories/test_trigger_subscription_repository.py b/api/tests/e2e_tests/containers/repositories/test_trigger_subscription_repository.pynew file mode 100644index 00000000000..b4d72f21f01--- /dev/null+++ b/api/tests/e2e_tests/containers/repositories/test_trigger_subscription_repository.py@@ -0,0 +1,125 @@+"""Execute subscription snapshot locking and name conflicts against real PostgreSQL in CI."""++from collections.abc import Sequence+from concurrent.futures import ThreadPoolExecutor+from dataclasses import replace+from threading import Barrier+from uuid import uuid4++from psycopg2.errors import UniqueViolation+from sqlalchemy import event+from sqlalchemy.exc import IntegrityError+from sqlalchemy.orm import Session, UOWTransaction, sessionmaker++from core.plugin.entities.plugin_daemon import CredentialType+from models.enums import PermissionEnum+from repositories.trigger.subscription_repository import TriggerSubscriptionRepository+from services.trigger.subscription_service import (+ TriggerSubscriptionChangedError,+ TriggerSubscriptionNameConflictError,+ TriggerSubscriptionSnapshot,+)+++def test_concurrent_updates_preserve_one_complete_subscription_snapshot(db_session_with_containers: Session) -> None:+ repository = TriggerSubscriptionRepository(+ session_factory=sessionmaker(bind=db_session_with_containers.get_bind(), expire_on_commit=False)+ )+ original = TriggerSubscriptionSnapshot(+ id=str(uuid4()),+ name="Concurrent subscription",+ tenant_id=str(uuid4()),+ user_id=str(uuid4()),+ provider_id="langgenius/github/github",+ endpoint_id=str(uuid4()),+ credential_type=CredentialType.API_KEY,+ parameters={"events": ["push"]},+ properties={"remote_id": "original"},+ credentials={"token": "original-ciphertext"},+ credential_expires_at=-1,+ expires_at=-1,+ visibility=PermissionEnum.ALL_TEAM,+ )+ repository.create(subscription=original, max_count=10)+ barrier = Barrier(2)+ replacements = (+ replace(original, parameters={"events": ["issues"]}, credentials={"token": "first-ciphertext"}),+ replace(original, parameters={"events": ["release"]}, credentials={"token": "second-ciphertext"}),+ )++ def update(replacement: TriggerSubscriptionSnapshot) -> bool:+ barrier.wait(timeout=10)+ try:+ repository.update(expected=original, replacement=replacement)+ except TriggerSubscriptionChangedError:+ return False+ return True++ with ThreadPoolExecutor(max_workers=2) as executor:+ results = list(executor.map(update, replacements))++ assert sorted(results) == [False, True]+ assert (+ repository.get(tenant_id=original.tenant_id, subscription_id=original.id) == replacements[results.index(True)]+ )+++def test_concurrent_renames_translate_postgres_unique_violation(db_session_with_containers: Session) -> None:+ session_factory = sessionmaker(bind=db_session_with_containers.get_bind(), expire_on_commit=False)+ repository = TriggerSubscriptionRepository(session_factory=session_factory)+ first = TriggerSubscriptionSnapshot(+ id=str(uuid4()),+ name="First subscription",+ tenant_id=str(uuid4()),+ user_id=str(uuid4()),+ provider_id="langgenius/github/github",+ endpoint_id=str(uuid4()),+ credential_type=CredentialType.API_KEY,+ parameters={"events": ["push"]},+ properties={"remote_id": "original"},+ credentials={"token": "original-ciphertext"},+ credential_expires_at=-1,+ expires_at=-1,+ visibility=PermissionEnum.ALL_TEAM,+ )+ originals = (first, replace(first, id=str(uuid4()), name="Second subscription", endpoint_id=str(uuid4())))+ for original in originals:+ repository.create(subscription=original, max_count=10)+ replacements = tuple(+ replace(original, name="Shared name", credentials={"token": f"replacement-{index}"})+ for index, original in enumerate(originals)+ )+ barrier = Barrier(2)++ def wait_before_flush(+ _session: Session, _flush_context: UOWTransaction, _instances: Sequence[object] | None+ ) -> None:+ # Both real name prechecks must finish before either UPDATE reaches PostgreSQL.+ barrier.wait(timeout=10)++ def rename(index: int) -> TriggerSubscriptionNameConflictError | None:+ try:+ repository.update(expected=originals[index], replacement=replacements[index])+ except TriggerSubscriptionNameConflictError as error:+ return error+ return None++ event.listen(session_factory, "before_flush", wait_before_flush)+ try:+ with ThreadPoolExecutor(max_workers=2) as executor:+ results = list(executor.map(rename, range(2)))+ finally:+ event.remove(session_factory, "before_flush", wait_before_flush)++ assert sum(error is None for error in results) == 1+ for index, error in enumerate(results):+ current = repository.get(tenant_id=originals[index].tenant_id, subscription_id=originals[index].id)+ if error is None:+ assert current == replacements[index]+ else:+ assert current == originals[index]+ assert "Shared name" in str(error)+ # Prove this exercised the database constraint, not the prequery rejection.+ assert isinstance(error.__cause__, IntegrityError)+ assert isinstance(error.__cause__.orig, UniqueViolation)+ assert error.__cause__.orig.diag.constraint_name == "unique_trigger_provider"diff --git a/api/tests/e2e_tests/containers/services/test_trigger_provider_service.py b/api/tests/e2e_tests/containers/services/test_trigger_provider_service.pydeleted file mode 100644index c42187afac6..00000000000--- a/api/tests/e2e_tests/containers/services/test_trigger_provider_service.py+++ /dev/null@@ -1,572 +0,0 @@-from collections.abc import Generator-from unittest.mock import MagicMock, patch--import pytest-from faker import Faker-from sqlalchemy.orm import Session--from constants import HIDDEN_VALUE, UNKNOWN_VALUE-from core.plugin.entities.plugin_daemon import CredentialType-from core.trigger.entities.entities import Subscription as TriggerSubscriptionEntity-from models.account import Account, Tenant-from models.provider_ids import TriggerProviderID-from models.trigger import TriggerSubscription-from services.trigger.trigger_provider_service import TriggerProviderService-from tests.e2e_tests.containers.helpers import generate_valid_password--MockExternalServiceDependencies = dict[str, MagicMock]---class TestTriggerProviderService:- """Integration tests for TriggerProviderService using testcontainers."""-- @pytest.fixture- def mock_external_service_dependencies(self) -> Generator[MockExternalServiceDependencies]:- """Mock setup for external service dependencies."""- with (- patch("services.trigger.trigger_provider_service.TriggerManager") as mock_trigger_manager,- patch("services.trigger.trigger_provider_service.redis_client") as mock_redis_client,- patch("services.trigger.trigger_provider_service.delete_cache_for_subscription") as mock_delete_cache,- patch("services.account.login_adapters.SystemFeatureService") as mock_account_feature_service,- ):- # Setup default mock returns- mock_provider_controller = MagicMock()- mock_provider_controller.get_credential_schema_config.return_value = MagicMock()- mock_provider_controller.get_properties_schema.return_value = MagicMock()- mock_trigger_manager.get_trigger_provider.return_value = mock_provider_controller-- # Mock redis lock- mock_lock = MagicMock()- mock_lock.__enter__ = MagicMock(return_value=None)- mock_lock.__exit__ = MagicMock(return_value=None)- mock_redis_client.lock.return_value = mock_lock-- # Setup account feature service mock- mock_account_feature_service.is_registration_allowed.return_value = True-- yield {- "trigger_manager": mock_trigger_manager,- "redis_client": mock_redis_client,- "delete_cache": mock_delete_cache,- "provider_controller": mock_provider_controller,- "account_feature_service": mock_account_feature_service,- }-- def _create_test_account_and_tenant(- self,- mock_external_service_dependencies: MockExternalServiceDependencies,- db_session_with_containers: Session,- ) -> tuple[Account, Tenant]:- """- Helper method to create a test account and tenant for testing.-- Args:- mock_external_service_dependencies: Mock dependencies-- Returns:- tuple: (account, tenant) - Created account and tenant instances- """- fake = Faker()-- from tests.e2e_tests.containers.helpers import accounts as account_fixtures-- # Setup mocks for account creation- mock_external_service_dependencies["account_feature_service"].is_registration_allowed.return_value = True- mock_external_service_dependencies[- "trigger_manager"- ].get_trigger_provider.return_value = mock_external_service_dependencies["provider_controller"]-- # Create account and tenant- account = account_fixtures.create_account(- email=fake.email(),- name=fake.name(),- interface_language="en-US",- password=generate_valid_password(fake),- session=db_session_with_containers,- )- account_fixtures.create_owner_workspace(account, name=fake.company(), session=db_session_with_containers)- tenant = account.current_tenant- assert tenant is not None-- return account, tenant-- def _create_test_subscription(- self,- db_session_with_containers: Session,- tenant_id: str,- user_id: str,- provider_id: TriggerProviderID,- credential_type: CredentialType,- credentials: dict[str, str],- mock_external_service_dependencies: MockExternalServiceDependencies,- name: str | None = None,- ) -> TriggerSubscription:- """- Helper method to create a test trigger subscription.-- Args:- db_session_with_containers: Database session- tenant_id: Tenant ID- user_id: User ID- provider_id: Provider ID- credential_type: Credential type- credentials: Credentials dict- mock_external_service_dependencies: Mock dependencies- name: Optional subscription name. Pass a deterministic value when a test depends on name uniqueness.-- Returns:- TriggerSubscription: Created subscription instance- """- fake = Faker()- from core.helper.provider_cache import NoOpProviderCredentialCache- from core.helper.provider_encryption import create_provider_encrypter-- # Use mock provider controller to encrypt credentials- provider_controller = mock_external_service_dependencies["provider_controller"]-- # Create encrypter for credentials- credential_encrypter, _ = create_provider_encrypter(- tenant_id=tenant_id,- config=provider_controller.get_credential_schema_config(credential_type),- cache=NoOpProviderCredentialCache(),- )-- subscription = TriggerSubscription(- name=name or fake.word(),- tenant_id=tenant_id,- user_id=user_id,- provider_id=str(provider_id),- endpoint_id=fake.uuid4(),- parameters={"param1": "value1"},- properties={"prop1": "value1"},- credentials=dict(credential_encrypter.encrypt(credentials)),- credential_type=credential_type,- credential_expires_at=-1,- expires_at=-1,- )-- db_session_with_containers.add(subscription)- db_session_with_containers.commit()- db_session_with_containers.refresh(subscription)-- return subscription-- def test_rebuild_trigger_subscription_success_with_merged_credentials(- self, db_session_with_containers: Session, mock_external_service_dependencies: MockExternalServiceDependencies- ) -> None:- """- Test successful rebuild with credential merging (HIDDEN_VALUE handling).-- This test verifies:- - Credentials are properly merged (HIDDEN_VALUE replaced with existing values)- - Single transaction wraps all operations- - Merged credentials are used for subscribe and update- - Database state is correctly updated- """-- account, tenant = self._create_test_account_and_tenant(- mock_external_service_dependencies, db_session_with_containers- )-- provider_id = TriggerProviderID("test_org/test_plugin/test_provider")- credential_type = CredentialType.API_KEY-- # Create initial subscription with credentials- original_credentials = {"api_key": "original-secret-key", "api_secret": "original-secret"}- subscription = self._create_test_subscription(- db_session_with_containers,- tenant.id,- account.id,- provider_id,- credential_type,- original_credentials,- mock_external_service_dependencies,- )-- # Prepare new credentials with HIDDEN_VALUE for api_key (should keep original)- # and new value for api_secret (should update)- new_credentials = {- "api_key": HIDDEN_VALUE, # Should be replaced with original- "api_secret": "new-secret-value", # Should be updated- }-- # Mock subscribe_trigger to return a new subscription entity- new_subscription_entity = TriggerSubscriptionEntity(- endpoint=subscription.endpoint_id,- parameters={"param1": "value1"},- properties={"prop1": "new_prop_value"},- expires_at=1234567890,- )- mock_external_service_dependencies["trigger_manager"].subscribe_trigger.return_value = new_subscription_entity-- # Mock unsubscribe_trigger- mock_external_service_dependencies["trigger_manager"].unsubscribe_trigger.return_value = MagicMock()-- # Execute rebuild- TriggerProviderService.rebuild_trigger_subscription(- tenant_id=tenant.id,- provider_id=provider_id,- subscription_id=subscription.id,- credentials=new_credentials,- parameters={"param1": "updated_value"},- name="updated_name",- )-- # Verify unsubscribe was called with decrypted original credentials- mock_external_service_dependencies["trigger_manager"].unsubscribe_trigger.assert_called_once()- unsubscribe_call_args = mock_external_service_dependencies["trigger_manager"].unsubscribe_trigger.call_args- assert unsubscribe_call_args.kwargs["tenant_id"] == tenant.id- assert unsubscribe_call_args.kwargs["provider_id"] == provider_id- assert unsubscribe_call_args.kwargs["credential_type"] == credential_type-- # Verify subscribe was called with merged credentials (api_key from original, api_secret new)- mock_external_service_dependencies["trigger_manager"].subscribe_trigger.assert_called_once()- subscribe_call_args = mock_external_service_dependencies["trigger_manager"].subscribe_trigger.call_args- subscribe_credentials = subscribe_call_args.kwargs["credentials"]- assert subscribe_credentials["api_key"] == original_credentials["api_key"] # Merged from original- assert subscribe_credentials["api_secret"] == "new-secret-value" # New value-- # Verify database state was updated- db_session_with_containers.refresh(subscription)- assert subscription.name == "updated_name"- assert subscription.parameters == {"param1": "updated_value"}-- # Verify credentials in DB were updated with merged values (decrypt to check)- from core.helper.provider_cache import NoOpProviderCredentialCache- from core.helper.provider_encryption import create_provider_encrypter-- # Use mock provider controller to decrypt credentials- provider_controller = mock_external_service_dependencies["provider_controller"]- credential_encrypter, _ = create_provider_encrypter(- tenant_id=tenant.id,- config=provider_controller.get_credential_schema_config(credential_type),- cache=NoOpProviderCredentialCache(),- )- decrypted_db_credentials = dict(credential_encrypter.decrypt(subscription.credentials))- assert decrypted_db_credentials["api_key"] == original_credentials["api_key"]- assert decrypted_db_credentials["api_secret"] == "new-secret-value"-- # Verify cache was cleared- mock_external_service_dependencies["delete_cache"].assert_called_once_with(- tenant_id=tenant.id,- provider_id=subscription.provider_id,- subscription_id=subscription.id,- )-- def test_rebuild_trigger_subscription_with_all_new_credentials(- self, db_session_with_containers: Session, mock_external_service_dependencies: MockExternalServiceDependencies- ) -> None:- """- Test rebuild when all credentials are new (no HIDDEN_VALUE).-- This test verifies:- - All new credentials are used when no HIDDEN_VALUE is present- - Merged credentials contain only new values- """-- account, tenant = self._create_test_account_and_tenant(- mock_external_service_dependencies, db_session_with_containers- )-- provider_id = TriggerProviderID("test_org/test_plugin/test_provider")- credential_type = CredentialType.API_KEY-- # Create initial subscription- original_credentials = {"api_key": "original-key", "api_secret": "original-secret"}- subscription = self._create_test_subscription(- db_session_with_containers,- tenant.id,- account.id,- provider_id,- credential_type,- original_credentials,- mock_external_service_dependencies,- )-- # All new credentials (no HIDDEN_VALUE)- new_credentials = {- "api_key": "completely-new-key",- "api_secret": "completely-new-secret",- }-- new_subscription_entity = TriggerSubscriptionEntity(- endpoint=subscription.endpoint_id,- parameters={},- properties={},- expires_at=-1,- )- mock_external_service_dependencies["trigger_manager"].subscribe_trigger.return_value = new_subscription_entity- mock_external_service_dependencies["trigger_manager"].unsubscribe_trigger.return_value = MagicMock()-- # Execute rebuild- TriggerProviderService.rebuild_trigger_subscription(- tenant_id=tenant.id,- provider_id=provider_id,- subscription_id=subscription.id,- credentials=new_credentials,- parameters={},- )-- # Verify subscribe was called with all new credentials- subscribe_call_args = mock_external_service_dependencies["trigger_manager"].subscribe_trigger.call_args- subscribe_credentials = subscribe_call_args.kwargs["credentials"]- assert subscribe_credentials["api_key"] == "completely-new-key"- assert subscribe_credentials["api_secret"] == "completely-new-secret"-- def test_rebuild_trigger_subscription_with_all_hidden_values(- self, db_session_with_containers: Session, mock_external_service_dependencies: MockExternalServiceDependencies- ) -> None:- """- Test rebuild when all credentials are HIDDEN_VALUE (preserve all existing).-- This test verifies:- - All HIDDEN_VALUE credentials are replaced with existing values- - Original credentials are preserved- """-- account, tenant = self._create_test_account_and_tenant(- mock_external_service_dependencies, db_session_with_containers- )-- provider_id = TriggerProviderID("test_org/test_plugin/test_provider")- credential_type = CredentialType.API_KEY-- original_credentials = {"api_key": "original-key", "api_secret": "original-secret"}- subscription = self._create_test_subscription(- db_session_with_containers,- tenant.id,- account.id,- provider_id,- credential_type,- original_credentials,- mock_external_service_dependencies,- )-- # All HIDDEN_VALUE (should preserve all original)- new_credentials = {- "api_key": HIDDEN_VALUE,- "api_secret": HIDDEN_VALUE,- }-- new_subscription_entity = TriggerSubscriptionEntity(- endpoint=subscription.endpoint_id,- parameters={},- properties={},- expires_at=-1,- )- mock_external_service_dependencies["trigger_manager"].subscribe_trigger.return_value = new_subscription_entity- mock_external_service_dependencies["trigger_manager"].unsubscribe_trigger.return_value = MagicMock()-- # Execute rebuild- TriggerProviderService.rebuild_trigger_subscription(- tenant_id=tenant.id,- provider_id=provider_id,- subscription_id=subscription.id,- credentials=new_credentials,- parameters={},- )-- # Verify subscribe was called with all original credentials- subscribe_call_args = mock_external_service_dependencies["trigger_manager"].subscribe_trigger.call_args- subscribe_credentials = subscribe_call_args.kwargs["credentials"]- assert subscribe_credentials["api_key"] == original_credentials["api_key"]- assert subscribe_credentials["api_secret"] == original_credentials["api_secret"]-- def test_rebuild_trigger_subscription_with_missing_key_uses_unknown_value(- self, db_session_with_containers: Session, mock_external_service_dependencies: MockExternalServiceDependencies- ) -> None:- """- Test rebuild when HIDDEN_VALUE is used for a key that doesn't exist in original.-- This test verifies:- - UNKNOWN_VALUE is used when HIDDEN_VALUE key doesn't exist in original credentials- """-- account, tenant = self._create_test_account_and_tenant(- mock_external_service_dependencies, db_session_with_containers- )-- provider_id = TriggerProviderID("test_org/test_plugin/test_provider")- credential_type = CredentialType.API_KEY-- # Original has only api_key- original_credentials = {"api_key": "original-key"}- subscription = self._create_test_subscription(- db_session_with_containers,- tenant.id,- account.id,- provider_id,- credential_type,- original_credentials,- mock_external_service_dependencies,- )-- # HIDDEN_VALUE for non-existent key should use UNKNOWN_VALUE- new_credentials = {- "api_key": HIDDEN_VALUE,- "non_existent_key": HIDDEN_VALUE, # This key doesn't exist in original- }-- new_subscription_entity = TriggerSubscriptionEntity(- endpoint=subscription.endpoint_id,- parameters={},- properties={},- expires_at=-1,- )- mock_external_service_dependencies["trigger_manager"].subscribe_trigger.return_value = new_subscription_entity- mock_external_service_dependencies["trigger_manager"].unsubscribe_trigger.return_value = MagicMock()-- # Execute rebuild- TriggerProviderService.rebuild_trigger_subscription(- tenant_id=tenant.id,- provider_id=provider_id,- subscription_id=subscription.id,- credentials=new_credentials,- parameters={},- )-- # Verify subscribe was called with original api_key and UNKNOWN_VALUE for missing key- subscribe_call_args = mock_external_service_dependencies["trigger_manager"].subscribe_trigger.call_args- subscribe_credentials = subscribe_call_args.kwargs["credentials"]- assert subscribe_credentials["api_key"] == original_credentials["api_key"]- assert subscribe_credentials["non_existent_key"] == UNKNOWN_VALUE-- def test_rebuild_trigger_subscription_rollback_on_error(- self, db_session_with_containers: Session, mock_external_service_dependencies: MockExternalServiceDependencies- ) -> None:- """- Test that transaction is rolled back on error.-- This test verifies:- - Database transaction is rolled back when an error occurs- - Original subscription state is preserved- """-- account, tenant = self._create_test_account_and_tenant(- mock_external_service_dependencies, db_session_with_containers- )-- provider_id = TriggerProviderID("test_org/test_plugin/test_provider")- credential_type = CredentialType.API_KEY-- original_credentials = {"api_key": "original-key"}- subscription = self._create_test_subscription(- db_session_with_containers,- tenant.id,- account.id,- provider_id,- credential_type,- original_credentials,- mock_external_service_dependencies,- )-- original_name = subscription.name- original_parameters = subscription.parameters.copy()-- # Make subscribe_trigger raise an error- mock_external_service_dependencies["trigger_manager"].subscribe_trigger.side_effect = ValueError(- "Subscribe failed"- )- mock_external_service_dependencies["trigger_manager"].unsubscribe_trigger.return_value = MagicMock()-- # Execute rebuild and expect error- with pytest.raises(ValueError, match="Subscribe failed"):- TriggerProviderService.rebuild_trigger_subscription(- tenant_id=tenant.id,- provider_id=provider_id,- subscription_id=subscription.id,- credentials={"api_key": "new-key"},- parameters={},- )-- # Verify subscription state was not changed (rolled back)- db_session_with_containers.refresh(subscription)- assert subscription.name == original_name- assert subscription.parameters == original_parameters-- def test_rebuild_trigger_subscription_subscription_not_found(- self, mock_external_service_dependencies: MockExternalServiceDependencies, db_session_with_containers: Session- ) -> None:- """- Test error when subscription is not found.-- This test verifies:- - Proper error is raised when subscription doesn't exist- """- fake = Faker()- account, tenant = self._create_test_account_and_tenant(- mock_external_service_dependencies, db_session_with_containers- )-- provider_id = TriggerProviderID("test_org/test_plugin/test_provider")- fake_subscription_id = fake.uuid4()-- with pytest.raises(ValueError, match="not found"):- TriggerProviderService.rebuild_trigger_subscription(- tenant_id=tenant.id,- provider_id=provider_id,- subscription_id=fake_subscription_id,- credentials={},- parameters={},- )-- def test_rebuild_trigger_subscription_name_uniqueness_check(- self, db_session_with_containers: Session, mock_external_service_dependencies: MockExternalServiceDependencies- ) -> None:- """- Test that name uniqueness is checked when updating name.-- This test verifies:- - Error is raised when new name conflicts with existing subscription- """-- account, tenant = self._create_test_account_and_tenant(- mock_external_service_dependencies, db_session_with_containers- )-- provider_id = TriggerProviderID("test_org/test_plugin/test_provider")- credential_type = CredentialType.API_KEY-- # Create first subscription- subscription1 = self._create_test_subscription(- db_session_with_containers,- tenant.id,- account.id,- provider_id,- credential_type,- {"api_key": "key1"},- mock_external_service_dependencies,- name="subscription-1",- )-- # Create second subscription with different name- subscription2 = self._create_test_subscription(- db_session_with_containers,- tenant.id,- account.id,- provider_id,- credential_type,- {"api_key": "key2"},- mock_external_service_dependencies,- name="subscription-2",- )-- new_subscription_entity = TriggerSubscriptionEntity(- endpoint=subscription2.endpoint_id,- parameters={},- properties={},- expires_at=-1,- )- mock_external_service_dependencies["trigger_manager"].subscribe_trigger.return_value = new_subscription_entity- mock_external_service_dependencies["trigger_manager"].unsubscribe_trigger.return_value = MagicMock()-- # Try to rename subscription2 to subscription1's name (should fail)- with pytest.raises(ValueError, match="already exists"):- TriggerProviderService.rebuild_trigger_subscription(- tenant_id=tenant.id,- provider_id=provider_id,- subscription_id=subscription2.id,- credentials={"api_key": "new-key"},- parameters={},- name=subscription1.name, # Conflicting name- )diff --git a/api/tests/e2e_tests/containers/services/test_trigger_subscription_management.py b/api/tests/e2e_tests/containers/services/test_trigger_subscription_management.pynew file mode 100644index 00000000000..c7fa2f75fdd--- /dev/null+++ b/api/tests/e2e_tests/containers/services/test_trigger_subscription_management.py@@ -0,0 +1,504 @@+"""Management HTTP tests use real SQL, Redis locks/caches, RSA and plugin transport."""++from contextvars import Context+from dataclasses import replace+from http import HTTPStatus+from socket import socket+from uuid import uuid4++import pytest+from redis import Redis+from redis.backoff import NoBackoff+from redis.exceptions import ConnectionError as RedisConnectionError+from redis.exceptions import LockNotOwnedError+from redis.exceptions import TimeoutError as RedisTimeoutError+from redis.retry import Retry+from sqlalchemy import Connection, Engine, event, select+from sqlalchemy.orm import Session++from constants import HIDDEN_VALUE, UNKNOWN_VALUE+from core.helper.encrypter import decrypt_token, encrypt_token+from core.plugin.entities.plugin_daemon import CredentialType+from core.trigger.utils.encryption import TriggerProviderCredentialsCache, TriggerProviderPropertiesCache+from core.trigger.utils.endpoint import generate_plugin_trigger_endpoint_url+from extensions.ext_application_services import application_services+from extensions.ext_redis import redis_client+from models.account import TenantAccountRole+from models.trigger import TriggerSubscription, WorkflowPluginTrigger+from repositories.trigger.subscription_repository import RedisTriggerSubscriptionLocks, TriggerSubscriptionRepository+from services.trigger.subscription_codec import ProviderTriggerSubscriptionCodec+from services.trigger.subscription_gateway import PluginTriggerSubscriptionGateway+from services.trigger.subscription_service import TriggerSubscriptionLeaseLostError, TriggerSubscriptionService+from tests.e2e_tests.containers.services import test_trigger_subscription_builder+from tests.e2e_tests.containers.services.test_trigger_subscription_query import _provider_with_secrets+from tests.unit_tests.controllers.console.workspace import test_trigger_oauth_client+from tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client import _PROVIDER, _Harness+from tests.unit_tests.controllers.console.workspace.test_trigger_subscription_builder import _BASE, _Daemon+from tests.unit_tests.controllers.console.workspace.test_trigger_subscription_management import _url+from tests.unit_tests.controllers.console.workspace.test_trigger_subscription_query import _add_subscription++application_redis = test_trigger_subscription_builder.application_redis+sqlite_engine = test_trigger_subscription_builder.sqlite_engine+sqlite_session_factory = test_trigger_subscription_builder.sqlite_session_factory+harness = test_trigger_oauth_client.harness+daemon = test_trigger_subscription_builder.daemon+++def test_subscription_lease_renews_and_does_not_release_a_successor(harness: _Harness) -> None:+ """Renew an owned Redis lease and fail closed if another owner replaces it."""+ subscription_id = str(uuid4())+ key = f"trigger_subscription_update_lock:{harness.tenant_id}_{subscription_id}"+ locks = RedisTriggerSubscriptionLocks(redis=redis_client)+ successor = b"successor-owner"+ try:+ with locks.for_subscription(tenant_id=harness.tenant_id, subscription_id=subscription_id) as lease:+ assert redis_client.expire(key, 2)+ lease.ensure_owned()+ assert 45 <= redis_client.ttl(key) <= 60+ redis_client.set(key, successor, ex=60)+ with pytest.raises(TriggerSubscriptionLeaseLostError):+ lease.ensure_owned()+ assert redis_client.get(key) == successor+ finally:+ redis_client.delete(key)+++def _seed(harness: _Harness, daemon: _Daemon, credential_type: CredentialType) -> TriggerSubscription:+ daemon.provider = _provider_with_secrets()+ with harness.app.app_context():+ token = encrypt_token(harness.tenant_id, "stored-token")+ secret = encrypt_token(harness.tenant_id, "stored-property")+ return _add_subscription(+ harness,+ user_id=str(uuid4()),+ credential_type=credential_type,+ credentials={} if credential_type == CredentialType.UNAUTHORIZED else {"token": token, "username": "old"},+ properties={"secret": secret, "repository": "before"},+ )+++def _read(harness: _Harness, subscription_id: str) -> TriggerSubscription:+ with harness.session_factory() as session:+ subscription = session.get(TriggerSubscription, subscription_id)+ assert subscription is not None+ return subscription+++def _decrypt(harness: _Harness, value: object) -> str:+ assert isinstance(value, str)+ with harness.app.app_context():+ return decrypt_token(harness.tenant_id, value)+++def _cache_keys(harness: _Harness, subscription_id: str) -> tuple[str, str]:+ return (+ TriggerProviderCredentialsCache(harness.tenant_id, _PROVIDER, subscription_id).cache_key,+ TriggerProviderPropertiesCache(harness.tenant_id, _PROVIDER, subscription_id).cache_key,+ )+++def test_manual_update_restores_hidden_property_and_invalidates_cache_after_commit(+ harness: _Harness, daemon: _Daemon, sqlite_engine: Engine+) -> None:+ subscription = _seed(harness, daemon, CredentialType.UNAUTHORIZED)+ harness.set_role(TenantAccountRole.EDITOR)+ keys = _cache_keys(harness, subscription.id)+ for key in keys:+ redis_client.setex(key, 1800, '{"secret":"stale-cache-must-not-be-restored"}')+ cache_present_at_commit: list[bool] = []++ def observe_commit(_connection: Connection) -> None:+ cache_present_at_commit.append(all(redis_client.exists(key) for key in keys))++ event.listen(sqlite_engine, "commit", observe_commit)+ try:+ response = Context().run(+ harness.call,+ "POST",+ url=_url("update", subscription.id),+ payload={"name": "Renamed", "properties": {"secret": HIDDEN_VALUE, "repository": "after"}},+ )+ finally:+ event.remove(sqlite_engine, "commit", observe_commit)++ assert response.status_code == HTTPStatus.OK+ assert response.get_json() == {"result": "success"}+ saved = _read(harness, subscription.id)+ assert saved.name == "Renamed"+ assert saved.credentials == {}+ assert saved.parameters == subscription.parameters+ assert saved.properties["repository"] == "after"+ assert _decrypt(harness, saved.properties["secret"]) == "stored-property"+ assert cache_present_at_commit == [True]+ assert all(redis_client.exists(key) == 0 for key in keys)+ assert all(sent.method == "GET" and not sent.open_transactions for sent in daemon.requests)+++def test_rename_authorized_subscription_does_not_rebuild_or_change_credentials(+ harness: _Harness, daemon: _Daemon+) -> None:+ subscription = _seed(harness, daemon, CredentialType.API_KEY)++ response = Context().run(+ harness.call, "POST", url=_url("update", subscription.id), payload={"name": "Only renamed"}+ )++ assert response.status_code == HTTPStatus.OK+ saved = _read(harness, subscription.id)+ assert saved.name == "Only renamed"+ assert saved.credentials == subscription.credentials+ assert saved.properties == subscription.properties+ assert saved.parameters == subscription.parameters+ assert not any(sent.method == "POST" for sent in daemon.requests)++[email protected]("operation", ["create", "update", "delete"])+def test_committed_changes_succeed_when_redis_lock_ownership_is_lost(+ harness: _Harness, daemon: _Daemon, caplog: pytest.LogCaptureFixture, operation: str+) -> None:+ if operation == "create":+ builder = test_trigger_subscription_builder._create(harness, daemon, CredentialType.UNAUTHORIZED)+ subscription_id = builder.id+ url = f"{_BASE}/build/{subscription_id}"+ lock_key = f"trigger_provider_create_lock:{harness.tenant_id}_{_PROVIDER}"+ else:+ subscription_id = _seed(harness, daemon, CredentialType.UNAUTHORIZED).id+ url = _url(operation, subscription_id)+ lock_key = f"trigger_subscription_update_lock:{harness.tenant_id}_{subscription_id}"+ cache_keys = _cache_keys(harness, subscription_id)+ if operation != "create":+ for key in cache_keys:+ redis_client.setex(key, 1800, "{}")+ lost_tokens: list[bytes] = []+ successor_token = b"another-lock-owner"++ def lose_lock_after_commit(_session: Session) -> None:+ token = redis_client.get(lock_key)+ assert isinstance(token, bytes)+ lost_tokens.append(token)+ redis_client.set(lock_key, successor_token, ex=60)++ event.listen(harness.session_factory, "after_commit", lose_lock_after_commit)+ try:+ response = Context().run(harness.call, "POST", url=url, payload={"name": "Committed"})+ assert redis_client.get(lock_key) == successor_token+ finally:+ event.remove(harness.session_factory, "after_commit", lose_lock_after_commit)+ redis_client.delete(lock_key)++ assert response.status_code == HTTPStatus.OK+ assert response.get_json() == {"result": "success"}+ assert len(lost_tokens) == 1+ assert any(record.exc_info and isinstance(record.exc_info[1], LockNotOwnedError) for record in caplog.records)+ with harness.session_factory() as session:+ saved = session.get(TriggerSubscription, subscription_id)+ if operation == "delete":+ assert saved is None+ else:+ assert saved is not None+ assert saved.name == "Committed"+ if operation == "create":+ assert redis_client.get(test_trigger_subscription_builder._key(subscription_id)) is None+ else:+ assert all(redis_client.exists(key) == 0 for key in cache_keys)+++def test_lock_release_failure_does_not_replace_subscription_name_conflict(+ harness: _Harness, daemon: _Daemon, caplog: pytest.LogCaptureFixture+) -> None:+ subscription = _seed(harness, daemon, CredentialType.UNAUTHORIZED)+ _add_subscription(harness, name="Taken", credential_type=CredentialType.UNAUTHORIZED)+ lock_key = f"trigger_subscription_update_lock:{harness.tenant_id}_{subscription.id}"+ successor_token = b"another-lock-owner"+ rolled_back: list[bool] = []++ def lose_lock_after_rollback(_session: Session) -> None:+ assert redis_client.get(lock_key) is not None+ redis_client.set(lock_key, successor_token, ex=60)+ rolled_back.append(True)++ event.listen(harness.session_factory, "after_rollback", lose_lock_after_rollback)+ try:+ response = Context().run(harness.call, "POST", url=_url("update", subscription.id), payload={"name": "Taken"})+ assert redis_client.get(lock_key) == successor_token+ finally:+ event.remove(harness.session_factory, "after_rollback", lose_lock_after_rollback)+ redis_client.delete(lock_key)++ assert response.status_code == HTTPStatus.CONFLICT+ assert response.get_json()["code"] == "trigger_subscription_name_conflict"+ assert rolled_back == [True]+ assert _read(harness, subscription.id).name == subscription.name+ assert any(record.exc_info and isinstance(record.exc_info[1], LockNotOwnedError) for record in caplog.records)++[email protected]("operation", ["update", "delete"])+def test_committed_changes_succeed_when_redis_cache_invalidation_is_unavailable(+ harness: _Harness, daemon: _Daemon, caplog: pytest.LogCaptureFixture, operation: str+) -> None:+ subscription = _seed(harness, daemon, CredentialType.UNAUTHORIZED)+ cache_values = dict.fromkeys(_cache_keys(harness, subscription.id), b'{"value":"cached-before-write"}')+ for key, value in cache_values.items():+ redis_client.setex(key, 1800, value)+ with harness.app.app_context():+ services = application_services()+ invalidation_attempts: list[tuple[str, str, str]] = []++ # Keep the port reserved without listening, so only the cache-cleanup+ # transport fails; persistence, plugin calls and Redis locks remain real.+ with socket() as unavailable:+ unavailable.bind(("127.0.0.1", 0))+ with Redis(+ host="127.0.0.1",+ port=unavailable.getsockname()[1],+ socket_connect_timeout=0.1,+ retry=Retry(NoBackoff(), 0),+ ) as disconnected:++ def invalidate_cache(*, tenant_id: str, provider_id: str, subscription_id: str) -> None:+ invalidation_attempts.append((tenant_id, provider_id, subscription_id))+ disconnected.delete(+ TriggerProviderCredentialsCache(tenant_id, provider_id, subscription_id).cache_key,+ TriggerProviderPropertiesCache(tenant_id, provider_id, subscription_id).cache_key,+ )++ management = TriggerSubscriptionService(+ subscriptions=TriggerSubscriptionRepository(session_factory=harness.session_factory),+ providers=PluginTriggerSubscriptionGateway(),+ locks=RedisTriggerSubscriptionLocks(redis=redis_client),+ codec=ProviderTriggerSubscriptionCodec(),+ invalidate_cache=invalidate_cache,+ )+ harness.app.extensions["application_services"] = replace(+ services, workspaces=replace(services.workspaces, trigger_subscription_management=management)+ )+ try:+ response = Context().run(+ harness.call, "POST", url=_url(operation, subscription.id), payload={"name": "Committed"}+ )+ finally:+ harness.app.extensions["application_services"] = services++ assert response.status_code == HTTPStatus.OK+ assert response.get_json() == {"result": "success"}+ assert invalidation_attempts == [(harness.tenant_id, _PROVIDER, subscription.id)]+ assert any(+ record.exc_info+ and isinstance(record.exc_info[1], RedisConnectionError | RedisTimeoutError)+ and subscription.id in record.getMessage()+ for record in caplog.records+ )+ with harness.session_factory() as session:+ saved = session.get(TriggerSubscription, subscription.id)+ if operation == "delete":+ assert saved is None+ else:+ assert saved is not None+ assert saved.name == "Committed"+ assert {key: redis_client.get(key) for key in cache_values} == cache_values+ assert all(redis_client.ttl(key) > 0 for key in cache_values)++[email protected]("outcome", ["verified", "invalid-credentials", "provider-failure"])+def test_verify_restores_hidden_credentials_without_updating_and_maps_provider_errors(+ harness: _Harness, daemon: _Daemon, outcome: str+) -> None:+ subscription = _seed(harness, daemon, CredentialType.API_KEY)+ harness.set_role(TenantAccountRole.EDITOR)+ daemon.response_data = {"result": outcome == "verified"}+ if outcome == "provider-failure":+ daemon.response_code = 1+ daemon.response_message = "provider unavailable"+ daemon.response_data = None++ response = Context().run(+ harness.call,+ "POST",+ url=_url("verify", subscription.id),+ payload={"credentials": {"token": HIDDEN_VALUE, "username": "candidate", "missing": HIDDEN_VALUE}},+ )++ if outcome == "verified":+ assert response.status_code == HTTPStatus.OK+ assert response.get_json() == {"verified": True}+ else:+ assert response.status_code == (+ HTTPStatus.BAD_REQUEST if outcome == "invalid-credentials" else HTTPStatus.BAD_GATEWAY+ )+ assert response.get_json()["code"] == (+ "trigger_subscription_invalid"+ if outcome == "invalid-credentials"+ else "trigger_subscription_provider_error"+ )+ assert _PROVIDER in response.get_json()["message"]+ sent = [sent for sent in daemon.requests if sent.method == "POST"]+ assert len(sent) == 1+ assert sent[0].path == f"/plugin/{harness.tenant_id}/dispatch/trigger/validate_credentials"+ assert sent[0].payload == {+ "user_id": harness.account_id,+ "data": {+ "provider": "github",+ "credentials": {"token": "stored-token", "username": "candidate", "missing": UNKNOWN_VALUE},+ },+ }+ assert all(not sent.open_transactions for sent in daemon.requests)+ assert _read(harness, subscription.id).credentials == subscription.credentials+++def test_rebuild_preserves_owner_and_endpoint_while_replacing_provider_state(+ harness: _Harness, daemon: _Daemon+) -> None:+ subscription = _seed(harness, daemon, CredentialType.OAUTH2)+ daemon.observed_lock_key = f"trigger_subscription_update_lock:{harness.tenant_id}_{subscription.id}"+ daemon.responses_by_path = {+ f"/plugin/{harness.tenant_id}/dispatch/trigger/unsubscribe": {"subscription": {"success": True}},+ f"/plugin/{harness.tenant_id}/dispatch/trigger/subscribe": {+ "subscription": {+ "endpoint": generate_plugin_trigger_endpoint_url(subscription.endpoint_id),+ "parameters": {"event": "pull"},+ "properties": {"secret": HIDDEN_VALUE, "repository": "rebuilt"},+ "expires_at": 987654321,+ }+ },+ }++ response = Context().run(+ harness.call,+ "POST",+ url=_url("update", subscription.id),+ payload={"name": "Rebuilt", "credentials": {"token": HIDDEN_VALUE}, "parameters": {"event": "pull"}},+ )++ assert response.status_code == HTTPStatus.OK+ assert response.get_json() == {"result": "success"}+ saved = _read(harness, subscription.id)+ assert (saved.id, saved.endpoint_id, saved.user_id, saved.tenant_id) == (+ subscription.id,+ subscription.endpoint_id,+ subscription.user_id,+ subscription.tenant_id,+ )+ assert saved.name == "Rebuilt"+ assert saved.parameters == {"event": "pull"}+ assert saved.properties["repository"] == "rebuilt"+ assert saved.expires_at == 987654321+ assert _decrypt(harness, saved.credentials["token"]) == "stored-token"+ assert _decrypt(harness, saved.properties["secret"]) == "stored-property"+ sent = [sent for sent in daemon.requests if sent.method == "POST"]+ assert [call.path.rsplit("/", 1)[-1] for call in sent] == ["unsubscribe", "subscribe"]+ assert all(call.lock_held is True for call in sent)+ assert all(call.payload["user_id"] == subscription.user_id for call in sent)+ assert sent[1].payload["data"] == {+ "provider": "github",+ "credentials": {"token": "stored-token"},+ "credential_type": "oauth2",+ "endpoint": generate_plugin_trigger_endpoint_url(subscription.endpoint_id),+ "parameters": {"event": "pull"},+ }+ assert all(not sent.open_transactions for sent in daemon.requests)++[email protected]("failed_operation", ["unsubscribe", "subscribe"])+def test_failed_rebuild_keeps_persisted_state_and_cache(+ harness: _Harness, daemon: _Daemon, failed_operation: str+) -> None:+ subscription = _seed(harness, daemon, CredentialType.OAUTH2)+ daemon.responses_by_path = {+ f"/plugin/{harness.tenant_id}/dispatch/trigger/unsubscribe": {"subscription": {"success": True}},+ }+ daemon.response_codes_by_path = {f"/plugin/{harness.tenant_id}/dispatch/trigger/{failed_operation}": 1}+ daemon.response_message = "provider unavailable"+ daemon.response_data = None+ cache_values = dict.fromkeys(_cache_keys(harness, subscription.id), b'{"value":"must-stay-cached"}')+ for key, value in cache_values.items():+ redis_client.setex(key, 1800, value)+ row_query = select(TriggerSubscription.__table__).where(TriggerSubscription.id == subscription.id)+ with harness.session_factory() as session:+ before = dict(session.execute(row_query).mappings().one())++ response = Context().run(+ harness.call,+ "POST",+ url=_url("update", subscription.id),+ payload={"name": "Must not commit", "parameters": {"event": "pull"}},+ )++ assert response.status_code == HTTPStatus.BAD_GATEWAY+ assert response.get_json()["code"] == "trigger_subscription_provider_error"+ assert subscription.id in response.get_json()["message"]+ assert ("remove" if failed_operation == "unsubscribe" else "rebuild") in response.get_json()["message"]+ sent = [sent for sent in daemon.requests if sent.method == "POST"]+ assert [call.path.rsplit("/", 1)[-1] for call in sent] == (+ ["unsubscribe"] if failed_operation == "unsubscribe" else ["unsubscribe", "subscribe"]+ )+ assert all(not sent.open_transactions for sent in daemon.requests)+ with harness.session_factory() as session:+ assert dict(session.execute(row_query).mappings().one()) == before+ assert {key: redis_client.get(key) for key in cache_values} == cache_values++[email protected]("provider_rejects", [False, True], ids=["unsubscribed", "provider-failed"])+def test_delete_removes_all_owned_workflow_links_even_when_provider_fails(+ harness: _Harness, daemon: _Daemon, provider_rejects: bool+) -> None:+ subscription = _seed(harness, daemon, CredentialType.API_KEY)+ harness.set_role(TenantAccountRole.ADMIN)+ daemon.observed_lock_key = f"trigger_subscription_update_lock:{harness.tenant_id}_{subscription.id}"+ daemon.response_data = {"subscription": {"success": True}}+ if provider_rejects:+ daemon.response_code = 1+ daemon.response_message = "provider unavailable"+ daemon.response_data = None+ with harness.session_factory.begin() as session:+ links = [+ WorkflowPluginTrigger(+ app_id=str(uuid4()),+ node_id=f"node-{index}",+ tenant_id=tenant,+ provider_id=_PROVIDER,+ event_name="push",+ subscription_id=subscription.id,+ )+ for index, tenant in enumerate([harness.tenant_id, harness.tenant_id, str(uuid4())])+ ]+ session.add_all(links)+ for key in _cache_keys(harness, subscription.id):+ redis_client.setex(key, 1800, "{}")++ response = Context().run(harness.call, "POST", url=_url("delete", subscription.id), payload={})++ assert response.status_code == HTTPStatus.OK+ assert response.get_json() == {"result": "success"}+ with harness.session_factory() as session:+ assert session.get(TriggerSubscription, subscription.id) is None+ assert list(session.scalars(select(WorkflowPluginTrigger.id))) == [links[2].id]+ assert all(redis_client.exists(key) == 0 for key in _cache_keys(harness, subscription.id))+ sent = [sent for sent in daemon.requests if sent.method == "POST"]+ assert len(sent) == 1+ assert sent[0].path.endswith("/dispatch/trigger/unsubscribe")+ assert sent[0].lock_held is True+ assert all(not sent.open_transactions for sent in daemon.requests)+++def test_builder_uses_the_shared_writer_to_encrypt_nonempty_credentials(harness: _Harness, daemon: _Daemon) -> None:+ builder = test_trigger_subscription_builder._create(harness, daemon, CredentialType.API_KEY)+ update = Context().run(+ harness.call, "POST", url=f"{_BASE}/update/{builder.id}", payload={"credentials": {"token": "builder-secret"}}+ )+ assert update.status_code == HTTPStatus.OK+ daemon.response_data = {+ "subscription": {+ "endpoint": generate_plugin_trigger_endpoint_url(builder.endpoint_id),+ "parameters": {"event": "push"},+ "properties": {"repository": "dify"},+ "expires_at": -1,+ }+ }++ response = Context().run(harness.call, "POST", url=f"{_BASE}/build/{builder.id}", payload={"name": "Published"})++ assert response.status_code == HTTPStatus.OK+ saved = _read(harness, builder.id)+ assert saved.credentials["token"] != "builder-secret"+ assert _decrypt(harness, saved.credentials["token"]) == "builder-secret"+ assert redis_client.get(test_trigger_subscription_builder._key(builder.id)) is Nonediff --git a/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_client.py b/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_client.pyindex fe404104d6f..cf918ea3ab0 100644--- a/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_client.py+++ b/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_client.py@@ -29,7 +29,10 @@ from controllers.console.workspace.trigger_providers import (TriggerSubscriptionBuilderLogsApi,TriggerSubscriptionBuilderUpdateApi,TriggerSubscriptionBuilderVerifyApi,+ TriggerSubscriptionDeleteApi,TriggerSubscriptionListApi,+ TriggerSubscriptionUpdateApi,+ TriggerSubscriptionVerifyApi,)from controllers.console.wraps import _is_setup_completedfrom core.entities.provider_entities import ProviderConfig, ProviderConfigType@@ -257,6 +260,18 @@ def harness()api.add_resource(TriggerSubscriptionBuilderLogsApi, f"{builder_path}/logs/<path:subscription_builder_id>")api.add_resource(TriggerSubscriptionBuilderBuildApi, f"{builder_path}/build/<path:subscription_builder_id>")+ api.add_resource(+ TriggerSubscriptionUpdateApi,+ "/workspaces/current/trigger-provider/<path:subscription_id>/subscriptions/update",+ )+ api.add_resource(+ TriggerSubscriptionDeleteApi,+ "/workspaces/current/trigger-provider/<path:subscription_id>/subscriptions/delete",+ )+ api.add_resource(+ TriggerSubscriptionVerifyApi,+ "/workspaces/current/trigger-provider/<path:provider>/subscriptions/verify/<path:subscription_id>",+ )app.register_blueprint(blueprint)with app.app_context():diff --git a/api/tests/unit_tests/controllers/console/workspace/test_trigger_providers.py b/api/tests/unit_tests/controllers/console/workspace/test_trigger_providers.pyindex 7e6a35afeed..02d8035b00d 100644--- a/api/tests/unit_tests/controllers/console/workspace/test_trigger_providers.py+++ b/api/tests/unit_tests/controllers/console/workspace/test_trigger_providers.py@@ -1,210 +1,20 @@-from __future__ import annotations--from collections.abc import Iterator-from importlib import import_module-from inspect import unwrap-from unittest.mock import MagicMock, patch+"""Trigger credential verification payload contracts."""import pytest-from flask import Flaskfrom pydantic import ValidationError-from sqlalchemy.engine import Engine-from werkzeug.exceptions import BadRequest-from controllers.common.errors import NotFoundErrorfrom controllers.console.workspace.trigger_providers import (- TriggerSubscriptionBuilderUpdatePayload,TriggerSubscriptionBuilderVerifyPayload,- TriggerSubscriptionDeleteApi,- TriggerSubscriptionUpdateApi,- TriggerSubscriptionVerifyApi,TriggerSubscriptionVerifyPayload,)-from core.plugin.entities.plugin_daemon import CredentialType-from models.account import Account-from models.engine import db--"""Unit tests for controllers.console.workspace.trigger_providers endpoints."""---def mock_user() -> Account:- user = Account(name="User", email="user.com")- user.id = "u1"- return user---class TestTriggerProviderApisCases:- class TestTriggerSubscriptionCrud:- def test_update_rename_only(self, app: Flask) -> None:- api = TriggerSubscriptionUpdateApi()- method = unwrap(api.post)-- sub = MagicMock()- sub.provider_id = "github"- sub.credential_type = CredentialType.UNAUTHORIZED-- with (- app.test_request_context("/", json={"name": "x"}),- patch(- "controllers.console.workspace.trigger_providers.TriggerProviderService.get_subscription_by_id",- return_value=sub,- ),- patch(- "controllers.console.workspace.trigger_providers.TriggerProviderService.update_trigger_subscription"- ),- ):- assert method(- api,- TriggerSubscriptionBuilderUpdatePayload(name="x"),- "t1",- "s1",- ) == {"result": "success"}-- def test_update_not_found(self, app: Flask) -> None:- api = TriggerSubscriptionUpdateApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"name": "x"}),- patch(- "controllers.console.workspace.trigger_providers.TriggerProviderService.get_subscription_by_id",- return_value=None,- ),- ):- with pytest.raises(NotFoundError):- method(api, TriggerSubscriptionBuilderUpdatePayload(name="x"), "t1", "x")-- def test_update_rebuild(self, app: Flask) -> None:- api = TriggerSubscriptionUpdateApi()- method = unwrap(api.post)-- sub = MagicMock()- sub.provider_id = "github"- sub.credential_type = CredentialType.OAUTH2- sub.credentials = {"token": "old"}- sub.parameters = {"repo": "demo"}-- with (- app.test_request_context("/", json={"credentials": {}}),- patch(- "controllers.console.workspace.trigger_providers.TriggerProviderService.get_subscription_by_id",- return_value=sub,- ),- patch(- "controllers.console.workspace.trigger_providers.TriggerProviderService.rebuild_trigger_subscription"- ),- ):- assert method(- api,- TriggerSubscriptionBuilderUpdatePayload(credentials={}),- "t1",- "s1",- ) == {"result": "success"}-- class TestTriggerSubscriptionVerifyApi:- def test_verify_success(self, app: Flask) -> None:- api = TriggerSubscriptionVerifyApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"credentials": {}}),- patch(- "controllers.console.workspace.trigger_providers.TriggerProviderService.verify_subscription_credentials",- return_value={"verified": True},- ),- ):- assert method(- api,- TriggerSubscriptionBuilderVerifyPayload(credentials={}),- "t1",- mock_user(),- "github",- "s1",- ) == {"verified": True}-- @pytest.mark.parametrize("raised_exception", [ValueError("bad"), Exception("boom")])- def test_verify_errors(self, app: Flask, raised_exception: Exception) -> None:- api = TriggerSubscriptionVerifyApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"credentials": {}}),- patch(- "controllers.console.workspace.trigger_providers.TriggerProviderService.verify_subscription_credentials",- side_effect=raised_exception,- ),- ):- with pytest.raises(BadRequest):- method(- api,- TriggerSubscriptionBuilderVerifyPayload(credentials={}),- "t1",- mock_user(),- "github",- "s1",- )---"""Unit tests for trigger-provider controller transaction boundaries."""---trigger_provider_module = import_module("controllers.console.workspace.trigger_providers")---class TestTriggerProvidersCases:- @staticmethod- @pytest.fixture- def flask_sqlite_engine() -> Iterator[Engine]:- app = Flask(__name__)- app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:"- db.init_app(app)-- with app.app_context():- yield db.engine-- @staticmethod- def test_delete_subscription_uses_sqlite_transaction(flask_sqlite_engine: Engine) -> None:- api = TriggerSubscriptionDeleteApi()- method = unwrap(api.post)-- with (- patch.object(trigger_provider_module.TriggerProviderService, "delete_trigger_provider") as delete_provider,- patch.object(- trigger_provider_module.TriggerSubscriptionOperatorService,- "delete_plugin_trigger_by_subscription",- ) as delete_triggers,- ):- result = method(api, "t1", "sub1")-- assert result == {"result": "success"}- provider_session = delete_provider.call_args.kwargs["session"]- trigger_session = delete_triggers.call_args.kwargs["session"]- assert provider_session is trigger_session- assert provider_session.get_bind() is flask_sqlite_engine- @staticmethod- @pytest.mark.usefixtures("flask_sqlite_engine")- def test_delete_subscription_translates_value_error() -> None:- api = TriggerSubscriptionDeleteApi()- method = unwrap(api.post)- with (- patch.object(- trigger_provider_module.TriggerProviderService,- "delete_trigger_provider",- side_effect=ValueError("bad"),- ),- pytest.raises(BadRequest, match="bad"),- ):- method(api, "t1", "sub1")+def test_builder_verify_payload_allows_credentials_to_be_omitted() -> None:+ payload = TriggerSubscriptionBuilderVerifyPayload.model_validate({})- @staticmethod- def test_builder_verify_payload_allows_credentials_to_be_omitted() -> None:- payload = TriggerSubscriptionBuilderVerifyPayload.model_validate({})+ assert payload.credentials is None- assert payload.credentials is None- @staticmethod- def test_subscription_verify_payload_requires_credentials() -> None:- with pytest.raises(ValidationError):- TriggerSubscriptionVerifyPayload.model_validate({})+def test_subscription_verify_payload_requires_credentials() -> None:+ with pytest.raises(ValidationError):+ TriggerSubscriptionVerifyPayload.model_validate({})diff --git a/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_builder.py b/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_builder.pyindex 27cdd9371e7..c550df56cd6 100644--- a/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_builder.py+++ b/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_builder.py@@ -15,6 +15,7 @@ from yarl import URLfrom core.plugin.entities.plugin_daemon import CredentialTypefrom core.plugin.impl import base as plugin_transportfrom core.plugin.impl.trigger import PluginTriggerClient+from extensions.ext_redis import redis_clientfrom models.account import TenantAccountRolefrom tests.unit_tests.controllers.console.workspace import test_trigger_oauth_clientfrom tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client import _PROVIDER, _Harness@@ -41,12 +42,16 @@ class _DaemonRequest:headers: dict[str, str]payload: dict[str, object]open_transactions: bool+ lock_held: bool | None@dataclassclass _Daemon:provider: dict[str, object] = field(default_factory=_provider)response_data: dict[str, object] | None = field(default_factory=lambda: {"result": True})+ responses_by_path: dict[str, dict[str, object] | None] = field(default_factory=dict)+ response_codes_by_path: dict[str, int] = field(default_factory=dict)+ observed_lock_key: str | None = Noneresponse_code: int = 0response_message: str = ""status: HTTPStatus = HTTPStatus.OK@@ -64,7 +69,8 @@ def daemon(harness: _Harness) -> Iterator[_Daemon]:def do_POST(self) -> None:payload = json.loads(self.rfile.read(int(self.headers["Content-Length"])))- self.respond(payload, daemon.response_data, daemon.post_status, streamed=True)+ data = daemon.responses_by_path.get(self.path, daemon.response_data)+ self.respond(payload, data, daemon.post_status, streamed=True)def respond(self, payload: dict[str, object], data: dict[str, object] | None, status: HTTPStatus, *, streamed: bool@@ -76,11 +82,14 @@ def daemon(harness: _Harness) -> Iterator[_Daemon]:dict(self.headers.items()),payload,any(session.in_transaction() for session in harness.metadata.sessions),+ bool(redis_client.exists(daemon.observed_lock_key))+ if daemon.observed_lock_key is not None+ else None,))body = json.dumps({- "code": daemon.response_code if streamed else 0,+ "code": daemon.response_codes_by_path.get(self.path, daemon.response_code) if streamed else 0,"message": daemon.response_message if streamed else "","data": data,}diff --git a/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_management.py b/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_management.pynew file mode 100644index 00000000000..b77ceb39f1d--- /dev/null+++ b/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_management.py@@ -0,0 +1,141 @@+"""Formal subscription admission and scope checks use the real HTTP and SQL paths."""++from contextvars import Context+from http import HTTPStatus+from uuid import uuid4++import pytest++from core.plugin.entities.plugin_daemon import CredentialType+from models.account import TenantAccountRole+from tests.unit_tests.controllers.console.workspace import test_trigger_oauth_client, test_trigger_subscription_builder+from tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client import _PROVIDER, _Harness+from tests.unit_tests.controllers.console.workspace.test_trigger_subscription_builder import _Daemon+from tests.unit_tests.controllers.console.workspace.test_trigger_subscription_query import _add_subscription++application_redis = test_trigger_oauth_client.application_redis+harness = test_trigger_oauth_client.harness+daemon = test_trigger_subscription_builder.daemon+++def _url(operation: str, subscription_id: str, provider: str = _PROVIDER) -> str:+ base = "/console/api/workspaces/current/trigger-provider"+ if operation == "verify":+ return f"{base}/{provider}/subscriptions/verify/{subscription_id}"+ return f"{base}/{subscription_id}/subscriptions/{operation}"+++def _payload(operation: str) -> dict[str, object]:+ if operation == "verify":+ return {"credentials": {"token": "request-secret"}}+ return {"name": "Updated"} if operation == "update" else {}++[email protected]("operation", ["update", "delete", "verify"])+def test_management_requires_login(harness: _Harness, daemon: _Daemon, operation: str) -> None:+ response = harness.client.post(_url(operation, str(uuid4())), json=_payload(operation))++ assert response.status_code == HTTPStatus.UNAUTHORIZED+ assert response.get_json()["code"] == "unauthorized"+ assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'+ assert daemon.requests == []+++ ("operation", "role"),+ [+ ("update", TenantAccountRole.NORMAL),+ ("update", TenantAccountRole.DATASET_OPERATOR),+ ("verify", TenantAccountRole.NORMAL),+ ("verify", TenantAccountRole.DATASET_OPERATOR),+ ("delete", TenantAccountRole.NORMAL),+ ("delete", TenantAccountRole.DATASET_OPERATOR),+ ("delete", TenantAccountRole.EDITOR),+ ],+)+def test_management_preserves_editor_and_admin_role_boundaries(+ harness: _Harness, daemon: _Daemon, operation: str, role: TenantAccountRole+) -> None:+ harness.set_role(role)+ subscription = _add_subscription(harness)++ response = Context().run(harness.call, "POST", url=_url(operation, subscription.id), payload=_payload(operation))++ assert response.status_code == HTTPStatus.FORBIDDEN+ assert response.get_json()["code"] == "forbidden"+ assert daemon.requests == []++[email protected]("operation", ["update", "delete", "verify"])[email protected]("exists_in_other_tenant", [False, True], ids=["missing", "foreign-tenant"])+def test_missing_or_foreign_subscriptions_fail_before_plugin_or_secret_access(+ harness: _Harness, daemon: _Daemon, operation: str, exists_in_other_tenant: bool+) -> None:+ subscription_id = (+ _add_subscription(harness, tenant_id=str(uuid4()), credentials={"token": "must-not-leave-workspace"}).id+ if exists_in_other_tenant+ else str(uuid4())+ )++ response = Context().run(harness.call, "POST", url=_url(operation, subscription_id), payload=_payload(operation))++ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.get_json()["code"] == "trigger_subscription_not_found"+ assert daemon.requests == []+++def test_verify_provider_mismatch_is_rejected_before_plugin_lookup(harness: _Harness, daemon: _Daemon) -> None:+ subscription = _add_subscription(harness, credentials={"token": "must-not-reach-other-plugin"})++ response = Context().run(+ harness.call,+ "POST",+ url=_url("verify", subscription.id, "langgenius/other/other"),+ payload={"credentials": {}},+ )++ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.get_json()["code"] == "trigger_subscription_not_found"+ assert daemon.requests == []+++ ("operation", "payload"),+ [("update", {}), ("update", {"properties": []}), ("verify", {"credentials": []})],+)+def test_management_rejects_invalid_payloads_before_external_io(+ harness: _Harness, daemon: _Daemon, operation: str, payload: dict[str, object]+) -> None:+ response = harness.call("POST", url=_url(operation, str(uuid4())), payload=payload)++ assert response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY+ assert daemon.requests == []++[email protected]("credential_type", [CredentialType.UNAUTHORIZED, CredentialType.OAUTH2])+def test_editor_can_verify_non_api_key_subscription_without_plugin_call(+ harness: _Harness, daemon: _Daemon, credential_type: CredentialType+) -> None:+ harness.set_role(TenantAccountRole.EDITOR)+ subscription = _add_subscription(harness, credential_type=credential_type)++ response = harness.call("POST", url=_url("verify", subscription.id), payload={"credentials": {}})++ assert response.status_code == HTTPStatus.OK+ assert response.get_json() == {"verified": True}+ assert daemon.requests == []+++def test_verify_provider_failure_returns_specific_error_after_read_transaction_closes(+ harness: _Harness, daemon: _Daemon+) -> None:+ subscription = _add_subscription(harness)+ daemon.status = HTTPStatus.SERVICE_UNAVAILABLE++ response = Context().run(harness.call, "POST", url=_url("verify", subscription.id), payload={"credentials": {}})++ assert response.status_code == HTTPStatus.BAD_GATEWAY+ assert response.get_json()["code"] == "trigger_subscription_provider_error"+ assert _PROVIDER in response.get_json()["message"]+ assert len(daemon.requests) == 1+ assert not daemon.requests[0].open_transactionsdiff --git a/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py b/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.pyindex 667add8f4d9..1f3c5ee2ba2 100644--- a/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py+++ b/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py@@ -18,12 +18,14 @@ from controllers.inner_api.workspace import workspace as controllerfrom controllers.inner_api.wraps import InnerApiUnauthorizedErrorfrom core.plugin.impl.oauth import OAuthHandlerfrom core.trigger.trigger_manager import TriggerManager+from core.trigger.utils.encryption import delete_cache_for_subscriptionfrom extensions.application_services.workspace import WorkspaceServicesfrom extensions.ext_redis import RedisClientWrapperfrom libs.external_api import register_external_error_handlersfrom repositories.credentials.query_repository import CredentialQueryRepositoryfrom repositories.trigger.oauth_client_repository import TriggerOAuthClientRepositoryfrom repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepository+from repositories.trigger.subscription_repository import RedisTriggerSubscriptionLocks, TriggerSubscriptionRepositoryfrom services.account_errors import AccountNotFoundErrorfrom services.errors.workspace import (InvalidWorkspaceMemberRoleError,@@ -39,8 +41,10 @@ from services.trigger.oauth_gateway import ()from services.trigger.oauth_service import TriggerOAuthServicefrom services.trigger.provider_gateway import PluginTriggerProviderQuery+from services.trigger.subscription_codec import ProviderTriggerSubscriptionCodec+from services.trigger.subscription_gateway import PluginTriggerSubscriptionGatewayfrom services.trigger.subscription_query_service import TriggerSubscriptionQueryService-from services.trigger.trigger_provider_service import TriggerProviderService+from services.trigger.subscription_service import TriggerSubscriptionServicefrom services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderServicefrom services.workspace.contracts import CreatedWorkspace, WorkspaceMembershipfrom services.workspace.provisioning_service import WorkspaceProvisioningService@@ -118,11 +122,18 @@ class TestWorkspaceCases:)redis = RedisClientWrapper()redis.initialize(Redis())+ subscription_management = TriggerSubscriptionService(+ subscriptions=TriggerSubscriptionRepository(session_factory=sqlite_session_factory),+ providers=PluginTriggerSubscriptionGateway(),+ locks=RedisTriggerSubscriptionLocks(redis=redis),+ codec=ProviderTriggerSubscriptionCodec(),+ invalidate_cache=delete_cache_for_subscription,+ )builders = TriggerSubscriptionBuilderService(builders=RedisTriggerSubscriptionBuilderRepository(redis=redis),get_provider=TriggerManager.get_trigger_provider,subscribe=TriggerManager.subscribe_trigger,- create_subscription=TriggerProviderService.add_trigger_subscription,+ create_subscription=subscription_management.create,)services = WorkspaceServices(queries=create_autospec(WorkspaceQueryService, instance=True),@@ -140,6 +151,7 @@ class TestWorkspaceCases:schemas=PluginTriggerProviderQuery(),),trigger_builders=builders,+ trigger_subscription_management=subscription_management,trigger_oauth_clients=oauth_clients,trigger_oauth=TriggerOAuthService(clients=oauth_clients,diff --git a/api/tests/unit_tests/extensions/test_ext_application_services.py b/api/tests/unit_tests/extensions/test_ext_application_services.pyindex fb202ddbc73..80df3a25a58 100644--- a/api/tests/unit_tests/extensions/test_ext_application_services.py+++ b/api/tests/unit_tests/extensions/test_ext_application_services.py@@ -1124,6 +1124,10 @@ def test_build_application_services_wires_credential_query(gateway = services.workspaces.trigger_oauth._buildersassert isinstance(gateway, TriggerOAuthBuilderGateway)assert gateway._builders is services.workspaces.trigger_builders+ assert (+ services.workspaces.trigger_builders._create_subscription+ == services.workspaces.trigger_subscription_management.create+ )def test_build_application_services_uses_supplied_redis_for_both_workflow_stop_signals(diff --git a/api/tests/unit_tests/repositories/trigger/test_subscription_repository.py b/api/tests/unit_tests/repositories/trigger/test_subscription_repository.pynew file mode 100644index 00000000000..bad99fe0ed6--- /dev/null+++ b/api/tests/unit_tests/repositories/trigger/test_subscription_repository.py@@ -0,0 +1,368 @@+import socket+from dataclasses import replace+from uuid import uuid4++import pytest+from redis import Redis+from redis.backoff import NoBackoff+from redis.exceptions import ConnectionError as RedisConnectionError+from redis.exceptions import TimeoutError as RedisTimeoutError+from redis.retry import Retry+from sqlalchemy import Engine, delete, select, update+from sqlalchemy.exc import IntegrityError+from sqlalchemy.orm import Session, sessionmaker+from sqlalchemy.pool import QueuePool++from core.plugin.entities.plugin_daemon import CredentialType+from extensions.ext_redis import RedisClientWrapper+from models.enums import PermissionEnum+from models.provider_ids import TriggerProviderID+from models.trigger import TriggerSubscription, WorkflowPluginTrigger+from repositories.trigger.subscription_repository import RedisTriggerSubscriptionLocks, TriggerSubscriptionRepository+from services.trigger.subscription_service import (+ TriggerSubscriptionChangedError,+ TriggerSubscriptionLimitError,+ TriggerSubscriptionNameConflictError,+ TriggerSubscriptionSnapshot,+)+++def repository(sqlite_session_factory: sessionmaker[Session]) -> TriggerSubscriptionRepository:+ return TriggerSubscriptionRepository(session_factory=sqlite_session_factory)+++def _snapshot() -> TriggerSubscriptionSnapshot:+ return TriggerSubscriptionSnapshot(+ id=str(uuid4()),+ name="GitHub events",+ tenant_id=str(uuid4()),+ user_id=str(uuid4()),+ provider_id="langgenius/github/github",+ endpoint_id=str(uuid4()),+ credential_type=CredentialType.API_KEY,+ parameters={"events": ["push"], "enabled": False},+ properties={"remote_id": "subscription-1"},+ credentials={"token": "encrypted-token"},+ credential_expires_at=0,+ expires_at=-1,+ visibility=PermissionEnum.ALL_TEAM,+ )+++def _persist(session_factory: sessionmaker[Session], *snapshots: TriggerSubscriptionSnapshot) -> None:+ with session_factory.begin() as session:+ for snapshot in snapshots:+ row = TriggerSubscription(+ name=snapshot.name,+ tenant_id=snapshot.tenant_id,+ user_id=snapshot.user_id,+ provider_id=snapshot.provider_id,+ endpoint_id=snapshot.endpoint_id,+ credential_type=snapshot.credential_type,+ parameters=dict(snapshot.parameters),+ properties=dict(snapshot.properties),+ credentials=dict(snapshot.credentials),+ credential_expires_at=snapshot.credential_expires_at,+ expires_at=snapshot.expires_at,+ visibility=snapshot.visibility,+ )+ row.id = snapshot.id+ session.add(row)++[email protected]("scope", ["provider", "subscription"])+def test_lock_connection_failure_prevents_repository_write(+ repository: TriggerSubscriptionRepository, scope: str+) -> None:+ subscription = _snapshot()+ # Reserve a non-listening port to exercise a real connection failure safely.+ with socket.socket() as unavailable_endpoint:+ unavailable_endpoint.bind(("127.0.0.1", 0))+ with Redis(+ host="127.0.0.1",+ port=unavailable_endpoint.getsockname()[1],+ socket_connect_timeout=0.1,+ socket_timeout=0.1,+ retry=Retry(NoBackoff(), 0),+ ) as client:+ redis = RedisClientWrapper()+ redis.initialize(client)+ locks = RedisTriggerSubscriptionLocks(redis=redis)+ lock = (+ locks.for_provider(+ tenant_id=subscription.tenant_id, provider_id=TriggerProviderID(subscription.provider_id)+ )+ if scope == "provider"+ else locks.for_subscription(tenant_id=subscription.tenant_id, subscription_id=subscription.id)+ )++ with pytest.raises((RedisConnectionError, RedisTimeoutError)), lock:+ repository.create(subscription=subscription, max_count=10)++ assert repository.get(tenant_id=subscription.tenant_id, subscription_id=subscription.id) is None+++def test_create_commits_all_subscription_fields_and_get_returns_detached_snapshot(+ repository: TriggerSubscriptionRepository,+ sqlite_session_factory: sessionmaker[Session],+ sqlite_engine: Engine,+) -> None:+ expected = _snapshot()+ pool = sqlite_engine.pool+ assert isinstance(pool, QueuePool)++ repository.create(subscription=expected, max_count=10)+ assert pool.checkedout() == 0+ snapshot = repository.get(tenant_id=expected.tenant_id, subscription_id=expected.id)+ assert pool.checkedout() == 0+ assert snapshot is not None+ assert snapshot == expected++ with sqlite_session_factory.begin() as session:+ session.execute(delete(TriggerSubscription).where(TriggerSubscription.id == expected.id))++ assert snapshot == expected+ assert snapshot.parameters == {"events": ["push"], "enabled": False}+ assert snapshot.credentials == {"token": "encrypted-token"}+ assert repository.get(tenant_id=expected.tenant_id, subscription_id=expected.id) is None+ assert pool.checkedout() == 0++[email protected]("wrong_scope", ["tenant", "subscription"])+def test_get_requires_tenant_and_subscription_id_with_valid_decoys(+ repository: TriggerSubscriptionRepository,+ sqlite_session_factory: sessionmaker[Session],+ wrong_scope: str,+) -> None:+ stored = _snapshot()+ decoy = replace(_snapshot(), tenant_id=stored.tenant_id, provider_id="langgenius/other/other")+ _persist(sqlite_session_factory, stored, decoy)++ assert (+ repository.get(+ tenant_id=str(uuid4()) if wrong_scope == "tenant" else stored.tenant_id,+ subscription_id=str(uuid4()) if wrong_scope == "subscription" else stored.id,+ )+ is None+ )+ assert repository.get(tenant_id=stored.tenant_id, subscription_id=stored.id) == stored+++def test_create_enforces_provider_limit_without_counting_other_tenants_or_providers(+ repository: TriggerSubscriptionRepository,+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ first = _snapshot()+ decoys = [+ replace(_snapshot(), provider_id=first.provider_id),+ replace(_snapshot(), tenant_id=first.tenant_id, provider_id="langgenius/other/other"),+ ]+ _persist(sqlite_session_factory, first, *decoys)+ second = replace(_snapshot(), tenant_id=first.tenant_id, name="Second")+ repository.create(subscription=second, max_count=2)+ third = replace(_snapshot(), tenant_id=first.tenant_id, name="Third")++ with pytest.raises(TriggerSubscriptionLimitError):+ repository.create(subscription=third, max_count=2)++ assert repository.get(tenant_id=first.tenant_id, subscription_id=second.id) == second+ assert repository.get(tenant_id=first.tenant_id, subscription_id=third.id) is None+ for decoy in decoys:+ assert repository.get(tenant_id=decoy.tenant_id, subscription_id=decoy.id) == decoy+++def test_create_rejects_duplicate_name_only_in_same_tenant_and_provider(+ repository: TriggerSubscriptionRepository,+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ original = _snapshot()+ _persist(sqlite_session_factory, original)+ duplicate = replace(_snapshot(), tenant_id=original.tenant_id)++ with pytest.raises(TriggerSubscriptionNameConflictError):+ repository.create(subscription=duplicate, max_count=10)++ for allowed in (+ _snapshot(),+ replace(_snapshot(), tenant_id=original.tenant_id, provider_id="langgenius/other/other"),+ ):+ repository.create(subscription=allowed, max_count=10)+ assert repository.get(tenant_id=allowed.tenant_id, subscription_id=allowed.id) == allowed+ assert repository.get(tenant_id=duplicate.tenant_id, subscription_id=duplicate.id) is None+++def test_create_does_not_mislabel_endpoint_constraint_as_name_conflict(+ repository: TriggerSubscriptionRepository,+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ original = _snapshot()+ _persist(sqlite_session_factory, original)+ conflicting = replace(_snapshot(), endpoint_id=original.endpoint_id)++ with pytest.raises(IntegrityError):+ repository.create(subscription=conflicting, max_count=10)++ assert repository.get(tenant_id=conflicting.tenant_id, subscription_id=conflicting.id) is None+++def test_update_commits_only_target_and_returns_connection(+ repository: TriggerSubscriptionRepository,+ sqlite_session_factory: sessionmaker[Session],+ sqlite_engine: Engine,+) -> None:+ original = _snapshot()+ decoys = [_snapshot(), replace(_snapshot(), tenant_id=original.tenant_id, provider_id="langgenius/other/other")]+ _persist(sqlite_session_factory, original, *decoys)+ replacement = replace(+ original,+ name="Updated",+ parameters={},+ properties={"remote_id": "subscription-2"},+ credentials={"token": "rotated-token"},+ credential_expires_at=-1,+ expires_at=0,+ )++ repository.update(expected=original, replacement=replacement)++ pool = sqlite_engine.pool+ assert isinstance(pool, QueuePool)+ assert pool.checkedout() == 0+ assert repository.get(tenant_id=original.tenant_id, subscription_id=original.id) == replacement+ for decoy in decoys:+ assert repository.get(tenant_id=decoy.tenant_id, subscription_id=decoy.id) == decoy+++def test_update_duplicate_name_rolls_back_other_fields(+ repository: TriggerSubscriptionRepository,+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ original = _snapshot()+ other = replace(_snapshot(), tenant_id=original.tenant_id, name="Taken")+ _persist(sqlite_session_factory, original, other)++ with pytest.raises(TriggerSubscriptionNameConflictError):+ repository.update(expected=original, replacement=replace(original, name=other.name, credentials={}))++ assert repository.get(tenant_id=original.tenant_id, subscription_id=original.id) == original+ assert repository.get(tenant_id=other.tenant_id, subscription_id=other.id) == other+++ ("field", "new_value"),+ [+ ("name", "Concurrent rename"),+ ("tenant_id", "a423cfd1-958f-4675-af10-154d3b59fddb"),+ ("user_id", "91924559-ddd1-471a-b208-3acc8126bc90"),+ ("provider_id", "langgenius/other/other"),+ ("endpoint_id", "replacement-endpoint"),+ ("credential_type", CredentialType.OAUTH2),+ ("parameters", {"events": ["issues"]}),+ ("properties", {"remote_id": "replacement"}),+ ("credentials", {"token": "replacement-ciphertext"}),+ ("credential_expires_at", 500),+ ("expires_at", 500),+ ("visibility", PermissionEnum.ONLY_ME),+ ],+)[email protected]("operation", ["update", "delete"])+def test_stale_snapshot_cannot_overwrite_or_delete_changed_subscription(+ repository: TriggerSubscriptionRepository,+ sqlite_session_factory: sessionmaker[Session],+ sqlite_engine: Engine,+ field: str,+ new_value: object,+ operation: str,+) -> None:+ original = _snapshot()+ _persist(sqlite_session_factory, original)+ with sqlite_session_factory.begin() as session:+ session.execute(+ update(TriggerSubscription).where(TriggerSubscription.id == original.id).values({field: new_value})+ )++ if operation == "update":+ with pytest.raises(TriggerSubscriptionChangedError):+ repository.update(expected=original, replacement=replace(original, name="Stale write"))+ else:+ with pytest.raises(TriggerSubscriptionChangedError):+ repository.delete(expected=original)++ pool = sqlite_engine.pool+ assert isinstance(pool, QueuePool)+ assert pool.checkedout() == 0+ with sqlite_session_factory() as session:+ row = session.get(TriggerSubscription, original.id)+ assert row is not None+ assert row.name == (new_value if field == "name" else original.name)+ assert row.credentials == (new_value if field == "credentials" else original.credentials)+ assert (+ session.scalar(select(TriggerSubscription.__table__.c[field]).where(TriggerSubscription.id == original.id))+ == new_value+ )++[email protected]("operation", ["update", "delete"])+def test_removed_snapshot_cannot_be_recreated_by_a_stale_write(+ repository: TriggerSubscriptionRepository,+ sqlite_session_factory: sessionmaker[Session],+ operation: str,+) -> None:+ original = _snapshot()+ decoy = _snapshot()+ _persist(sqlite_session_factory, decoy)++ if operation == "update":+ with pytest.raises(TriggerSubscriptionChangedError):+ repository.update(expected=original, replacement=replace(original, name="Stale write"))+ else:+ with pytest.raises(TriggerSubscriptionChangedError):+ repository.delete(expected=original)++ assert repository.get(tenant_id=decoy.tenant_id, subscription_id=decoy.id) == decoy+ assert repository.get(tenant_id=original.tenant_id, subscription_id=original.id) is None+++def test_delete_removes_every_matching_workflow_binding_and_preserves_other_scopes(+ repository: TriggerSubscriptionRepository,+ sqlite_session_factory: sessionmaker[Session],+ sqlite_engine: Engine,+) -> None:+ original = _snapshot()+ other = replace(_snapshot(), tenant_id=original.tenant_id, name="Other")+ _persist(sqlite_session_factory, original, other)+ matching = [+ WorkflowPluginTrigger(+ app_id=str(uuid4()),+ node_id=f"node-{index}",+ tenant_id=original.tenant_id,+ provider_id=original.provider_id,+ event_name="push",+ subscription_id=original.id,+ )+ for index in range(2)+ ]+ decoys = [+ WorkflowPluginTrigger(+ app_id=str(uuid4()),+ node_id="node-decoy",+ tenant_id=tenant_id,+ provider_id=original.provider_id,+ event_name="push",+ subscription_id=subscription_id,+ )+ for tenant_id, subscription_id in [(str(uuid4()), original.id), (original.tenant_id, other.id)]+ ]+ with sqlite_session_factory.begin() as session:+ session.add_all([*matching, *decoys])++ repository.delete(expected=original)++ pool = sqlite_engine.pool+ assert isinstance(pool, QueuePool)+ assert pool.checkedout() == 0+ assert repository.get(tenant_id=original.tenant_id, subscription_id=original.id) is None+ assert repository.get(tenant_id=other.tenant_id, subscription_id=other.id) == other+ with sqlite_session_factory() as session:+ assert set(session.scalars(select(WorkflowPluginTrigger.id))) == {row.id for row in decoys}diff --git a/api/tests/unit_tests/services/plugin/test_plugin_parameter_service.py b/api/tests/unit_tests/services/plugin/test_plugin_parameter_service.pyindex 475f2bb9ea3..28b2ea965c8 100644--- a/api/tests/unit_tests/services/plugin/test_plugin_parameter_service.py+++ b/api/tests/unit_tests/services/plugin/test_plugin_parameter_service.py@@ -15,18 +15,22 @@ from uuid import uuid4import pytestfrom flask import Flaskfrom redis import Redis-from sqlalchemy.orm import Session+from sqlalchemy.orm import Session, sessionmakerimport contextsfrom core.plugin.entities.plugin_daemon import CredentialTypefrom core.trigger.trigger_manager import TriggerManager+from core.trigger.utils.encryption import delete_cache_for_subscriptionfrom extensions.ext_redis import RedisClientWrapperfrom models.engine import dbfrom models.provider_ids import TriggerProviderIDfrom models.tools import BuiltinToolProviderfrom repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepository+from repositories.trigger.subscription_repository import RedisTriggerSubscriptionLocks, TriggerSubscriptionRepositoryfrom services.plugin.plugin_parameter_service import PluginParameterService-from services.trigger.trigger_provider_service import TriggerProviderService+from services.trigger.subscription_codec import ProviderTriggerSubscriptionCodec+from services.trigger.subscription_gateway import PluginTriggerSubscriptionGateway+from services.trigger.subscription_service import TriggerSubscriptionServicefrom services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderServicefrom tests.unit_tests.core.trigger.conftest import make_controller@@ -49,16 +53,23 @@ def trigger_declaration() -> Iterator[None]:@pytest.fixture-def builders() -> Iterator[TriggerSubscriptionBuilderService]:+def builders(sqlite_session_factory: sessionmaker[Session]) -> Iterator[TriggerSubscriptionBuilderService]:# Tool-provider paths receive the real dependency but must not query builder Redis.with Redis(socket_connect_timeout=0.1) as client:redis = RedisClientWrapper()redis.initialize(client)+ subscription_management = TriggerSubscriptionService(+ subscriptions=TriggerSubscriptionRepository(session_factory=sqlite_session_factory),+ providers=PluginTriggerSubscriptionGateway(),+ locks=RedisTriggerSubscriptionLocks(redis=redis),+ codec=ProviderTriggerSubscriptionCodec(),+ invalidate_cache=delete_cache_for_subscription,+ )yield TriggerSubscriptionBuilderService(builders=RedisTriggerSubscriptionBuilderRepository(redis=redis),get_provider=TriggerManager.get_trigger_provider,subscribe=TriggerManager.subscribe_trigger,- create_subscription=TriggerProviderService.add_trigger_subscription,+ create_subscription=subscription_management.create,)diff --git a/api/tests/unit_tests/services/trigger/test_subscription_codec.py b/api/tests/unit_tests/services/trigger/test_subscription_codec.pynew file mode 100644index 00000000000..791b70d4c18--- /dev/null+++ b/api/tests/unit_tests/services/trigger/test_subscription_codec.py@@ -0,0 +1,32 @@+"""The subscription codec uses the existing workspace key provider and schema semantics."""++from core.entities.provider_entities import BasicProviderConfig, ProviderConfigType+from services.trigger.subscription_codec import ProviderTriggerSubscriptionCodec+from tests.unit_tests.controllers.console.workspace import test_trigger_oauth_client+from tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client import _Harness++application_redis = test_trigger_oauth_client.application_redis+harness = test_trigger_oauth_client.harness+++def test_codec_round_trips_secret_fields_and_preserves_other_values(harness: _Harness) -> None:+ schema = [+ BasicProviderConfig(name="token", type=ProviderConfigType.SECRET_INPUT),+ BasicProviderConfig(name="label", type=ProviderConfigType.TEXT_INPUT),+ ]+ values: dict[str, object] = {"token": "secret-token", "label": "public", "count": 0}+ with harness.app.app_context():+ cipher = ProviderTriggerSubscriptionCodec().for_schema(tenant_id=harness.tenant_id, schema=schema)+ encrypted = cipher.encrypt(values)+ assert encrypted["token"] != values["token"]+ assert encrypted["label"] == "public"+ assert encrypted["count"] == 0+ assert cipher.decrypt(encrypted) == values+ assert values == {"token": "secret-token", "label": "public", "count": 0}+++def test_codec_with_empty_schema_keeps_values(harness: _Harness) -> None:+ values = {"token": "unmodified", "empty": ""}+ cipher = ProviderTriggerSubscriptionCodec().for_schema(tenant_id=harness.tenant_id, schema=[])+ assert cipher.encrypt(values) == values+ assert cipher.decrypt(values) == valuesdiff --git a/api/tests/unit_tests/services/trigger/test_subscription_gateway.py b/api/tests/unit_tests/services/trigger/test_subscription_gateway.pynew file mode 100644index 00000000000..460cf422a5f--- /dev/null+++ b/api/tests/unit_tests/services/trigger/test_subscription_gateway.py@@ -0,0 +1,240 @@+"""Exercise subscription provider resolution and dispatch through real daemon HTTP."""++from collections.abc import Callable+from contextvars import Context+from functools import partial+from http import HTTPStatus++import pytest++from configs import dify_config+from core.plugin.entities.plugin_daemon import CredentialType+from core.trigger.entities.entities import Subscription+from models.provider_ids import TriggerProviderID+from services.trigger.subscription_gateway import PluginTriggerSubscriptionGateway+from services.trigger.subscription_query_service import TriggerSubscriptionSchemas+from services.trigger.subscription_service import (+ TriggerSubscriptionInvalidError,+ TriggerSubscriptionProviderError,+)+from tests.unit_tests.controllers.console.workspace import test_trigger_oauth_client, test_trigger_subscription_builder+from tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client import _PROVIDER, _Harness+from tests.unit_tests.controllers.console.workspace.test_trigger_provider_query import _IDENTIFIER+from tests.unit_tests.controllers.console.workspace.test_trigger_subscription_builder import _Daemon++application_redis = test_trigger_oauth_client.application_redis+harness = test_trigger_oauth_client.harness+daemon = test_trigger_subscription_builder.daemon++_CREDENTIALS = {"token": "provider-secret"}+_ENDPOINT = "https://example.test/triggers/plugin/subscription"+++def _prepare(+ harness: _Harness, daemon: _Daemon+) -> tuple[PluginTriggerSubscriptionGateway, Context, TriggerSubscriptionSchemas]:+ declaration = daemon.provider["declaration"]+ assert isinstance(declaration, dict)+ declaration["subscription_constructor"] = {+ "credentials_schema": [{"name": "token", "type": "secret-input", "required": True}],+ }+ declaration["subscription_schema"] = [{"name": "remote_id", "type": "text-input"}]+ gateway = PluginTriggerSubscriptionGateway()+ context = Context()+ schemas = context.run(+ gateway.get_schemas,+ tenant_id=harness.tenant_id,+ provider_id=TriggerProviderID(_PROVIDER),+ credential_type=CredentialType.API_KEY,+ )+ return gateway, context, schemas+++def test_one_operation_reuses_provider_for_schema_and_dispatch(harness: _Harness, daemon: _Daemon) -> None:+ gateway, context, schemas = _prepare(harness, daemon)+ assert [field.name for field in schemas.credentials[CredentialType.API_KEY]] == ["token"]+ assert [field.name for field in schemas.properties] == ["remote_id"]+ assert len(daemon.requests) == 1+ assert daemon.requests[0].method == "GET"++ # All calls in one synchronous operation share the manager's context cache;+ # an intervening package replacement does not change schema/dispatch identity.+ daemon.provider["plugin_unique_identifier"] = "langgenius/github:2.0.0@replacement"+ context.run(+ gateway.validate_credentials,+ tenant_id=harness.tenant_id,+ provider_id=TriggerProviderID(_PROVIDER),+ user_id=harness.account_id,+ credentials=_CREDENTIALS,+ )+ created = Subscription(+ expires_at=12345,+ endpoint=_ENDPOINT,+ parameters={"event": "push"},+ properties={"remote_id": "remote-subscription"},+ )+ daemon.response_data = {"subscription": created.model_dump()}+ actual = context.run(+ gateway.subscribe,+ tenant_id=harness.tenant_id,+ provider_id=TriggerProviderID(_PROVIDER),+ user_id=harness.account_id,+ endpoint=_ENDPOINT,+ parameters=created.parameters,+ credentials=_CREDENTIALS,+ credential_type=CredentialType.API_KEY,+ )+ assert actual == created+ daemon.response_data = {"subscription": {"success": True, "message": "removed"}}+ removed = context.run(+ gateway.unsubscribe,+ tenant_id=harness.tenant_id,+ provider_id=TriggerProviderID(_PROVIDER),+ user_id=harness.account_id,+ subscription=actual,+ credentials=_CREDENTIALS,+ credential_type=CredentialType.API_KEY,+ )+ assert removed.success+ assert removed.message == "removed"++ assert [request.method for request in daemon.requests] == ["GET", "POST", "POST", "POST"]+ verify, subscribe, unsubscribe = daemon.requests[1:]+ for request in (verify, subscribe, unsubscribe):+ assert request.headers["X-Plugin-ID"] == "langgenius/github"+ assert request.headers["X-Plugin-Unique-Identifier"] == _IDENTIFIER+ assert request.headers["X-Api-Key"] == dify_config.PLUGIN_DAEMON_KEY+ assert not request.open_transactions+ assert verify.path == f"/plugin/{harness.tenant_id}/dispatch/trigger/validate_credentials"+ assert verify.payload == {+ "user_id": harness.account_id,+ "data": {"provider": "github", "credentials": _CREDENTIALS},+ }+ assert subscribe.path == f"/plugin/{harness.tenant_id}/dispatch/trigger/subscribe"+ assert subscribe.payload == {+ "user_id": harness.account_id,+ "data": {+ "provider": "github",+ "credentials": _CREDENTIALS,+ "credential_type": "api-key",+ "endpoint": _ENDPOINT,+ "parameters": {"event": "push"},+ },+ }+ assert unsubscribe.path == f"/plugin/{harness.tenant_id}/dispatch/trigger/unsubscribe"+ assert unsubscribe.payload == {+ "user_id": harness.account_id,+ "data": {+ "provider": "github",+ "credentials": _CREDENTIALS,+ "credential_type": "api-key",+ "subscription": created.model_dump(),+ },+ }+++def test_missing_required_credential_is_invalid_without_dispatch(harness: _Harness, daemon: _Daemon) -> None:+ gateway, context, _ = _prepare(harness, daemon)++ with pytest.raises(TriggerSubscriptionInvalidError, match="Missing required credential field: token"):+ context.run(+ gateway.validate_credentials,+ tenant_id=harness.tenant_id,+ provider_id=TriggerProviderID(_PROVIDER),+ user_id=harness.account_id,+ credentials={},+ )++ assert len(daemon.requests) == 1+ assert daemon.requests[0].method == "GET"+++def test_plugin_credential_rejection_is_invalid(harness: _Harness, daemon: _Daemon) -> None:+ gateway, context, _ = _prepare(harness, daemon)+ daemon.response_data = {"result": False}++ with pytest.raises(TriggerSubscriptionInvalidError, match="Invalid credentials"):+ context.run(+ gateway.validate_credentials,+ tenant_id=harness.tenant_id,+ provider_id=TriggerProviderID(_PROVIDER),+ user_id=harness.account_id,+ credentials=_CREDENTIALS,+ )++ assert len(daemon.requests) == 2+ assert daemon.requests[-1].path.endswith("/validate_credentials")++[email protected]("failure", ["plugin", "invalid-response"])+def test_verification_failures_are_provider_errors_without_exposing_credentials(+ harness: _Harness, daemon: _Daemon, failure: str+) -> None:+ gateway, context, _ = _prepare(harness, daemon)+ if failure == "plugin":+ daemon.response_code = 1+ daemon.response_message = "remote operation failed"+ daemon.response_data = None+ else:+ daemon.response_data = {}++ with pytest.raises(TriggerSubscriptionProviderError) as caught:+ context.run(+ gateway.validate_credentials,+ tenant_id=harness.tenant_id,+ provider_id=TriggerProviderID(_PROVIDER),+ user_id=harness.account_id,+ credentials=_CREDENTIALS,+ )++ assert caught.value.__cause__ is not None+ assert "provider-secret" not in str(caught.value)+ assert len(daemon.requests) == 2++[email protected]("operation", ["subscribe", "unsubscribe"])+def test_remote_subscription_failures_propagate_for_service_context(+ harness: _Harness, daemon: _Daemon, operation: str+) -> None:+ gateway, context, _ = _prepare(harness, daemon)+ daemon.response_code = 1+ daemon.response_message = "remote operation failed"+ daemon.response_data = None+ commands: dict[str, Callable[[], object]] = {+ "subscribe": partial(+ gateway.subscribe,+ tenant_id=harness.tenant_id,+ provider_id=TriggerProviderID(_PROVIDER),+ user_id=harness.account_id,+ endpoint=_ENDPOINT,+ parameters={},+ credentials=_CREDENTIALS,+ credential_type=CredentialType.API_KEY,+ ),+ "unsubscribe": partial(+ gateway.unsubscribe,+ tenant_id=harness.tenant_id,+ provider_id=TriggerProviderID(_PROVIDER),+ user_id=harness.account_id,+ subscription=Subscription(expires_at=-1, endpoint=_ENDPOINT, properties={}),+ credentials=_CREDENTIALS,+ credential_type=CredentialType.API_KEY,+ ),+ }+ invoke = commands[operation]++ with pytest.raises(ValueError, match="^plugin daemon: remote operation failed, code: 1$"):+ context.run(invoke)++ assert len(daemon.requests) == 2+++def test_provider_lookup_failure_is_a_domain_error(harness: _Harness, daemon: _Daemon) -> None:+ daemon.status = HTTPStatus.SERVICE_UNAVAILABLE++ with pytest.raises(TriggerSubscriptionProviderError) as caught:+ _prepare(harness, daemon)++ assert caught.value.__cause__ is not None+ assert len(daemon.requests) == 1+ assert daemon.requests[0].method == "GET"diff --git a/api/tests/unit_tests/services/trigger/test_subscription_mutation_serialization.py b/api/tests/unit_tests/services/trigger/test_subscription_mutation_serialization.pynew file mode 100644index 00000000000..9b5e17bc230--- /dev/null+++ b/api/tests/unit_tests/services/trigger/test_subscription_mutation_serialization.py@@ -0,0 +1,248 @@+"""Subscription writers share the critical section across provider I/O and SQL commits."""++from collections.abc import Callable, Generator, Mapping+from concurrent.futures import ThreadPoolExecutor+from contextlib import contextmanager+from threading import Event, Lock+from uuid import uuid4++import pytest+from sqlalchemy.orm import Session, sessionmaker++from core.plugin.entities.plugin_daemon import CredentialType+from core.trigger.entities.entities import Subscription, UnsubscribeResult+from models.enums import PermissionEnum+from models.provider_ids import TriggerProviderID+from repositories.trigger.subscription_repository import TriggerSubscriptionRepository+from services.trigger.subscription_codec import ProviderTriggerSubscriptionCodec+from services.trigger.subscription_query_service import TriggerSubscriptionSchemas+from services.trigger.subscription_service import (+ TriggerSubscriptionLeaseLostError,+ TriggerSubscriptionService,+ TriggerSubscriptionSnapshot,+)+++class _Lease:+ def __init__(self) -> None:+ self.lost = Event()++ def ensure_owned(self) -> None:+ if self.lost.is_set():+ raise TriggerSubscriptionLeaseLostError("The lease was lost")+++class _Locks:+ """A deterministic stand-in for the distributed lock boundary."""++ def __init__(self) -> None:+ self.lock = Lock()+ self.attempt_lock = Lock()+ self.attempts = 0+ self.second_attempted = Event()+ self.lease = _Lease()++ @contextmanager+ def for_subscription(self, *, tenant_id: str, subscription_id: str) -> Generator[_Lease]:+ assert tenant_id+ assert subscription_id+ with self.attempt_lock:+ self.attempts += 1+ if self.attempts == 2:+ self.second_attempted.set()+ with self.lock:+ yield self.lease++ @contextmanager+ def for_provider(self, *, tenant_id: str, provider_id: TriggerProviderID) -> Generator[None]:+ assert tenant_id+ assert provider_id+ with self.lock:+ yield+++class _Provider:+ def __init__(self) -> None:+ self.first_unsubscribe_started = Event()+ self.release_first_unsubscribe = Event()+ self.calls: list[tuple[str, str]] = []+ self.after_unsubscribe: Callable[[], None] | None = None+ self.after_subscribe: Callable[[], None] | None = None++ def get_schemas(+ self, *, tenant_id: str, provider_id: TriggerProviderID, credential_type: CredentialType+ ) -> TriggerSubscriptionSchemas:+ assert tenant_id+ assert provider_id+ return TriggerSubscriptionSchemas(credentials={credential_type: []}, properties=[])++ def validate_credentials(+ self, *, tenant_id: str, provider_id: TriggerProviderID, user_id: str, credentials: Mapping[str, object]+ ) -> None:+ raise AssertionError(f"Unexpected verification for {tenant_id}, {provider_id}, {user_id}: {credentials}")++ def unsubscribe(+ self,+ *,+ tenant_id: str,+ provider_id: TriggerProviderID,+ user_id: str,+ subscription: Subscription,+ credentials: Mapping[str, str],+ credential_type: CredentialType,+ ) -> UnsubscribeResult:+ assert tenant_id+ assert provider_id+ assert user_id+ assert credentials+ assert credential_type+ self.calls.append(("unsubscribe", str(subscription.properties["remote"])))+ if len(self.calls) == 1:+ self.first_unsubscribe_started.set()+ if not self.release_first_unsubscribe.wait(timeout=10):+ raise TimeoutError("The test did not release the first provider request")+ if self.after_unsubscribe is not None:+ self.after_unsubscribe()+ return UnsubscribeResult(success=True)++ def subscribe(+ self,+ *,+ tenant_id: str,+ provider_id: TriggerProviderID,+ user_id: str,+ endpoint: str,+ parameters: Mapping[str, object],+ credentials: Mapping[str, str],+ credential_type: CredentialType,+ ) -> Subscription:+ assert tenant_id+ assert provider_id+ assert user_id+ assert credentials+ assert credential_type+ value = str(parameters["event"])+ self.calls.append(("subscribe", value))+ if self.after_subscribe is not None:+ self.after_subscribe()+ return Subscription(expires_at=-1, endpoint=endpoint, parameters=parameters, properties={"remote": value})+++def _subscription() -> TriggerSubscriptionSnapshot:+ return TriggerSubscriptionSnapshot(+ id=str(uuid4()),+ name="subscription",+ tenant_id=str(uuid4()),+ user_id=str(uuid4()),+ provider_id="langgenius/github/github",+ endpoint_id=str(uuid4()),+ credential_type=CredentialType.API_KEY,+ parameters={"event": "old"},+ properties={"remote": "old"},+ credentials={"token": "secret"},+ credential_expires_at=-1,+ expires_at=-1,+ visibility=PermissionEnum.ALL_TEAM,+ )++[email protected]("second_operation", ["update", "delete"])+def test_concurrent_mutations_wait_for_provider_and_reload_committed_snapshot(+ sqlite_session_factory: sessionmaker[Session], second_operation: str+) -> None:+ """A competing update or delete cannot modify the provider before the first SQL commit."""+ snapshot = _subscription()+ repository = TriggerSubscriptionRepository(session_factory=sqlite_session_factory)+ repository.create(subscription=snapshot, max_count=10)+ locks, provider = _Locks(), _Provider()+ service = TriggerSubscriptionService(+ subscriptions=repository,+ providers=provider,+ locks=locks,+ codec=ProviderTriggerSubscriptionCodec(),+ invalidate_cache=lambda **_: None,+ )++ def update(event: str) -> None:+ service.update(+ tenant_id=snapshot.tenant_id,+ subscription_id=snapshot.id,+ name=None,+ credentials=None,+ parameters={"event": event},+ properties=None,+ )++ def second() -> None:+ if second_operation == "update":+ update("second")+ else:+ service.delete(tenant_id=snapshot.tenant_id, subscription_id=snapshot.id)++ with ThreadPoolExecutor(max_workers=2) as pool:+ first = pool.submit(update, "first")+ try:+ assert provider.first_unsubscribe_started.wait(timeout=5)+ other = pool.submit(second)+ assert locks.second_attempted.wait(timeout=5)+ assert provider.calls == [("unsubscribe", "old")]+ finally:+ provider.release_first_unsubscribe.set()+ first.result(timeout=10)+ other.result(timeout=10)++ assert provider.calls[:3] == [("unsubscribe", "old"), ("subscribe", "first"), ("unsubscribe", "first")]+ result = repository.get(tenant_id=snapshot.tenant_id, subscription_id=snapshot.id)+ if second_operation == "update":+ assert provider.calls[3:] == [("subscribe", "second")]+ assert result is not None+ assert result.parameters == {"event": "second"}+ assert result.properties == {"remote": "second"}+ else:+ assert len(provider.calls) == 3+ assert result is None++[email protected]("operation", ["update-after-unsubscribe", "update-after-subscribe", "delete"])+def test_lost_lease_stops_further_effects_and_preserves_database(+ sqlite_session_factory: sessionmaker[Session], operation: str+) -> None:+ """An owner that loses its lease must not start another provider call or SQL write."""+ snapshot = _subscription()+ repository = TriggerSubscriptionRepository(session_factory=sqlite_session_factory)+ repository.create(subscription=snapshot, max_count=10)+ locks, provider = _Locks(), _Provider()+ provider.release_first_unsubscribe.set()+ if operation == "update-after-subscribe":+ provider.after_subscribe = locks.lease.lost.set+ else:+ provider.after_unsubscribe = locks.lease.lost.set+ service = TriggerSubscriptionService(+ subscriptions=repository,+ providers=provider,+ locks=locks,+ codec=ProviderTriggerSubscriptionCodec(),+ invalidate_cache=lambda **_: None,+ )++ def mutate() -> None:+ if operation == "delete":+ service.delete(tenant_id=snapshot.tenant_id, subscription_id=snapshot.id)+ else:+ service.update(+ tenant_id=snapshot.tenant_id,+ subscription_id=snapshot.id,+ name=None,+ credentials=None,+ parameters={"event": "new"},+ properties=None,+ )++ with pytest.raises(TriggerSubscriptionLeaseLostError):+ mutate()++ assert repository.get(tenant_id=snapshot.tenant_id, subscription_id=snapshot.id) == snapshot+ if operation == "update-after-subscribe":+ assert provider.calls == [("unsubscribe", "old"), ("subscribe", "new")]+ else:+ assert provider.calls == [("unsubscribe", "old")]diff --git a/api/tests/unit_tests/services/trigger/test_trigger_provider_service.py b/api/tests/unit_tests/services/trigger/test_trigger_provider_service.pyindex 7c5b88637e6..db871623ba7 100644--- a/api/tests/unit_tests/services/trigger/test_trigger_provider_service.py+++ b/api/tests/unit_tests/services/trigger/test_trigger_provider_service.py@@ -8,7 +8,6 @@ provider daemons, encryption, Redis locks, and caches remain external mocks.from __future__ import annotations-import contextlibimport jsonfrom dataclasses import dataclassfrom types import SimpleNamespace@@ -16,12 +15,9 @@ from unittest.mock import Mockfrom uuid import uuid4import pytest-from sqlalchemy import event, func, select-from sqlalchemy.engine import Connection, Engine-from sqlalchemy.exc import IntegrityError+from sqlalchemy.engine import Enginefrom sqlalchemy.orm import Session, sessionmaker-from constants import HIDDEN_VALUEfrom core.plugin.entities.plugin_daemon import CredentialTypefrom core.trigger.entities.entities import Subscription as TriggerSubscriptionEntityfrom models.base import TypeBase@@ -127,11 +123,6 @@ def _patch_provider(mocker, provider: object) -> None:mocker.patch.object(service_module.TriggerManager, "get_trigger_provider", return_value=provider)-def _patch_lock(mocker) -> None:- redis = mocker.patch.object(service_module, "redis_client")- redis.lock.return_value = contextlib.nullcontext()--def _encrypter(*,decrypted: dict[str, object] | None = None,@@ -163,173 +154,6 @@ def _patch_identity_encryption(mocker) -> Mock:return cache[email protected]("credential_type", [CredentialType.API_KEY, CredentialType.UNAUTHORIZED])-def test_add_subscription_commits_encrypted_state(- mocker,- trigger_db: TriggerDatabase,- provider_controller: Mock,- credential_type: CredentialType,-) -> None:- _patch_lock(mocker)- _patch_provider(mocker, provider_controller)- encrypter = _encrypter(encrypted={"stored": "encrypted"})- mocker.patch.object(service_module, "create_provider_encrypter", return_value=(encrypter, Mock()))- subscription_id = str(uuid4())-- result = TriggerProviderService.add_trigger_subscription(- tenant_id=trigger_db.tenant_id,- user_id=trigger_db.user_id,- name="main",- provider_id=trigger_db.provider_id,- endpoint_id="endpoint-main",- credential_type=credential_type,- parameters={"event": "push"},- properties={"project": "plain"},- credentials={"token": "plain"},- subscription_id=subscription_id,- )-- persisted = trigger_db.get_subscription(subscription_id)- assert result == {"result": "success", "id": subscription_id}- assert persisted is not None- assert persisted.properties == {"stored": "encrypted"}- expected_credentials = {} if credential_type == CredentialType.UNAUTHORIZED else {"stored": "encrypted"}- assert persisted.credentials == expected_credentials---def test_add_subscription_limit_rolls_back_without_cross_tenant_count(- mocker, trigger_db: TriggerDatabase, provider_controller: Mock-) -> None:- for index in range(TriggerProviderService.__MAX_TRIGGER_PROVIDER_COUNT__):- trigger_db.add_subscription(name=f"target-{index}")- for index in range(3):- trigger_db.add_subscription(tenant_id=trigger_db.other_tenant_id, name=f"foreign-{index}")- _patch_lock(mocker)- _patch_provider(mocker, provider_controller)-- with pytest.raises(ValueError, match="Maximum number of providers"):- TriggerProviderService.add_trigger_subscription(- tenant_id=trigger_db.tenant_id,- user_id=trigger_db.user_id,- name="overflow",- provider_id=trigger_db.provider_id,- endpoint_id="overflow",- credential_type=CredentialType.UNAUTHORIZED,- parameters={},- properties={},- credentials={},- )-- with trigger_db.session_maker() as session:- count = session.scalar(- select(func.count())- .select_from(TriggerSubscription)- .where(TriggerSubscription.tenant_id == trigger_db.tenant_id)- )- assert count == TriggerProviderService.__MAX_TRIGGER_PROVIDER_COUNT__---def test_add_duplicate_name_rolls_back_and_database_constraint_matches_precheck(- mocker, trigger_db: TriggerDatabase, provider_controller: Mock-) -> None:- original = trigger_db.add_subscription(name="main")- _patch_lock(mocker)- _patch_provider(mocker, provider_controller)-- with pytest.raises(ValueError, match="already exists"):- TriggerProviderService.add_trigger_subscription(- tenant_id=trigger_db.tenant_id,- user_id=trigger_db.user_id,- name="main",- provider_id=trigger_db.provider_id,- endpoint_id="second-endpoint",- credential_type=CredentialType.UNAUTHORIZED,- parameters={},- properties={},- credentials={},- )-- duplicate = TriggerSubscription(- tenant_id=trigger_db.tenant_id,- user_id=trigger_db.user_id,- name="main",- endpoint_id="constraint-endpoint",- provider_id=str(trigger_db.provider_id),- parameters={},- properties={},- credentials={},- credential_type=CredentialType.UNAUTHORIZED,- )- with pytest.raises(IntegrityError):- with trigger_db.session_maker.begin() as session:- session.add(duplicate)- assert trigger_db.get_subscription(original.id) is not None---def test_update_subscription_persists_fields_and_preserves_hidden_property(- mocker, trigger_db: TriggerDatabase, provider_controller: Mock, sqlite_engine: Engine-) -> None:- subscription = trigger_db.add_subscription(properties={"project": "old-encrypted"})- _patch_lock(mocker)- _patch_provider(mocker, provider_controller)- properties = _encrypter(decrypted={"project": "old-value"})- credentials = _encrypter(encrypted={"token": "new-encrypted"})- mocker.patch.object(- service_module,- "create_provider_encrypter",- side_effect=[(properties, Mock()), (credentials, Mock())],- )- clear_cache = mocker.patch.object(service_module, "delete_cache_for_subscription")-- events: list[str] = []-- def committed(_connection: Connection) -> None:- events.append("commit")-- def invalidated(*_args: object, **_kwargs: object) -> None:- events.append("invalidate")-- clear_cache.side_effect = invalidated- event.listen(sqlite_engine, "commit", committed)- try:- TriggerProviderService.update_trigger_subscription(- trigger_db.tenant_id,- subscription.id,- name="renamed",- properties={"project": HIDDEN_VALUE, "region": "us"},- parameters={"event": "issues"},- credentials={"token": "plain"},- credential_expires_at=100,- expires_at=200,- )- finally:- event.remove(sqlite_engine, "commit", committed)- assert events == ["commit", "invalidate"]-- persisted = trigger_db.get_subscription(subscription.id)- assert persisted is not None- assert persisted.name == "renamed"- assert persisted.properties == {"project": "old-value", "region": "us"}- assert persisted.credentials == {"token": "new-encrypted"}- assert persisted.expires_at == 200- clear_cache.assert_called_once()---def test_update_missing_and_conflicting_names_leave_rows_unchanged(- mocker, trigger_db: TriggerDatabase, provider_controller: Mock-) -> None:- first = trigger_db.add_subscription(name="first")- trigger_db.add_subscription(name="second")- _patch_lock(mocker)- _patch_provider(mocker, provider_controller)-- with pytest.raises(ValueError, match="not found"):- TriggerProviderService.update_trigger_subscription(trigger_db.tenant_id, str(uuid4()))- with pytest.raises(ValueError, match="already exists"):- TriggerProviderService.update_trigger_subscription(trigger_db.tenant_id, first.id, name="second")- assert trigger_db.get_subscription(first.id).name == "first" # type: ignore[union-attr]--def test_get_subscription_scopes_tenant_and_decrypts(mocker, trigger_db: TriggerDatabase, provider_controller: Mock) -> None:@@ -357,29 +181,6 @@ def test_get_subscription_scopes_tenant_and_decrypts(assert result.properties == {"project": "plain"}[email protected]("credential_type", [CredentialType.API_KEY, CredentialType.UNAUTHORIZED])-def test_delete_subscription_uses_real_caller_transaction(- mocker,- trigger_db: TriggerDatabase,- provider_controller: Mock,- credential_type: CredentialType,-) -> None:- subscription = trigger_db.add_subscription(credential_type=credential_type)- _patch_provider(mocker, provider_controller)- _patch_identity_encryption(mocker)- unsubscribe = mocker.patch.object(service_module.TriggerManager, "unsubscribe_trigger")- mocker.patch.object(service_module, "delete_cache_for_subscription")-- with trigger_db.session_maker.begin() as session:- TriggerProviderService.delete_trigger_provider(trigger_db.tenant_id, subscription.id, session=session)-- assert trigger_db.get_subscription(subscription.id) is None- if credential_type == CredentialType.UNAUTHORIZED:- unsubscribe.assert_not_called()- else:- unsubscribe.assert_called_once()--@pytest.mark.parametrize("client_credentials", [None, {}, {"client": "system"}])def test_refresh_oauth_token_persists_credentials_after_commit(mocker, trigger_db: TriggerDatabase, provider_controller: Mock, client_credentials: dict[str, str] | None@@ -512,78 +313,3 @@ def test_endpoint_lookup_decrypts_persisted_subscription(found = TriggerProviderService.get_subscription_by_endpoint("lookup-endpoint")assert found is not Noneassert found.id == subscription.id--[email protected]("valid", [True, False])-def test_verify_api_key_credentials_uses_persisted_subscription(- mocker,- trigger_db: TriggerDatabase,- provider_controller: Mock,- valid: bool,-) -> None:- subscription = trigger_db.add_subscription(credentials={"token": "old"})- _patch_provider(mocker, provider_controller)- _patch_identity_encryption(mocker)- if not valid:- provider_controller.validate_credentials.side_effect = RuntimeError("denied")-- if valid:- assert TriggerProviderService.verify_subscription_credentials(- trigger_db.tenant_id,- trigger_db.user_id,- trigger_db.provider_id,- subscription.id,- {"token": HIDDEN_VALUE},- ) == {"verified": True}- provider_controller.validate_credentials.assert_called_once_with(- trigger_db.user_id, credentials={"token": "old"}- )- else:- with pytest.raises(ValueError, match="Invalid credentials"):- TriggerProviderService.verify_subscription_credentials(- trigger_db.tenant_id,- trigger_db.user_id,- trigger_db.provider_id,- subscription.id,- {"token": "new"},- )---def test_rebuild_subscription_preserves_id_endpoint_and_updates_state(- mocker, trigger_db: TriggerDatabase, provider_controller: Mock-) -> None:- subscription = trigger_db.add_subscription(endpoint_id="stable-endpoint", credentials={"token": "old"})- _patch_provider(mocker, provider_controller)- _patch_lock(mocker)- _patch_identity_encryption(mocker)- mocker.patch.object(- service_module.TriggerManager, "unsubscribe_trigger", return_value=SimpleNamespace(success=True)- )- mocker.patch.object(- service_module.TriggerManager,- "subscribe_trigger",- return_value=TriggerSubscriptionEntity(- expires_at=777,- endpoint="stable-endpoint",- parameters={"event": "issues"},- properties={"hook": "new"},- ),- )- mocker.patch.object(service_module, "delete_cache_for_subscription")-- TriggerProviderService.rebuild_trigger_subscription(- trigger_db.tenant_id,- trigger_db.provider_id,- subscription.id,- credentials={"token": HIDDEN_VALUE},- parameters={"event": "issues"},- name="rebuilt",- )-- persisted = trigger_db.get_subscription(subscription.id)- assert persisted is not None- assert persisted.endpoint_id == "stable-endpoint"- assert persisted.name == "rebuilt"- assert persisted.credentials == {"token": "old"}- assert persisted.properties == {"hook": "new"}- assert persisted.expires_at == 777diff --git a/packages/contracts/generated/api/console/errors.gen.ts b/packages/contracts/generated/api/console/errors.gen.tsindex 22c3caea276..5376f6b8b67 100644--- a/packages/contracts/generated/api/console/errors.gen.ts+++ b/packages/contracts/generated/api/console/errors.gen.ts@@ -527,6 +527,8 @@ export { post7Errors as 'POST /rag/pipelines/{pipeline_id}/customized/publish' }export { post7Errors as 'POST /snippets/{snippet_id}/workflows/draft/nodes/{node_id}/agent-composer/validate' } from './snippets/errors.gen.ts'export { post7Errors as 'POST /trial-apps/{app_id}/text-to-audio' } from './trial-apps/errors.gen.ts'export { post84Errors as 'POST /workspaces/current/trigger-provider/{provider}/oauth/client' } from './workspaces/errors.gen.ts'+export { post85Errors as 'POST /workspaces/current/trigger-provider/{provider}/subscriptions/builder/build/{subscription_builder_id}' } from './workspaces/errors.gen.ts'+export { post89Errors as 'POST /workspaces/current/trigger-provider/{provider}/subscriptions/verify/{subscription_id}' } from './workspaces/errors.gen.ts'export { post8Errors as 'POST /account/init' } from './account/errors.gen.ts'export { post8Errors as 'POST /agent/{agent_id}/composer/validate' } from './agent/errors.gen.ts'export { post8Errors as 'POST /apps/{app_id}/advanced-chat/workflows/draft/loop/nodes/{node_id}/run' } from './apps/errors.gen.ts'@@ -534,6 +536,8 @@ export { post8Errors as 'POST /installed-apps/{installed_app_id}/saved-messages'export { post8Errors as 'POST /knowledge-fs/spaces/{control_space_id}/golden-questions/bulk-import' } from './knowledge-fs/errors.gen.ts'export { post8Errors as 'POST /rag/pipelines/{pipeline_id}/workflow-runs/tasks/{task_id}/stop' } from './rag/errors.gen.ts'export { post8Errors as 'POST /trial-apps/{app_id}/workflows/run' } from './trial-apps/errors.gen.ts'+export { post90Errors as 'POST /workspaces/current/trigger-provider/{subscription_id}/subscriptions/delete' } from './workspaces/errors.gen.ts'+export { post91Errors as 'POST /workspaces/current/trigger-provider/{subscription_id}/subscriptions/update' } from './workspaces/errors.gen.ts'export { post92Errors as 'POST /workspaces/custom-config/webapp-logo/upload' } from './workspaces/errors.gen.ts'export { post95Errors as 'POST /workspaces/switch' } from './workspaces/errors.gen.ts'export { post9Errors as 'POST /account/password' } from './account/errors.gen.ts'diff --git a/packages/contracts/generated/api/console/workspaces/errors.gen.ts b/packages/contracts/generated/api/console/workspaces/errors.gen.tsindex fd15779c0dd..b389926b8cd 100644--- a/packages/contracts/generated/api/console/workspaces/errors.gen.ts+++ b/packages/contracts/generated/api/console/workspaces/errors.gen.ts@@ -274,6 +274,30 @@ const zTriggerOauthClientChangedError = /* @__PURE__ */ (() =>}),))()+const zTriggerSubscriptionLimitReachedError = /* @__PURE__ */ (() =>+ zErrorResponse.and(+ z.object({+ code: z.literal('trigger_subscription_limit_reached'),+ status: z.literal(400),+ }),+ ))()++const zTriggerSubscriptionNameConflictError = /* @__PURE__ */ (() =>+ zErrorResponse.and(+ z.object({+ code: z.literal('trigger_subscription_name_conflict'),+ status: z.literal(409),+ }),+ ))()++const zTriggerSubscriptionProviderError = /* @__PURE__ */ (() =>+ zErrorResponse.and(+ z.object({+ code: z.literal('trigger_subscription_provider_error'),+ status: z.literal(502),+ }),+ ))()+const zTriggerOauthProviderError = /* @__PURE__ */ (() =>zErrorResponse.and(z.object({@@ -282,6 +306,30 @@ const zTriggerOauthProviderError = /* @__PURE__ */ (() =>}),))()+const zTriggerSubscriptionInvalidError = /* @__PURE__ */ (() =>+ zErrorResponse.and(+ z.object({+ code: z.literal('trigger_subscription_invalid'),+ status: z.literal(400),+ }),+ ))()++const zTriggerSubscriptionNotFoundError = /* @__PURE__ */ (() =>+ zErrorResponse.and(+ z.object({+ code: z.literal('trigger_subscription_not_found'),+ status: z.literal(404),+ }),+ ))()++const zTriggerSubscriptionChangedError = /* @__PURE__ */ (() =>+ zErrorResponse.and(+ z.object({+ code: z.literal('trigger_subscription_changed'),+ status: z.literal(409),+ }),+ ))()+const zFilenameNotExistsError = /* @__PURE__ */ (() =>zErrorResponse.and(z.object({@@ -525,11 +573,36 @@ export const post84Errors = {trigger_oauth_client_config_invalid: { status: 500, data: zTriggerOauthClientConfigInvalidError },}+export const post85Errors = {+ trigger_subscription_limit_reached: { status: 400, data: zTriggerSubscriptionLimitReachedError },+ trigger_subscription_name_conflict: { status: 409, data: zTriggerSubscriptionNameConflictError },+ trigger_subscription_provider_error: { status: 502, data: zTriggerSubscriptionProviderError },+}+export const get131Errors = {trigger_oauth_client_config_invalid: { status: 500, data: zTriggerOauthClientConfigInvalidError },trigger_oauth_provider_error: { status: 502, data: zTriggerOauthProviderError },}+export const post89Errors = {+ trigger_subscription_invalid: { status: 400, data: zTriggerSubscriptionInvalidError },+ trigger_subscription_not_found: { status: 404, data: zTriggerSubscriptionNotFoundError },+ trigger_subscription_provider_error: { status: 502, data: zTriggerSubscriptionProviderError },+}++export const post90Errors = {+ trigger_subscription_changed: { status: 409, data: zTriggerSubscriptionChangedError },+ trigger_subscription_not_found: { status: 404, data: zTriggerSubscriptionNotFoundError },+ trigger_subscription_provider_error: { status: 502, data: zTriggerSubscriptionProviderError },+}++export const post91Errors = {+ trigger_subscription_changed: { status: 409, data: zTriggerSubscriptionChangedError },+ trigger_subscription_name_conflict: { status: 409, data: zTriggerSubscriptionNameConflictError },+ trigger_subscription_not_found: { status: 404, data: zTriggerSubscriptionNotFoundError },+ trigger_subscription_provider_error: { status: 502, data: zTriggerSubscriptionProviderError },+}+export const post92Errors = {file_too_large: { status: 413, data: zFileTooLargeError },filename_not_exists_error: { status: 400, data: zFilenameNotExistsError },diff --git a/packages/contracts/generated/api/console/workspaces/orpc.gen.ts b/packages/contracts/generated/api/console/workspaces/orpc.gen.tsindex ac3ae3e9925..3827461929a 100644--- a/packages/contracts/generated/api/console/workspaces/orpc.gen.ts+++ b/packages/contracts/generated/api/console/workspaces/orpc.gen.ts@@ -41,6 +41,12 @@ import {zTriggerOauthClientChangedError,zTriggerOauthClientConfigInvalidError,zTriggerOauthProviderError,+ zTriggerSubscriptionChangedError,+ zTriggerSubscriptionInvalidError,+ zTriggerSubscriptionLimitReachedError,+ zTriggerSubscriptionNameConflictError,+ zTriggerSubscriptionNotFoundError,+ zTriggerSubscriptionProviderError,zUnsupportedFileTypeError,} from './zod.gen.ts'import {@@ -5835,6 +5841,17 @@ export const post85 = oc.output(zPostWorkspacesCurrentTriggerProviderByProviderSubscriptionsBuilderBuildBySubscriptionBuilderIdResponse,)+ .errors({+ trigger_subscription_limit_reached: {+ status: 400,+ data: zTriggerSubscriptionLimitReachedError,+ },+ trigger_subscription_name_conflict: {+ status: 409,+ data: zTriggerSubscriptionNameConflictError,+ },+ trigger_subscription_provider_error: { status: 502, data: zTriggerSubscriptionProviderError },+ })export const bySubscriptionBuilderId = {post: post85,@@ -6053,7 +6070,7 @@ export const oauth3 = {}/**- * Verify credentials for an existing subscription (edit mode only)+ * Verify credentials against the subscription's own provider without updating it*/export const post89 = oc.route({@@ -6062,7 +6079,7 @@ export const post89 = ocoperationId:'postWorkspacesCurrentTriggerProviderByProviderSubscriptionsVerifyBySubscriptionId',path: '/workspaces/current/trigger-provider/{provider}/subscriptions/verify/{subscription_id}',- summary: 'Verify credentials for an existing subscription (edit mode only)',+ summary: "Verify credentials against the subscription's own provider without updating it",tags: ['console'],}).input(@@ -6075,6 +6092,11 @@ export const post89 = oc.output(zPostWorkspacesCurrentTriggerProviderByProviderSubscriptionsVerifyBySubscriptionIdResponse,)+ .errors({+ trigger_subscription_invalid: { status: 400, data: zTriggerSubscriptionInvalidError },+ trigger_subscription_not_found: { status: 404, data: zTriggerSubscriptionNotFoundError },+ trigger_subscription_provider_error: { status: 502, data: zTriggerSubscriptionProviderError },+ })export const bySubscriptionId = {post: post89,@@ -6099,7 +6121,7 @@ export const byProvider3 = {}/**- * Delete a subscription instance+ * Delete the subscription and its workflow trigger bindings*/export const post90 = oc.route({@@ -6107,7 +6129,7 @@ export const post90 = ocmethod: 'POST',operationId: 'postWorkspacesCurrentTriggerProviderBySubscriptionIdSubscriptionsDelete',path: '/workspaces/current/trigger-provider/{subscription_id}/subscriptions/delete',- summary: 'Delete a subscription instance',+ summary: 'Delete the subscription and its workflow trigger bindings',tags: ['console'],}).input(@@ -6116,13 +6138,18 @@ export const post90 = oc}),).output(zPostWorkspacesCurrentTriggerProviderBySubscriptionIdSubscriptionsDeleteResponse)+ .errors({+ trigger_subscription_changed: { status: 409, data: zTriggerSubscriptionChangedError },+ trigger_subscription_not_found: { status: 404, data: zTriggerSubscriptionNotFoundError },+ trigger_subscription_provider_error: { status: 502, data: zTriggerSubscriptionProviderError },+ })export const delete27 = {post: post90,}/**- * Update a subscription instance+ * Rename a subscription or rebuild its provider configuration*/export const post91 = oc.route({@@ -6130,7 +6157,7 @@ export const post91 = ocmethod: 'POST',operationId: 'postWorkspacesCurrentTriggerProviderBySubscriptionIdSubscriptionsUpdate',path: '/workspaces/current/trigger-provider/{subscription_id}/subscriptions/update',- summary: 'Update a subscription instance',+ summary: 'Rename a subscription or rebuild its provider configuration',tags: ['console'],}).input(@@ -6140,6 +6167,15 @@ export const post91 = oc}),).output(zPostWorkspacesCurrentTriggerProviderBySubscriptionIdSubscriptionsUpdateResponse)+ .errors({+ trigger_subscription_changed: { status: 409, data: zTriggerSubscriptionChangedError },+ trigger_subscription_name_conflict: {+ status: 409,+ data: zTriggerSubscriptionNameConflictError,+ },+ trigger_subscription_not_found: { status: 404, data: zTriggerSubscriptionNotFoundError },+ trigger_subscription_provider_error: { status: 502, data: zTriggerSubscriptionProviderError },+ })export const update7 = {post: post91,diff --git a/packages/contracts/generated/api/console/workspaces/types.gen.ts b/packages/contracts/generated/api/console/workspaces/types.gen.tsindex 7f499a865dc..5d837ff28b1 100644--- a/packages/contracts/generated/api/console/workspaces/types.gen.ts+++ b/packages/contracts/generated/api/console/workspaces/types.gen.ts@@ -1614,6 +1614,21 @@ export type TriggerSubscriptionBuilderUpdatePayload = {} | null}+export type TriggerSubscriptionLimitReachedError = ErrorResponse & {+ code: 'trigger_subscription_limit_reached'+ status: 400+}++export type TriggerSubscriptionNameConflictError = ErrorResponse & {+ code: 'trigger_subscription_name_conflict'+ status: 409+}++export type TriggerSubscriptionProviderError = ErrorResponse & {+ code: 'trigger_subscription_provider_error'+ status: 502+}+export type TriggerSubscriptionBuilderCreatePayload = {credential_type?: string}@@ -1676,6 +1691,21 @@ export type TriggerSubscriptionVerifyPayload = {}}+export type TriggerSubscriptionInvalidError = ErrorResponse & {+ code: 'trigger_subscription_invalid'+ status: 400+}++export type TriggerSubscriptionNotFoundError = ErrorResponse & {+ code: 'trigger_subscription_not_found'+ status: 404+}++export type TriggerSubscriptionChangedError = ErrorResponse & {+ code: 'trigger_subscription_changed'+ status: 409+}+export type TriggerProviderListResponse = Array<TriggerProviderApiEntity>export type WorkspaceCustomConfigResponse = {@@ -10547,6 +10577,9 @@ export type PostWorkspacesCurrentTriggerProviderByProviderSubscriptionsBuilderBuexport type PostWorkspacesCurrentTriggerProviderByProviderSubscriptionsBuilderBuildBySubscriptionBuilderIdErrors ={+ 400: TriggerSubscriptionLimitReachedError | ErrorResponse+ 409: TriggerSubscriptionNameConflictError | ErrorResponse+ 502: TriggerSubscriptionProviderError | ErrorResponsedefault: ErrorResponse}@@ -10754,6 +10787,9 @@ export type PostWorkspacesCurrentTriggerProviderByProviderSubscriptionsVerifyBySexport type PostWorkspacesCurrentTriggerProviderByProviderSubscriptionsVerifyBySubscriptionIdErrors ={+ 400: TriggerSubscriptionInvalidError | ErrorResponse+ 404: TriggerSubscriptionNotFoundError | ErrorResponse+ 502: TriggerSubscriptionProviderError | ErrorResponsedefault: ErrorResponse}@@ -10778,6 +10814,9 @@ export type PostWorkspacesCurrentTriggerProviderBySubscriptionIdSubscriptionsDel}export type PostWorkspacesCurrentTriggerProviderBySubscriptionIdSubscriptionsDeleteErrors = {+ 404: TriggerSubscriptionNotFoundError | ErrorResponse+ 409: TriggerSubscriptionChangedError | ErrorResponse+ 502: TriggerSubscriptionProviderError | ErrorResponsedefault: ErrorResponse}@@ -10801,6 +10840,9 @@ export type PostWorkspacesCurrentTriggerProviderBySubscriptionIdSubscriptionsUpd}export type PostWorkspacesCurrentTriggerProviderBySubscriptionIdSubscriptionsUpdateErrors = {+ 404: TriggerSubscriptionNotFoundError | ErrorResponse+ 409: TriggerSubscriptionChangedError | TriggerSubscriptionNameConflictError | ErrorResponse+ 502: TriggerSubscriptionProviderError | ErrorResponsedefault: ErrorResponse}diff --git a/packages/contracts/generated/api/console/workspaces/zod.gen.ts b/packages/contracts/generated/api/console/workspaces/zod.gen.tsindex f640dce667b..12fb6f2239d 100644--- a/packages/contracts/generated/api/console/workspaces/zod.gen.ts+++ b/packages/contracts/generated/api/console/workspaces/zod.gen.ts@@ -1293,6 +1293,42 @@ export const zTriggerSubscriptionBuilderUpdatePayload = z.object({properties: z.record(z.string(), z.unknown()).nullish(),})+/**+ * TriggerSubscriptionLimitReachedError+ *+ * The maximum number of trigger subscriptions for this provider has been reached.+ */+export const zTriggerSubscriptionLimitReachedError = zErrorResponse.and(+ z.object({+ code: z.literal('trigger_subscription_limit_reached'),+ status: z.literal(400),+ }),+)++/**+ * TriggerSubscriptionNameConflictError+ *+ * A trigger subscription with this name already exists for the provider.+ */+export const zTriggerSubscriptionNameConflictError = zErrorResponse.and(+ z.object({+ code: z.literal('trigger_subscription_name_conflict'),+ status: z.literal(409),+ }),+)++/**+ * TriggerSubscriptionProviderError+ *+ * The trigger provider could not complete the subscription operation.+ */+export const zTriggerSubscriptionProviderError = zErrorResponse.and(+ z.object({+ code: z.literal('trigger_subscription_provider_error'),+ status: z.literal(502),+ }),+)+/*** TriggerSubscriptionBuilderCreatePayload*/@@ -1340,6 +1376,42 @@ export const zTriggerSubscriptionVerifyPayload = z.object({credentials: z.record(z.string(), z.unknown()),})+/**+ * TriggerSubscriptionInvalidError+ *+ * The trigger subscription configuration or credentials are invalid.+ */+export const zTriggerSubscriptionInvalidError = zErrorResponse.and(+ z.object({+ code: z.literal('trigger_subscription_invalid'),+ status: z.literal(400),+ }),+)++/**+ * TriggerSubscriptionNotFoundError+ *+ * The trigger subscription does not exist in this workspace and provider.+ */+export const zTriggerSubscriptionNotFoundError = zErrorResponse.and(+ z.object({+ code: z.literal('trigger_subscription_not_found'),+ status: z.literal(404),+ }),+)++/**+ * TriggerSubscriptionChangedError+ *+ * The trigger subscription changed. Reload it before trying again.+ */+export const zTriggerSubscriptionChangedError = zErrorResponse.and(+ z.object({+ code: z.literal('trigger_subscription_changed'),+ status: z.literal(409),+ }),+)+/*** WorkspaceCustomConfigResponse*/