Skip to content

armgit / dify

Public Imported from GitHub
0

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

refactor(api): isolate trigger subscription management (#44541)

非法操作803f5d3d9cc9
diff --git a/api/.importlinter b/api/.importlinter
index 90df3674e1f..7a75529eb9b 100644
--- a/api/.importlinter
+++ b/api/.importlinter
@@ -1436,6 +1436,7 @@ source_modules =
services.trigger.oauth_service
services.trigger.provider_query
services.trigger.subscription_query_service
+ services.trigger.subscription_service
forbidden_modules =
controllers
extensions
@@ -1457,3 +1458,27 @@ forbidden_modules =
sqlalchemy
services.trigger.trigger_provider_service
allow_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 = True
diff --git a/api/controllers/console/workspace/error.py b/api/controllers/console/workspace/error.py
index 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.py
index 15db2094adf..10f5909e6d7 100644
--- a/api/controllers/console/workspace/trigger_providers.py
+++ b/api/controllers/console/workspace/trigger_providers.py
@@ -1,13 +1,11 @@
import logging
from http import HTTPStatus
-from typing import Any
+from typing import Any, NoReturn, Self
from flask import make_response, redirect, request
from flask_restx import Resource
from pydantic import BaseModel, RootModel, model_validator
-from sqlalchemy.orm import sessionmaker
from werkzeug import Response
-from werkzeug.exceptions import BadRequest
from configs import dify_config
from 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 ProviderConfig
from 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, SubscriptionBuilderUpdater
from enums.account import TenantAccountRole
from extensions.ext_application_services import application_services
-from extensions.ext_database import db
from fields.base import ResponseModel
from libs.external_api import error_responses
from libs.helper import dump_response
-from libs.login import login_required
from machinery.context import RequestContext
-from models.account import Account
from models.provider_ids import TriggerProviderID
from services.trigger.oauth_client_service import TriggerOAuthClientChangedError as TriggerOAuthClientChanged
from 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 SubscriptionProviderError
logger = 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.py
index 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, sessionmaker
from core.plugin.impl.oauth import OAuthHandler
from core.trigger.trigger_manager import TriggerManager
+from core.trigger.utils.encryption import delete_cache_for_subscription
from extensions.ext_redis import RedisClientWrapper
from repositories.account.repository import SQLAlchemyAccountRepository
from repositories.app.console_repository import ConsoleAppRepository
from repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepository
from repositories.trigger.oauth_client_repository import TriggerOAuthClientRepository
from repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepository
+from repositories.trigger.subscription_repository import RedisTriggerSubscriptionLocks, TriggerSubscriptionRepository
from repositories.workspace.resource_cleanup_repository import WorkspaceResourceCleanupRepository
from repositories.workspace.workspace_repository import WorkspaceRepository
from services.account.adapters import RedisInvitationTokenStore
@@ -26,8 +28,10 @@ from services.trigger.oauth_gateway import (
from services.trigger.oauth_service import TriggerOAuthService
from services.trigger.provider_gateway import PluginTriggerProviderQuery
from services.trigger.provider_query import TriggerProviderQuery
+from services.trigger.subscription_codec import ProviderTriggerSubscriptionCodec
+from services.trigger.subscription_gateway import PluginTriggerSubscriptionGateway
from services.trigger.subscription_query_service import TriggerSubscriptionQueryService
-from services.trigger.trigger_provider_service import TriggerProviderService
+from services.trigger.subscription_service import TriggerSubscriptionService
from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderService
from services.workspace.gateways import (
DeploymentWorkspaceCreationPolicy,
@@ -66,6 +70,7 @@ class WorkspaceServices:
resource_cleanup: WorkspaceResourceCleanupService
trigger_providers: TriggerProviderQuery
trigger_subscriptions: TriggerSubscriptionQueryService
+ trigger_subscription_management: TriggerSubscriptionService
trigger_builders: TriggerSubscriptionBuilderService
trigger_oauth_clients: TriggerOAuthClientService
trigger_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.md
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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 encrypter
diff --git a/api/services/trigger/subscription_gateway.py b/api/services/trigger/subscription_gateway.py
new file mode 100644
index 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 error
diff --git a/api/services/trigger/subscription_service.py b/api/services/trigger/subscription_service.py
new file mode 100644
index 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.py
index 97180dd5e03..c0587a86271 100644
--- a/api/services/trigger/trigger_provider_service.py
+++ b/api/services/trigger/trigger_provider_service.py
@@ -1,16 +1,14 @@
import logging
import time as _time
-import uuid
from collections.abc import Mapping
-from typing import Any, TypedDict
+from typing import Any
-from sqlalchemy import func, select
+from sqlalchemy import select
from sqlalchemy.orm import Session, sessionmaker
from configs import dify_config
-from constants import HIDDEN_VALUE, UNKNOWN_VALUE
from core.helper.provider_cache import NoOpProviderCredentialCache
-from core.helper.provider_encryption import ProviderConfigEncrypter, create_provider_encrypter
+from core.helper.provider_encryption import create_provider_encrypter
from core.plugin.entities.plugin_daemon import CredentialType
from core.plugin.impl.oauth import OAuthHandler
from 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_url
from extensions.ext_database import db
-from extensions.ext_redis import redis_client
from models.provider_ids import TriggerProviderID
from models.trigger import (
TriggerOAuthSystemClient,
@@ -37,224 +34,13 @@ from services.plugin.dispatch_identity import PluginOAuthClientConfig
logger = 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.
+ """
@classmethod
def 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,
- )
-
@classmethod
def 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.py
index 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.py
new file mode 100644
index 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.py
deleted file mode 100644
index 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.py
new file mode 100644
index 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 None
diff --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.py
index 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_completed
from 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.py
index 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 Flask
from pydantic import ValidationError
-from sqlalchemy.engine import Engine
-from werkzeug.exceptions import BadRequest
-from controllers.common.errors import NotFoundError
from 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.py
index 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 URL
from core.plugin.entities.plugin_daemon import CredentialType
from core.plugin.impl import base as plugin_transport
from core.plugin.impl.trigger import PluginTriggerClient
+from extensions.ext_redis import redis_client
from models.account import TenantAccountRole
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
@@ -41,12 +42,16 @@ class _DaemonRequest:
headers: dict[str, str]
payload: dict[str, object]
open_transactions: bool
+ lock_held: bool | None
@dataclass
class _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 = None
response_code: int = 0
response_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.py
new file mode 100644
index 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_transactions
diff --git a/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py b/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py
index 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 controller
from controllers.inner_api.wraps import InnerApiUnauthorizedError
from core.plugin.impl.oauth import OAuthHandler
from core.trigger.trigger_manager import TriggerManager
+from core.trigger.utils.encryption import delete_cache_for_subscription
from extensions.application_services.workspace import WorkspaceServices
from extensions.ext_redis import RedisClientWrapper
from libs.external_api import register_external_error_handlers
from repositories.credentials.query_repository import CredentialQueryRepository
from repositories.trigger.oauth_client_repository import TriggerOAuthClientRepository
from repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepository
+from repositories.trigger.subscription_repository import RedisTriggerSubscriptionLocks, TriggerSubscriptionRepository
from services.account_errors import AccountNotFoundError
from services.errors.workspace import (
InvalidWorkspaceMemberRoleError,
@@ -39,8 +41,10 @@ from services.trigger.oauth_gateway import (
)
from services.trigger.oauth_service import TriggerOAuthService
from services.trigger.provider_gateway import PluginTriggerProviderQuery
+from services.trigger.subscription_codec import ProviderTriggerSubscriptionCodec
+from services.trigger.subscription_gateway import PluginTriggerSubscriptionGateway
from services.trigger.subscription_query_service import TriggerSubscriptionQueryService
-from services.trigger.trigger_provider_service import TriggerProviderService
+from services.trigger.subscription_service import TriggerSubscriptionService
from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderService
from services.workspace.contracts import CreatedWorkspace, WorkspaceMembership
from 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.py
index 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._builders
assert 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.py
new file mode 100644
index 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.py
index 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 uuid4
import pytest
from flask import Flask
from redis import Redis
-from sqlalchemy.orm import Session
+from sqlalchemy.orm import Session, sessionmaker
import contexts
from core.plugin.entities.plugin_daemon import CredentialType
from core.trigger.trigger_manager import TriggerManager
+from core.trigger.utils.encryption import delete_cache_for_subscription
from extensions.ext_redis import RedisClientWrapper
from models.engine import db
from models.provider_ids import TriggerProviderID
from models.tools import BuiltinToolProvider
from repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepository
+from repositories.trigger.subscription_repository import RedisTriggerSubscriptionLocks, TriggerSubscriptionRepository
from 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 TriggerSubscriptionService
from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderService
from 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.py
new file mode 100644
index 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) == values
diff --git a/api/tests/unit_tests/services/trigger/test_subscription_gateway.py b/api/tests/unit_tests/services/trigger/test_subscription_gateway.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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 contextlib
import json
from dataclasses import dataclass
from types import SimpleNamespace
@@ -16,12 +15,9 @@ from unittest.mock import Mock
from uuid import uuid4
import pytest
-from sqlalchemy import event, func, select
-from sqlalchemy.engine import Connection, Engine
-from sqlalchemy.exc import IntegrityError
+from sqlalchemy.engine import Engine
from sqlalchemy.orm import Session, sessionmaker
-from constants import HIDDEN_VALUE
from core.plugin.entities.plugin_daemon import CredentialType
from core.trigger.entities.entities import Subscription as TriggerSubscriptionEntity
from 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 None
assert 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 == 777
diff --git a/packages/contracts/generated/api/console/errors.gen.ts b/packages/contracts/generated/api/console/errors.gen.ts
index 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.ts
index 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.ts
index 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 = oc
operationId:
'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 = oc
method: '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 = oc
method: '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.ts
index 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 PostWorkspacesCurrentTriggerProviderByProviderSubscriptionsBuilderBu
export type PostWorkspacesCurrentTriggerProviderByProviderSubscriptionsBuilderBuildBySubscriptionBuilderIdErrors =
{
+ 400: TriggerSubscriptionLimitReachedError | ErrorResponse
+ 409: TriggerSubscriptionNameConflictError | ErrorResponse
+ 502: TriggerSubscriptionProviderError | ErrorResponse
default: ErrorResponse
}
@@ -10754,6 +10787,9 @@ export type PostWorkspacesCurrentTriggerProviderByProviderSubscriptionsVerifyByS
export type PostWorkspacesCurrentTriggerProviderByProviderSubscriptionsVerifyBySubscriptionIdErrors =
{
+ 400: TriggerSubscriptionInvalidError | ErrorResponse
+ 404: TriggerSubscriptionNotFoundError | ErrorResponse
+ 502: TriggerSubscriptionProviderError | ErrorResponse
default: ErrorResponse
}
@@ -10778,6 +10814,9 @@ export type PostWorkspacesCurrentTriggerProviderBySubscriptionIdSubscriptionsDel
}
export type PostWorkspacesCurrentTriggerProviderBySubscriptionIdSubscriptionsDeleteErrors = {
+ 404: TriggerSubscriptionNotFoundError | ErrorResponse
+ 409: TriggerSubscriptionChangedError | ErrorResponse
+ 502: TriggerSubscriptionProviderError | ErrorResponse
default: ErrorResponse
}
@@ -10801,6 +10840,9 @@ export type PostWorkspacesCurrentTriggerProviderBySubscriptionIdSubscriptionsUpd
}
export type PostWorkspacesCurrentTriggerProviderBySubscriptionIdSubscriptionsUpdateErrors = {
+ 404: TriggerSubscriptionNotFoundError | ErrorResponse
+ 409: TriggerSubscriptionChangedError | TriggerSubscriptionNameConflictError | ErrorResponse
+ 502: TriggerSubscriptionProviderError | ErrorResponse
default: ErrorResponse
}
diff --git a/packages/contracts/generated/api/console/workspaces/zod.gen.ts b/packages/contracts/generated/api/console/workspaces/zod.gen.ts
index 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
*/