Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
refactor(api): isolate trigger OAuth client configuration (#44469)
非法操作b501b64f8253
diff --git a/api/.importlinter b/api/.importlinterindex 3502fc9237c..01d9b6a79c3 100644--- a/api/.importlinter+++ b/api/.importlinter@@ -1427,3 +1427,17 @@ forbidden_modules =services.tracing.runtime_bridgeservices.tracing.serviceallow_indirect_imports = True++[importlinter:contract:trigger-oauth-client-service-boundary]+name = Trigger OAuth client orchestration does not directly depend on persistence or HTTP+type = forbidden+source_modules =+ services.trigger.oauth_client_service+forbidden_modules =+ controllers+ extensions+ flask+ repositories+ sqlalchemy+ werkzeug+allow_indirect_imports = Truediff --git a/api/controllers/console/workspace/error.py b/api/controllers/console/workspace/error.pyindex 7f46df990db..33e0bc6263c 100644--- a/api/controllers/console/workspace/error.py+++ b/api/controllers/console/workspace/error.py@@ -3,6 +3,18 @@ from http import HTTPStatusfrom libs.exception import BaseHTTPException+class TriggerOAuthClientConfigInvalidError(BaseHTTPException):+ error_code = "trigger_oauth_client_config_invalid"+ code = HTTPStatus.INTERNAL_SERVER_ERROR+ description = "The stored trigger OAuth client configuration is invalid."+++class TriggerOAuthClientChangedError(BaseHTTPException):+ error_code = "trigger_oauth_client_changed"+ code = HTTPStatus.CONFLICT+ description = "The trigger OAuth client configuration changed. Reload it before saving again."++class CurrentWorkspaceArchivedError(BaseHTTPException):error_code = "current_workspace_archived"description = "The current workspace has been archived."diff --git a/api/controllers/console/workspace/trigger_providers.py b/api/controllers/console/workspace/trigger_providers.pyindex e3887a0d336..a2d4ded66d7 100644--- a/api/controllers/console/workspace/trigger_providers.py+++ b/api/controllers/console/workspace/trigger_providers.py@@ -1,4 +1,5 @@import logging+from http import HTTPStatusfrom typing import Anyfrom flask import make_response, redirect, request@@ -13,6 +14,8 @@ from controllers.common.fields import SimpleResultResponsefrom controllers.common.rbac import RBACCheck, Workspacefrom controllers.common.schema import register_response_schema_models, register_schema_modelsfrom controllers.console import console_ns+from controllers.console.flask_admission import console_account_admission+from controllers.console.workspace.error import TriggerOAuthClientChangedError, TriggerOAuthClientConfigInvalidErrorfrom controllers.console.wraps import (RBACPermission,account_initialization_required,@@ -34,14 +37,19 @@ from core.trigger.entities.api_entities import ()from core.trigger.entities.entities import RequestLog, SubscriptionBuilderUpdaterfrom core.trigger.trigger_manager import TriggerManager+from enums.account import TenantAccountRolefrom extensions.ext_application_services import application_servicesfrom extensions.ext_database import dbfrom fields.base import ResponseModel+from libs.external_api import error_responsesfrom libs.helper import dump_responsefrom libs.login import login_required+from machinery.context import RequestContextfrom models.account import Accountfrom models.provider_ids import TriggerProviderIDfrom services.plugin.oauth_service import OAuthProxyService+from services.trigger.oauth_client_service import TriggerOAuthClientChangedError as TriggerOAuthClientChanged+from services.trigger.oauth_client_service import TriggerOAuthClientConfigErrorfrom services.trigger.trigger_provider_service import TriggerProviderServicefrom services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderServicefrom services.trigger.trigger_subscription_operator_service import TriggerSubscriptionOperatorService@@ -75,7 +83,7 @@ class TriggerSubscriptionBuilderUpdatePayload(BaseModel):class TriggerOAuthClientPayload(BaseModel):- client_params: dict[str, Any] | None = None+ client_params: dict[str, object] | None = Noneenabled: bool | None = None@@ -112,7 +120,7 @@ class TriggerOAuthClientResponse(ResponseModel):oauth_client_schema: list[ProviderConfig]custom_enabled: boolredirect_uri: str- params: dict[str, Any]+ params: dict[str, object]class TriggerProviderErrorResponse(ResponseModel):@@ -722,109 +730,77 @@ class TriggerOAuthCallbackApi(Resource):@console_ns.route("/workspaces/current/trigger-provider/<path:provider>/oauth/client")class TriggerOAuthClientManageApi(Resource):+ @error_responses(TriggerOAuthClientConfigInvalidError)@console_ns.response(- 200,+ HTTPStatus.OK,"Trigger OAuth client retrieved successfully",console_ns.models[TriggerOAuthClientResponse.__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 get(self, tenant_id: str, provider: str):- """Get OAuth client configuration for a provider"""-+ @console_account_admission(+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN}),+ rbac_checks=[RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace())],+ )+ def get(self, context: RequestContext, provider: str) -> dict[str, object]:+ """Get the masked OAuth client configuration for a provider."""try:- provider_id = TriggerProviderID(provider)-- # Get custom OAuth client params if exists- custom_params = TriggerProviderService.get_custom_oauth_client_params(- tenant_id=tenant_id,- provider_id=provider_id,- )-- # Check if custom client is enabled- is_custom_enabled = TriggerProviderService.is_oauth_custom_client_enabled(- tenant_id=tenant_id,- provider_id=provider_id,- )- system_client_exists = TriggerProviderService.is_oauth_system_client_exists(- tenant_id=tenant_id,- provider_id=provider_id,+ configuration = application_services().workspaces.trigger_oauth_clients.get(+ tenant_id=context.active_workspace_id,+ provider_id=TriggerProviderID(provider),)- provider_controller = TriggerManager.get_trigger_provider(tenant_id, provider_id)- redirect_uri = f"{dify_config.CONSOLE_API_URL}/console/api/oauth/plugin/{provider}/trigger/callback"- return TriggerOAuthClientResponse(- configured=bool(custom_params or system_client_exists),- system_configured=system_client_exists,- custom_configured=bool(custom_params),- oauth_client_schema=provider_controller.get_oauth_client_schema(),- custom_enabled=is_custom_enabled,- redirect_uri=redirect_uri,- params=dict(custom_params or {}),- ).model_dump(mode="json")-- except Exception as e:- logger.exception("Error getting OAuth client", exc_info=e)- raise+ except TriggerOAuthClientConfigError as error:+ raise TriggerOAuthClientConfigInvalidError(str(error)) from error+ return dump_response(+ TriggerOAuthClientResponse,+ {+ "configured": bool(configuration.params or configuration.system_configured),+ "system_configured": configuration.system_configured,+ "custom_configured": bool(configuration.params),+ "oauth_client_schema": configuration.schema,+ "custom_enabled": configuration.custom_enabled,+ "redirect_uri": f"{dify_config.CONSOLE_API_URL}/console/api/oauth/plugin/{provider}/trigger/callback",+ "params": dict(configuration.params),+ },+ )+ @error_responses(TriggerOAuthClientConfigInvalidError, TriggerOAuthClientChangedError)@console_ns.expect(console_ns.models[TriggerOAuthClientPayload.__name__])@console_ns.response(- 200, "Trigger OAuth client saved successfully", console_ns.models[SimpleResultResponse.__name__]+ HTTPStatus.OK, "Trigger OAuth client saved successfully", console_ns.models[SimpleResultResponse.__name__]+ )+ @console_account_admission(+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN}),+ rbac_checks=[RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace())],)- @setup_required- @login_required- @is_admin_or_owner_required- @rbac_permission_required(RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace()))- @account_initialization_required- @with_current_tenant_id@model_validate(TriggerOAuthClientPayload)- def post(self, req_data: TriggerOAuthClientPayload, tenant_id: str, provider: str):- """Configure custom OAuth client for a provider"""-+ def post(self, req_data: TriggerOAuthClientPayload, context: RequestContext, provider: str) -> dict[str, object]:+ """Configure the workspace's custom OAuth client for a provider."""try:- provider_id = TriggerProviderID(provider)- result = TriggerProviderService.save_custom_oauth_client_params(- tenant_id=tenant_id,- provider_id=provider_id,+ application_services().workspaces.trigger_oauth_clients.save(+ tenant_id=context.active_workspace_id,+ provider_id=TriggerProviderID(provider),client_params=req_data.client_params,enabled=req_data.enabled,)- return dump_response(SimpleResultResponse, result)-- except ValueError as e:- raise BadRequest(str(e)) from e- except Exception as e:- logger.exception("Error configuring OAuth client", exc_info=e)- raise+ except TriggerOAuthClientChanged as error:+ raise TriggerOAuthClientChangedError(str(error)) from error+ except TriggerOAuthClientConfigError as error:+ raise TriggerOAuthClientConfigInvalidError(str(error)) from error+ return dump_response(SimpleResultResponse, {"result": "success"})@console_ns.response(- 200, "Trigger OAuth client deleted successfully", console_ns.models[SimpleResultResponse.__name__]+ HTTPStatus.OK, "Trigger OAuth client deleted successfully", 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 delete(self, tenant_id: str, provider: str):- """Remove custom OAuth client configuration"""-- try:- provider_id = TriggerProviderID(provider)-- result = TriggerProviderService.delete_custom_oauth_client_params(- tenant_id=tenant_id,- provider_id=provider_id,- )- return dump_response(SimpleResultResponse, result)- except ValueError as e:- raise BadRequest(str(e)) from e- except Exception as e:- logger.exception("Error removing OAuth client", exc_info=e)- raise+ @console_account_admission(+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN}),+ rbac_checks=[RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace())],+ )+ def delete(self, context: RequestContext, provider: str) -> dict[str, object]:+ """Remove the workspace's custom OAuth client configuration."""+ application_services().workspaces.trigger_oauth_clients.delete(+ tenant_id=context.active_workspace_id,+ provider_id=TriggerProviderID(provider),+ )+ return dump_response(SimpleResultResponse, {"result": "success"})@console_ns.route(diff --git a/api/extensions/application_services/workspace.py b/api/extensions/application_services/workspace.pyindex 5a7019688cf..33836e13082 100644--- a/api/extensions/application_services/workspace.py+++ b/api/extensions/application_services/workspace.py@@ -4,14 +4,18 @@ from dataclasses import dataclassfrom sqlalchemy.orm import Session, sessionmaker+from core.plugin.plugin_service import PluginService+from core.trigger.trigger_manager import TriggerManagerfrom extensions.ext_redis import RedisClientWrapperfrom repositories.account.repository import SQLAlchemyAccountRepositoryfrom repositories.app.console_repository import ConsoleAppRepositoryfrom repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepository+from repositories.trigger.oauth_client_repository import TriggerOAuthClientRepositoryfrom repositories.workspace.resource_cleanup_repository import WorkspaceResourceCleanupRepositoryfrom repositories.workspace.workspace_repository import WorkspaceRepositoryfrom services.account.adapters import RedisInvitationTokenStorefrom services.file_service import FileService+from services.trigger.oauth_client_service import TriggerOAuthClientServicefrom services.workspace.gateways import (DeploymentWorkspaceCreationPolicy,DeploymentWorkspaceFeatureGateway,@@ -47,6 +51,7 @@ class WorkspaceServices:invitations: WorkspaceInvitationServiceidentity: WorkspaceIdentityGatewayresource_cleanup: WorkspaceResourceCleanupService+ trigger_oauth_clients: TriggerOAuthClientServicedef build_workspace_membership_services(@@ -115,4 +120,9 @@ def build_workspace_services(datasets=SQLAlchemyDatasetRepository(session_factory=database_client),agent_resources=WorkspaceResourceCleanupRepository(session_factory=database_client),),+ trigger_oauth_clients=TriggerOAuthClientService(+ clients=TriggerOAuthClientRepository(session_factory=database_client),+ get_provider=TriggerManager.get_trigger_provider,+ is_plugin_verified=PluginService.is_plugin_verified,+ ),)diff --git a/api/openapi/markdown/console-openapi.md b/api/openapi/markdown/console-openapi.mdindex 50497e0c6af..3633b8592e7 100644--- a/api/openapi/markdown/console-openapi.md+++ b/api/openapi/markdown/console-openapi.md@@ -18421,7 +18421,7 @@ Import a Skill zip package from multipart form field `file`.| default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |### [DELETE] /workspaces/current/trigger-provider/{provider}/oauth/client-**Remove custom OAuth client configuration**+**Remove the workspace's custom OAuth client configuration**#### Parameters@@ -18437,7 +18437,7 @@ Import a Skill zip package from multipart form field `file`.| default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |### [GET] /workspaces/current/trigger-provider/{provider}/oauth/client-**Get OAuth client configuration for a provider**+**Get the masked OAuth client configuration for a provider**#### Parameters@@ -18450,10 +18450,11 @@ Import a Skill zip package from multipart form field `file`.| Code | Description | Schema || ---- | ----------- | ------ || 200 | Trigger OAuth client retrieved successfully | **application/json**: [TriggerOAuthClientResponse](#triggeroauthclientresponse)<br> |+| 500 | Internal Server Error | **application/json**: [TriggerOauthClientConfigInvalidError](#triggeroauthclientconfiginvaliderror)<br>[ErrorResponse](#errorresponse)<br> || default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |### [POST] /workspaces/current/trigger-provider/{provider}/oauth/client-**Configure custom OAuth client for a provider**+**Configure the workspace's custom OAuth client for a provider**#### Parameters@@ -18472,6 +18473,8 @@ Import a Skill zip package from multipart form field `file`.| Code | Description | Schema || ---- | ----------- | ------ || 200 | Trigger OAuth client saved successfully | **application/json**: [SimpleResultResponse](#simpleresultresponse)<br> |+| 409 | Conflict | **application/json**: [TriggerOauthClientChangedError](#triggeroauthclientchangederror)<br>[ErrorResponse](#errorresponse)<br> |+| 500 | Internal Server Error | **application/json**: [TriggerOauthClientConfigInvalidError](#triggeroauthclientconfiginvaliderror)<br>[ErrorResponse](#errorresponse)<br> || default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |### [POST] /workspaces/current/trigger-provider/{provider}/subscriptions/builder/build/{subscription_builder_id}@@ -36511,6 +36514,22 @@ the app is not allowed to be trial.| redirect_uri | string | | Yes || system_configured | boolean | | Yes |+#### TriggerOauthClientChangedError++The trigger OAuth client configuration changed. Reload it before saving again.++| Name | Type | Description | Required |+| ---- | ---- | ----------- | -------- |+| TriggerOauthClientChangedError | | The trigger OAuth client configuration changed. Reload it before saving again. | |++#### TriggerOauthClientConfigInvalidError++The stored trigger OAuth client configuration is invalid.++| Name | Type | Description | Required |+| ---- | ---- | ----------- | -------- |+| TriggerOauthClientConfigInvalidError | | The stored trigger OAuth client configuration is invalid. | |+#### TriggerProviderApiEntity| Name | Type | Description | Required |diff --git a/api/repositories/trigger/oauth_client_repository.py b/api/repositories/trigger/oauth_client_repository.pynew file mode 100644index 00000000000..59a8021622d--- /dev/null+++ b/api/repositories/trigger/oauth_client_repository.py@@ -0,0 +1,154 @@+"""Bounded database operations for workspace trigger OAuth clients."""++import sqlite3+from typing import override++from psycopg2.errors import UniqueViolation+from pymysql.err import IntegrityError as MySQLIntegrityError+from sqlalchemy import delete, select+from sqlalchemy.exc import IntegrityError+from sqlalchemy.orm import Session, sessionmaker++from models.provider_ids import TriggerProviderID+from models.trigger import TriggerOAuthSystemClient, TriggerOAuthTenantClient+from services.trigger.oauth_client_service import (+ TriggerOAuthClientChangedError,+ TriggerOAuthClientSnapshot,+ TriggerOAuthClientStore,+ TriggerOAuthTenantClientRecord,+)+++def _is_custom_client_conflict(error: IntegrityError) -> bool:+ """Identify only the tenant/provider uniqueness constraint, not other write failures."""+ original = error.orig+ constraint = "unique_trigger_oauth_tenant_client"+ 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_oauth_tenant_clients.{constraint}'",+ f"`{constraint}`",+ f"`trigger_oauth_tenant_clients.{constraint}`",+ )+ if isinstance(original, sqlite3.IntegrityError):+ return original.sqlite_errorcode == sqlite3.SQLITE_CONSTRAINT_UNIQUE and str(original) == (+ "UNIQUE constraint failed: trigger_oauth_tenant_clients.tenant_id, "+ "trigger_oauth_tenant_clients.plugin_id, trigger_oauth_tenant_clients.provider"+ )+ return False+++class TriggerOAuthClientRepository(TriggerOAuthClientStore):+ def __init__(self, *, session_factory: sessionmaker[Session]) -> None:+ self._session_factory = session_factory++ @override+ def get(self, *, tenant_id: str, provider_id: TriggerProviderID) -> TriggerOAuthClientSnapshot:+ with self._session_factory() as session:+ custom = self._find_custom(session=session, tenant_id=tenant_id, provider_id=provider_id)+ system_configured = (+ session.scalar(+ select(TriggerOAuthSystemClient.id).where(+ TriggerOAuthSystemClient.plugin_id == provider_id.plugin_id,+ TriggerOAuthSystemClient.provider == provider_id.provider_name,+ )+ )+ is not None+ )+ return TriggerOAuthClientSnapshot(+ custom=TriggerOAuthTenantClientRecord(+ id=custom.id,+ encrypted_oauth_params=custom.encrypted_oauth_params,+ enabled=custom.enabled,+ )+ if custom is not None+ else None,+ system_configured=system_configured,+ )++ @override+ def save(+ self,+ *,+ tenant_id: str,+ provider_id: TriggerProviderID,+ encrypted_oauth_params: str,+ enabled: bool | None,+ expected: TriggerOAuthTenantClientRecord | None,+ ) -> None:+ """Create for a None snapshot, otherwise save only the unchanged read client.++ None enabled preserves the stored value, or defaults to True on create.+ """+ if expected is None:+ try:+ with self._session_factory.begin() as session:+ session.add(+ TriggerOAuthTenantClient(+ tenant_id=tenant_id,+ plugin_id=provider_id.plugin_id,+ provider=provider_id.provider_name,+ encrypted_oauth_params=encrypted_oauth_params,+ enabled=True if enabled is None else enabled,+ )+ )+ except IntegrityError as error:+ if not _is_custom_client_conflict(error):+ raise+ raise TriggerOAuthClientChangedError(+ f"OAuth client configuration for trigger provider {provider_id} changed. Reload and retry."+ ) from error+ return++ with self._session_factory.begin() as session:+ custom = session.scalar(+ select(TriggerOAuthTenantClient)+ .where(+ TriggerOAuthTenantClient.id == expected.id,+ TriggerOAuthTenantClient.tenant_id == tenant_id,+ TriggerOAuthTenantClient.plugin_id == provider_id.plugin_id,+ TriggerOAuthTenantClient.provider == provider_id.provider_name,+ )+ .with_for_update()+ )+ # Compare exact strings in Python: MySQL text collations can otherwise+ # consider different ciphertexts equal. The lock ends before returning.+ if (+ custom is None+ or custom.encrypted_oauth_params != expected.encrypted_oauth_params+ or custom.enabled != expected.enabled+ ):+ raise TriggerOAuthClientChangedError(+ f"OAuth client configuration for trigger provider {provider_id} changed. Reload and retry."+ )+ custom.encrypted_oauth_params = encrypted_oauth_params+ if enabled is not None:+ custom.enabled = enabled++ @override+ def delete(self, *, tenant_id: str, provider_id: TriggerProviderID) -> None:+ with self._session_factory.begin() as session:+ session.execute(+ delete(TriggerOAuthTenantClient).where(+ TriggerOAuthTenantClient.tenant_id == tenant_id,+ TriggerOAuthTenantClient.plugin_id == provider_id.plugin_id,+ TriggerOAuthTenantClient.provider == provider_id.provider_name,+ )+ )++ @staticmethod+ def _find_custom(+ *, session: Session, tenant_id: str, provider_id: TriggerProviderID+ ) -> TriggerOAuthTenantClient | None:+ return session.scalar(+ select(TriggerOAuthTenantClient).where(+ TriggerOAuthTenantClient.tenant_id == tenant_id,+ TriggerOAuthTenantClient.plugin_id == provider_id.plugin_id,+ TriggerOAuthTenantClient.provider == provider_id.provider_name,+ )+ )diff --git a/api/services/trigger/oauth_client_service.py b/api/services/trigger/oauth_client_service.pynew file mode 100644index 00000000000..b6cb13ab207--- /dev/null+++ b/api/services/trigger/oauth_client_service.py@@ -0,0 +1,169 @@+"""Trigger OAuth client configuration and credential masking."""++import json+from collections.abc import Callable, Mapping+from dataclasses import dataclass+from typing import Protocol++from constants import HIDDEN_VALUE, UNKNOWN_VALUE+from core.entities.provider_entities import ProviderConfig+from core.helper.provider_cache import NoOpProviderCredentialCache+from core.helper.provider_encryption import create_provider_encrypter+from core.trigger.provider import PluginTriggerProviderController+from models.provider_ids import TriggerProviderID+++class TriggerOAuthClientConfigError(Exception):+ """The stored tenant OAuth client configuration cannot be read."""+++class TriggerOAuthClientChangedError(Exception):+ """The OAuth client changed while settings were being prepared."""+++@dataclass(frozen=True, slots=True)+class TriggerOAuthTenantClientRecord:+ id: str+ encrypted_oauth_params: str+ enabled: bool+++@dataclass(frozen=True, slots=True)+class TriggerOAuthClientSnapshot:+ custom: TriggerOAuthTenantClientRecord | None+ system_configured: bool+++@dataclass(frozen=True, slots=True)+class TriggerOAuthClientConfiguration:+ schema: list[ProviderConfig]+ params: Mapping[str, object]+ system_configured: bool+ custom_enabled: bool+++class TriggerOAuthClientStore(Protocol):+ """Persistence operations finish their sessions before returning."""++ def get(self, *, tenant_id: str, provider_id: TriggerProviderID) -> TriggerOAuthClientSnapshot: ...++ def save(+ self,+ *,+ tenant_id: str,+ provider_id: TriggerProviderID,+ expected: TriggerOAuthTenantClientRecord | None,+ encrypted_oauth_params: str,+ enabled: bool | None,+ ) -> None:+ """Create when expected is None; otherwise update only an unchanged snapshot.++ None enabled leaves it unchanged or uses the new-row default.+ """+ ...++ def delete(self, *, tenant_id: str, provider_id: TriggerProviderID) -> None: ...+++class TriggerOAuthClientService:+ """Handle credentials outside repository transactions.++ TODO: The shared RSA key provider still owns a scoped DB session; remove that+ dependency when its tenant key reads return detached values.+ """++ def __init__(+ self,+ *,+ clients: TriggerOAuthClientStore,+ # TODO: When migrating OAuth authorize/callback, consolidate these callbacks+ # into a shared provider gateway returning metadata instead of a controller.+ get_provider: Callable[[str, TriggerProviderID], PluginTriggerProviderController],+ is_plugin_verified: Callable[[str, str], bool],+ ) -> None:+ self._clients = clients+ self._get_provider = get_provider+ self._is_plugin_verified = is_plugin_verified++ def get(self, *, tenant_id: str, provider_id: TriggerProviderID) -> TriggerOAuthClientConfiguration:+ snapshot = self._clients.get(tenant_id=tenant_id, provider_id=provider_id)+ provider = self._get_provider(tenant_id, provider_id)+ schema = provider.get_oauth_client_schema()+ params: Mapping[str, object] = {}+ if snapshot.custom is not None:+ encrypter, _ = create_provider_encrypter(+ tenant_id=tenant_id,+ config=[field.to_basic_provider_config() for field in schema],+ cache=NoOpProviderCredentialCache(),+ )+ params = encrypter.mask_plugin_credentials(+ encrypter.decrypt(self._parse_params(snapshot.custom, provider_id))+ )++ return TriggerOAuthClientConfiguration(+ schema=schema,+ params=params,+ system_configured=snapshot.system_configured+ and self._is_plugin_verified(tenant_id, provider.plugin_unique_identifier),+ custom_enabled=snapshot.custom is not None and snapshot.custom.enabled,+ )++ def save(+ self,+ *,+ tenant_id: str,+ provider_id: TriggerProviderID,+ client_params: Mapping[str, object] | None,+ enabled: bool | None,+ ) -> None:+ """Save client settings, preserving the existing request semantics.++ When both values are None this is a no-op. Otherwise None parameters+ clear the saved credentials; None enabled retains the current value.+ """+ if client_params is None and enabled is None:+ return++ snapshot = self._clients.get(tenant_id=tenant_id, provider_id=provider_id)+ provider = self._get_provider(tenant_id, provider_id)+ encrypted_params = "{}"+ if client_params is not None:+ encrypter, cache = create_provider_encrypter(+ tenant_id=tenant_id,+ config=[field.to_basic_provider_config() for field in provider.get_oauth_client_schema()],+ cache=NoOpProviderCredentialCache(),+ )+ original_params = encrypter.decrypt(+ self._parse_params(snapshot.custom, provider_id) if snapshot.custom is not None else {}+ )+ new_params = {+ key: value if value != HIDDEN_VALUE else original_params.get(key, UNKNOWN_VALUE)+ for key, value in client_params.items()+ }+ encrypted_params = json.dumps(encrypter.encrypt(new_params))+ cache.delete()++ self._clients.save(+ tenant_id=tenant_id,+ provider_id=provider_id,+ expected=snapshot.custom,+ encrypted_oauth_params=encrypted_params,+ enabled=enabled,+ )++ def delete(self, *, tenant_id: str, provider_id: TriggerProviderID) -> None:+ self._clients.delete(tenant_id=tenant_id, provider_id=provider_id)++ @staticmethod+ def _parse_params(custom: TriggerOAuthTenantClientRecord, provider_id: TriggerProviderID) -> dict[str, object]:+ try:+ params: object = json.loads(custom.encrypted_oauth_params or "{}")+ except json.JSONDecodeError as error:+ raise TriggerOAuthClientConfigError(+ f"Stored OAuth client configuration for trigger provider {provider_id} is invalid."+ ) from error+ if not isinstance(params, dict):+ raise TriggerOAuthClientConfigError(+ f"Stored OAuth client configuration for trigger provider {provider_id} must be an object."+ )+ return paramsdiff --git a/api/services/trigger/trigger_provider_service.py b/api/services/trigger/trigger_provider_service.pyindex 30717345cde..1565c48e8c7 100644--- a/api/services/trigger/trigger_provider_service.py+++ b/api/services/trigger/trigger_provider_service.py@@ -1,4 +1,3 @@-import jsonimport loggingimport time as _timeimport uuid@@ -11,7 +10,7 @@ from services.plugin.dispatch_identity import PluginOAuthClientConfigif TYPE_CHECKING:from models.account import Account-from sqlalchemy import delete, func, select+from sqlalchemy import func, selectfrom sqlalchemy.orm import Session, sessionmakerfrom configs import dify_config@@ -654,178 +653,6 @@ class TriggerProviderService:else None)- @classmethod- def is_oauth_system_client_exists(cls, tenant_id: str, provider_id: TriggerProviderID) -> bool:- """- Check if system OAuth client exists for a trigger provider.- """- provider_controller = TriggerManager.get_trigger_provider(tenant_id=tenant_id, provider_id=provider_id)- is_verified = PluginService.is_plugin_verified(tenant_id, provider_controller.plugin_unique_identifier)- if not is_verified:- return False- with Session(db.engine, expire_on_commit=False) as session:- system_client = session.scalar(- select(TriggerOAuthSystemClient)- .where(- TriggerOAuthSystemClient.plugin_id == provider_id.plugin_id,- TriggerOAuthSystemClient.provider == provider_id.provider_name,- )- .limit(1)- )- return system_client is not None-- @classmethod- def save_custom_oauth_client_params(- cls,- tenant_id: str,- provider_id: TriggerProviderID,- client_params: Mapping[str, Any] | None = None,- enabled: bool | None = None,- ) -> Mapping[str, Any]:- """- Save or update custom OAuth client parameters for a trigger provider.-- :param tenant_id: Tenant ID- :param provider_id: Provider identifier- :param client_params: OAuth client parameters (client_id, client_secret, etc.)- :param enabled: Enable/disable the custom OAuth client- :return: Success response- """- if client_params is None and enabled is None:- return {"result": "success"}-- # Get provider controller to access schema- provider_controller: PluginTriggerProviderController = TriggerManager.get_trigger_provider(- tenant_id=tenant_id, provider_id=provider_id- )-- with sessionmaker(bind=db.engine).begin() as session:- # Find existing custom client params- custom_client = session.scalar(- select(TriggerOAuthTenantClient)- .where(- TriggerOAuthTenantClient.tenant_id == tenant_id,- TriggerOAuthTenantClient.plugin_id == provider_id.plugin_id,- TriggerOAuthTenantClient.provider == provider_id.provider_name,- )- .limit(1)- )-- # Create new record if doesn't exist- if custom_client is None:- custom_client = TriggerOAuthTenantClient(- tenant_id=tenant_id,- plugin_id=provider_id.plugin_id,- provider=provider_id.provider_name,- )- session.add(custom_client)-- # Update client params if provided- if client_params is None:- custom_client.encrypted_oauth_params = json.dumps({})- else:- encrypter, cache = create_provider_encrypter(- tenant_id=tenant_id,- config=[x.to_basic_provider_config() for x in provider_controller.get_oauth_client_schema()],- cache=NoOpProviderCredentialCache(),- )-- # Handle hidden values- original_params = encrypter.decrypt(dict(custom_client.oauth_params))- new_params: dict[str, Any] = {- key: value if value != HIDDEN_VALUE else original_params.get(key, UNKNOWN_VALUE)- for key, value in client_params.items()- }- custom_client.encrypted_oauth_params = json.dumps(encrypter.encrypt(new_params))- cache.delete()-- # Update enabled status if provided- if enabled is not None:- custom_client.enabled = enabled-- return {"result": "success"}-- @classmethod- def get_custom_oauth_client_params(cls, tenant_id: str, provider_id: TriggerProviderID) -> Mapping[str, Any]:- """- Get custom OAuth client parameters for a trigger provider.-- :param tenant_id: Tenant ID- :param provider_id: Provider identifier- :return: Masked OAuth client parameters- """- with Session(db.engine) as session:- custom_client = session.scalar(- select(TriggerOAuthTenantClient)- .where(- TriggerOAuthTenantClient.tenant_id == tenant_id,- TriggerOAuthTenantClient.plugin_id == provider_id.plugin_id,- TriggerOAuthTenantClient.provider == provider_id.provider_name,- )- .limit(1)- )-- if custom_client is None:- return {}-- # Get provider controller to access schema- provider_controller: PluginTriggerProviderController = TriggerManager.get_trigger_provider(- tenant_id=tenant_id, provider_id=provider_id- )-- # Create encrypter to decrypt and mask values- encrypter, _ = create_provider_encrypter(- tenant_id=tenant_id,- config=[x.to_basic_provider_config() for x in provider_controller.get_oauth_client_schema()],- cache=NoOpProviderCredentialCache(),- )-- return encrypter.mask_plugin_credentials(encrypter.decrypt(dict(custom_client.oauth_params)))-- @classmethod- def delete_custom_oauth_client_params(cls, tenant_id: str, provider_id: TriggerProviderID) -> Mapping[str, Any]:- """- Delete custom OAuth client parameters for a trigger provider.-- :param tenant_id: Tenant ID- :param provider_id: Provider identifier- :return: Success response- """- with sessionmaker(bind=db.engine).begin() as session:- session.execute(- delete(TriggerOAuthTenantClient)- .where(- TriggerOAuthTenantClient.tenant_id == tenant_id,- TriggerOAuthTenantClient.provider == provider_id.provider_name,- TriggerOAuthTenantClient.plugin_id == provider_id.plugin_id,- )- .execution_options(synchronize_session=False)- )-- return {"result": "success"}-- @classmethod- def is_oauth_custom_client_enabled(cls, tenant_id: str, provider_id: TriggerProviderID) -> bool:- """- Check if custom OAuth client is enabled for a trigger provider.-- :param tenant_id: Tenant ID- :param provider_id: Provider identifier- :return: True if enabled, False otherwise- """- with Session(db.engine, expire_on_commit=False) as session:- custom_client = session.scalar(- select(TriggerOAuthTenantClient)- .where(- TriggerOAuthTenantClient.tenant_id == tenant_id,- TriggerOAuthTenantClient.plugin_id == provider_id.plugin_id,- TriggerOAuthTenantClient.provider == provider_id.provider_name,- TriggerOAuthTenantClient.enabled.is_(True),- )- .limit(1)- )- return custom_client is not None-@classmethoddef get_subscription_by_endpoint(cls, endpoint_id: str) -> TriggerSubscription | None:"""diff --git a/api/tests/e2e_tests/containers/repositories/test_trigger_oauth_client_repository.py b/api/tests/e2e_tests/containers/repositories/test_trigger_oauth_client_repository.pynew file mode 100644index 00000000000..97c87824439--- /dev/null+++ b/api/tests/e2e_tests/containers/repositories/test_trigger_oauth_client_repository.py@@ -0,0 +1,55 @@+"""Exercise OAuth client conflicts and row locking against real PostgreSQL."""++from concurrent.futures import ThreadPoolExecutor+from threading import Barrier+from uuid import uuid4++import pytest+from sqlalchemy.orm import Session, sessionmaker++from models.provider_ids import TriggerProviderID+from repositories.trigger.oauth_client_repository import TriggerOAuthClientRepository+from services.trigger.oauth_client_service import TriggerOAuthClientChangedError++[email protected]("existing", [False, True])+def test_concurrent_saves_preserve_one_winner(db_session_with_containers: Session, existing: bool) -> None:+ repository = TriggerOAuthClientRepository(+ session_factory=sessionmaker(bind=db_session_with_containers.get_bind(), expire_on_commit=False)+ )+ tenant_id = str(uuid4())+ provider_id = TriggerProviderID("langgenius/github/github")+ if existing:+ repository.save(+ tenant_id=tenant_id,+ provider_id=provider_id,+ expected=None,+ encrypted_oauth_params='{"client_secret":"original-ciphertext"}',+ enabled=True,+ )+ expected = repository.get(tenant_id=tenant_id, provider_id=provider_id).custom+ barrier = Barrier(2)++ def save(ciphertext: str) -> bool:+ barrier.wait(timeout=10)+ try:+ repository.save(+ tenant_id=tenant_id,+ provider_id=provider_id,+ expected=expected,+ encrypted_oauth_params=ciphertext,+ enabled=False,+ )+ except TriggerOAuthClientChangedError:+ return False+ return True++ values = ('{"client_secret":"first-ciphertext"}', '{"client_secret":"second-ciphertext"}')+ with ThreadPoolExecutor(max_workers=2) as executor:+ results = list(executor.map(save, values))++ assert sorted(results) == [False, True]+ current = repository.get(tenant_id=tenant_id, provider_id=provider_id).custom+ assert current is not None+ assert current.encrypted_oauth_params == values[results.index(True)]+ assert current.enabled is Falsediff --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.pynew file mode 100644index 00000000000..3ffa1ea6548--- /dev/null+++ b/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_client.py@@ -0,0 +1,487 @@+"""OAuth client routes exercise admission, credentials and persistence together."""++import json+from collections.abc import Callable, Iterator+from dataclasses import dataclass, replace+from http import HTTPStatus+from tempfile import TemporaryDirectory+from uuid import uuid4++import pytest+from flask import Blueprint, Flask, Response+from flask.testing import FlaskClient+from redis import Redis+from sqlalchemy import Connection, Engine, event, select+from sqlalchemy.orm import Session, SessionTransaction, sessionmaker+from werkzeug.test import TestResponse++from constants import HEADER_NAME_CSRF_TOKEN, HIDDEN_VALUE, UNKNOWN_VALUE+from controllers.console.workspace.trigger_providers import TriggerOAuthClientManageApi+from controllers.console.wraps import _is_setup_completed+from core.entities.provider_entities import ProviderConfig, ProviderConfigType+from core.helper.encrypter import decrypt_token+from core.plugin.entities.oauth import OAuthSchema+from core.tools.entities.common_entities import I18nObject+from core.trigger.entities.entities import SubscriptionConstructor, TriggerProviderEntity, TriggerProviderIdentity+from core.trigger.provider import PluginTriggerProviderController+from enums import DeploymentEdition+from extensions.ext_application_services import application_services, build_application_services+from extensions.ext_key_provider import key_provider_manager+from extensions.ext_login import DifyLoginManager, bind_account_loader, load_user_from_request, unauthorized_handler+from extensions.ext_redis import RedisClientWrapper+from extensions.ext_storage import storage+from libs.datetime_utils import naive_utc_now+from libs.external_api import ExternalApi+from libs.passport import PassportService+from libs.token import _real_cookie_name, generate_csrf_token+from models import Account, DifySetup, Tenant, TenantAccountJoin+from models.account import AccountStatus, TenantAccountRole+from models.engine import db+from models.provider_ids import TriggerProviderID+from models.trigger import TriggerOAuthSystemClient, TriggerOAuthTenantClient+from repositories.trigger.oauth_client_repository import TriggerOAuthClientRepository+from services.trigger.oauth_client_service import TriggerOAuthClientService+from tests.helpers.unit.config_override import config_overrides_context++_PROVIDER = "langgenius/github/github"+_URL = f"/console/api/workspaces/current/trigger-provider/{_PROVIDER}/oauth/client"+_SCHEMA = [+ ProviderConfig(name="client_id", type=ProviderConfigType.TEXT_INPUT),+ ProviderConfig(name="client_secret", type=ProviderConfigType.SECRET_INPUT),+]+++@dataclass+class _PluginMetadata:+ """Only plugin-daemon metadata is supplied locally; credential logic is real."""++ provider: PluginTriggerProviderController+ sessions: list[Session]+ verified: bool = True+ provider_requests: int = 0+ # None means metadata arrives immediately; a callback controls one external+ # lookup so tests can interleave a real concurrent persistence operation.+ before_provider: Callable[[], None] | None = None++ def get_provider(self, tenant_id: str, provider_id: TriggerProviderID) -> PluginTriggerProviderController:+ assert all(not session.in_transaction() for session in self.sessions)+ assert tenant_id == self.provider.tenant_id+ assert str(provider_id) == str(self.provider.provider_id)+ self.provider_requests += 1+ before_provider = self.before_provider+ self.before_provider = None+ if before_provider is not None:+ before_provider()+ return self.provider++ def is_verified(self, tenant_id: str, plugin_unique_identifier: str) -> bool:+ assert all(not session.in_transaction() for session in self.sessions)+ assert tenant_id == self.provider.tenant_id+ assert plugin_unique_identifier == self.provider.plugin_unique_identifier+ return self.verified+++@dataclass(frozen=True)+class _Harness:+ app: Flask+ client: FlaskClient+ session_factory: sessionmaker[Session]+ account_id: str+ tenant_id: str+ headers: dict[str, str]+ metadata: _PluginMetadata++ def call(self, method: str, *, payload: dict[str, object] | None = None, url: str = _URL) -> TestResponse:+ return self.client.open(url, method=method, headers=self.headers, json=payload)++ def set_role(self, role: TenantAccountRole) -> None:+ with self.session_factory.begin() as session:+ membership = session.scalar(+ select(TenantAccountJoin).where(TenantAccountJoin.account_id == self.account_id)+ )+ assert membership is not None+ membership.role = role++ def add_client(self, *, tenant_id: str, encrypted_params: str = "{}", enabled: bool = True) -> str:+ with self.session_factory.begin() as session:+ client = TriggerOAuthTenantClient(+ tenant_id=tenant_id,+ plugin_id="langgenius/github",+ provider="github",+ encrypted_oauth_params=encrypted_params,+ enabled=enabled,+ )+ session.add(client)+ session.flush()+ return client.id++ def saved_params(self) -> dict[str, object]:+ with self.session_factory() as session:+ client = session.scalar(+ select(TriggerOAuthTenantClient).where(TriggerOAuthTenantClient.tenant_id == self.tenant_id)+ )+ assert client is not None+ params = json.loads(client.encrypted_oauth_params)+ assert isinstance(params, dict)+ return params+++def harness(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]) -> Iterator[_Harness]:+ previous_storage = storage.__dict__.copy()+ previous_key_provider = key_provider_manager._provider+ with (+ TemporaryDirectory(prefix="trigger-oauth-keys-") as storage_path,+ Redis() as redis_client,+ config_overrides_context(+ DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY,+ RBAC_ENABLED=False,+ LOGIN_DISABLED=False,+ INIT_PASSWORD="",+ SECRET_KEY="trigger-oauth-http-secret-at-least-32-bytes",+ CONSOLE_API_URL="https://console.example.test",+ KEY_PROVIDER_TYPE="local",+ STORAGE_TYPE="local",+ STORAGE_LOCAL_PATH=storage_path,+ ),+ ):+ app = Flask(__name__)+ app.config.update(TESTING=True, SQLALCHEMY_DATABASE_URI=str(sqlite_engine.url))+ db.init_app(app)+ storage.init_app(app)+ key_provider_manager.init_app(app)+ now = naive_utc_now()+ with sqlite_session_factory.begin() as session:+ account = Account(+ email="[email protected]", name="OAuth admin", status=AccountStatus.ACTIVE, initialized_at=now+ )+ account.last_active_at = now+ tenant = Tenant(name="OAuth workspace")+ session.add_all([account, tenant, DifySetup(version="test")])+ session.flush()+ tenant.encrypt_public_key = key_provider_manager.provider.generate_key_pair(tenant.id)+ session.add(+ TenantAccountJoin(+ tenant_id=tenant.id,+ account_id=account.id,+ role=TenantAccountRole.OWNER,+ current=True,+ )+ )+ account_id, tenant_id = account.id, tenant.id++ sessions: list[Session] = []+ provider = PluginTriggerProviderController(+ entity=TriggerProviderEntity(+ identity=TriggerProviderIdentity(+ author="Dify",+ name="github",+ label=I18nObject(en_US="GitHub"),+ description=I18nObject(en_US="GitHub trigger"),+ ),+ subscription_constructor=SubscriptionConstructor(oauth_schema=OAuthSchema(client_schema=_SCHEMA)),+ ),+ plugin_id="langgenius/github",+ plugin_unique_identifier="langgenius/github:1.0.0@test",+ provider_id=TriggerProviderID(_PROVIDER),+ tenant_id=tenant_id,+ )+ metadata = _PluginMetadata(provider, sessions)+ redis = RedisClientWrapper()+ redis.initialize(redis_client)+ services = build_application_services(+ database_client=sqlite_session_factory,+ deployment_edition=DeploymentEdition.COMMUNITY,+ initialization_password="",+ redis=redis,+ )+ oauth_clients = TriggerOAuthClientService(+ clients=TriggerOAuthClientRepository(session_factory=sqlite_session_factory),+ get_provider=metadata.get_provider,+ is_plugin_verified=metadata.is_verified,+ )+ services = replace(services, workspaces=replace(services.workspaces, trigger_oauth_clients=oauth_clients))+ app.extensions["application_services"] = services+ bind_account_loader(app, services.accounts.identity.load_user)+ login_manager = DifyLoginManager()+ login_manager.request_loader(load_user_from_request)+ login_manager.unauthorized_handler(unauthorized_handler)+ login_manager.init_app(app)+ blueprint = Blueprint("console", __name__, url_prefix="/console/api")+ api = ExternalApi(blueprint)+ api.add_resource(+ TriggerOAuthClientManageApi, "/workspaces/current/trigger-provider/<path:provider>/oauth/client"+ )+ app.register_blueprint(blueprint)++ with app.app_context():+ _is_setup_completed.reset_success()+ assert _is_setup_completed()+ db.session.remove()+ client = app.test_client()+ csrf_token = generate_csrf_token(account_id)+ client.set_cookie(_real_cookie_name("csrf_token"), csrf_token)+ headers = {+ "Authorization": f"Bearer {PassportService().issue({'user_id': account_id})}",+ HEADER_NAME_CSRF_TOKEN: csrf_token,+ }++ def observe_session(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:+ sessions.append(session)++ @app.after_request+ def assert_repository_sessions_closed(response: Response) -> Response:+ assert all(not session.in_transaction() and not session.identity_map for session in sessions)+ return response++ # The existing RSA provider uses Flask's scoped session for its tenant+ # key lookup. Observe the injected repository factory independently.+ event.listen(sqlite_session_factory.class_, "after_begin", observe_session)+ try:+ yield _Harness(app, client, sqlite_session_factory, account_id, tenant_id, headers, metadata)+ finally:+ event.remove(sqlite_session_factory.class_, "after_begin", observe_session)+ _is_setup_completed.reset_success()+ with app.app_context():+ db.session.remove()+ db.engine.dispose()+ storage.__dict__.clear()+ storage.__dict__.update(previous_storage)+ key_provider_manager._provider = previous_key_provider+++def test_missing_configuration_returns_complete_shape(harness: _Harness) -> None:+ response = harness.call("GET")++ assert response.status_code == HTTPStatus.OK+ assert response.content_type == "application/json"+ assert response.get_json() == {+ "configured": False,+ "system_configured": False,+ "custom_configured": False,+ "custom_enabled": False,+ "oauth_client_schema": [field.model_dump(mode="json") for field in _SCHEMA],+ "redirect_uri": f"https://console.example.test/console/api/oauth/plugin/{_PROVIDER}/trigger/callback",+ "params": {},+ }+++def test_credentials_encrypt_mask_and_preserve_hidden_secret(harness: _Harness) -> None:+ secret = "oauth-secret-value"+ response = harness.call("POST", payload={"client_params": {"client_id": "before", "client_secret": secret}})+ assert response.status_code == HTTPStatus.OK+ assert response.get_json() == {"result": "success"}+ encrypted = harness.saved_params()["client_secret"]+ assert isinstance(encrypted, str)+ assert encrypted != secret+ with harness.app.app_context():+ assert decrypt_token(harness.tenant_id, encrypted) == secret++ response = harness.call("GET")+ assert response.status_code == HTTPStatus.OK+ body = response.get_json()+ assert body["configured"] is True+ assert body["custom_configured"] is True+ assert body["custom_enabled"] is True+ assert body["params"] == {"client_id": "before", "client_secret": "oa**************ue"}+ assert secret not in response.get_data(as_text=True)++ response = harness.call(+ "POST", payload={"client_params": {"client_id": "after", "client_secret": HIDDEN_VALUE}, "enabled": False}+ )+ assert response.status_code == HTTPStatus.OK+ saved = harness.saved_params()+ assert saved["client_id"] == "after"+ assert isinstance(saved["client_secret"], str)+ with harness.app.app_context():+ assert decrypt_token(harness.tenant_id, saved["client_secret"]) == secret+ response = harness.call("GET")+ assert response.get_json()["custom_enabled"] is False+ assert response.get_json()["params"]["client_id"] == "after"++[email protected]("payload", [{}, {"client_params": None, "enabled": None}])+def test_empty_update_is_noop_without_plugin_lookup(harness: _Harness, payload: dict[str, object]) -> None:+ response = harness.call("POST", payload=payload)++ assert response.status_code == HTTPStatus.OK+ assert harness.metadata.provider_requests == 0+ with harness.session_factory() as session:+ assert session.scalar(select(TriggerOAuthTenantClient)) is None+++def test_enabled_only_update_retains_existing_clear_credentials_behavior(harness: _Harness) -> None:+ harness.add_client(tenant_id=harness.tenant_id, encrypted_params='{"client_id":"existing"}')++ response = harness.call("POST", payload={"enabled": False})++ assert response.status_code == HTTPStatus.OK+ assert harness.saved_params() == {}+ response = harness.call("GET")+ assert response.get_json()["custom_configured"] is False+ assert response.get_json()["custom_enabled"] is False+++def test_hidden_value_without_prior_value_uses_existing_unknown_fallback(harness: _Harness) -> None:+ response = harness.call("POST", payload={"client_params": {"client_id": HIDDEN_VALUE}})++ assert response.status_code == HTTPStatus.OK+ assert harness.saved_params() == {"client_id": UNKNOWN_VALUE}+++def test_concurrent_delete_does_not_resurrect_a_hidden_secret(harness: _Harness) -> None:+ secret = "deleted-oauth-secret"+ response = harness.call("POST", payload={"client_params": {"client_secret": secret}})+ assert response.status_code == HTTPStatus.OK++ def delete_during_provider_lookup() -> None:+ repository = TriggerOAuthClientRepository(session_factory=harness.session_factory)+ repository.delete(tenant_id=harness.tenant_id, provider_id=TriggerProviderID(_PROVIDER))++ harness.metadata.before_provider = delete_during_provider_lookup+ response = harness.call("POST", payload={"client_params": {"client_secret": HIDDEN_VALUE}})++ assert response.status_code == HTTPStatus.CONFLICT+ assert response.get_json()["code"] == "trigger_oauth_client_changed"+ assert secret not in response.get_data(as_text=True)+ with harness.session_factory() as session:+ assert session.scalar(select(TriggerOAuthTenantClient)) is None++[email protected]("existing", [False, True])+def test_concurrent_save_preserves_winning_secret(harness: _Harness, existing: bool) -> None:+ old_secret = "old-oauth-secret"+ winning_secret = "rotated-oauth-secret"+ if existing:+ response = harness.call("POST", payload={"client_params": {"client_secret": old_secret}})+ assert response.status_code == HTTPStatus.OK++ def save_during_provider_lookup() -> None:+ application_services().workspaces.trigger_oauth_clients.save(+ tenant_id=harness.tenant_id,+ provider_id=TriggerProviderID(_PROVIDER),+ client_params={"client_id": "winning-client", "client_secret": winning_secret},+ enabled=False,+ )++ harness.metadata.before_provider = save_during_provider_lookup+ response = harness.call(+ "POST",+ payload={"client_params": {"client_secret": HIDDEN_VALUE if existing else old_secret}, "enabled": True},+ )++ assert response.status_code == HTTPStatus.CONFLICT+ assert response.get_json()["code"] == "trigger_oauth_client_changed"+ assert old_secret not in response.get_data(as_text=True)+ assert winning_secret not in response.get_data(as_text=True)+ saved = harness.saved_params()+ assert saved["client_id"] == "winning-client"+ encrypted_secret = saved["client_secret"]+ assert isinstance(encrypted_secret, str)+ with harness.app.app_context():+ assert decrypt_token(harness.tenant_id, encrypted_secret) == winning_secret+ assert harness.call("GET").get_json()["custom_enabled"] is False++[email protected]("verified", [True, False])+def test_system_configuration_requires_verified_plugin(harness: _Harness, verified: bool) -> None:+ harness.metadata.verified = verified+ with harness.session_factory.begin() as session:+ session.add(+ TriggerOAuthSystemClient(+ plugin_id="langgenius/github", provider="github", encrypted_oauth_params='{"secret":"system-secret"}'+ )+ )++ response = harness.call("GET")++ assert response.status_code == HTTPStatus.OK+ assert response.get_json()["system_configured"] is verified+ assert response.get_json()["configured"] is verified+ assert response.get_json()["params"] == {}+ assert "system-secret" not in response.get_data(as_text=True)+++def test_client_read_and_delete_do_not_touch_other_workspace(harness: _Harness) -> None:+ other_client_id = harness.add_client(tenant_id=str(uuid4()), encrypted_params='{"client_id":"other-workspace"}')+ assert harness.call("GET").get_json()["params"] == {}+ harness.call("POST", payload={"client_params": {"client_id": "own-workspace"}})++ for _ in range(2):+ response = harness.call("DELETE")+ assert response.status_code == HTTPStatus.OK+ assert response.get_json() == {"result": "success"}+ with harness.session_factory() as session:+ clients = session.scalars(select(TriggerOAuthTenantClient)).all()+ assert [client.id for client in clients] == [other_client_id]+ assert clients[0].oauth_params == {"client_id": "other-workspace"}++[email protected]("method", ["GET", "POST"])[email protected]("stored_params", ["{broken-json", "[]"])+def test_corrupt_persisted_configuration_is_server_error(harness: _Harness, method: str, stored_params: str) -> None:+ harness.add_client(tenant_id=harness.tenant_id, encrypted_params=stored_params)++ response = harness.call(method, payload={"client_params": {"client_id": "new"}} if method == "POST" else None)++ assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR+ assert response.get_json()["code"] == "trigger_oauth_client_config_invalid"+ assert _PROVIDER in response.get_json()["message"]+ assert stored_params not in response.get_data(as_text=True)++[email protected]("method", ["GET", "POST", "DELETE"])+ "role", [TenantAccountRole.EDITOR, TenantAccountRole.NORMAL, TenantAccountRole.DATASET_OPERATOR]+)+def test_configuration_requires_workspace_admin(harness: _Harness, method: str, role: TenantAccountRole) -> None:+ harness.set_role(role)++ response = harness.call(method, payload={"enabled": True} if method == "POST" else None)++ assert response.status_code == HTTPStatus.FORBIDDEN+ assert harness.metadata.provider_requests == 0+ with harness.session_factory() as session:+ assert session.scalar(select(TriggerOAuthTenantClient)) is None+++def test_admin_can_manage_configuration(harness: _Harness) -> None:+ harness.set_role(TenantAccountRole.ADMIN)++ assert harness.call("POST", payload={"client_params": {"client_id": "admin"}}).status_code == HTTPStatus.OK+ assert harness.call("GET").get_json()["params"] == {"client_id": "admin"}+ assert harness.call("DELETE").status_code == HTTPStatus.OK++[email protected]("method", ["GET", "POST", "DELETE"])+def test_invalid_provider_has_client_error(harness: _Harness, method: str) -> None:+ response = harness.call(method, payload={"enabled": True}, url=_URL.replace(_PROVIDER, "not/a/valid/provider"))++ assert response.status_code == HTTPStatus.BAD_REQUEST+ assert response.get_json()["code"] == "invalid_param"+ assert harness.metadata.provider_requests == 0++[email protected]("payload", [{"client_params": []}, {"enabled": "not-a-bool"}])+def test_invalid_payload_returns_validation_error(harness: _Harness, payload: dict[str, object]) -> None:+ response = harness.call("POST", payload=payload)++ assert response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY+ assert harness.metadata.provider_requests == 0++[email protected]("method", ["POST", "DELETE"])+def test_write_requires_csrf(harness: _Harness, method: str) -> None:+ response = harness.client.open(+ _URL, method=method, headers={"Authorization": harness.headers["Authorization"]}, json={"enabled": True}+ )++ assert response.status_code == HTTPStatus.UNAUTHORIZED+ assert harness.metadata.provider_requests == 0+++def test_configuration_requires_login(harness: _Harness) -> None:+ response = harness.client.get(_URL)++ assert response.status_code == HTTPStatus.UNAUTHORIZED+ assert harness.metadata.provider_requests == 0diff --git a/api/tests/unit_tests/controllers/console/workspace/test_trigger_providers.py b/api/tests/unit_tests/controllers/console/workspace/test_trigger_providers.pyindex 4b2eda34495..98471033c51 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@@ -17,8 +17,6 @@ from controllers.common.errors import NotFoundErrorfrom controllers.console.workspace.trigger_providers import (TriggerOAuthAuthorizeApi,TriggerOAuthCallbackApi,- TriggerOAuthClientManageApi,- TriggerOAuthClientPayload,TriggerProviderIconApi,TriggerProviderInfoApi,TriggerProviderListApi,@@ -580,78 +578,6 @@ class TestTriggerProviderApisCases:with pytest.raises(ValueError, match="Failed to get OAuth credentials from the provider\\."):method(api, "github")- class TestTriggerOAuthClientManageApi:- def test_get_client(self, app: Flask) -> None:- api = TriggerOAuthClientManageApi()- method = unwrap(api.get)-- with (- app.test_request_context("/"),- patch(- "controllers.console.workspace.trigger_providers.TriggerProviderService.get_custom_oauth_client_params",- return_value={},- ),- patch(- "controllers.console.workspace.trigger_providers.TriggerProviderService.is_oauth_custom_client_enabled",- return_value=False,- ),- patch(- "controllers.console.workspace.trigger_providers.TriggerProviderService.is_oauth_system_client_exists",- return_value=True,- ),- patch(- "controllers.console.workspace.trigger_providers.TriggerManager.get_trigger_provider",- return_value=MagicMock(get_oauth_client_schema=lambda: []),- ),- ):- result = method(api, "t1", "github")- assert "configured" in result-- def test_post_client(self, app: Flask) -> None:- api = TriggerOAuthClientManageApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"enabled": True}),- patch(- "controllers.console.workspace.trigger_providers.TriggerProviderService.save_custom_oauth_client_params",- return_value={"result": "success"},- ),- ):- assert method(- api,- TriggerOAuthClientPayload(enabled=True),- "t1",- "github",- ) == {"result": "success"}-- def test_delete_client(self, app: Flask) -> None:- api = TriggerOAuthClientManageApi()- method = unwrap(api.delete)-- with (- app.test_request_context("/"),- patch(- "controllers.console.workspace.trigger_providers.TriggerProviderService.delete_custom_oauth_client_params",- return_value={"result": "success"},- ),- ):- assert method(api, "t1", "github") == {"result": "success"}-- def test_oauth_client_post_value_error(self, app: Flask) -> None:- api = TriggerOAuthClientManageApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"enabled": True}),- patch(- "controllers.console.workspace.trigger_providers.TriggerProviderService.save_custom_oauth_client_params",- side_effect=ValueError("bad"),- ),- ):- with pytest.raises(BadRequest):- method(api, TriggerOAuthClientPayload(enabled=True), "t1", "github")-class TestTriggerSubscriptionVerifyApi:def test_verify_success(self, app: Flask) -> None:api = TriggerSubscriptionVerifyApi()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.pyindex 5e8710a0d86..ad82f06dcc8 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@@ -10,12 +10,16 @@ import pytestfrom flask import Flaskfrom flask.typing import ResponseReturnValuefrom flask_restx import Api, Resource+from sqlalchemy.orm import Session, sessionmakerfrom werkzeug.exceptions import UnprocessableEntityfrom controllers.inner_api.workspace import workspace as controllerfrom controllers.inner_api.wraps import InnerApiUnauthorizedError+from core.plugin.plugin_service import PluginService+from core.trigger.trigger_manager import TriggerManagerfrom extensions.application_services.workspace import WorkspaceServicesfrom libs.external_api import register_external_error_handlers+from repositories.trigger.oauth_client_repository import TriggerOAuthClientRepositoryfrom services.account_errors import AccountNotFoundErrorfrom services.errors.workspace import (InvalidWorkspaceMemberRoleError,@@ -23,6 +27,7 @@ from services.errors.workspace import (WorkspaceOwnerNotFoundError,WorkspacesLimitExceededError,)+from services.trigger.oauth_client_service import TriggerOAuthClientServicefrom services.workspace.contracts import CreatedWorkspace, WorkspaceMembershipfrom services.workspace.provisioning_service import WorkspaceProvisioningServicefrom services.workspace.service import WorkspaceQueryService, WorkspaceService@@ -91,7 +96,7 @@ MEMBER = {"workspace_id": "w1", "account_id": "a1", "email": "[email protected]class TestWorkspaceCases:@staticmethod@pytest.fixture- def provisioning(monkeypatch: pytest.MonkeyPatch) -> Mock:+ def provisioning(monkeypatch: pytest.MonkeyPatch, sqlite_session_factory: sessionmaker[Session]) -> Mock:provisioning = create_autospec(WorkspaceProvisioningService, instance=True)services = WorkspaceServices(queries=create_autospec(WorkspaceQueryService, instance=True),@@ -103,6 +108,11 @@ class TestWorkspaceCases:invitations=Mock(),identity=Mock(),resource_cleanup=Mock(),+ trigger_oauth_clients=TriggerOAuthClientService(+ clients=TriggerOAuthClientRepository(session_factory=sqlite_session_factory),+ get_provider=TriggerManager.get_trigger_provider,+ is_plugin_verified=PluginService.is_plugin_verified,+ ),)monkeypatch.setattr(controller, "application_services", lambda: Services(services))return provisioningdiff --git a/api/tests/unit_tests/repositories/test_trigger_oauth_client_repository.py b/api/tests/unit_tests/repositories/test_trigger_oauth_client_repository.pynew file mode 100644index 00000000000..9ce1411c449--- /dev/null+++ b/api/tests/unit_tests/repositories/test_trigger_oauth_client_repository.py@@ -0,0 +1,447 @@+import sqlite3+from uuid import uuid4++import pytest+from psycopg2.errors import UniqueViolation+from pymysql.err import IntegrityError as MySQLIntegrityError+from sqlalchemy import Engine, select+from sqlalchemy.exc import IntegrityError+from sqlalchemy.orm import Session, sessionmaker+from sqlalchemy.pool import QueuePool++from models.provider_ids import TriggerProviderID+from models.trigger import TriggerOAuthSystemClient, TriggerOAuthTenantClient+from repositories.trigger.oauth_client_repository import TriggerOAuthClientRepository, _is_custom_client_conflict+from services.trigger.oauth_client_service import (+ TriggerOAuthClientChangedError,+ TriggerOAuthClientSnapshot,+ TriggerOAuthTenantClientRecord,+)+++def repository(sqlite_session_factory: sessionmaker[Session]) -> TriggerOAuthClientRepository:+ return TriggerOAuthClientRepository(session_factory=sqlite_session_factory)+++def _custom(*, tenant_id: str, plugin_id: str, provider: str) -> TriggerOAuthTenantClient:+ return TriggerOAuthTenantClient(+ tenant_id=tenant_id,+ plugin_id=plugin_id,+ provider=provider,+ encrypted_oauth_params='{"client_secret": "original-ciphertext"}',+ enabled=False,+ )+++def test_missing_clients_return_empty_snapshot(repository: TriggerOAuthClientRepository) -> None:+ assert repository.get(+ tenant_id=str(uuid4()), provider_id=TriggerProviderID("langgenius/github/github")+ ) == TriggerOAuthClientSnapshot(custom=None, system_configured=False)+++def test_repository_returns_its_connection_after_every_operation(+ repository: TriggerOAuthClientRepository,+ sqlite_engine: Engine,+) -> None:+ tenant_id = str(uuid4())+ provider_id = TriggerProviderID("langgenius/github/github")+ pool = sqlite_engine.pool+ assert isinstance(pool, QueuePool)++ repository.save(+ tenant_id=tenant_id,+ provider_id=provider_id,+ encrypted_oauth_params="{}",+ enabled=None,+ expected=None,+ )+ assert pool.checkedout() == 0+ repository.get(tenant_id=tenant_id, provider_id=provider_id)+ assert pool.checkedout() == 0+ repository.delete(tenant_id=tenant_id, provider_id=provider_id)+ assert pool.checkedout() == 0++[email protected]("other_scope", ["tenant", "plugin", "provider"])+def test_custom_lookup_uses_complete_owner_scope(+ repository: TriggerOAuthClientRepository,+ sqlite_session_factory: sessionmaker[Session],+ other_scope: str,+) -> None:+ tenant_id = str(uuid4())+ with sqlite_session_factory.begin() as session:+ session.add(+ _custom(+ tenant_id=str(uuid4()) if other_scope == "tenant" else tenant_id,+ plugin_id="langgenius/other" if other_scope == "plugin" else "langgenius/github",+ provider="other" if other_scope == "provider" else "github",+ )+ )++ assert repository.get(+ tenant_id=tenant_id, provider_id=TriggerProviderID("langgenius/github/github")+ ) == TriggerOAuthClientSnapshot(custom=None, system_configured=False)++[email protected]("other_scope", ["plugin", "provider"])+def test_system_lookup_uses_plugin_and_provider(+ repository: TriggerOAuthClientRepository,+ sqlite_session_factory: sessionmaker[Session],+ other_scope: str,+) -> None:+ with sqlite_session_factory.begin() as session:+ session.add(+ TriggerOAuthSystemClient(+ plugin_id="langgenius/other" if other_scope == "plugin" else "langgenius/github",+ provider="other" if other_scope == "provider" else "github",+ encrypted_oauth_params="system-ciphertext",+ )+ )++ assert (+ repository.get(+ tenant_id=str(uuid4()), provider_id=TriggerProviderID("langgenius/github/github")+ ).system_configured+ is False+ )+++def test_get_materializes_ciphertext_and_enabled_before_closing_session(+ repository: TriggerOAuthClientRepository,+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ tenant_id = str(uuid4())+ provider_id = TriggerProviderID("langgenius/github/github")+ custom = _custom(tenant_id=tenant_id, plugin_id=provider_id.plugin_id, provider=provider_id.provider_name)+ with sqlite_session_factory.begin() as session:+ session.add(custom)+ session.add(+ TriggerOAuthSystemClient(+ plugin_id=provider_id.plugin_id,+ provider=provider_id.provider_name,+ encrypted_oauth_params="system-ciphertext",+ )+ )++ snapshot = repository.get(tenant_id=tenant_id, provider_id=provider_id)+ repository.delete(tenant_id=tenant_id, provider_id=provider_id)++ assert snapshot == TriggerOAuthClientSnapshot(+ custom=TriggerOAuthTenantClientRecord(+ id=custom.id,+ encrypted_oauth_params='{"client_secret": "original-ciphertext"}',+ enabled=False,+ ),+ system_configured=True,+ )++[email protected](("enabled", "expected"), [(None, True), (False, False), (True, True)])+def test_save_creates_committed_client_with_default_or_explicit_enabled(+ repository: TriggerOAuthClientRepository,+ sqlite_session_factory: sessionmaker[Session],+ enabled: bool | None,+ expected: bool,+) -> None:+ tenant_id = str(uuid4())+ provider_id = TriggerProviderID("langgenius/github/github")++ repository.save(+ tenant_id=tenant_id,+ provider_id=provider_id,+ encrypted_oauth_params='{"client_secret": "new-ciphertext"}',+ enabled=enabled,+ expected=None,+ )++ with sqlite_session_factory() as session:+ clients = session.scalars(select(TriggerOAuthTenantClient)).all()+ assert len(clients) == 1+ client = clients[0]+ assert (client.tenant_id, client.plugin_id, client.provider) == (tenant_id, "langgenius/github", "github")+ assert client.encrypted_oauth_params == '{"client_secret": "new-ciphertext"}'+ assert client.enabled is expected++[email protected](("enabled", "expected"), [(None, False), (False, False), (True, True)])+def test_save_updates_only_matching_client_and_preserves_enabled_when_omitted(+ repository: TriggerOAuthClientRepository,+ sqlite_session_factory: sessionmaker[Session],+ enabled: bool | None,+ expected: bool,+) -> None:+ tenant_id = str(uuid4())+ provider_id = TriggerProviderID("langgenius/github/github")+ target = _custom(tenant_id=tenant_id, plugin_id=provider_id.plugin_id, provider=provider_id.provider_name)+ decoys = [+ _custom(tenant_id=str(uuid4()), plugin_id=provider_id.plugin_id, provider=provider_id.provider_name),+ _custom(tenant_id=tenant_id, plugin_id="langgenius/other", provider=provider_id.provider_name),+ _custom(tenant_id=tenant_id, plugin_id=provider_id.plugin_id, provider="other"),+ ]+ with sqlite_session_factory.begin() as session:+ session.add_all([*decoys, target])++ repository.save(+ tenant_id=tenant_id,+ provider_id=provider_id,+ encrypted_oauth_params="{}",+ enabled=enabled,+ expected=TriggerOAuthTenantClientRecord(+ id=target.id, encrypted_oauth_params=target.encrypted_oauth_params, enabled=target.enabled+ ),+ )++ with sqlite_session_factory() as session:+ clients = {client.id: client for client in session.scalars(select(TriggerOAuthTenantClient))}+ assert len(clients) == 4+ assert clients[target.id].encrypted_oauth_params == "{}"+ assert clients[target.id].enabled is expected+ for decoy in decoys:+ assert clients[decoy.id].encrypted_oauth_params == decoy.encrypted_oauth_params+ assert clients[decoy.id].enabled is False++[email protected]("recreate", [False, True])+def test_save_rejects_deleted_snapshot_without_resurrecting_or_overwriting_client(+ repository: TriggerOAuthClientRepository,+ sqlite_session_factory: sessionmaker[Session],+ recreate: bool,+) -> None:+ tenant_id = str(uuid4())+ provider_id = TriggerProviderID("langgenius/github/github")+ with sqlite_session_factory.begin() as session:+ session.add(_custom(tenant_id=tenant_id, plugin_id=provider_id.plugin_id, provider=provider_id.provider_name))+ snapshot = repository.get(tenant_id=tenant_id, provider_id=provider_id)+ assert snapshot.custom is not None++ repository.delete(tenant_id=tenant_id, provider_id=provider_id)+ if recreate:+ repository.save(+ tenant_id=tenant_id,+ provider_id=provider_id,+ encrypted_oauth_params='{"client_secret": "replacement-ciphertext"}',+ enabled=False,+ expected=None,+ )++ with pytest.raises(TriggerOAuthClientChangedError):+ repository.save(+ tenant_id=tenant_id,+ provider_id=provider_id,+ encrypted_oauth_params='{"client_secret": "stale-ciphertext"}',+ enabled=None,+ expected=snapshot.custom,+ )++ with sqlite_session_factory() as session:+ clients = session.scalars(select(TriggerOAuthTenantClient)).all()+ if recreate:+ assert len(clients) == 1+ assert clients[0].id != snapshot.custom.id+ assert clients[0].encrypted_oauth_params == '{"client_secret": "replacement-ciphertext"}'+ assert clients[0].enabled is False+ else:+ assert clients == []++[email protected]("other_scope", ["tenant", "plugin", "provider"])+def test_save_requires_owner_scope_even_with_existing_client_id(+ repository: TriggerOAuthClientRepository,+ sqlite_session_factory: sessionmaker[Session],+ other_scope: str,+) -> None:+ tenant_id = str(uuid4())+ target = _custom(tenant_id=tenant_id, plugin_id="langgenius/github", provider="github")+ with sqlite_session_factory.begin() as session:+ session.add(target)++ provider_ids = {+ "tenant": "langgenius/github/github",+ "plugin": "langgenius/other/github",+ "provider": "langgenius/github/other",+ }+ provider_id = TriggerProviderID(provider_ids[other_scope])+ with pytest.raises(TriggerOAuthClientChangedError):+ repository.save(+ tenant_id=str(uuid4()) if other_scope == "tenant" else tenant_id,+ provider_id=provider_id,+ encrypted_oauth_params="{}",+ enabled=True,+ expected=TriggerOAuthTenantClientRecord(+ id=target.id, encrypted_oauth_params=target.encrypted_oauth_params, enabled=target.enabled+ ),+ )++ with sqlite_session_factory() as session:+ stored = session.get(TriggerOAuthTenantClient, target.id)+ assert stored is not None+ assert stored.encrypted_oauth_params == target.encrypted_oauth_params+ assert stored.enabled is False++[email protected]("changed_field", ["ciphertext", "enabled"])+def test_save_rejects_changed_snapshot_without_overwriting_current_values(+ repository: TriggerOAuthClientRepository,+ sqlite_session_factory: sessionmaker[Session],+ changed_field: str,+) -> None:+ tenant_id = str(uuid4())+ provider_id = TriggerProviderID("langgenius/github/github")+ repository.save(+ tenant_id=tenant_id,+ provider_id=provider_id,+ encrypted_oauth_params='{"client_secret": "AbCd"}',+ enabled=False,+ expected=None,+ )+ stale = repository.get(tenant_id=tenant_id, provider_id=provider_id).custom+ assert stale is not None++ current_ciphertext = '{"client_secret": "aBcD"}' if changed_field == "ciphertext" else stale.encrypted_oauth_params+ current_enabled = changed_field == "enabled"+ repository.save(+ tenant_id=tenant_id,+ provider_id=provider_id,+ encrypted_oauth_params=current_ciphertext,+ enabled=current_enabled,+ expected=stale,+ )++ with pytest.raises(TriggerOAuthClientChangedError):+ repository.save(+ tenant_id=tenant_id,+ provider_id=provider_id,+ encrypted_oauth_params=stale.encrypted_oauth_params,+ enabled=False,+ expected=stale,+ )++ with sqlite_session_factory() as session:+ stored = session.get(TriggerOAuthTenantClient, stale.id)+ assert stored is not None+ assert stored.encrypted_oauth_params == current_ciphertext+ assert stored.enabled is current_enabled+++def test_concurrent_first_create_returns_conflict_and_preserves_winner(+ repository: TriggerOAuthClientRepository,+) -> None:+ tenant_id = str(uuid4())+ provider_id = TriggerProviderID("langgenius/github/github")+ first_snapshot = repository.get(tenant_id=tenant_id, provider_id=provider_id)+ second_snapshot = repository.get(tenant_id=tenant_id, provider_id=provider_id)+ assert first_snapshot.custom is None+ assert second_snapshot.custom is None++ repository.save(+ tenant_id=tenant_id,+ provider_id=provider_id,+ encrypted_oauth_params='{"client_secret": "winner-ciphertext"}',+ enabled=False,+ expected=first_snapshot.custom,+ )+ with pytest.raises(TriggerOAuthClientChangedError):+ repository.save(+ tenant_id=tenant_id,+ provider_id=provider_id,+ encrypted_oauth_params='{"client_secret": "stale-ciphertext"}',+ enabled=True,+ expected=second_snapshot.custom,+ )++ stored = repository.get(tenant_id=tenant_id, provider_id=provider_id).custom+ assert stored is not None+ assert stored.encrypted_oauth_params == '{"client_secret": "winner-ciphertext"}'+ assert stored.enabled is False+++def test_unrelated_insert_constraint_is_not_mapped_to_conflict_even_when_client_exists(+ repository: TriggerOAuthClientRepository,+ sqlite_engine: Engine,+) -> None:+ tenant_id = str(uuid4())+ provider_id = TriggerProviderID("langgenius/github/github")+ repository.save(+ tenant_id=tenant_id,+ provider_id=provider_id,+ encrypted_oauth_params="{}",+ enabled=False,+ expected=None,+ )+ with sqlite_engine.begin() as connection:+ connection.exec_driver_sql(+ "CREATE TRIGGER reject_oauth_client_insert BEFORE INSERT ON trigger_oauth_tenant_clients "+ "BEGIN SELECT RAISE(ABORT, 'database_trigger_failed'); END"+ )++ with pytest.raises(IntegrityError) as raised:+ repository.save(+ tenant_id=tenant_id,+ provider_id=provider_id,+ encrypted_oauth_params="{}",+ enabled=True,+ expected=None,+ )++ assert isinstance(raised.value.orig, sqlite3.IntegrityError)+ assert raised.value.orig.sqlite_errorcode == sqlite3.SQLITE_CONSTRAINT_TRIGGER+ assert str(raised.value.orig) == "database_trigger_failed"+++ ("code", "message", "expected"),+ [+ (1062, "Duplicate entry 'value' for key 'unique_trigger_oauth_tenant_client'", True),+ (+ 1062,+ "Duplicate entry 'value' for key 'trigger_oauth_tenant_clients.unique_trigger_oauth_tenant_client'",+ True,+ ),+ (1062, "Duplicate entry 'value' for key `unique_trigger_oauth_tenant_client`", True),+ (1062, "Duplicate entry 'value' for key 'PRIMARY'", False),+ (1062, "Duplicate entry 'value' for key 'unique_trigger_oauth_tenant_client_extra'", False),+ (1062, "Duplicate entry 'value' for key 'another_table.unique_trigger_oauth_tenant_client'", False),+ (1048, "Column cannot be null for key 'unique_trigger_oauth_tenant_client'", False),+ ],+)+def test_mysql_classifier_matches_only_expected_unique_constraint(code: int, message: str, expected: bool) -> None:+ error = IntegrityError(statement=None, params=None, orig=MySQLIntegrityError(code, message))++ assert _is_custom_client_conflict(error) is expected+++def test_postgres_unique_violation_without_expected_constraint_is_not_classified() -> None:+ error = IntegrityError(statement=None, params=None, orig=UniqueViolation("Unspecified unique violation"))++ assert _is_custom_client_conflict(error) is False+++def test_delete_is_idempotent_and_preserves_other_workspaces_providers_and_system_client(+ repository: TriggerOAuthClientRepository,+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ tenant_id = str(uuid4())+ provider_id = TriggerProviderID("langgenius/github/github")+ target = _custom(tenant_id=tenant_id, plugin_id=provider_id.plugin_id, provider=provider_id.provider_name)+ decoys = [+ _custom(tenant_id=str(uuid4()), plugin_id=provider_id.plugin_id, provider=provider_id.provider_name),+ _custom(tenant_id=tenant_id, plugin_id="langgenius/other", provider=provider_id.provider_name),+ _custom(tenant_id=tenant_id, plugin_id=provider_id.plugin_id, provider="other"),+ ]+ with sqlite_session_factory.begin() as session:+ session.add_all([*decoys, target])+ session.add(+ TriggerOAuthSystemClient(+ plugin_id=provider_id.plugin_id,+ provider=provider_id.provider_name,+ encrypted_oauth_params="system-ciphertext",+ )+ )++ repository.delete(tenant_id=tenant_id, provider_id=provider_id)+ repository.delete(tenant_id=tenant_id, provider_id=provider_id)++ with sqlite_session_factory() as session:+ assert set(session.scalars(select(TriggerOAuthTenantClient.id))) == {decoy.id for decoy in decoys}+ assert session.scalar(select(TriggerOAuthSystemClient.encrypted_oauth_params)) == "system-ciphertext"diff --git a/api/tests/unit_tests/services/trigger/test_trigger_provider_service.py b/api/tests/unit_tests/services/trigger/test_trigger_provider_service.pyindex 56cf35f4972..5366ace04b4 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@@ -575,7 +575,6 @@ def test_oauth_client_falls_back_to_verified_system_record(assert TriggerProviderService.get_oauth_client(trigger_db.tenant_id, trigger_db.provider_id) == PluginOAuthClientConfig(provider_controller.plugin_unique_identifier, {"client": "system"})- assert TriggerProviderService.is_oauth_system_client_exists(trigger_db.tenant_id, trigger_db.provider_id)def test_unverified_plugin_cannot_read_system_oauth(@@ -585,33 +584,6 @@ def test_unverified_plugin_cannot_read_system_oauth(mocker.patch.object(service_module.PluginService, "is_plugin_verified", return_value=False)assert TriggerProviderService.get_oauth_client(trigger_db.tenant_id, trigger_db.provider_id) is None- assert not TriggerProviderService.is_oauth_system_client_exists(trigger_db.tenant_id, trigger_db.provider_id)---def test_custom_oauth_client_create_mask_enable_and_delete(- mocker, trigger_db: TriggerDatabase, provider_controller: Mock-) -> None:- _patch_provider(mocker, provider_controller)- encrypter = _encrypter(- encrypted={"client_secret": "encrypted"}, decrypted={"client_secret": "plain"}, masked={"client_secret": "****"}- )- cache = Mock()- mocker.patch.object(service_module, "create_provider_encrypter", return_value=(encrypter, cache))-- assert TriggerProviderService.save_custom_oauth_client_params(- trigger_db.tenant_id,- trigger_db.provider_id,- client_params={"client_secret": "plain"},- enabled=True,- ) == {"result": "success"}- assert TriggerProviderService.is_oauth_custom_client_enabled(trigger_db.tenant_id, trigger_db.provider_id)- assert TriggerProviderService.get_custom_oauth_client_params(trigger_db.tenant_id, trigger_db.provider_id) == {- "client_secret": "****"- }- assert TriggerProviderService.delete_custom_oauth_client_params(trigger_db.tenant_id, trigger_db.provider_id) == {- "result": "success"- }- assert TriggerProviderService.get_custom_oauth_client_params(trigger_db.tenant_id, trigger_db.provider_id) == {}def test_endpoint_lookup_decrypts_persisted_subscription(diff --git a/packages/contracts/generated/api/console/errors.gen.ts b/packages/contracts/generated/api/console/errors.gen.tsindex 89f30deea20..aa0e6a892ab 100644--- a/packages/contracts/generated/api/console/errors.gen.ts+++ b/packages/contracts/generated/api/console/errors.gen.ts@@ -52,6 +52,7 @@ export { get11Errors as 'GET /apps/{app_id}/agent/config/skills/{name}/files/conexport { get11Errors as 'GET /knowledge-fs/spaces/{control_space_id}/documents/{document_id}/outline' } from './knowledge-fs/errors.gen.ts'export { get11Errors as 'GET /rag/pipelines/{pipeline_id}/workflows/default-workflow-block-configs' } from './rag/errors.gen.ts'export { get11Errors as 'GET /trial-apps/{app_id}/datasets' } from './trial-apps/errors.gen.ts'+export { get127Errors as 'GET /workspaces/current/trigger-provider/{provider}/oauth/client' } from './workspaces/errors.gen.ts'export { get12Errors as 'GET /agent/{agent_id}/config/manifest' } from './agent/errors.gen.ts'export { get12Errors as 'GET /apps/{app_id}/agent/config/skills/{name}/files/download' } from './apps/errors.gen.ts'export { get12Errors as 'GET /knowledge-fs/spaces/{control_space_id}/documents/{document_id}/revisions/{revision}/chunks/{chunk_id}' } from './knowledge-fs/errors.gen.ts'@@ -524,6 +525,7 @@ export { post7Errors as 'POST /knowledge-fs/spaces/{control_space_id}/documents'export { post7Errors as 'POST /rag/pipelines/{pipeline_id}/customized/publish' } from './rag/errors.gen.ts'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 { 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'diff --git a/packages/contracts/generated/api/console/workspaces/errors.gen.ts b/packages/contracts/generated/api/console/workspaces/errors.gen.tsindex 80e86480a82..b94e045d728 100644--- a/packages/contracts/generated/api/console/workspaces/errors.gen.ts+++ b/packages/contracts/generated/api/console/workspaces/errors.gen.ts@@ -258,6 +258,22 @@ const zCurrentWorkspaceArchivedError = /* @__PURE__ */ (() =>}),))()+const zTriggerOauthClientConfigInvalidError = /* @__PURE__ */ (() =>+ zErrorResponse.and(+ z.object({+ code: z.literal('trigger_oauth_client_config_invalid'),+ status: z.literal(500),+ }),+ ))()++const zTriggerOauthClientChangedError = /* @__PURE__ */ (() =>+ zErrorResponse.and(+ z.object({+ code: z.literal('trigger_oauth_client_changed'),+ status: z.literal(409),+ }),+ ))()+const zFilenameNotExistsError = /* @__PURE__ */ (() =>zErrorResponse.and(z.object({@@ -492,6 +508,15 @@ export const get101Errors = {current_workspace_archived: { status: 409, data: zCurrentWorkspaceArchivedError },}+export const get127Errors = {+ trigger_oauth_client_config_invalid: { status: 500, data: zTriggerOauthClientConfigInvalidError },+}++export const post84Errors = {+ trigger_oauth_client_changed: { status: 409, data: zTriggerOauthClientChangedError },+ trigger_oauth_client_config_invalid: { status: 500, data: zTriggerOauthClientConfigInvalidError },+}+export const post92Errors = {file_too_large: { status: 413, data: zFileTooLargeError },filename_not_exists_error: { status: 400, data: zFilenameNotExistsError },diff --git a/packages/contracts/generated/api/console/workspaces/orpc.gen.ts b/packages/contracts/generated/api/console/workspaces/orpc.gen.tsindex 5fc2e147f09..ed1a7c36c15 100644--- a/packages/contracts/generated/api/console/workspaces/orpc.gen.ts+++ b/packages/contracts/generated/api/console/workspaces/orpc.gen.ts@@ -38,6 +38,8 @@ import {zPluginError,zRoleAlreadyAssignedError,zTooManyFilesError,+ zTriggerOauthClientChangedError,+ zTriggerOauthClientConfigInvalidError,zUnsupportedFileTypeError,} from './zod.gen.ts'import {@@ -5737,7 +5739,7 @@ export const info3 = {}/**- * Remove custom OAuth client configuration+ * Remove the workspace's custom OAuth client configuration*/export const delete26 = oc.route({@@ -5745,14 +5747,14 @@ export const delete26 = ocmethod: 'DELETE',operationId: 'deleteWorkspacesCurrentTriggerProviderByProviderOauthClient',path: '/workspaces/current/trigger-provider/{provider}/oauth/client',- summary: 'Remove custom OAuth client configuration',+ summary: "Remove the workspace's custom OAuth client configuration",tags: ['console'],}).input(z.object({ params: zDeleteWorkspacesCurrentTriggerProviderByProviderOauthClientPath })).output(zDeleteWorkspacesCurrentTriggerProviderByProviderOauthClientResponse)/**- * Get OAuth client configuration for a provider+ * Get the masked OAuth client configuration for a provider*/export const get127 = oc.route({@@ -5760,14 +5762,20 @@ export const get127 = ocmethod: 'GET',operationId: 'getWorkspacesCurrentTriggerProviderByProviderOauthClient',path: '/workspaces/current/trigger-provider/{provider}/oauth/client',- summary: 'Get OAuth client configuration for a provider',+ summary: 'Get the masked OAuth client configuration for a provider',tags: ['console'],}).input(z.object({ params: zGetWorkspacesCurrentTriggerProviderByProviderOauthClientPath })).output(zGetWorkspacesCurrentTriggerProviderByProviderOauthClientResponse)+ .errors({+ trigger_oauth_client_config_invalid: {+ status: 500,+ data: zTriggerOauthClientConfigInvalidError,+ },+ })/**- * Configure custom OAuth client for a provider+ * Configure the workspace's custom OAuth client for a provider*/export const post84 = oc.route({@@ -5775,7 +5783,7 @@ export const post84 = ocmethod: 'POST',operationId: 'postWorkspacesCurrentTriggerProviderByProviderOauthClient',path: '/workspaces/current/trigger-provider/{provider}/oauth/client',- summary: 'Configure custom OAuth client for a provider',+ summary: "Configure the workspace's custom OAuth client for a provider",tags: ['console'],}).input(@@ -5785,6 +5793,13 @@ export const post84 = oc}),).output(zPostWorkspacesCurrentTriggerProviderByProviderOauthClientResponse)+ .errors({+ trigger_oauth_client_changed: { status: 409, data: zTriggerOauthClientChangedError },+ trigger_oauth_client_config_invalid: {+ status: 500,+ data: zTriggerOauthClientConfigInvalidError,+ },+ })export const client = {delete: delete26,diff --git a/packages/contracts/generated/api/console/workspaces/types.gen.ts b/packages/contracts/generated/api/console/workspaces/types.gen.tsindex 4acbdf8bf13..a110b9a6b29 100644--- a/packages/contracts/generated/api/console/workspaces/types.gen.ts+++ b/packages/contracts/generated/api/console/workspaces/types.gen.ts@@ -1584,6 +1584,11 @@ export type TriggerOAuthClientResponse = {system_configured: boolean}+export type TriggerOauthClientConfigInvalidError = ErrorResponse & {+ code: 'trigger_oauth_client_config_invalid'+ status: 500+}+export type TriggerOAuthClientPayload = {client_params?: {[key: string]: unknown@@ -1591,6 +1596,11 @@ export type TriggerOAuthClientPayload = {enabled?: boolean | null}+export type TriggerOauthClientChangedError = ErrorResponse & {+ code: 'trigger_oauth_client_changed'+ status: 409+}+export type TriggerSubscriptionBuilderUpdatePayload = {credentials?: {[key: string]: unknown@@ -10480,6 +10490,7 @@ export type GetWorkspacesCurrentTriggerProviderByProviderOauthClientData = {}export type GetWorkspacesCurrentTriggerProviderByProviderOauthClientErrors = {+ 500: TriggerOauthClientConfigInvalidError | ErrorResponsedefault: ErrorResponse}@@ -10503,6 +10514,8 @@ export type PostWorkspacesCurrentTriggerProviderByProviderOauthClientData = {}export type PostWorkspacesCurrentTriggerProviderByProviderOauthClientErrors = {+ 409: TriggerOauthClientChangedError | ErrorResponse+ 500: TriggerOauthClientConfigInvalidError | ErrorResponsedefault: ErrorResponse}diff --git a/packages/contracts/generated/api/console/workspaces/zod.gen.ts b/packages/contracts/generated/api/console/workspaces/zod.gen.tsindex 2dad9ed7522..83520111d69 100644--- a/packages/contracts/generated/api/console/workspaces/zod.gen.ts+++ b/packages/contracts/generated/api/console/workspaces/zod.gen.ts@@ -1251,6 +1251,18 @@ export const zWorkflowToolDeletePayload = z.object({workflow_tool_id: z.string(),})+/**+ * TriggerOauthClientConfigInvalidError+ *+ * The stored trigger OAuth client configuration is invalid.+ */+export const zTriggerOauthClientConfigInvalidError = zErrorResponse.and(+ z.object({+ code: z.literal('trigger_oauth_client_config_invalid'),+ status: z.literal(500),+ }),+)+/*** TriggerOAuthClientPayload*/@@ -1259,6 +1271,18 @@ export const zTriggerOAuthClientPayload = z.object({enabled: z.boolean().nullish(),})+/**+ * TriggerOauthClientChangedError+ *+ * The trigger OAuth client configuration changed. Reload it before saving again.+ */+export const zTriggerOauthClientChangedError = zErrorResponse.and(+ z.object({+ code: z.literal('trigger_oauth_client_changed'),+ status: z.literal(409),+ }),+)+/*** TriggerSubscriptionBuilderUpdatePayload*/