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 provider and subscription queries (#44514)
非法操作db3ffcc92b96
diff --git a/api/.importlinter b/api/.importlinterindex fa65cae4b57..6becbed4160 100644--- a/api/.importlinter+++ b/api/.importlinter@@ -1434,6 +1434,8 @@ type = forbiddensource_modules =services.trigger.oauth_client_serviceservices.trigger.oauth_service+ services.trigger.provider_query+ services.trigger.subscription_query_serviceforbidden_modules =controllersextensionsdiff --git a/api/controllers/console/workspace/trigger_providers.py b/api/controllers/console/workspace/trigger_providers.pyindex dd2dbaa5d9e..9bd463966d7 100644--- a/api/controllers/console/workspace/trigger_providers.py+++ b/api/controllers/console/workspace/trigger_providers.py@@ -41,7 +41,6 @@ from core.trigger.entities.api_entities import (TriggerProviderSubscriptionApiEntity,)from core.trigger.entities.entities import RequestLog, SubscriptionBuilderUpdater-from core.trigger.trigger_manager import TriggerManagerfrom enums.account import TenantAccountRolefrom extensions.ext_application_services import application_servicesfrom extensions.ext_database import db@@ -163,79 +162,77 @@ register_response_schema_models(@console_ns.route("/workspaces/current/trigger-provider/<path:provider>/icon")class TriggerProviderIconApi(Resource):- # response-contract:ignore binary trigger provider icon- @console_ns.response(200, "Trigger provider icon")- @setup_required- @login_required- @account_initialization_required- @with_current_tenant_id- def get(self, tenant_id: str, provider: str):- return TriggerManager.get_trigger_plugin_icon(tenant_id=tenant_id, provider_id=provider)+ # response-contract:ignore legacy JSON string containing the icon URL+ @console_ns.response(HTTPStatus.OK, "Trigger provider icon")+ @console_account_admission()+ def get(self, context: RequestContext, provider: str) -> str:+ return application_services().workspaces.trigger_providers.get_icon(+ tenant_id=context.active_workspace_id, provider_id=TriggerProviderID(provider)+ )@console_ns.route("/workspaces/current/triggers")class TriggerProviderListApi(Resource):@console_ns.response(- 200,+ HTTPStatus.OK,"Trigger providers retrieved successfully",console_ns.models[TriggerProviderListResponse.__name__],)- @setup_required- @login_required- @account_initialization_required- @with_current_tenant_id- def get(self, tenant_id: str):+ @console_account_admission()+ def get(self, context: RequestContext) -> list[dict[str, Any]]:"""List all trigger providers for the current tenant"""- return dump_response(TriggerProviderListResponse, TriggerProviderService.list_trigger_providers(tenant_id))+ return TriggerProviderListResponse(+ application_services().workspaces.trigger_providers.list(tenant_id=context.active_workspace_id),+ ).model_dump(mode="json")@console_ns.route("/workspaces/current/trigger-provider/<path:provider>/info")class TriggerProviderInfoApi(Resource):@console_ns.response(- 200,+ HTTPStatus.OK,"Trigger provider retrieved successfully",console_ns.models[TriggerProviderApiEntity.__name__],)- @setup_required- @login_required- @account_initialization_required- @with_current_tenant_id- def get(self, tenant_id: str, provider: str):+ @console_account_admission()+ def get(self, context: RequestContext, provider: str) -> dict[str, Any]:"""Get info for a trigger provider"""- provider_entity = TriggerProviderService.get_trigger_provider(tenant_id, TriggerProviderID(provider))- return provider_entity.model_dump(mode="json")+ return dump_response(+ TriggerProviderApiEntity,+ application_services().workspaces.trigger_providers.get(+ tenant_id=context.active_workspace_id, provider_id=TriggerProviderID(provider)+ ),+ )@console_ns.route("/workspaces/current/trigger-provider/<path:provider>/subscriptions/list")class TriggerSubscriptionListApi(Resource):@console_ns.response(- 200,+ HTTPStatus.OK,"Trigger subscriptions retrieved successfully",console_ns.models[TriggerProviderSubscriptionListResponse.__name__],)- @console_ns.response(404, "Trigger provider not found", console_ns.models[TriggerProviderErrorResponse.__name__])- @setup_required- @login_required- @edit_permission_required- @rbac_permission_required(RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace()))+ @console_ns.response(+ HTTPStatus.NOT_FOUND, "Trigger provider not found", console_ns.models[TriggerProviderErrorResponse.__name__]+ )+ @console_account_admission(+ require_initialized=False,+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR}),+ rbac_checks=[RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace())],+ )@account_initialization_required- @with_current_user- @with_current_tenant_id- def get(self, tenant_id: str, user: Account, provider: str):+ def get(self, context: RequestContext, provider: str) -> list[dict[str, Any]] | tuple[dict[str, Any], HTTPStatus]:"""List all trigger subscriptions for the current tenant's provider"""try:- return dump_response(- TriggerProviderSubscriptionListResponse,- TriggerProviderService.list_trigger_provider_subscriptions(- tenant_id=tenant_id,+ return TriggerProviderSubscriptionListResponse(+ application_services().workspaces.trigger_subscriptions.list(+ tenant_id=context.active_workspace_id,+ account_id=context.account_id,provider_id=TriggerProviderID(provider),- user=user,- credential_query=application_services().credential_queries,),- )+ ).model_dump(mode="json")except ValueError as e:- return TriggerProviderErrorResponse(error=str(e)).model_dump(mode="json"), 404+ return TriggerProviderErrorResponse(error=str(e)).model_dump(mode="json"), HTTPStatus.NOT_FOUNDexcept Exception as e:logger.exception("Error listing trigger providers", exc_info=e)raisediff --git a/api/extensions/application_services/workspace.py b/api/extensions/application_services/workspace.pyindex 96895b623c4..2bacdf8db6e 100644--- a/api/extensions/application_services/workspace.py+++ b/api/extensions/application_services/workspace.py@@ -13,6 +13,7 @@ from repositories.trigger.oauth_client_repository import TriggerOAuthClientReposfrom repositories.workspace.resource_cleanup_repository import WorkspaceResourceCleanupRepositoryfrom repositories.workspace.workspace_repository import WorkspaceRepositoryfrom services.account.adapters import RedisInvitationTokenStore+from services.credentials.query import CredentialQueryfrom services.file_service import FileServicefrom services.trigger.oauth_client_service import TriggerOAuthClientServicefrom services.trigger.oauth_gateway import (@@ -21,6 +22,9 @@ from services.trigger.oauth_gateway import (TriggerOAuthBuilderGateway,)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_query_service import TriggerSubscriptionQueryServicefrom services.workspace.gateways import (DeploymentWorkspaceCreationPolicy,DeploymentWorkspaceFeatureGateway,@@ -56,6 +60,8 @@ class WorkspaceServices:invitations: WorkspaceInvitationServiceidentity: WorkspaceIdentityGatewayresource_cleanup: WorkspaceResourceCleanupService+ trigger_providers: TriggerProviderQuery+ trigger_subscriptions: TriggerSubscriptionQueryServicetrigger_oauth_clients: TriggerOAuthClientServicetrigger_oauth: TriggerOAuthService@@ -93,11 +99,13 @@ def build_workspace_services(provisioning: WorkspaceProvisioningService,registration: InvitedAccountRegistration,invitation_tokens: RedisInvitationTokenStore,+ credentials: CredentialQuery,) -> WorkspaceServices:- trigger_providers = PluginTriggerOAuthGateway(oauth=OAuthHandler())+ trigger_providers = PluginTriggerProviderQuery()+ trigger_oauth_provider = PluginTriggerOAuthGateway(oauth=OAuthHandler())trigger_oauth_clients = TriggerOAuthClientService(clients=TriggerOAuthClientRepository(session_factory=database_client),- providers=trigger_providers,+ providers=trigger_oauth_provider,)return WorkspaceServices(queries=WorkspaceQueryService(workspaces=workspaces, plans=DeploymentWorkspacePlanGateway()),@@ -131,10 +139,12 @@ def build_workspace_services(datasets=SQLAlchemyDatasetRepository(session_factory=database_client),agent_resources=WorkspaceResourceCleanupRepository(session_factory=database_client),),+ trigger_providers=trigger_providers,+ trigger_subscriptions=TriggerSubscriptionQueryService(credentials=credentials, schemas=trigger_providers),trigger_oauth_clients=trigger_oauth_clients,trigger_oauth=TriggerOAuthService(clients=trigger_oauth_clients,- providers=trigger_providers,+ providers=trigger_oauth_provider,contexts=OAuthProxyContextGateway(),builders=TriggerOAuthBuilderGateway(),),diff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.pyindex 8bedb8fc91c..bc117963922 100644--- a/api/extensions/ext_application_services.py+++ b/api/extensions/ext_application_services.py@@ -575,6 +575,7 @@ def build_application_services(invitation_tokens=invitation_tokens,activation_accounts=activation_accounts,)+ credential_queries = CredentialQueryRepository(session_factory=database_client)workspace_services = build_workspace_services(database_client=database_client,workspaces=workspace_repository,@@ -585,6 +586,7 @@ def build_application_services(provisioning=workspace_provisioning,registration=account_services.lifecycle,invitation_tokens=invitation_tokens,+ credentials=credential_queries,)conversations = ConversationRepository(session_factory=database_client)conversation_names = ConversationNameService(@@ -639,7 +641,7 @@ def build_application_services(conversation_queries=conversation_queries,accounts=account_services,apps=apps,- credential_queries=CredentialQueryRepository(session_factory=database_client),+ credential_queries=credential_queries,agent_apps=build_agent_app_services(database_client=database_client),advanced_prompt_templates=AdvancedPromptTemplateService(),app_definitions=app_definitions,diff --git a/api/services/trigger/provider_gateway.py b/api/services/trigger/provider_gateway.pynew file mode 100644index 00000000000..cd4b7833f4e--- /dev/null+++ b/api/services/trigger/provider_gateway.py@@ -0,0 +1,34 @@+"""Adapt plugin trigger declarations to the workspace provider query contract."""++from core.plugin.entities.plugin_daemon import CredentialType+from core.trigger.entities.api_entities import TriggerProviderApiEntity+from core.trigger.trigger_manager import TriggerManager+from models.provider_ids import TriggerProviderID+from services.trigger.subscription_query_service import TriggerSubscriptionSchemas+++class PluginTriggerProviderQuery:+ def list(self, *, tenant_id: str) -> list[TriggerProviderApiEntity]:+ return [provider.to_api_entity() for provider in TriggerManager.list_all_trigger_providers(tenant_id)]++ def get(self, *, tenant_id: str, provider_id: TriggerProviderID) -> TriggerProviderApiEntity:+ return TriggerManager.get_trigger_provider(tenant_id, provider_id).to_api_entity()++ def get_icon(self, *, tenant_id: str, provider_id: TriggerProviderID) -> str:+ return TriggerManager.get_trigger_plugin_icon(tenant_id=tenant_id, provider_id=str(provider_id))++ def get_subscription_schemas(+ self,+ *,+ tenant_id: str,+ provider_id: TriggerProviderID,+ credential_types: frozenset[CredentialType],+ ) -> TriggerSubscriptionSchemas:+ provider = TriggerManager.get_trigger_provider(tenant_id, provider_id)+ return TriggerSubscriptionSchemas(+ credentials={+ credential_type: provider.get_credential_schema_config(credential_type)+ for credential_type in credential_types+ },+ properties=provider.get_properties_schema(),+ )diff --git a/api/services/trigger/provider_query.py b/api/services/trigger/provider_query.pynew file mode 100644index 00000000000..5f9bd37a4e8--- /dev/null+++ b/api/services/trigger/provider_query.py@@ -0,0 +1,16 @@+"""Read contract for the trigger providers installed in a workspace."""++from typing import Protocol++from core.trigger.entities.api_entities import TriggerProviderApiEntity+from models.provider_ids import TriggerProviderID+++class TriggerProviderQuery(Protocol):+ def list(self, *, tenant_id: str) -> list[TriggerProviderApiEntity]: ...++ def get(self, *, tenant_id: str, provider_id: TriggerProviderID) -> TriggerProviderApiEntity: ...++ def get_icon(self, *, tenant_id: str, provider_id: TriggerProviderID) -> str:+ """Return the icon URL, not the icon bytes."""+ ...diff --git a/api/services/trigger/subscription_query_service.py b/api/services/trigger/subscription_query_service.pynew file mode 100644index 00000000000..0cadd156fe6--- /dev/null+++ b/api/services/trigger/subscription_query_service.py@@ -0,0 +1,96 @@+"""Read visible trigger subscriptions and mask their credentials outside the query transaction."""++from collections.abc import Mapping+from dataclasses import dataclass+from typing import Protocol++from core.entities.provider_entities import BasicProviderConfig+from core.helper.provider_encryption import create_provider_encrypter+from core.plugin.entities.plugin_daemon import CredentialType+from core.trigger.entities.api_entities import TriggerProviderSubscriptionApiEntity+from core.trigger.utils.encryption import TriggerProviderCredentialsCache, TriggerProviderPropertiesCache+from core.trigger.utils.endpoint import generate_plugin_trigger_endpoint_url+from models.provider_ids import TriggerProviderID+from services.credentials.query import CredentialQuery+++@dataclass(frozen=True, slots=True)+class TriggerSubscriptionSchemas:+ credentials: Mapping[CredentialType, list[BasicProviderConfig]]+ properties: list[BasicProviderConfig]+++class TriggerSubscriptionSchemaQuery(Protocol):+ def get_subscription_schemas(+ self,+ *,+ tenant_id: str,+ provider_id: TriggerProviderID,+ credential_types: frozenset[CredentialType],+ ) -> TriggerSubscriptionSchemas: ...+++class TriggerSubscriptionQueryService:+ """Compose visible records with plugin schemas after the read session closes.++ Credential decryption and caching remain with the shared encryption helpers.+ """++ def __init__(self, *, credentials: CredentialQuery, schemas: TriggerSubscriptionSchemaQuery) -> None:+ self._credentials = credentials+ self._schemas = schemas++ def list(+ self, *, tenant_id: str, account_id: str, provider_id: TriggerProviderID+ ) -> list[TriggerProviderSubscriptionApiEntity]:+ rows = self._credentials.list_trigger_subscriptions(+ workspace_id=tenant_id,+ provider=str(provider_id),+ actor_id=account_id,+ )+ if not rows:+ return []++ schemas = self._schemas.get_subscription_schemas(+ tenant_id=tenant_id,+ provider_id=provider_id,+ credential_types=frozenset(row.credential_type for row in rows),+ )+ subscriptions: list[TriggerProviderSubscriptionApiEntity] = []+ for row in rows:+ credential_encrypter, _ = create_provider_encrypter(+ tenant_id=tenant_id,+ config=schemas.credentials[row.credential_type],+ cache=TriggerProviderCredentialsCache(+ tenant_id=tenant_id,+ provider_id=str(provider_id),+ credential_id=row.id,+ ),+ )+ properties_encrypter, _ = create_provider_encrypter(+ tenant_id=tenant_id,+ config=schemas.properties,+ cache=TriggerProviderPropertiesCache(+ tenant_id=tenant_id,+ provider_id=str(provider_id),+ subscription_id=row.id,+ ),+ )+ subscriptions.append(+ TriggerProviderSubscriptionApiEntity(+ id=row.id,+ name=row.name,+ provider=row.provider,+ credential_type=row.credential_type,+ credentials=dict(+ credential_encrypter.mask_credentials(credential_encrypter.decrypt(row.credentials))+ ),+ endpoint=generate_plugin_trigger_endpoint_url(row.endpoint_id),+ parameters=dict(row.parameters),+ properties=dict(+ properties_encrypter.mask_credentials(properties_encrypter.decrypt(row.properties))+ ),+ workflows_in_use=row.workflows_in_use,+ )+ )+ return subscriptionsdiff --git a/api/services/trigger/trigger_provider_service.py b/api/services/trigger/trigger_provider_service.pyindex 3741ffd37de..97180dd5e03 100644--- a/api/services/trigger/trigger_provider_service.py+++ b/api/services/trigger/trigger_provider_service.py@@ -2,13 +2,7 @@ import loggingimport time as _timeimport uuidfrom collections.abc import Mapping-from typing import TYPE_CHECKING, Any, TypedDict--from services.credentials.query import CredentialQuery-from services.plugin.dispatch_identity import PluginOAuthClientConfig--if TYPE_CHECKING:- from models.account import Account+from typing import Any, TypedDictfrom sqlalchemy import func, selectfrom sqlalchemy.orm import Session, sessionmaker@@ -21,10 +15,6 @@ from core.plugin.entities.plugin_daemon import CredentialTypefrom core.plugin.impl.oauth import OAuthHandlerfrom core.plugin.plugin_service import PluginServicefrom core.tools.utils.system_encryption import decrypt_system_params-from core.trigger.entities.api_entities import (- TriggerProviderApiEntity,- TriggerProviderSubscriptionApiEntity,-)from core.trigger.entities.entities import Subscription as TriggerSubscriptionEntityfrom core.trigger.provider import PluginTriggerProviderControllerfrom core.trigger.trigger_manager import TriggerManager@@ -42,6 +32,7 @@ from models.trigger import (TriggerOAuthTenantClient,TriggerSubscription,)+from services.plugin.dispatch_identity import PluginOAuthClientConfiglogger = logging.getLogger(__name__)@@ -58,67 +49,6 @@ class TriggerProviderService:##########################__MAX_TRIGGER_PROVIDER_COUNT__ = 10- @classmethod- def get_trigger_provider(cls, tenant_id: str, provider: TriggerProviderID) -> TriggerProviderApiEntity:- """Get info for a trigger provider"""- return TriggerManager.get_trigger_provider(tenant_id, provider).to_api_entity()-- @classmethod- def list_trigger_providers(cls, tenant_id: str) -> list[TriggerProviderApiEntity]:- """List all trigger providers for the current tenant"""- return [provider.to_api_entity() for provider in TriggerManager.list_all_trigger_providers(tenant_id)]-- @classmethod- def list_trigger_provider_subscriptions(- cls,- tenant_id: str,- provider_id: TriggerProviderID,- user: "Account | None" = None,- *,- credential_query: CredentialQuery,- ) -> list[TriggerProviderSubscriptionApiEntity]:- """List all trigger subscriptions for the current tenant, filtered by visibility."""- subscriptions = [- TriggerProviderSubscriptionApiEntity(- id=row.id,- name=row.name,- provider=row.provider,- credential_type=row.credential_type,- credentials=dict(row.credentials),- endpoint=generate_plugin_trigger_endpoint_url(row.endpoint_id),- parameters=dict(row.parameters),- properties=dict(row.properties),- workflows_in_use=row.workflows_in_use,- )- for row in credential_query.list_trigger_subscriptions(- workspace_id=tenant_id, provider=str(provider_id), actor_id=user.id if user else None- )- ]- if not subscriptions:- return []-- provider_controller = TriggerManager.get_trigger_provider(tenant_id, provider_id)- for subscription in subscriptions:- credential_encrypter, _ = create_trigger_provider_encrypter_for_subscription(- tenant_id=tenant_id,- controller=provider_controller,- subscription=subscription,- )- subscription.credentials = dict(- credential_encrypter.mask_credentials(dict(credential_encrypter.decrypt(subscription.credentials)))- )- properties_encrypter, _ = create_trigger_provider_encrypter_for_properties(- tenant_id=tenant_id,- controller=provider_controller,- subscription=subscription,- )- subscription.properties = dict(- properties_encrypter.mask_credentials(dict(properties_encrypter.decrypt(subscription.properties)))- )- subscription.parameters = dict(subscription.parameters)-- return subscriptions-@classmethoddef add_trigger_subscription(cls,diff --git a/api/tests/e2e_tests/containers/services/test_trigger_subscription_query.py b/api/tests/e2e_tests/containers/services/test_trigger_subscription_query.pynew file mode 100644index 00000000000..b417a89905f--- /dev/null+++ b/api/tests/e2e_tests/containers/services/test_trigger_subscription_query.py@@ -0,0 +1,178 @@+"""Subscription HTTP reads use real plugin HTTP, RSA, SQL and Redis credential caches."""++import json+from collections.abc import Iterator+from contextvars import Context+from http import HTTPStatus+from pathlib import Path+from uuid import uuid4++import pytest+from flask import Flask+from sqlalchemy import Engine, create_engine, select+from sqlalchemy.orm import Session, sessionmaker++from core.entities.provider_entities import ProviderConfig, ProviderConfigType+from core.helper.encrypter import 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_redis import redis_client+from models.base import TypeBase+from models.credential_permission import CredentialPermission+from models.credential_permission import CredentialType as PermissionCredentialType+from models.enums import PermissionEnum+from models.trigger import TriggerSubscription, WorkflowPluginTrigger+from tests.unit_tests.controllers.console.workspace import test_trigger_oauth_client, test_trigger_provider_query+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 _Daemon, _provider+from tests.unit_tests.controllers.console.workspace.test_trigger_subscription_query import _LIST, _add_subscription++harness = test_trigger_oauth_client.harness+daemon = test_trigger_provider_query.daemon+++def sqlite_engine(flask_app_with_containers: Flask, tmp_path: Path) -> Iterator[Engine]:+ # Reuse the real HTTP/admission harness with an isolated SQL database. Redis+ # is the container-backed production cache, initialized by the Flask fixture.+ assert redis_client is flask_app_with_containers.extensions["redis"]+ engine = create_engine(f"sqlite:///{tmp_path / 'subscriptions.sqlite3'}")+ TypeBase.metadata.create_all(engine)+ try:+ yield engine+ finally:+ engine.dispose()+++def sqlite_session_factory(sqlite_engine: Engine) -> sessionmaker[Session]:+ return sessionmaker(bind=sqlite_engine, expire_on_commit=False)+++def _provider_with_secrets() -> dict[str, object]:+ provider = _provider()+ declaration = provider["declaration"]+ assert isinstance(declaration, dict)+ credential_schema = [+ ProviderConfig(name="token", type=ProviderConfigType.SECRET_INPUT).model_dump(mode="json"),+ ProviderConfig(name="username", type=ProviderConfigType.TEXT_INPUT).model_dump(mode="json"),+ ]+ declaration["subscription_constructor"] = {+ "credentials_schema": credential_schema,+ "oauth_schema": {"credentials_schema": credential_schema},+ }+ declaration["subscription_schema"] = [+ ProviderConfig(name="secret", type=ProviderConfigType.SECRET_INPUT).model_dump(mode="json"),+ ProviderConfig(name="repository", type=ProviderConfigType.TEXT_INPUT).model_dump(mode="json"),+ ]+ return provider+++ "credential_type", [CredentialType.API_KEY, CredentialType.OAUTH2, CredentialType.UNAUTHORIZED]+)+def test_subscription_http_masks_real_secrets_and_preserves_visibility_and_workflow_counts(+ harness: _Harness, daemon: _Daemon, credential_type: CredentialType+) -> None:+ daemon.response = _provider_with_secrets()+ with harness.app.app_context():+ ciphertext = encrypt_token(harness.tenant_id, "credential-secret")+ property_ciphertext = encrypt_token(harness.tenant_id, "property-secret")+ credentials = {} if credential_type == CredentialType.UNAUTHORIZED else {"token": ciphertext, "username": "octocat"}+ visible = [+ _add_subscription(+ harness,+ name="personal",+ credential_type=credential_type,+ credentials=credentials,+ properties={"secret": property_ciphertext, "repository": "dify"},+ visibility=PermissionEnum.ONLY_ME,+ ),+ _add_subscription(harness, name="team", user_id=str(uuid4())),+ _add_subscription(harness, name="shared", user_id=str(uuid4()), visibility=PermissionEnum.PARTIAL_TEAM),+ ]+ _add_subscription(harness, name="private", user_id=str(uuid4()), visibility=PermissionEnum.ONLY_ME)+ revoked = _add_subscription(harness, name="revoked", user_id=str(uuid4()), visibility=PermissionEnum.PARTIAL_TEAM)+ _add_subscription(harness, name="foreign-tenant", tenant_id=str(uuid4()))+ _add_subscription(harness, name="foreign-provider", provider_id="langgenius/github/other")+ app_id = str(uuid4())+ with harness.session_factory.begin() as session:+ session.add_all(+ [+ CredentialPermission(+ credential_id=row.id,+ credential_type=PermissionCredentialType.TRIGGER_SUBSCRIPTION,+ account_id=harness.account_id,+ tenant_id=harness.tenant_id,+ has_permission=allowed,+ )+ for row, allowed in [(visible[2], True), (revoked, False)]+ ]+ + [+ WorkflowPluginTrigger(+ app_id=app_id,+ node_id=f"node-{index}",+ tenant_id=harness.tenant_id,+ provider_id=_PROVIDER,+ event_name="push",+ subscription_id=visible[0].id,+ )+ for index in range(2)+ ]+ + [+ WorkflowPluginTrigger(+ app_id=str(uuid4()),+ node_id="foreign-node",+ tenant_id=str(uuid4()),+ provider_id=_PROVIDER,+ event_name="push",+ subscription_id=visible[0].id,+ )+ ]+ )++ response = Context().run(harness.call, "GET", url=_LIST)++ assert response.status_code == HTTPStatus.OK+ assert response.content_type == "application/json"+ rows = {row["id"]: row for row in response.get_json()}+ assert rows.keys() == {row.id for row in visible}+ target = visible[0]+ assert rows[target.id] == {+ "id": target.id,+ "name": "personal",+ "provider": _PROVIDER,+ "credential_type": credential_type.value,+ "credentials": {}+ if credential_type == CredentialType.UNAUTHORIZED+ else {"token": "cr*************et", "username": "octocat"},+ "endpoint": generate_plugin_trigger_endpoint_url(target.endpoint_id),+ "parameters": {"event": "push"},+ "properties": {"secret": "pr***********et", "repository": "dify"},+ "workflows_in_use": 1,+ }+ assert all(rows[row.id]["workflows_in_use"] == 0 for row in visible[1:])+ assert len(daemon.requests) == 1+ assert not daemon.requests[0].open_transactions+ with harness.session_factory() as session:+ saved = session.scalar(select(TriggerSubscription).where(TriggerSubscription.id == target.id))+ assert saved is not None+ assert saved.credentials == credentials+ assert saved.properties == {"secret": property_ciphertext, "repository": "dify"}++ # The normal cache must contain decrypted values while the HTTP response+ # remains masked, including on a second request served from that cache.+ key = TriggerProviderPropertiesCache(harness.tenant_id, _PROVIDER, target.id).cache_key+ cached = redis_client.get(key)+ assert cached is not None+ assert json.loads(cached) == {"secret": "property-secret", "repository": "dify"}+ credential_key = TriggerProviderCredentialsCache(harness.tenant_id, _PROVIDER, target.id).cache_key+ cached_credentials = redis_client.get(credential_key)+ assert cached_credentials is not None+ assert json.loads(cached_credentials) == (+ {} if credential_type == CredentialType.UNAUTHORIZED else {"token": "credential-secret", "username": "octocat"}+ )+ repeated = Context().run(harness.call, "GET", url=_LIST)+ assert repeated.status_code == HTTPStatus.OK+ assert repeated.get_json() == response.get_json()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.pyindex b86b2bb925d..e703487338f 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@@ -20,6 +20,10 @@ from controllers.console.workspace.trigger_providers import (TriggerOAuthAuthorizeApi,TriggerOAuthCallbackApi,TriggerOAuthClientManageApi,+ TriggerProviderIconApi,+ TriggerProviderInfoApi,+ TriggerProviderListApi,+ TriggerSubscriptionListApi,)from controllers.console.wraps import _is_setup_completedfrom core.entities.provider_entities import ProviderConfig, ProviderConfigType@@ -215,6 +219,12 @@ def harness(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]login_manager.init_app(app)blueprint = Blueprint("console", __name__, url_prefix="/console/api")api = ExternalApi(blueprint)+ api.add_resource(TriggerProviderListApi, "/workspaces/current/triggers")+ api.add_resource(TriggerProviderInfoApi, "/workspaces/current/trigger-provider/<path:provider>/info")+ api.add_resource(TriggerProviderIconApi, "/workspaces/current/trigger-provider/<path:provider>/icon")+ api.add_resource(+ TriggerSubscriptionListApi, "/workspaces/current/trigger-provider/<path:provider>/subscriptions/list"+ )api.add_resource(TriggerOAuthClientManageApi, "/workspaces/current/trigger-provider/<path:provider>/oauth/client")diff --git a/api/tests/unit_tests/controllers/console/workspace/test_trigger_provider_query.py b/api/tests/unit_tests/controllers/console/workspace/test_trigger_provider_query.pynew file mode 100644index 00000000000..b064a510f4d--- /dev/null+++ b/api/tests/unit_tests/controllers/console/workspace/test_trigger_provider_query.py@@ -0,0 +1,230 @@+"""Provider queries exercise real admission, gateway and plugin-daemon HTTP transport."""++import json+from collections.abc import Iterator+from contextvars import Context+from dataclasses import dataclass, field+from http import HTTPStatus+from http.server import BaseHTTPRequestHandler, HTTPServer+from threading import Thread+from typing import override+from urllib.parse import parse_qs, urlsplit++import pytest+from sqlalchemy import delete+from yarl import URL++from configs import dify_config+from core.plugin.impl import base as plugin_transport+from models import TenantAccountJoin+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++harness = test_trigger_oauth_client.harness++_LIST = "/console/api/workspaces/current/triggers"+_INFO = f"/console/api/workspaces/current/trigger-provider/{_PROVIDER}/info"+_ICON = f"/console/api/workspaces/current/trigger-provider/{_PROVIDER}/icon"+_IDENTIFIER = "langgenius/github:1.0.0@package-hash"+++def _provider() -> dict[str, object]:+ return {+ "provider": "github",+ "plugin_id": "langgenius/github",+ "plugin_unique_identifier": _IDENTIFIER,+ "declaration": {+ "identity": {+ "author": "Dify",+ "name": "github",+ "label": {"en_US": "GitHub"},+ "description": {"en_US": "GitHub trigger"},+ "icon": "icon.svg",+ "tags": ["code"],+ },+ "events": [+ {+ "identity": {"author": "Dify", "name": "push", "label": {"en_US": "Push"}},+ "description": {"en_US": "Repository push"},+ "output_schema": {"type": "object"},+ }+ ],+ },+ }+++@dataclass(frozen=True)+class _DaemonRequest:+ path: str+ headers: dict[str, str]+ open_transactions: bool+++@dataclass+class _Daemon:+ response: dict[str, object] | list[dict[str, object]] = field(default_factory=_provider)+ status: HTTPStatus = HTTPStatus.OK+ requests: list[_DaemonRequest] = field(default_factory=list)+++def daemon(harness: _Harness) -> Iterator[_Daemon]:+ daemon = _Daemon()++ class Handler(BaseHTTPRequestHandler):+ def do_GET(self) -> None:+ daemon.requests.append(+ _DaemonRequest(+ path=self.path,+ headers=dict(self.headers.items()),+ open_transactions=any(session.in_transaction() for session in harness.metadata.sessions),+ )+ )+ response = json.dumps({"code": 0, "message": "", "data": daemon.response}).encode()+ self.send_response(daemon.status)+ self.send_header("Content-Type", "application/json")+ self.send_header("Content-Length", str(len(response)))+ self.end_headers()+ self.wfile.write(response)++ @override+ def log_message(self, format: str, *args: object) -> None:+ pass++ server = HTTPServer(("127.0.0.1", 0), Handler)+ thread = Thread(target=server.serve_forever, kwargs={"poll_interval": 0.01}, daemon=True)+ previous_url = plugin_transport.plugin_daemon_inner_api_baseurl+ plugin_transport.plugin_daemon_inner_api_baseurl = URL(f"http://127.0.0.1:{server.server_port}")+ thread.start()+ try:+ yield daemon+ finally:+ plugin_transport.plugin_daemon_inner_api_baseurl = previous_url+ server.shutdown()+ server.server_close()+ thread.join(timeout=5)+++def _localized(text: str) -> dict[str, str]:+ return dict.fromkeys(("en_US", "zh_Hans", "pt_BR", "ja_JP"), text)+++def _expected_provider(tenant_id: str) -> dict[str, object]:+ return {+ "author": "Dify",+ "name": _PROVIDER,+ "label": _localized("GitHub"),+ "description": _localized("GitHub trigger"),+ "icon": f"https://console.example.test/console/api/workspaces/current/plugin/icon?tenant_id={tenant_id}&filename=icon.svg",+ "icon_dark": None,+ "tags": ["code"],+ "plugin_id": "langgenius/github",+ "plugin_unique_identifier": _IDENTIFIER,+ "supported_creation_methods": ["MANUAL"],+ "subscription_constructor": None,+ "subscription_schema": [],+ "events": [+ {+ "name": "push",+ "identity": {+ "author": "Dify",+ "name": "push",+ "label": _localized("Push"),+ "provider": _PROVIDER,+ },+ "description": _localized("Repository push"),+ "parameters": [],+ "output_schema": {"type": "object"},+ }+ ],+ }++[email protected]("url", [_LIST, _INFO, _ICON], ids=["list", "info", "icon"])+def test_queries_keep_response_shapes_and_use_active_workspace_after_admission(+ harness: _Harness, daemon: _Daemon, url: str+) -> None:+ harness.set_role(TenantAccountRole.NORMAL)+ if url == _LIST:+ daemon.response = [_provider()]++ # A fresh context uses the real per-request provider cache without leaking it+ # to another test. Query-string workspace IDs must not override admission.+ response = Context().run(harness.call, "GET", url=f"{url}?tenant_id=other-workspace")++ assert response.status_code == HTTPStatus.OK+ assert response.content_type == "application/json"+ expected = _expected_provider(harness.tenant_id)+ if url == _LIST:+ assert response.get_json() == [expected]+ elif url == _INFO:+ assert response.get_json() == expected+ else:+ assert response.get_json() == expected["icon"]+ assert "Location" not in response.headers+ assert len(daemon.requests) == 1+ sent = daemon.requests[0]+ upstream = urlsplit(sent.path)+ assert upstream.path == f"/plugin/{harness.tenant_id}/management/{'triggers' if url == _LIST else 'trigger'}"+ assert parse_qs(upstream.query) == (+ {"page": ["1"], "page_size": ["256"]}+ if url == _LIST+ else {"provider": ["github"], "plugin_id": ["langgenius/github"]}+ )+ assert sent.headers["X-Api-Key"] == dify_config.PLUGIN_DAEMON_KEY+ assert harness.metadata.sessions+ assert not sent.open_transactions+++def test_empty_provider_list_is_an_empty_json_array(harness: _Harness, daemon: _Daemon) -> None:+ daemon.response = []++ response = Context().run(harness.call, "GET", url=_LIST)++ assert response.status_code == HTTPStatus.OK+ assert response.get_json() == []+ assert len(daemon.requests) == 1++[email protected]("url", [_LIST, _INFO, _ICON], ids=["list", "info", "icon"])+def test_queries_require_login_before_plugin_lookup(harness: _Harness, daemon: _Daemon, url: str) -> None:+ response = Context().run(harness.client.get, url)++ assert response.status_code == HTTPStatus.UNAUTHORIZED+ assert response.get_json()["code"] == "unauthorized"+ assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'+ assert daemon.requests == []++[email protected]("url", [_LIST, _INFO, _ICON], ids=["list", "info", "icon"])+def test_queries_reject_account_without_workspace_membership(harness: _Harness, daemon: _Daemon, url: str) -> None:+ with harness.session_factory.begin() as session:+ session.execute(delete(TenantAccountJoin).where(TenantAccountJoin.account_id == harness.account_id))++ response = Context().run(harness.call, "GET", url=url)++ assert response.status_code == HTTPStatus.UNAUTHORIZED+ assert response.get_json()["code"] == "unauthorized"+ assert daemon.requests == []++[email protected]("url", [_INFO, _ICON], ids=["info", "icon"])+def test_invalid_provider_is_rejected_before_plugin_lookup(harness: _Harness, daemon: _Daemon, url: str) -> None:+ response = Context().run(harness.call, "GET", url=url.replace(_PROVIDER, "not/a/valid/provider"))++ assert response.status_code == HTTPStatus.BAD_REQUEST+ assert response.get_json()["code"] == "invalid_param"+ assert daemon.requests == []++[email protected]("url", [_LIST, _INFO, _ICON], ids=["list", "info", "icon"])+def test_daemon_failure_is_not_returned_as_success(harness: _Harness, daemon: _Daemon, url: str) -> None:+ daemon.status = HTTPStatus.SERVICE_UNAVAILABLE++ response = Context().run(harness.call, "GET", url=url)++ assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR+ assert response.get_json()["status"] == HTTPStatus.INTERNAL_SERVER_ERROR+ assert len(daemon.requests) == 1+ assert not daemon.requests[0].open_transactionsdiff --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 32bf8fb747e..a253ee0ec14 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@@ -4,8 +4,7 @@ from collections.abc import Iteratorfrom datetime import datetimefrom importlib import import_modulefrom inspect import unwrap-from types import SimpleNamespace-from unittest.mock import ANY, MagicMock, create_autospec, patch+from unittest.mock import ANY, MagicMock, patchimport pytestfrom flask import Flask@@ -15,9 +14,6 @@ from werkzeug.exceptions import BadRequestfrom controllers.common.errors import NotFoundErrorfrom controllers.console.workspace.trigger_providers import (- TriggerProviderIconApi,- TriggerProviderInfoApi,- TriggerProviderListApi,TriggerSubscriptionBuilderBuildApi,TriggerSubscriptionBuilderCreateApi,TriggerSubscriptionBuilderCreatePayload,@@ -28,17 +24,15 @@ from controllers.console.workspace.trigger_providers import (TriggerSubscriptionBuilderVerifyApi,TriggerSubscriptionBuilderVerifyPayload,TriggerSubscriptionDeleteApi,- TriggerSubscriptionListApi,TriggerSubscriptionUpdateApi,TriggerSubscriptionVerifyApi,TriggerSubscriptionVerifyPayload,)from core.plugin.entities.plugin_daemon import CredentialType-from core.trigger.entities.api_entities import SubscriptionBuilderApiEntity, TriggerProviderApiEntity+from core.trigger.entities.api_entities import SubscriptionBuilderApiEntityfrom core.trigger.entities.entities import RequestLogfrom models.account import Accountfrom models.engine import db-from services.credentials.query import CredentialQuery"""Unit tests for controllers.console.workspace.trigger_providers endpoints."""@@ -49,24 +43,6 @@ def mock_user() -> Account:return user-def trigger_provider() -> TriggerProviderApiEntity:- return TriggerProviderApiEntity(- author="Dify",- name="github",- label={"en_US": "GitHub"},- description={"en_US": "GitHub trigger provider"},- icon="icon.svg",- icon_dark=None,- tags=["code"],- plugin_id="plugin",- plugin_unique_identifier="plugin:github",- supported_creation_methods=[],- subscription_constructor=None,- subscription_schema=[],- events=[],- )--def subscription_builder() -> SubscriptionBuilderApiEntity:return SubscriptionBuilderApiEntity(id="b1",@@ -91,86 +67,6 @@ def request_log() -> RequestLog:class TestTriggerProviderApisCases:- @staticmethod- @pytest.fixture- def credential_query() -> Iterator[MagicMock]:- query = create_autospec(CredentialQuery, instance=True, spec_set=True)- with patch(- "controllers.console.workspace.trigger_providers.application_services",- return_value=SimpleNamespace(credential_queries=query),- ):- yield query-- class TestTriggerProviderApis:- def test_icon_success(self, app: Flask) -> None:- api = TriggerProviderIconApi()- method = unwrap(api.get)-- with (- app.test_request_context("/"),- patch(- "controllers.console.workspace.trigger_providers.TriggerManager.get_trigger_plugin_icon",- return_value="icon",- ),- ):- assert method(api, "t1", "github") == "icon"-- def test_list_providers(self, app: Flask) -> None:- api = TriggerProviderListApi()- method = unwrap(api.get)-- with (- app.test_request_context("/"),- patch(- "controllers.console.workspace.trigger_providers.TriggerProviderService.list_trigger_providers",- return_value=[],- ),- ):- assert method(api, "t1") == []-- def test_provider_info(self, app: Flask) -> None:- api = TriggerProviderInfoApi()- method = unwrap(api.get)-- with (- app.test_request_context("/"),- patch(- "controllers.console.workspace.trigger_providers.TriggerProviderService.get_trigger_provider",- return_value=trigger_provider(),- ),- ):- assert method(api, "t1", "github")["name"] == "github"-- class TestTriggerSubscriptionListApi:- def test_list_success(self, app: Flask, credential_query: MagicMock) -> None:- api = TriggerSubscriptionListApi()- method = unwrap(api.get)-- with (- app.test_request_context("/"),- patch(- "controllers.console.workspace.trigger_providers.TriggerProviderService.list_trigger_provider_subscriptions",- return_value=[],- ) as list_subscriptions,- ):- assert method(api, "t1", mock_user(), "github") == []- assert list_subscriptions.call_args.kwargs["credential_query"] is credential_query-- def test_list_invalid_provider(self, app: Flask, credential_query: MagicMock) -> None:- api = TriggerSubscriptionListApi()- method = unwrap(api.get)-- with (- app.test_request_context("/"),- patch(- "controllers.console.workspace.trigger_providers.TriggerProviderService.list_trigger_provider_subscriptions",- side_effect=ValueError("bad"),- ) as list_subscriptions,- ):- result, status = method(api, "t1", mock_user(), "bad")- assert status == 404- assert list_subscriptions.call_args.kwargs["credential_query"] is credential_query-class TestTriggerSubscriptionBuilderApis:def test_create_builder(self, app: Flask) -> None:api = TriggerSubscriptionBuilderCreateApi()diff --git a/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_query.py b/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_query.pynew file mode 100644index 00000000000..a10b40547ed--- /dev/null+++ b/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_query.py@@ -0,0 +1,200 @@+"""Subscription reads exercise real admission, SQL visibility and daemon transport."""++import json+from contextvars import Context+from http import HTTPStatus+from http.server import BaseHTTPRequestHandler, HTTPServer+from threading import Thread+from typing import override+from uuid import uuid4++import pytest+from sqlalchemy import delete++from core.plugin.entities.plugin_daemon import CredentialType+from models import TenantAccountJoin+from models.account import Account, AccountStatus, TenantAccountRole+from models.enums import PermissionEnum+from models.trigger import TriggerSubscription+from services.enterprise.base import EnterpriseRequest+from tests.helpers.unit.config_override import config_overrides_context+from tests.unit_tests.controllers.console.workspace import test_trigger_oauth_client, test_trigger_provider_query+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 _Daemon++harness = test_trigger_oauth_client.harness+daemon = test_trigger_provider_query.daemon++_LIST = f"/console/api/workspaces/current/trigger-provider/{_PROVIDER}/subscriptions/list"+++def _add_subscription(+ harness: _Harness,+ *,+ name: str = "subscription",+ tenant_id: str | None = None,+ user_id: str | None = None,+ provider_id: str = _PROVIDER,+ visibility: PermissionEnum = PermissionEnum.ALL_TEAM,+ credential_type: CredentialType = CredentialType.API_KEY,+ credentials: dict[str, str] | None = None,+ properties: dict[str, object] | None = None,+) -> TriggerSubscription:+ subscription = TriggerSubscription(+ name=name,+ tenant_id=tenant_id or harness.tenant_id,+ user_id=user_id or harness.account_id,+ provider_id=provider_id,+ endpoint_id=str(uuid4()),+ parameters={"event": "push"},+ properties=properties or {},+ credentials=credentials or {},+ credential_type=credential_type,+ visibility=visibility,+ )+ with harness.session_factory.begin() as session:+ session.add(subscription)+ return subscription++[email protected]("role", [TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR])+def test_empty_subscriptions_return_array_without_plugin_lookup(+ harness: _Harness, daemon: _Daemon, role: TenantAccountRole+) -> None:+ harness.set_role(role)++ response = Context().run(harness.call, "GET", url=_LIST)++ assert response.status_code == HTTPStatus.OK+ assert response.content_type == "application/json"+ assert response.get_json() == []+ assert daemon.requests == []+++def test_owner_cannot_see_other_members_private_or_foreign_subscriptions(harness: _Harness, daemon: _Daemon) -> None:+ _add_subscription(harness, name="private", user_id=str(uuid4()), visibility=PermissionEnum.ONLY_ME)+ _add_subscription(harness, name="unshared", user_id=str(uuid4()), visibility=PermissionEnum.PARTIAL_TEAM)+ _add_subscription(harness, name="foreign-workspace", tenant_id=str(uuid4()))+ _add_subscription(harness, name="foreign-provider", provider_id="langgenius/github/other")++ response = Context().run(harness.call, "GET", url=f"{_LIST}?tenant_id=other-workspace")++ assert response.status_code == HTTPStatus.OK+ assert response.get_json() == []+ assert daemon.requests == []++[email protected]("role", [TenantAccountRole.NORMAL, TenantAccountRole.DATASET_OPERATOR])+def test_subscriptions_require_editor_role_before_querying_plugin(+ harness: _Harness, daemon: _Daemon, role: TenantAccountRole+) -> None:+ harness.set_role(role)+ _add_subscription(harness)++ response = Context().run(harness.call, "GET", url=_LIST)++ assert response.status_code == HTTPStatus.FORBIDDEN+ assert response.get_json()["code"] == "forbidden"+ assert daemon.requests == []+++def test_uninitialized_member_without_editor_role_is_forbidden(harness: _Harness, daemon: _Daemon) -> None:+ harness.set_role(TenantAccountRole.NORMAL)+ with harness.session_factory.begin() as session:+ account = session.get(Account, harness.account_id)+ assert account is not None+ account.status = AccountStatus.UNINITIALIZED++ response = Context().run(harness.call, "GET", url=_LIST)++ assert response.status_code == HTTPStatus.FORBIDDEN+ assert response.get_json()["code"] == "forbidden"+ assert daemon.requests == []++[email protected]("allowed", [False, True], ids=["permission-denied", "permission-granted"])+def test_rbac_precedes_account_initialization(harness: _Harness, daemon: _Daemon, allowed: bool) -> None:+ harness.set_role(TenantAccountRole.NORMAL)+ with harness.session_factory.begin() as session:+ account = session.get(Account, harness.account_id)+ assert account is not None+ account.status = AccountStatus.UNINITIALIZED++ requests: list[dict[str, object]] = []++ class Handler(BaseHTTPRequestHandler):+ def do_POST(self) -> None:+ assert self.path == "/rbac/check-access"+ requests.append(json.loads(self.rfile.read(int(self.headers["Content-Length"]))))+ body = json.dumps({"allowed": allowed}).encode()+ self.send_response(HTTPStatus.OK)+ self.send_header("Content-Type", "application/json")+ self.send_header("Content-Length", str(len(body)))+ self.end_headers()+ self.wfile.write(body)++ @override+ def log_message(self, format: str, *args: object) -> None:+ pass++ server = HTTPServer(("127.0.0.1", 0), Handler)+ thread = Thread(target=server.serve_forever, kwargs={"poll_interval": 0.01}, daemon=True)+ previous_url = EnterpriseRequest.rbac_base_url+ EnterpriseRequest.rbac_base_url = f"http://127.0.0.1:{server.server_port}"+ thread.start()+ try:+ with config_overrides_context(RBAC_ENABLED=True):+ response = Context().run(harness.call, "GET", url=_LIST)+ finally:+ EnterpriseRequest.rbac_base_url = previous_url+ server.shutdown()+ server.server_close()+ thread.join(timeout=5)++ assert response.status_code == (HTTPStatus.BAD_REQUEST if allowed else HTTPStatus.FORBIDDEN)+ assert response.get_json()["code"] == ("account_not_initialized" if allowed else "forbidden")+ assert len(requests) == 1+ assert requests[0]["account_id"] == harness.account_id+ assert requests[0]["tenant_id"] == harness.tenant_id+ assert requests[0]["scene"] == "plugin_preferences"+ assert daemon.requests == []+++def test_subscriptions_require_login(harness: _Harness, daemon: _Daemon) -> None:+ response = harness.client.get(_LIST)++ assert response.status_code == HTTPStatus.UNAUTHORIZED+ assert response.get_json()["code"] == "unauthorized"+ assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'+ assert daemon.requests == []+++def test_subscriptions_require_workspace_membership(harness: _Harness, daemon: _Daemon) -> None:+ with harness.session_factory.begin() as session:+ session.execute(delete(TenantAccountJoin).where(TenantAccountJoin.account_id == harness.account_id))++ response = Context().run(harness.call, "GET", url=_LIST)++ assert response.status_code == HTTPStatus.UNAUTHORIZED+ assert response.get_json()["code"] == "unauthorized"+ assert daemon.requests == []+++def test_invalid_provider_preserves_not_found_response(harness: _Harness, daemon: _Daemon) -> None:+ response = harness.call("GET", url=_LIST.replace(_PROVIDER, "not/a/valid/provider"))++ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.get_json() == {"error": "Invalid plugin id not/a/valid/provider"}+ assert daemon.requests == []+++def test_plugin_failure_propagates_after_query_transaction_closes(harness: _Harness, daemon: _Daemon) -> None:+ _add_subscription(harness)+ daemon.status = HTTPStatus.SERVICE_UNAVAILABLE++ response = Context().run(harness.call, "GET", url=_LIST)++ assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR+ assert response.get_json()["status"] == HTTPStatus.INTERNAL_SERVER_ERROR+ assert len(daemon.requests) == 1+ assert not daemon.requests[0].open_transactionsdiff --git a/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py b/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.pyindex 53dc3759603..279deaa9dd4 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,6 +18,7 @@ from controllers.inner_api.wraps import InnerApiUnauthorizedErrorfrom core.plugin.impl.oauth import OAuthHandlerfrom extensions.application_services.workspace import WorkspaceServicesfrom libs.external_api import register_external_error_handlers+from repositories.credentials.query_repository import CredentialQueryRepositoryfrom repositories.trigger.oauth_client_repository import TriggerOAuthClientRepositoryfrom services.account_errors import AccountNotFoundErrorfrom services.errors.workspace import (@@ -33,6 +34,8 @@ from services.trigger.oauth_gateway import (TriggerOAuthBuilderGateway,)from services.trigger.oauth_service import TriggerOAuthService+from services.trigger.provider_gateway import PluginTriggerProviderQuery+from services.trigger.subscription_query_service import TriggerSubscriptionQueryServicefrom services.workspace.contracts import CreatedWorkspace, WorkspaceMembershipfrom services.workspace.provisioning_service import WorkspaceProvisioningServicefrom services.workspace.service import WorkspaceQueryService, WorkspaceService@@ -117,6 +120,11 @@ class TestWorkspaceCases:invitations=Mock(),identity=Mock(),resource_cleanup=Mock(),+ trigger_providers=PluginTriggerProviderQuery(),+ trigger_subscriptions=TriggerSubscriptionQueryService(+ credentials=CredentialQueryRepository(session_factory=sqlite_session_factory),+ schemas=PluginTriggerProviderQuery(),+ ),trigger_oauth_clients=oauth_clients,trigger_oauth=TriggerOAuthService(clients=oauth_clients,diff --git a/api/tests/unit_tests/extensions/test_ext_application_services.py b/api/tests/unit_tests/extensions/test_ext_application_services.pyindex 51c60a08f96..749de53bb7f 100644--- a/api/tests/unit_tests/extensions/test_ext_application_services.py+++ b/api/tests/unit_tests/extensions/test_ext_application_services.py@@ -1118,6 +1118,8 @@ def test_build_application_services_wires_credential_query(records = services.credential_queries.list_models(workspace_id=tenant_id, provider="openai", actor_id=actor_id)assert [(record.id, record.name) for record in records] == [(credential_id, "Team")]+ assert services.workspaces.trigger_subscriptions._credentials is services.credential_queries+ assert services.workspaces.trigger_subscriptions._schemas is services.workspaces.trigger_providersdef test_build_application_services_uses_supplied_redis_for_both_workflow_stop_signals(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 5366ace04b4..7c5b88637e6 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@@ -32,7 +32,6 @@ from models.trigger import (TriggerSubscription,WorkflowPluginTrigger,)-from repositories.credentials.query_repository import CredentialQueryRepositoryfrom services.plugin.dispatch_identity import PluginOAuthClientConfigfrom services.trigger import trigger_provider_service as service_modulefrom services.trigger.trigger_provider_service import TriggerProviderService@@ -164,90 +163,6 @@ def _patch_identity_encryption(mocker) -> Mock:return cache-def test_provider_manager_entities_are_forwarded(mocker, trigger_db: TriggerDatabase) -> None:- provider = Mock()- provider.to_api_entity.return_value = {"provider": "ok"}- _patch_provider(mocker, provider)- provider_b = Mock()- provider_b.to_api_entity.return_value = {"provider": "other"}- mocker.patch.object(- service_module.TriggerManager, "list_all_trigger_providers", return_value=[provider, provider_b]- )-- assert TriggerProviderService.get_trigger_provider(trigger_db.tenant_id, trigger_db.provider_id) == {- "provider": "ok"- }- assert TriggerProviderService.list_trigger_providers(trigger_db.tenant_id) == [- {"provider": "ok"},- {"provider": "other"},- ]---def test_list_subscriptions_empty_state(trigger_db: TriggerDatabase) -> None:- assert (- TriggerProviderService.list_trigger_provider_subscriptions(- trigger_db.tenant_id,- trigger_db.provider_id,- credential_query=CredentialQueryRepository(session_factory=trigger_db.session_maker),- )- == []- )---def test_list_subscriptions_masks_and_counts_distinct_apps(- mocker, trigger_db: TriggerDatabase, provider_controller: Mock-) -> None:- target = trigger_db.add_subscription(subscription_id=str(uuid4()))- trigger_db.add_subscription(tenant_id=trigger_db.other_tenant_id, name="foreign")- with trigger_db.session_maker.begin() as session:- session.add_all(- [- WorkflowPluginTrigger(- app_id=str(uuid4()),- node_id="node-1",- tenant_id=trigger_db.tenant_id,- provider_id=str(trigger_db.provider_id),- event_name="push",- subscription_id=target.id,- ),- WorkflowPluginTrigger(- app_id=str(uuid4()),- node_id="node-2",- tenant_id=trigger_db.tenant_id,- provider_id=str(trigger_db.provider_id),- event_name="push",- subscription_id=target.id,- ),- WorkflowPluginTrigger(- app_id=str(uuid4()),- node_id="foreign",- tenant_id=trigger_db.other_tenant_id,- provider_id=str(trigger_db.provider_id),- event_name="push",- subscription_id=target.id,- ),- ]- )- _patch_provider(mocker, provider_controller)- masked = _encrypter(masked={"secret": "****"})- mocker.patch.object(- service_module, "create_trigger_provider_encrypter_for_subscription", return_value=(masked, Mock())- )- mocker.patch.object(- service_module, "create_trigger_provider_encrypter_for_properties", return_value=(masked, Mock())- )-- subscriptions = TriggerProviderService.list_trigger_provider_subscriptions(- trigger_db.tenant_id,- trigger_db.provider_id,- credential_query=CredentialQueryRepository(session_factory=trigger_db.session_maker),- )-- assert [item.id for item in subscriptions] == [target.id]- assert subscriptions[0].credentials == {"secret": "****"}- assert subscriptions[0].workflows_in_use == 2--@pytest.mark.parametrize("credential_type", [CredentialType.API_KEY, CredentialType.UNAUTHORIZED])def test_add_subscription_commits_encrypted_state(mocker,