Skip to content

armgit / dify

Public Imported from GitHub
0

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

refactor(api): detach console app trigger management (#44457)

非法操作5fb3658c28fe
diff --git a/api/.importlinter b/api/.importlinter
index 5f9ab46613b..864f92cfac6 100644
--- a/api/.importlinter
+++ b/api/.importlinter
@@ -1149,6 +1149,35 @@ forbidden_modules =
# so only direct imports are checked here.
allow_indirect_imports = True
+[importlinter:contract:app-trigger-store-boundary]
+name = App trigger management contracts are framework and persistence neutral
+type = forbidden
+source_modules =
+ services.trigger.app_trigger_store
+forbidden_modules =
+ configs
+ controllers
+ extensions
+ flask
+ models
+ repositories
+ sqlalchemy
+ werkzeug
+
+[importlinter:contract:console-app-trigger-controller-boundary]
+name = Console app trigger controller reaches persistence only through the composition root
+type = forbidden
+source_modules =
+ controllers.console.app.workflow_trigger
+forbidden_modules =
+ extensions.ext_database
+ models.model
+ models.trigger
+ repositories
+ sqlalchemy
+# The composition root wires repositories, so only direct imports are checked here.
+allow_indirect_imports = True
+
[importlinter:contract:app-audio-boundary]
name = App audio operations and values are framework and persistence neutral
type = forbidden
diff --git a/api/controllers/console/app/error.py b/api/controllers/console/app/error.py
index 22e8bc7ed2a..04a3cedafc1 100644
--- a/api/controllers/console/app/error.py
+++ b/api/controllers/console/app/error.py
@@ -1,3 +1,5 @@
+from http import HTTPStatus
+
from libs.exception import BaseHTTPException
@@ -7,6 +9,18 @@ class AppNotFoundError(BaseHTTPException):
code = 404
+class AppTriggerNotFoundError(BaseHTTPException):
+ error_code = "app_trigger_not_found"
+ description = "Trigger not found."
+ code = HTTPStatus.NOT_FOUND
+
+
+class WebhookTriggerNotFoundError(BaseHTTPException):
+ error_code = "webhook_trigger_not_found"
+ description = "Webhook trigger not found for this node."
+ code = HTTPStatus.NOT_FOUND
+
+
class ProviderNotInitializeError(BaseHTTPException):
error_code = "provider_not_initialize"
description = (
diff --git a/api/controllers/console/app/workflow_trigger.py b/api/controllers/console/app/workflow_trigger.py
index ab684a6d8f0..45dc76ffcd8 100644
--- a/api/controllers/console/app/workflow_trigger.py
+++ b/api/controllers/console/app/workflow_trigger.py
@@ -1,35 +1,36 @@
-import logging
+from dataclasses import asdict
from datetime import datetime
+from http import HTTPStatus
+from uuid import UUID
from flask_restx import Resource
from pydantic import BaseModel, field_validator
-from sqlalchemy import select
-from sqlalchemy.orm import Session
-from werkzeug.exceptions import NotFound
from configs import dify_config
from controllers.common.rbac import PlainApp, RBACCheck
-from controllers.common.schema import query_params_from_model, register_schema_models
-from controllers.common.session import with_session
+from controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_models
from controllers.console import console_ns
-from controllers.console.app.wraps import get_app_model
-from controllers.console.wraps import (
- RBACPermission,
- account_initialization_required,
- edit_permission_required,
- model_validate,
- rbac_permission_required,
- setup_required,
- with_current_tenant_id,
-)
+from controllers.console.app.error import AppNotFoundError, AppTriggerNotFoundError, WebhookTriggerNotFoundError
+from controllers.console.flask_admission import console_account_admission
+from controllers.console.wraps import RBACPermission, model_validate
+from core.trigger.utils.endpoint import generate_webhook_trigger_endpoint
+from enums.account import TenantAccountRole
+from extensions.ext_application_services import application_services
from fields.base import ResponseModel
+from libs.external_api import error_responses
from libs.helper import dump_response
-from libs.login import login_required
-from models.enums import AppTriggerStatus
-from models.model import App, AppMode
-from models.trigger import AppTrigger, WorkflowWebhookTrigger
-
-logger = logging.getLogger(__name__)
+from machinery.context import RequestContext
+from models.enums import AppTriggerType
+from services.app.console_service import ConsoleAppNotFoundError
+from services.trigger.app_trigger_store import (
+ AppTriggerNotFoundError as AppTriggerMissing,
+)
+from services.trigger.app_trigger_store import (
+ AppTriggerRecord,
+)
+from services.trigger.app_trigger_store import (
+ WebhookTriggerNotFoundError as WebhookTriggerMissing,
+)
class WebhookTriggerQuery(BaseModel):
@@ -80,126 +81,86 @@ class WebhookTriggerResponse(ResponseModel):
return str(value)
-register_schema_models(
+register_schema_models(console_ns, WebhookTriggerQuery, ParserEnable)
+register_response_schema_models(
console_ns,
- WebhookTriggerQuery,
- ParserEnable,
WorkflowTriggerResponse,
WorkflowTriggerListResponse,
WebhookTriggerResponse,
)
+def _with_trigger_icon(trigger: AppTriggerRecord) -> dict[str, object]:
+ icon = ""
+ if trigger.trigger_type == AppTriggerType.TRIGGER_PLUGIN:
+ icon = (
+ dify_config.CONSOLE_API_URL
+ + "/console/api/workspaces/current/tool-provider/builtin/"
+ + (trigger.provider_name or "")
+ + "/icon"
+ )
+ return {**asdict(trigger), "icon": icon}
+
+
@console_ns.route("/apps/<uuid:app_id>/workflows/triggers/webhook")
class WebhookTriggerApi(Resource):
- """Webhook Trigger API"""
-
+ @error_responses(AppNotFoundError, WebhookTriggerNotFoundError)
@console_ns.doc(params=query_params_from_model(WebhookTriggerQuery))
- @setup_required
- @login_required
- @account_initialization_required
- @console_ns.response(200, "Success", console_ns.models[WebhookTriggerResponse.__name__])
- @rbac_permission_required(RBACCheck(RBACPermission.APP_VIEW_LAYOUT, PlainApp()))
- @with_session(write=False)
- @get_app_model(mode=AppMode.WORKFLOW)
+ @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[WebhookTriggerResponse.__name__])
+ @console_account_admission(rbac_checks=[RBACCheck(RBACPermission.APP_VIEW_LAYOUT, PlainApp())])
@model_validate(WebhookTriggerQuery)
- def get(self, req_data: WebhookTriggerQuery, session: Session, app_model: App):
+ def get(self, req_data: WebhookTriggerQuery, context: RequestContext, app_id: UUID) -> dict[str, object]:
"""Get webhook trigger for a node"""
-
- node_id = req_data.node_id
-
- # Get webhook trigger for this app and node
- webhook_trigger = session.scalar(
- select(WorkflowWebhookTrigger)
- .where(
- WorkflowWebhookTrigger.app_id == app_model.id,
- WorkflowWebhookTrigger.node_id == node_id,
- )
- .limit(1)
+ try:
+ webhook = application_services().apps.triggers.get_webhook(context, str(app_id), req_data.node_id)
+ except ConsoleAppNotFoundError as error:
+ raise AppNotFoundError(str(error)) from error
+ except WebhookTriggerMissing as error:
+ raise WebhookTriggerNotFoundError(str(error)) from error
+ return dump_response(
+ WebhookTriggerResponse,
+ {
+ **asdict(webhook),
+ "webhook_url": generate_webhook_trigger_endpoint(webhook.webhook_id),
+ "webhook_debug_url": generate_webhook_trigger_endpoint(webhook.webhook_id, debug=True),
+ },
)
- if not webhook_trigger:
- raise NotFound("Webhook trigger not found for this node")
-
- return dump_response(WebhookTriggerResponse, webhook_trigger)
-
@console_ns.route("/apps/<uuid:app_id>/triggers")
class AppTriggersApi(Resource):
- """App Triggers list API"""
-
- @setup_required
- @login_required
- @account_initialization_required
- @console_ns.response(200, "Success", console_ns.models[WorkflowTriggerListResponse.__name__])
- @with_current_tenant_id
- @rbac_permission_required(RBACCheck(RBACPermission.APP_VIEW_LAYOUT, PlainApp()))
- @with_session(write=False)
- @get_app_model(mode=AppMode.WORKFLOW)
- def get(self, session: Session, current_tenant_id: str, app_model: App):
+ @error_responses(AppNotFoundError)
+ @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[WorkflowTriggerListResponse.__name__])
+ @console_account_admission(rbac_checks=[RBACCheck(RBACPermission.APP_VIEW_LAYOUT, PlainApp())])
+ def get(self, context: RequestContext, app_id: UUID) -> dict[str, object]:
"""Get app triggers list"""
- # Get all triggers for this app using select API
- triggers = (
- session.execute(
- select(AppTrigger)
- .where(
- AppTrigger.tenant_id == current_tenant_id,
- AppTrigger.app_id == app_model.id,
- )
- .order_by(AppTrigger.created_at.desc(), AppTrigger.id.desc())
- )
- .scalars()
- .all()
+ try:
+ triggers = application_services().apps.triggers.list_triggers(context, str(app_id))
+ except ConsoleAppNotFoundError as error:
+ raise AppNotFoundError(str(error)) from error
+ return dump_response(
+ WorkflowTriggerListResponse, {"data": [_with_trigger_icon(trigger) for trigger in triggers]}
)
- # Add computed icon field for each trigger
- url_prefix = dify_config.CONSOLE_API_URL + "/console/api/workspaces/current/tool-provider/builtin/"
- for trigger in triggers:
- if trigger.trigger_type == "trigger-plugin":
- trigger.icon = url_prefix + trigger.provider_name + "/icon" # type: ignore
- else:
- trigger.icon = "" # type: ignore
-
- return dump_response(WorkflowTriggerListResponse, {"data": triggers})
-
@console_ns.route("/apps/<uuid:app_id>/trigger-enable")
class AppTriggerEnableApi(Resource):
+ @error_responses(AppNotFoundError, AppTriggerNotFoundError)
@console_ns.expect(console_ns.models[ParserEnable.__name__])
- @setup_required
- @login_required
- @account_initialization_required
- @edit_permission_required
- @rbac_permission_required(RBACCheck(RBACPermission.APP_EDIT, PlainApp()))
- @console_ns.response(200, "Success", console_ns.models[WorkflowTriggerResponse.__name__])
- @with_current_tenant_id
- @with_session
- @get_app_model(mode=AppMode.WORKFLOW)
+ @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[WorkflowTriggerResponse.__name__])
+ @console_account_admission(
+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR}),
+ rbac_checks=[RBACCheck(RBACPermission.APP_EDIT, PlainApp())],
+ )
@model_validate(ParserEnable)
- def post(self, req_data: ParserEnable, session: Session, current_tenant_id: str, app_model: App):
+ def post(self, req_data: ParserEnable, context: RequestContext, app_id: UUID) -> dict[str, object]:
"""Update app trigger (enable/disable)"""
-
- trigger_id = req_data.trigger_id
- # Find the trigger using select
- trigger = session.execute(
- select(AppTrigger).where(
- AppTrigger.id == trigger_id,
- AppTrigger.tenant_id == current_tenant_id,
- AppTrigger.app_id == app_model.id,
+ try:
+ trigger = application_services().apps.triggers.set_enabled(
+ context, str(app_id), req_data.trigger_id, enabled=req_data.enable_trigger
)
- ).scalar_one_or_none()
-
- if not trigger:
- raise NotFound("Trigger not found")
-
- # Update status based on enable_trigger boolean
- trigger.status = AppTriggerStatus.ENABLED if req_data.enable_trigger else AppTriggerStatus.DISABLED
-
- # Add computed icon field
- url_prefix = dify_config.CONSOLE_API_URL + "/console/api/workspaces/current/tool-provider/builtin/"
- if trigger.trigger_type == "trigger-plugin":
- trigger.icon = url_prefix + trigger.provider_name + "/icon" # type: ignore
- else:
- trigger.icon = "" # type: ignore
-
- return dump_response(WorkflowTriggerResponse, trigger)
+ except ConsoleAppNotFoundError as error:
+ raise AppNotFoundError(str(error)) from error
+ except AppTriggerMissing as error:
+ raise AppTriggerNotFoundError(str(error)) from error
+ return dump_response(WorkflowTriggerResponse, _with_trigger_icon(trigger))
diff --git a/api/extensions/application_services/app.py b/api/extensions/application_services/app.py
index 6eb6f2b5d9f..14f10db69a4 100644
--- a/api/extensions/application_services/app.py
+++ b/api/extensions/application_services/app.py
@@ -13,6 +13,7 @@ from repositories.app.dsl_import_repository import DslImportRepository
from repositories.app.enterprise_app_repository import EnterpriseAppRepository
from repositories.app.export_repository import AppExportRepository
from repositories.factory import DifyAPIRepositoryFactory
+from repositories.trigger.app_repository import SQLAlchemyAppTriggerRepository
from repositories.workspace.workspace_repository import WorkspaceRepository
from services.agent.roster_package_exporter import RosterAgentPackageExporter
from services.agent.roster_package_importer import RosterAgentPackageImporter
@@ -32,6 +33,7 @@ from services.app_tracing_config_service import AppTracingConfigService
from services.oauth_server_service import OAuthServerService
from services.rbac.members import MemberService
from services.recommended_app_package_service import RecommendedAppPackageService
+from services.trigger.app_trigger_store import AppTriggerStore
from services.workflow.dsl_import import DslImportService
@@ -43,6 +45,7 @@ class AppServices:
discovery: AppDiscoveryService
console: ConsoleAppService
enterprise: EnterpriseAppService
+ triggers: AppTriggerStore
def build_app_services(
@@ -90,6 +93,7 @@ def build_app_services(
workflow_runs=DifyAPIRepositoryFactory.create_api_workflow_run_repository(session_maker=database_client),
now=naive_utc_now,
),
+ triggers=SQLAlchemyAppTriggerRepository(session_factory=database_client),
)
diff --git a/api/openapi/markdown/console-openapi.md b/api/openapi/markdown/console-openapi.md
index 09c87762c2c..056bcc3922a 100644
--- a/api/openapi/markdown/console-openapi.md
+++ b/api/openapi/markdown/console-openapi.md
@@ -3977,7 +3977,7 @@ Create a new tracing configuration for an application
| Code | Description | Schema |
| ---- | ----------- | ------ |
| 200 | Success | **application/json**: [WorkflowTriggerResponse](#workflowtriggerresponse)<br> |
-| 404 | Not Found | **application/json**: [AppNotFoundError](#appnotfounderror)<br>[ErrorResponse](#errorresponse)<br> |
+| 404 | Not Found | **application/json**: [AppNotFoundError](#appnotfounderror)<br>[AppTriggerNotFoundError](#apptriggernotfounderror)<br>[ErrorResponse](#errorresponse)<br> |
| default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |
### [GET] /apps/{app_id}/triggers
@@ -5518,7 +5518,7 @@ Full value for one declared output of a published run.
| Code | Description | Schema |
| ---- | ----------- | ------ |
| 200 | Success | **application/json**: [WebhookTriggerResponse](#webhooktriggerresponse)<br> |
-| 404 | Not Found | **application/json**: [AppNotFoundError](#appnotfounderror)<br>[ErrorResponse](#errorresponse)<br> |
+| 404 | Not Found | **application/json**: [AppNotFoundError](#appnotfounderror)<br>[WebhookTriggerNotFoundError](#webhooktriggernotfounderror)<br>[ErrorResponse](#errorresponse)<br> |
| default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |
### [DELETE] /apps/{app_id}/workflows/{workflow_id}
@@ -19159,6 +19159,14 @@ Function Suggested questions after answer disabled.
| enabled | boolean | | No |
| tracing_provider | string | | No |
+#### AppTriggerNotFoundError
+
+Trigger not found.
+
+| Name | Type | Description | Required |
+| ---- | ---- | ----------- | -------- |
+| AppTriggerNotFoundError | | Trigger not found. | |
+
#### AppUnavailableError
App unavailable, please check your app configurations.
@@ -28890,6 +28898,14 @@ The app access service is unavailable. Try again later.
| ---- | ---- | ----------- | -------- |
| protocol | [SSOProtocol](#ssoprotocol) | | Yes |
+#### WebhookTriggerNotFoundError
+
+Webhook trigger not found for this node.
+
+| Name | Type | Description | Required |
+| ---- | ---- | ----------- | -------- |
+| WebhookTriggerNotFoundError | | Webhook trigger not found for this node. | |
+
#### WebhookTriggerQuery
| Name | Type | Description | Required |
diff --git a/api/repositories/trigger/__init__.py b/api/repositories/trigger/__init__.py
new file mode 100644
index 00000000000..8b137891791
--- /dev/null
+++ b/api/repositories/trigger/__init__.py
@@ -0,0 +1 @@
+
diff --git a/api/repositories/trigger/app_repository.py b/api/repositories/trigger/app_repository.py
new file mode 100644
index 00000000000..70872c57e41
--- /dev/null
+++ b/api/repositories/trigger/app_repository.py
@@ -0,0 +1,92 @@
+"""App trigger management with workspace-scoped, bounded database transactions."""
+
+from typing import override
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session, sessionmaker
+
+from machinery.context import RequestContext
+from models.enums import AppTriggerStatus
+from models.model import AppMode
+from models.trigger import AppTrigger, WorkflowWebhookTrigger
+from repositories.app.console_repository import require_console_app
+from services.app.console_service import ConsoleAppNotFoundError
+from services.trigger.app_trigger_store import (
+ AppTriggerNotFoundError,
+ AppTriggerRecord,
+ AppTriggerStore,
+ WebhookTriggerNotFoundError,
+ WebhookTriggerRecord,
+)
+
+
+def _require_workflow_app(session: Session, context: RequestContext, app_id: str) -> None:
+ app = require_console_app(session, context, app_id)
+ if app.mode != AppMode.WORKFLOW:
+ raise ConsoleAppNotFoundError(f"App mode is not in the supported list: {{{AppMode.WORKFLOW.value!r}}}")
+
+
+def _trigger_record(trigger: AppTrigger) -> AppTriggerRecord:
+ return AppTriggerRecord(
+ id=trigger.id,
+ trigger_type=trigger.trigger_type,
+ title=trigger.title,
+ node_id=trigger.node_id,
+ provider_name=trigger.provider_name,
+ status=trigger.status,
+ created_at=trigger.created_at,
+ updated_at=trigger.updated_at,
+ )
+
+
+class SQLAlchemyAppTriggerRepository(AppTriggerStore):
+ def __init__(self, *, session_factory: sessionmaker[Session]) -> None:
+ self._session_factory = session_factory
+
+ @override
+ def get_webhook(self, context: RequestContext, app_id: str, node_id: str) -> WebhookTriggerRecord:
+ with self._session_factory() as session:
+ _require_workflow_app(session, context, app_id)
+ webhook = session.scalar(
+ select(WorkflowWebhookTrigger).where(
+ WorkflowWebhookTrigger.tenant_id == context.active_workspace_id,
+ WorkflowWebhookTrigger.app_id == app_id,
+ WorkflowWebhookTrigger.node_id == node_id,
+ )
+ )
+ if webhook is None:
+ raise WebhookTriggerNotFoundError("Webhook trigger not found for this node")
+ return WebhookTriggerRecord(
+ id=webhook.id,
+ webhook_id=webhook.webhook_id,
+ node_id=webhook.node_id,
+ created_at=webhook.created_at,
+ )
+
+ @override
+ def list_triggers(self, context: RequestContext, app_id: str) -> tuple[AppTriggerRecord, ...]:
+ with self._session_factory() as session:
+ _require_workflow_app(session, context, app_id)
+ triggers = session.scalars(
+ select(AppTrigger)
+ .where(AppTrigger.tenant_id == context.active_workspace_id, AppTrigger.app_id == app_id)
+ .order_by(AppTrigger.created_at.desc(), AppTrigger.id.desc())
+ )
+ return tuple(_trigger_record(trigger) for trigger in triggers)
+
+ @override
+ def set_enabled(self, context: RequestContext, app_id: str, trigger_id: str, *, enabled: bool) -> AppTriggerRecord:
+ with self._session_factory.begin() as session:
+ _require_workflow_app(session, context, app_id)
+ trigger = session.scalar(
+ select(AppTrigger).where(
+ AppTrigger.id == trigger_id,
+ AppTrigger.tenant_id == context.active_workspace_id,
+ AppTrigger.app_id == app_id,
+ )
+ )
+ if trigger is None:
+ raise AppTriggerNotFoundError("Trigger not found")
+ trigger.status = AppTriggerStatus.ENABLED if enabled else AppTriggerStatus.DISABLED
+ session.flush()
+ return _trigger_record(trigger)
diff --git a/api/services/trigger/__init__.py b/api/services/trigger/__init__.py
new file mode 100644
index 00000000000..8b137891791
--- /dev/null
+++ b/api/services/trigger/__init__.py
@@ -0,0 +1 @@
+
diff --git a/api/services/trigger/app_trigger_store.py b/api/services/trigger/app_trigger_store.py
new file mode 100644
index 00000000000..3d13994fdd6
--- /dev/null
+++ b/api/services/trigger/app_trigger_store.py
@@ -0,0 +1,47 @@
+"""Detached records and persistence contract for Console app trigger management."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Protocol
+
+from machinery.context import RequestContext
+
+
+class WebhookTriggerNotFoundError(Exception):
+ """The requested node has no webhook in the admitted app and workspace."""
+
+
+class AppTriggerNotFoundError(Exception):
+ """The trigger does not belong to the admitted app and workspace."""
+
+
+@dataclass(frozen=True, slots=True)
+class AppTriggerRecord:
+ """Persisted values; None preserves a missing legacy node or provider name."""
+
+ id: str
+ trigger_type: str
+ title: str
+ node_id: str | None
+ provider_name: str | None
+ status: str
+ created_at: datetime
+ updated_at: datetime
+
+
+@dataclass(frozen=True, slots=True)
+class WebhookTriggerRecord:
+ id: str
+ webhook_id: str
+ node_id: str
+ created_at: datetime
+
+
+class AppTriggerStore(Protocol):
+ def get_webhook(self, context: RequestContext, app_id: str, node_id: str) -> WebhookTriggerRecord: ...
+
+ def list_triggers(self, context: RequestContext, app_id: str) -> tuple[AppTriggerRecord, ...]: ...
+
+ def set_enabled(
+ self, context: RequestContext, app_id: str, trigger_id: str, *, enabled: bool
+ ) -> AppTriggerRecord: ...
diff --git a/api/tests/unit_tests/controllers/console/app/test_app_apis.py b/api/tests/unit_tests/controllers/console/app/test_app_apis.py
index bdbd6282f7c..b68a3fb717d 100644
--- a/api/tests/unit_tests/controllers/console/app/test_app_apis.py
+++ b/api/tests/unit_tests/controllers/console/app/test_app_apis.py
@@ -45,9 +45,6 @@ from controllers.console.app import (
from controllers.console.app import (
workflow_statistic as workflow_statistic_module,
)
-from controllers.console.app import (
- workflow_trigger as workflow_trigger_module,
-)
from controllers.console.app import (
wraps as wraps_module,
)
@@ -68,12 +65,10 @@ from controllers.console.app.workflow_draft_variable import (
WorkflowDraftVariableUpdatePayload,
)
from controllers.console.app.workflow_statistic import WorkflowStatisticQuery
-from controllers.console.app.workflow_trigger import ParserEnable, WebhookTriggerQuery
from machinery.context import RequestContext
from models import App, Site
from models.account import Account, AccountStatus
from models.engine import db
-from models.trigger import WorkflowWebhookTrigger
from services.app_site_service import (
AppSiteAppNotFoundError,
AppSiteChanges,
@@ -130,7 +125,6 @@ def database_app() -> Iterator[Flask]:
with app.app_context():
Site.__table__.create(db.engine)
- WorkflowWebhookTrigger.__table__.create(db.engine)
yield app
@@ -782,39 +776,6 @@ class TestWorkflowStatisticEndpoints:
)
-class TestWorkflowTriggerEndpoints:
- def test_webhook_trigger_payload(self):
- payload = WebhookTriggerQuery(node_id="node-1")
- assert payload.node_id == "node-1"
-
- enable_payload = ParserEnable(trigger_id="trigger-1", enable_trigger=True)
- assert enable_payload.enable_trigger is True
-
- def test_webhook_trigger_api_get(
- self,
- database_app: Flask,
- sqlite_session: Session,
- ) -> None:
- api = workflow_trigger_module.WebhookTriggerApi()
- method = unwrap(api.get)
- trigger = WorkflowWebhookTrigger(
- app_id=APP_ID,
- node_id="node-1",
- tenant_id=TENANT_ID,
- webhook_id="webhook-1",
- created_by=USER_ID,
- )
- sqlite_session.add(trigger)
- sqlite_session.commit()
-
- with database_app.test_request_context("/?node_id=node-1"):
- result = method(api, WebhookTriggerQuery(node_id="node-1"), sqlite_session, app_model=_make_app())
-
- assert isinstance(result, dict)
- assert {"id", "webhook_id", "webhook_url", "webhook_debug_url", "node_id", "created_at"} <= set(result.keys())
- assert result["webhook_id"] == "webhook-1"
-
-
class TestWrapsEndpoints:
def test_get_app_model_context(self):
assert hasattr(wraps_module, "get_app_model")
diff --git a/api/tests/unit_tests/controllers/console/app/test_workflow_trigger_api.py b/api/tests/unit_tests/controllers/console/app/test_workflow_trigger_api.py
index 1d931b0be53..6a26681f11a 100644
--- a/api/tests/unit_tests/controllers/console/app/test_workflow_trigger_api.py
+++ b/api/tests/unit_tests/controllers/console/app/test_workflow_trigger_api.py
@@ -1,145 +1,459 @@
-from __future__ import annotations
+"""Workflow trigger routes use real admission, composition, and SQLite transactions."""
-import inspect
-import uuid
-from datetime import UTC, datetime
-from unittest.mock import PropertyMock, patch
+from collections.abc import Iterator
+from dataclasses import dataclass
+from datetime import datetime
+from http import HTTPStatus
+from uuid import uuid4
-from flask import Flask
-from sqlalchemy.orm import Session
+import pytest
+from flask import Blueprint, Flask, Response
+from flask.testing import FlaskClient
+from flask_restx import Resource
+from redis import Redis
+from sqlalchemy import Connection, Engine, event, select, text
+from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
+from werkzeug.test import TestResponse
-from controllers.console import console_ns
-from controllers.console.app import workflow_trigger as workflow_trigger_module
+from constants import HEADER_NAME_CSRF_TOKEN
+from controllers.console.app import workflow_trigger
+from controllers.console.wraps import _is_setup_completed
+from core.trigger.utils.endpoint import base_url
+from enums import DeploymentEdition
+from extensions.ext_application_services import build_application_services
+from extensions.ext_login import DifyLoginManager, bind_account_loader, load_user_from_request, unauthorized_handler
+from extensions.ext_redis import RedisClientWrapper
+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.agent import Agent, AgentScope, AgentSource
+from models.engine import db
from models.enums import AppTriggerStatus, AppTriggerType
-from models.model import App, AppMode, IconType
-from models.trigger import AppTrigger
-
-
-def _persist_app_trigger(
- session: Session,
- *,
- tenant_id: str | None = None,
- status: AppTriggerStatus = AppTriggerStatus.ENABLED,
-) -> tuple[App, AppTrigger]:
- tenant_id = tenant_id or str(uuid.uuid4())
- app_model = App(
- id=str(uuid.uuid4()),
- tenant_id=tenant_id,
- name="Workflow App",
- mode=AppMode.WORKFLOW,
- icon_type=IconType.EMOJI,
- icon="workflow",
- icon_background="#FFFFFF",
- enable_site=False,
- enable_api=True,
- )
- trigger = AppTrigger(
- tenant_id=tenant_id,
- app_id=app_model.id,
- node_id="node-1",
- trigger_type=AppTriggerType.TRIGGER_PLUGIN,
- title="Trigger",
- provider_name="provider",
- status=status,
- )
- session.add_all([app_model, trigger])
- session.commit()
- return app_model, trigger
+from models.model import App, AppMode
+from models.trigger import AppTrigger, WorkflowWebhookTrigger
+from tests.unit_tests.config_override import config_overrides_context
+_CREATED_AT = datetime(2026, 1, 2, 3, 4, 5)
-def test_parser_models_validate():
- parser = workflow_trigger_module.WebhookTriggerQuery(node_id="node-1")
- enable_parser = workflow_trigger_module.ParserEnable(
- trigger_id="550e8400-e29b-41d4-a716-446655440000", enable_trigger=True
- )
- assert parser.node_id == "node-1"
- assert enable_parser.enable_trigger is True
-
-
-def test_workflow_trigger_response_serializes_datetime():
- created_at = datetime(2026, 1, 2, 3, 4, 5, tzinfo=UTC)
- response = workflow_trigger_module.WorkflowTriggerResponse(
- id=str(uuid.uuid4()),
- trigger_type=AppTriggerType.TRIGGER_PLUGIN,
- title="Trigger",
- node_id="node-1",
- provider_name="provider",
- icon="https://example.com/icon",
- status=AppTriggerStatus.ENABLED,
- created_at=created_at,
- updated_at=created_at,
- )
+@dataclass(frozen=True)
+class _Endpoint:
+ method: str
+ path: str
+ resource: type[Resource]
- payload = response.model_dump(mode="json")
- assert payload["id"] == response.id
- assert payload["created_at"] == "2026-01-02T03:04:05Z"
- assert payload["updated_at"] == "2026-01-02T03:04:05Z"
+_ENDPOINTS = (
+ _Endpoint("GET", "workflows/triggers/webhook", workflow_trigger.WebhookTriggerApi),
+ _Endpoint("GET", "triggers", workflow_trigger.AppTriggersApi),
+ _Endpoint("POST", "trigger-enable", workflow_trigger.AppTriggerEnableApi),
+)
-def test_webhook_trigger_response_serializes_datetime():
- created_at = datetime(2026, 1, 2, 3, 4, 5, tzinfo=UTC)
- webhook = {
- "id": "webhook-1",
- "webhook_id": "whk-1",
- "webhook_url": "https://example.com/hook",
- "webhook_debug_url": "https://example.com/hook/debug",
- "node_id": "node-1",
- "created_at": created_at,
- }
- payload = workflow_trigger_module.WebhookTriggerResponse.model_validate(webhook).model_dump(mode="json")
- assert payload["webhook_id"] == "whk-1"
- assert payload["created_at"] == "2026-01-02T03:04:05Z"
-
-
-def test_app_triggers_get_uses_injected_tenant_id(app: Flask, sqlite_session: Session) -> None:
- app_model, trigger = _persist_app_trigger(sqlite_session)
- other_tenant_trigger = AppTrigger(
- tenant_id=str(uuid.uuid4()),
- app_id=app_model.id,
- node_id="node-1",
- trigger_type=AppTriggerType.TRIGGER_PLUGIN,
- title="Other Tenant Trigger",
- provider_name="provider",
- status=AppTriggerStatus.ENABLED,
- )
- sqlite_session.add(other_tenant_trigger)
- sqlite_session.commit()
+@dataclass(frozen=True)
+class _Harness:
+ client: FlaskClient
+ session_factory: sessionmaker[Session]
+ account_id: str
+ tenant_id: str
+ headers: dict[str, str]
+ sessions: list[Session]
- api = workflow_trigger_module.AppTriggersApi()
- method = inspect.unwrap(api.get)
+ def create_app(self, *, tenant_id: str | None = None, mode: AppMode = AppMode.WORKFLOW) -> str:
+ with self.session_factory.begin() as session:
+ app = App(
+ tenant_id=tenant_id or self.tenant_id,
+ name="Trigger app",
+ mode=mode,
+ created_by=self.account_id,
+ maintainer=self.account_id,
+ enable_api=True,
+ enable_site=True,
+ )
+ session.add(app)
+ session.flush()
+ return app.id
- with app.test_request_context("/"):
- response = method(api, sqlite_session, app_model.tenant_id, app_model)
+ def create_trigger(
+ self,
+ app_id: str,
+ *,
+ tenant_id: str | None = None,
+ trigger_type: AppTriggerType = AppTriggerType.TRIGGER_PLUGIN,
+ status: AppTriggerStatus = AppTriggerStatus.ENABLED,
+ created_at: datetime = _CREATED_AT,
+ ) -> str:
+ with self.session_factory.begin() as session:
+ trigger = AppTrigger(
+ tenant_id=tenant_id or self.tenant_id,
+ app_id=app_id,
+ node_id="node-1",
+ trigger_type=trigger_type,
+ title="Trigger",
+ provider_name="langgenius/github/github",
+ status=status,
+ )
+ trigger.created_at = created_at
+ trigger.updated_at = created_at
+ session.add(trigger)
+ session.flush()
+ return trigger.id
- assert [item["id"] for item in response["data"]] == [trigger.id]
- assert response["data"][0]["icon"].endswith("/provider/icon")
+ def create_webhook(self, app_id: str, *, tenant_id: str | None = None, node_id: str = "node-1") -> str:
+ with self.session_factory.begin() as session:
+ webhook = WorkflowWebhookTrigger(
+ app_id=app_id,
+ tenant_id=tenant_id or self.tenant_id,
+ node_id=node_id,
+ webhook_id=str(uuid4())[:24],
+ created_by=self.account_id,
+ )
+ webhook.created_at = _CREATED_AT
+ session.add(webhook)
+ session.flush()
+ return webhook.id
+ 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 test_app_trigger_enable_uses_injected_tenant_id(app: Flask, sqlite_session: Session) -> None:
- app_model, trigger = _persist_app_trigger(sqlite_session, status=AppTriggerStatus.DISABLED)
- payload = {"trigger_id": trigger.id, "enable_trigger": True}
+ def call(self, endpoint: _Endpoint, app_id: str) -> TestResponse:
+ self.sessions.clear()
+ if endpoint.method == "POST":
+ return self.client.post(
+ f"/console/api/apps/{app_id}/{endpoint.path}",
+ headers=self.headers,
+ json={"trigger_id": str(uuid4()), "enable_trigger": True},
+ )
+ return self.client.get(
+ f"/console/api/apps/{app_id}/{endpoint.path}", headers=self.headers, query_string={"node_id": "node-1"}
+ )
- api = workflow_trigger_module.AppTriggerEnableApi()
- method = inspect.unwrap(api.post)
+ def enable(self, app_id: str, payload: dict[str, object]) -> TestResponse:
+ self.sessions.clear()
+ return self.client.post(f"/console/api/apps/{app_id}/trigger-enable", headers=self.headers, json=payload)
+
+def harness(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]) -> Iterator[_Harness]:
with (
- app.test_request_context("/", json=payload),
- patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value=payload),
+ Redis() as redis_client,
+ config_overrides_context(
+ DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY,
+ RBAC_ENABLED=False,
+ LOGIN_DISABLED=False,
+ INIT_PASSWORD="",
+ SECRET_KEY="trigger-http-test-secret-at-least-32-bytes",
+ CONSOLE_API_URL="https://console.example.test",
+ ),
):
- response = method(
- api,
- workflow_trigger_module.ParserEnable(trigger_id=trigger.id, enable_trigger=True),
- sqlite_session,
- app_model.tenant_id,
- app_model,
+ app = Flask(__name__)
+ app.config.update(TESTING=True, SQLALCHEMY_DATABASE_URI=str(sqlite_engine.url))
+ db.init_app(app)
+ redis = RedisClientWrapper()
+ redis.initialize(redis_client)
+ services = build_application_services(
+ database_client=sqlite_session_factory,
+ deployment_edition=DeploymentEdition.COMMUNITY,
+ initialization_password="",
+ redis=redis,
)
+ 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)
+ for endpoint in _ENDPOINTS:
+ api.add_resource(endpoint.resource, f"/apps/<uuid:app_id>/{endpoint.path}")
+ app.register_blueprint(blueprint)
+
+ now = naive_utc_now()
+ with sqlite_session_factory.begin() as session:
+ account = Account(
+ name="Trigger editor",
+ status=AccountStatus.ACTIVE,
+ initialized_at=now,
+ )
+ account.last_active_at = now
+ tenant = Tenant(name="Trigger workspace")
+ session.add_all([account, tenant, DifySetup(version="test")])
+ session.flush()
+ session.add(
+ TenantAccountJoin(
+ tenant_id=tenant.id,
+ account_id=account.id,
+ role=TenantAccountRole.OWNER,
+ current=True,
+ )
+ )
+ account_id, tenant_id = account.id, tenant.id
+
+ # The legacy setup cache has a separate scoped session. Warm and remove
+ # it before observing the transaction boundaries of each actual request.
+ 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,
+ }
+ sessions: list[Session] = []
+
+ def observe_session(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
+ sessions.append(session)
+
+ @app.after_request
+ def assert_request_sessions_closed(response: Response) -> Response:
+ assert all(not session.in_transaction() and not session.identity_map for session in sessions)
+ return response
+
+ event.listen(Session, "after_begin", observe_session)
+ try:
+ yield _Harness(client, sqlite_session_factory, account_id, tenant_id, headers, sessions)
+ finally:
+ event.remove(Session, "after_begin", observe_session)
+ _is_setup_completed.reset_success()
+ with app.app_context():
+ db.session.remove()
+ db.engine.dispose()
+
+
[email protected]("endpoint", _ENDPOINTS, ids=lambda endpoint: endpoint.path)
[email protected]("visibility", ["missing", "different-workspace", "non-normal", "workflow-only", "wrong-mode"])
+def test_triggers_reject_inaccessible_apps(harness: _Harness, endpoint: _Endpoint, visibility: str) -> None:
+ app_id = str(uuid4())
+ if visibility != "missing":
+ app_id = harness.create_app(tenant_id=str(uuid4()) if visibility == "different-workspace" else None)
+ with harness.session_factory.begin() as session:
+ app = session.get(App, app_id)
+ assert app is not None
+ if visibility == "non-normal":
+ session.execute(text("UPDATE apps SET status = 'archived' WHERE id = :app_id"), {"app_id": app_id})
+ elif visibility == "wrong-mode":
+ app.mode = AppMode.CHAT
+ elif visibility == "workflow-only":
+ app.mode = AppMode.AGENT
+ session.add(
+ Agent(
+ tenant_id=harness.tenant_id,
+ name="Hidden workflow agent",
+ scope=AgentScope.WORKFLOW_ONLY,
+ source=AgentSource.WORKFLOW,
+ app_id=str(uuid4()),
+ backing_app_id=app_id,
+ )
+ )
+
+ response = harness.call(endpoint, app_id)
+
+ assert response.status_code == HTTPStatus.NOT_FOUND
+ assert response.get_json()["code"] == "app_not_found"
+ assert response.content_type == "application/json"
+ assert harness.sessions
+
+
+def test_list_empty_triggers(harness: _Harness) -> None:
+ response = harness.call(_ENDPOINTS[1], harness.create_app())
+
+ assert response.status_code == HTTPStatus.OK
+ assert response.get_json() == {"data": []}
+
+
+def test_list_orders_and_serializes_triggers_without_leaking_other_owners(harness: _Harness) -> None:
+ app_id = harness.create_app()
+ older = harness.create_trigger(app_id, created_at=datetime(2025, 1, 1))
+ same_time = [
+ harness.create_trigger(app_id, trigger_type=trigger_type, status=status)
+ for trigger_type, status in zip(AppTriggerType, AppTriggerStatus, strict=True)
+ ]
+ expected_statuses = dict(zip(same_time, AppTriggerStatus, strict=True))
+ expected_statuses[older] = AppTriggerStatus.ENABLED
+ harness.create_trigger(app_id, tenant_id=str(uuid4()))
+ harness.create_trigger(harness.create_app())
+
+ response = harness.call(_ENDPOINTS[1], app_id)
+
+ assert response.status_code == HTTPStatus.OK
+ data = response.get_json()["data"]
+ assert [item["id"] for item in data] == sorted(same_time, reverse=True) + [older]
+ for item in data:
+ assert set(item) == {
+ "id",
+ "trigger_type",
+ "title",
+ "node_id",
+ "provider_name",
+ "icon",
+ "status",
+ "created_at",
+ "updated_at",
+ }
+ assert item["title"] == "Trigger"
+ assert item["node_id"] == "node-1"
+ assert item["provider_name"] == "langgenius/github/github"
+ assert item["status"] == expected_statuses[item["id"]].value
+ if item["trigger_type"] == AppTriggerType.TRIGGER_PLUGIN:
+ assert item["icon"] == (
+ "https://console.example.test/console/api/workspaces/current/tool-provider/builtin/"
+ "langgenius/github/github/icon"
+ )
+ else:
+ assert item["icon"] == ""
+ if item["id"] in same_time:
+ assert item["created_at"] == "2026-01-02T03:04:05"
+ assert item["updated_at"] == "2026-01-02T03:04:05"
+
+
[email protected]("role", [TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR])
+def test_editor_roles_can_disable_and_enable_with_committed_status(harness: _Harness, role: TenantAccountRole) -> None:
+ harness.set_role(role)
+ app_id = harness.create_app()
+ trigger_id = harness.create_trigger(app_id)
+
+ for enabled, expected in [(False, AppTriggerStatus.DISABLED), (True, AppTriggerStatus.ENABLED)]:
+ response = harness.enable(app_id, {"trigger_id": trigger_id, "enable_trigger": enabled})
+
+ assert response.status_code == HTTPStatus.OK
+ body = response.get_json()
+ assert body["id"] == trigger_id
+ assert body["status"] == expected.value
+ assert body["icon"].endswith("/langgenius/github/github/icon")
+ with harness.session_factory() as session:
+ persisted = session.get(AppTrigger, trigger_id)
+ assert persisted is not None
+ assert persisted.status == expected
+
+
[email protected]("role", [TenantAccountRole.NORMAL, TenantAccountRole.DATASET_OPERATOR])
+def test_read_only_roles_cannot_update_trigger(harness: _Harness, role: TenantAccountRole) -> None:
+ harness.set_role(role)
+ app_id = harness.create_app()
+ trigger_id = harness.create_trigger(app_id)
+
+ response = harness.enable(app_id, {"trigger_id": trigger_id, "enable_trigger": False})
+
+ assert response.status_code == HTTPStatus.FORBIDDEN
+ with harness.session_factory() as session:
+ persisted = session.get(AppTrigger, trigger_id)
+ assert persisted is not None
+ assert persisted.status == AppTriggerStatus.ENABLED
+ assert harness.call(_ENDPOINTS[1], app_id).status_code == HTTPStatus.OK
+
+
[email protected]("missing_field", ["trigger_id", "enable_trigger"])
+def test_invalid_update_payload_does_not_write(harness: _Harness, missing_field: str) -> None:
+ app_id = harness.create_app()
+ trigger_id = harness.create_trigger(app_id)
+ payload: dict[str, object] = {"trigger_id": trigger_id, "enable_trigger": False}
+ del payload[missing_field]
+
+ response = harness.enable(app_id, payload)
+
+ assert response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY
+ with harness.session_factory() as session:
+ persisted = session.get(AppTrigger, trigger_id)
+ assert persisted is not None
+ assert persisted.status == AppTriggerStatus.ENABLED
+
+
[email protected]("target", ["missing", "other-app", "other-tenant"])
+def test_update_rejects_trigger_outside_requested_owner_chain(harness: _Harness, target: str) -> None:
+ app_id = harness.create_app()
+ trigger_id = str(uuid4())
+ if target == "other-app":
+ trigger_id = harness.create_trigger(harness.create_app())
+ elif target == "other-tenant":
+ trigger_id = harness.create_trigger(app_id, tenant_id=str(uuid4()))
+
+ response = harness.enable(app_id, {"trigger_id": trigger_id, "enable_trigger": False})
+
+ assert response.status_code == HTTPStatus.NOT_FOUND
+ assert response.get_json()["code"] == "app_trigger_not_found"
+ if target != "missing":
+ with harness.session_factory() as session:
+ persisted = session.get(AppTrigger, trigger_id)
+ assert persisted is not None
+ assert persisted.status == AppTriggerStatus.ENABLED
+
+
+def test_webhook_returns_detached_configuration_and_urls(harness: _Harness) -> None:
+ app_id = harness.create_app()
+ webhook_id = harness.create_webhook(app_id)
+ with harness.session_factory() as session:
+ webhook = session.get(WorkflowWebhookTrigger, webhook_id)
+ assert webhook is not None
+ external_id = webhook.webhook_id
+
+ response = harness.call(_ENDPOINTS[0], app_id)
+
+ assert response.status_code == HTTPStatus.OK
+ assert response.get_json() == {
+ "id": webhook_id,
+ "webhook_id": external_id,
+ "node_id": "node-1",
+ "webhook_url": f"{str(base_url).rstrip('/')}/triggers/webhook/{external_id}",
+ "webhook_debug_url": f"{str(base_url).rstrip('/')}/triggers/webhook-debug/{external_id}",
+ "created_at": "2026-01-02T03:04:05",
+ }
+
+
[email protected]("target", ["missing", "other-app", "other-tenant", "other-node"])
+def test_webhook_rejects_references_outside_requested_owner_chain(harness: _Harness, target: str) -> None:
+ app_id = harness.create_app()
+ if target == "other-app":
+ harness.create_webhook(harness.create_app())
+ elif target == "other-tenant":
+ harness.create_webhook(app_id, tenant_id=str(uuid4()))
+ elif target == "other-node":
+ harness.create_webhook(app_id, node_id="node-2")
+
+ response = harness.call(_ENDPOINTS[0], app_id)
+
+ assert response.status_code == HTTPStatus.NOT_FOUND
+ assert response.get_json()["code"] == "webhook_trigger_not_found"
+
+
+def test_app_owner_with_rbac_enabled_uses_real_owner_admission(harness: _Harness) -> None:
+ harness.set_role(TenantAccountRole.NORMAL)
+ app_id = harness.create_app()
+ trigger_id = harness.create_trigger(app_id)
+
+ with config_overrides_context(RBAC_ENABLED=True):
+ response = harness.enable(app_id, {"trigger_id": trigger_id, "enable_trigger": False})
+
+ assert response.status_code == HTTPStatus.OK
+ assert response.get_json()["status"] == AppTriggerStatus.DISABLED
+
+
+def test_update_requires_csrf_before_persistence(harness: _Harness) -> None:
+ app_id = harness.create_app()
+ trigger_id = harness.create_trigger(app_id)
+ harness.sessions.clear()
+
+ response = harness.client.post(
+ f"/console/api/apps/{app_id}/trigger-enable",
+ headers={"Authorization": harness.headers["Authorization"]},
+ json={"trigger_id": trigger_id, "enable_trigger": False},
+ )
- assert response["id"] == trigger.id
- assert response["status"] == "enabled"
- sqlite_session.flush()
- sqlite_session.expire_all()
- persisted_trigger = sqlite_session.get(AppTrigger, trigger.id)
- assert persisted_trigger is not None
- assert persisted_trigger.status == AppTriggerStatus.ENABLED
+ assert response.status_code == HTTPStatus.UNAUTHORIZED
+ with harness.session_factory() as session:
+ persisted = session.get(AppTrigger, trigger_id)
+ assert persisted is not None
+ assert persisted.status == AppTriggerStatus.ENABLED
diff --git a/api/tests/unit_tests/pyrefly.toml b/api/tests/unit_tests/pyrefly.toml
index 65bcafc864a..7f255a647c4 100644
--- a/api/tests/unit_tests/pyrefly.toml
+++ b/api/tests/unit_tests/pyrefly.toml
@@ -42,7 +42,6 @@ project-excludes = [
"controllers/console/app/test_workflow_node_output_inspector.py",
"controllers/console/app/test_workflow_pause_details_api.py",
"controllers/console/app/test_workflow_run_api.py",
- "controllers/console/app/test_workflow_trigger_api.py",
"controllers/console/app/test_wraps.py",
"controllers/console/app/workflow_draft_variables_test.py",
"controllers/console/auth/test_account_activation.py",
diff --git a/api/tests/unit_tests/repositories/test_app_trigger_repository.py b/api/tests/unit_tests/repositories/test_app_trigger_repository.py
new file mode 100644
index 00000000000..bf32f645c17
--- /dev/null
+++ b/api/tests/unit_tests/repositories/test_app_trigger_repository.py
@@ -0,0 +1,327 @@
+"""Exercise app trigger ownership and transaction boundaries with real SQLite."""
+
+from collections.abc import Iterator
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from functools import partial
+from uuid import uuid4
+
+import pytest
+from sqlalchemy import Engine, event, select, text
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import Session, sessionmaker
+
+from machinery.context import RequestContext
+from models.agent import Agent, AgentScope, AgentSource, AgentStatus
+from models.enums import AppTriggerStatus, AppTriggerType
+from models.model import App, AppMode
+from models.trigger import AppTrigger, WorkflowWebhookTrigger
+from repositories.trigger.app_repository import SQLAlchemyAppTriggerRepository
+from services.app.console_service import ConsoleAppNotFoundError
+from services.trigger.app_trigger_store import AppTriggerNotFoundError, WebhookTriggerNotFoundError
+
+_CREATED_AT = datetime(2026, 10, 20, 8, 0)
+
+
+@dataclass(frozen=True)
+class TriggerScope:
+ context: RequestContext
+ app_id: str
+ trigger_id: str
+ webhook_id: str
+ node_id: str
+
+
+def scope(sqlite_session_factory: sessionmaker[Session]) -> TriggerScope:
+ context = RequestContext("request", None, str(uuid4()), str(uuid4()))
+ with sqlite_session_factory.begin() as session:
+ app = App(
+ tenant_id=context.active_workspace_id,
+ name="Workflow",
+ mode=AppMode.WORKFLOW,
+ enable_site=True,
+ enable_api=True,
+ )
+ session.add(app)
+ session.flush()
+ trigger = AppTrigger(
+ tenant_id=context.active_workspace_id,
+ app_id=app.id,
+ node_id="webhook-node",
+ trigger_type=AppTriggerType.TRIGGER_WEBHOOK,
+ title="Webhook",
+ provider_name=None,
+ status=AppTriggerStatus.ENABLED,
+ )
+ webhook = WorkflowWebhookTrigger(
+ tenant_id=context.active_workspace_id,
+ app_id=app.id,
+ node_id=trigger.node_id or "",
+ webhook_id="webhook-endpoint",
+ created_by=context.account_id,
+ )
+ trigger.created_at = _CREATED_AT
+ webhook.created_at = _CREATED_AT
+ session.add_all([trigger, webhook])
+ session.flush()
+ # The insert default replaces None with ""; existing rows may still be NULL.
+ trigger.provider_name = None
+ session.flush()
+ return TriggerScope(context, app.id, trigger.id, webhook.id, webhook.node_id)
+
+
+def repository(sqlite_session_factory: sessionmaker[Session]) -> SQLAlchemyAppTriggerRepository:
+ return SQLAlchemyAppTriggerRepository(session_factory=sqlite_session_factory)
+
+
+def open_connections(sqlite_engine: Engine) -> Iterator[set[object]]:
+ connections: set[object] = set()
+
+ def checkout(connection: object, *_args: object) -> None:
+ connections.add(connection)
+
+ def checkin(connection: object, *_args: object) -> None:
+ connections.remove(connection)
+
+ event.listen(sqlite_engine, "checkout", checkout)
+ event.listen(sqlite_engine, "checkin", checkin)
+ try:
+ yield connections
+ assert not connections
+ finally:
+ event.remove(sqlite_engine, "checkout", checkout)
+ event.remove(sqlite_engine, "checkin", checkin)
+
+
+def test_reads_return_detached_records_and_release_connections(
+ repository: SQLAlchemyAppTriggerRepository,
+ scope: TriggerScope,
+ open_connections: set[object],
+) -> None:
+ triggers = repository.list_triggers(scope.context, scope.app_id)
+ assert not open_connections
+ webhook = repository.get_webhook(scope.context, scope.app_id, scope.node_id)
+ assert not open_connections
+
+ assert len(triggers) == 1
+ trigger = triggers[0]
+ assert trigger.id == scope.trigger_id
+ assert trigger.trigger_type == AppTriggerType.TRIGGER_WEBHOOK
+ assert trigger.title == "Webhook"
+ assert trigger.node_id == scope.node_id
+ assert trigger.provider_name is None
+ assert trigger.status == AppTriggerStatus.ENABLED
+ assert trigger.created_at == _CREATED_AT
+ assert webhook.id == scope.webhook_id
+ assert webhook.webhook_id == "webhook-endpoint"
+ assert webhook.node_id == scope.node_id
+ assert webhook.created_at == _CREATED_AT
+
+ repository.set_enabled(scope.context, scope.app_id, scope.trigger_id, enabled=False)
+ # Existing query results remain snapshots even after the database changes.
+ assert trigger.status == AppTriggerStatus.ENABLED
+ assert not open_connections
+
+
[email protected]("operation", ["get_webhook", "list_triggers", "set_enabled"])
[email protected]("visibility", ["missing", "other_workspace", "disabled", "wrong_mode", "hidden_agent"])
+def test_operations_require_visible_workflow_in_current_workspace(
+ repository: SQLAlchemyAppTriggerRepository,
+ sqlite_session_factory: sessionmaker[Session],
+ scope: TriggerScope,
+ operation: str,
+ visibility: str,
+ open_connections: set[object],
+) -> None:
+ context = scope.context
+ app_id = scope.app_id
+ with sqlite_session_factory.begin() as session:
+ if visibility == "missing":
+ app_id = str(uuid4())
+ elif visibility == "other_workspace":
+ context = context._replace(active_workspace_id=str(uuid4()))
+ elif visibility == "disabled":
+ session.execute(text("UPDATE apps SET status = 'disabled' WHERE id = :id"), {"id": app_id})
+ elif visibility == "wrong_mode":
+ session.get_one(App, app_id).mode = AppMode.CHAT
+ else:
+ session.get_one(App, app_id).mode = AppMode.AGENT
+ session.add(
+ Agent(
+ tenant_id=context.active_workspace_id,
+ name="Workflow-only",
+ scope=AgentScope.WORKFLOW_ONLY,
+ source=AgentSource.WORKFLOW,
+ status=AgentStatus.ACTIVE,
+ backing_app_id=app_id,
+ )
+ )
+
+ if operation == "get_webhook":
+ run = partial(repository.get_webhook, context, app_id, scope.node_id)
+ elif operation == "list_triggers":
+ run = partial(repository.list_triggers, context, app_id)
+ else:
+ run = partial(repository.set_enabled, context, app_id, scope.trigger_id, enabled=False)
+ with pytest.raises(ConsoleAppNotFoundError) as raised:
+ run()
+ assert not open_connections
+ if visibility == "wrong_mode":
+ assert str(raised.value) == "App mode is not in the supported list: {'workflow'}"
+ else:
+ assert str(raised.value) == "App not found"
+ with sqlite_session_factory() as session:
+ assert session.get_one(AppTrigger, scope.trigger_id).status == AppTriggerStatus.ENABLED
+
+
[email protected]("field", ["tenant_id", "app_id", "node_id"])
+def test_webhook_lookup_requires_complete_owner_chain_and_node(
+ repository: SQLAlchemyAppTriggerRepository,
+ sqlite_session_factory: sessionmaker[Session],
+ scope: TriggerScope,
+ field: str,
+) -> None:
+ with sqlite_session_factory.begin() as session:
+ webhook = session.get_one(WorkflowWebhookTrigger, scope.webhook_id)
+ if field == "tenant_id":
+ webhook.tenant_id = str(uuid4())
+ elif field == "app_id":
+ webhook.app_id = str(uuid4())
+ else:
+ webhook.node_id = "other-node"
+
+ with pytest.raises(WebhookTriggerNotFoundError, match="Webhook trigger not found for this node"):
+ repository.get_webhook(scope.context, scope.app_id, scope.node_id)
+
+
+def test_list_preserves_stable_order_and_excludes_foreign_records(
+ repository: SQLAlchemyAppTriggerRepository,
+ sqlite_session_factory: sessionmaker[Session],
+ scope: TriggerScope,
+) -> None:
+ with sqlite_session_factory.begin() as session:
+ older = session.get_one(AppTrigger, scope.trigger_id)
+ records = [
+ AppTrigger(
+ tenant_id=scope.context.active_workspace_id,
+ app_id=scope.app_id,
+ node_id=f"node-{index}",
+ trigger_type=trigger_type,
+ title=f"Trigger {index}",
+ provider_name="provider" if trigger_type == AppTriggerType.TRIGGER_PLUGIN else "",
+ )
+ for index, trigger_type in enumerate(
+ [AppTriggerType.TRIGGER_PLUGIN, AppTriggerType.TRIGGER_SCHEDULE, AppTriggerType.UNKNOWN]
+ )
+ ]
+ for record in records:
+ record.created_at = _CREATED_AT + timedelta(days=1)
+ foreign_workspace = AppTrigger(
+ tenant_id=str(uuid4()),
+ app_id=scope.app_id,
+ node_id="foreign-workspace",
+ trigger_type=AppTriggerType.TRIGGER_WEBHOOK,
+ title="Foreign workspace",
+ )
+ foreign_app = AppTrigger(
+ tenant_id=scope.context.active_workspace_id,
+ app_id=str(uuid4()),
+ node_id="foreign-app",
+ trigger_type=AppTriggerType.TRIGGER_WEBHOOK,
+ title="Foreign app",
+ )
+ session.add_all([*records, foreign_workspace, foreign_app])
+ session.flush()
+ expected_ids = sorted([record.id for record in records], reverse=True) + [older.id]
+
+ result = repository.list_triggers(scope.context, scope.app_id)
+
+ assert [record.id for record in result] == expected_ids
+ assert {record.trigger_type for record in result} == set(AppTriggerType)
+
+
+def test_empty_app_has_no_triggers(
+ repository: SQLAlchemyAppTriggerRepository, sqlite_session_factory: sessionmaker[Session], scope: TriggerScope
+) -> None:
+ with sqlite_session_factory.begin() as session:
+ session.delete(session.get_one(AppTrigger, scope.trigger_id))
+
+ assert repository.list_triggers(scope.context, scope.app_id) == ()
+
+
[email protected]("enabled", [True, False])
[email protected]("initial_status", list(AppTriggerStatus))
+def test_enable_disable_commits_only_status_and_returns_persisted_timestamps(
+ repository: SQLAlchemyAppTriggerRepository,
+ sqlite_session_factory: sessionmaker[Session],
+ scope: TriggerScope,
+ enabled: bool,
+ initial_status: AppTriggerStatus,
+ open_connections: set[object],
+) -> None:
+ with sqlite_session_factory.begin() as session:
+ session.get_one(AppTrigger, scope.trigger_id).status = initial_status
+
+ result = repository.set_enabled(scope.context, scope.app_id, scope.trigger_id, enabled=enabled)
+ assert not open_connections
+
+ with sqlite_session_factory() as session:
+ stored = session.get_one(AppTrigger, scope.trigger_id)
+ assert stored.status == (AppTriggerStatus.ENABLED if enabled else AppTriggerStatus.DISABLED)
+ assert result.status == stored.status
+ assert result.created_at == stored.created_at == _CREATED_AT
+ assert result.updated_at == stored.updated_at
+ assert stored.tenant_id == scope.context.active_workspace_id
+ assert stored.app_id == scope.app_id
+ assert stored.title == "Webhook"
+ assert stored.node_id == scope.node_id
+ assert stored.provider_name is None
+ assert session.scalar(select(WorkflowWebhookTrigger.id)) == scope.webhook_id
+
+
[email protected]("field", ["tenant_id", "app_id", "id"])
+def test_status_update_requires_complete_owner_chain_and_trigger(
+ repository: SQLAlchemyAppTriggerRepository,
+ sqlite_session_factory: sessionmaker[Session],
+ scope: TriggerScope,
+ field: str,
+) -> None:
+ trigger_id = scope.trigger_id
+ with sqlite_session_factory.begin() as session:
+ trigger = session.get_one(AppTrigger, trigger_id)
+ if field == "tenant_id":
+ trigger.tenant_id = str(uuid4())
+ elif field == "app_id":
+ trigger.app_id = str(uuid4())
+ else:
+ trigger_id = str(uuid4())
+
+ with pytest.raises(AppTriggerNotFoundError, match="Trigger not found"):
+ repository.set_enabled(scope.context, scope.app_id, trigger_id, enabled=False)
+
+ with sqlite_session_factory() as session:
+ assert session.get_one(AppTrigger, scope.trigger_id).status == AppTriggerStatus.ENABLED
+
+
+def test_failed_status_write_rolls_back_and_releases_connection(
+ repository: SQLAlchemyAppTriggerRepository,
+ sqlite_session_factory: sessionmaker[Session],
+ scope: TriggerScope,
+ open_connections: set[object],
+) -> None:
+ with sqlite_session_factory.begin() as session:
+ session.execute(
+ text(
+ "CREATE TRIGGER reject_trigger_update BEFORE UPDATE ON app_triggers "
+ "BEGIN SELECT RAISE(ABORT, 'trigger update rejected'); END"
+ )
+ )
+
+ with pytest.raises(IntegrityError, match="trigger update rejected"):
+ repository.set_enabled(scope.context, scope.app_id, scope.trigger_id, enabled=False)
+ assert not open_connections
+ with sqlite_session_factory() as session:
+ assert session.get_one(AppTrigger, scope.trigger_id).status == AppTriggerStatus.ENABLED
diff --git a/packages/contracts/generated/api/console/apps/orpc.gen.ts b/packages/contracts/generated/api/console/apps/orpc.gen.ts
index 43e89f94d39..ebd72032f4d 100644
--- a/packages/contracts/generated/api/console/apps/orpc.gen.ts
+++ b/packages/contracts/generated/api/console/apps/orpc.gen.ts
@@ -13,6 +13,7 @@ import {
zAgentVersionNotFoundError,
zAppNotFoundError,
zAppSuggestedQuestionsAfterAnswerDisabledError,
+ zAppTriggerNotFoundError,
zAppUnavailableError,
zAudioTooLargeError,
zBindingFileDownloadUnavailableError,
@@ -58,6 +59,7 @@ import {
zTracingSourceNotFoundError,
zUnsupportedAudioTypeError,
zUnsupportedTracingProviderError,
+ zWebhookTriggerNotFoundError,
zWorkflowRunNotFoundError,
} from './zod.gen.ts'
import {
@@ -2946,7 +2948,10 @@ export const post38 = oc
}),
)
.output(zPostAppsByAppIdTriggerEnableResponse)
- .errors({ app_not_found: { status: 404, data: zAppNotFoundError } })
+ .errors({
+ app_not_found: { status: 404, data: zAppNotFoundError },
+ app_trigger_not_found: { status: 404, data: zAppTriggerNotFoundError },
+ })
export const triggerEnable = {
post: post38,
@@ -4932,7 +4937,10 @@ export const get86 = oc
}),
)
.output(zGetAppsByAppIdWorkflowsTriggersWebhookResponse)
- .errors({ app_not_found: { status: 404, data: zAppNotFoundError } })
+ .errors({
+ app_not_found: { status: 404, data: zAppNotFoundError },
+ webhook_trigger_not_found: { status: 404, data: zWebhookTriggerNotFoundError },
+ })
export const webhook = {
get: get86,
diff --git a/packages/contracts/generated/api/console/apps/types.gen.ts b/packages/contracts/generated/api/console/apps/types.gen.ts
index d2ba8be55c7..b8a4a7526c5 100644
--- a/packages/contracts/generated/api/console/apps/types.gen.ts
+++ b/packages/contracts/generated/api/console/apps/types.gen.ts
@@ -1018,6 +1018,11 @@ export type WorkflowTriggerResponse = {
updated_at?: string | null
}
+export type AppTriggerNotFoundError = ErrorResponse & {
+ code: 'app_trigger_not_found'
+ status: 404
+}
+
export type WorkflowTriggerListResponse = {
data: Array<WorkflowTriggerResponse>
}
@@ -1530,6 +1535,11 @@ export type WebhookTriggerResponse = {
webhook_url: string
}
+export type WebhookTriggerNotFoundError = ErrorResponse & {
+ code: 'webhook_trigger_not_found'
+ status: 404
+}
+
export type WorkflowUpdatePayload = {
marked_comment?: string | null
marked_name?: string | null
@@ -7378,7 +7388,7 @@ export type PostAppsByAppIdTriggerEnableData = {
}
export type PostAppsByAppIdTriggerEnableErrors = {
- 404: AppNotFoundError | ErrorResponse
+ 404: AppNotFoundError | AppTriggerNotFoundError | ErrorResponse
default: ErrorResponse
}
@@ -9317,7 +9327,7 @@ export type GetAppsByAppIdWorkflowsTriggersWebhookData = {
}
export type GetAppsByAppIdWorkflowsTriggersWebhookErrors = {
- 404: AppNotFoundError | ErrorResponse
+ 404: AppNotFoundError | WebhookTriggerNotFoundError | ErrorResponse
default: ErrorResponse
}
diff --git a/packages/contracts/generated/api/console/apps/zod.gen.ts b/packages/contracts/generated/api/console/apps/zod.gen.ts
index cf994692b68..0b01731da91 100644
--- a/packages/contracts/generated/api/console/apps/zod.gen.ts
+++ b/packages/contracts/generated/api/console/apps/zod.gen.ts
@@ -994,6 +994,18 @@ export const zWorkflowTriggerResponse = z.object({
updated_at: z.iso.datetime().nullish(),
})
+/**
+ * AppTriggerNotFoundError
+ *
+ * Trigger not found.
+ */
+export const zAppTriggerNotFoundError = zErrorResponse.and(
+ z.object({
+ code: z.literal('app_trigger_not_found'),
+ status: z.literal(404),
+ }),
+)
+
/**
* WorkflowTriggerListResponse
*/
@@ -1384,6 +1396,18 @@ export const zWebhookTriggerResponse = z.object({
webhook_url: z.string(),
})
+/**
+ * WebhookTriggerNotFoundError
+ *
+ * Webhook trigger not found for this node.
+ */
+export const zWebhookTriggerNotFoundError = zErrorResponse.and(
+ z.object({
+ code: z.literal('webhook_trigger_not_found'),
+ status: z.literal(404),
+ }),
+)
+
/**
* WorkflowUpdatePayload
*/