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): detach console app trigger management (#44457)
非法操作5fb3658c28fe
diff --git a/api/.importlinter b/api/.importlinterindex 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 neutraltype = forbiddendiff --git a/api/controllers/console/app/error.py b/api/controllers/console/app/error.pyindex 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.pyindex 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 asdictfrom datetime import datetime+from http import HTTPStatus+from uuid import UUIDfrom flask_restx import Resourcefrom pydantic import BaseModel, field_validator-from sqlalchemy import select-from sqlalchemy.orm import Session-from werkzeug.exceptions import NotFoundfrom configs import dify_configfrom 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_modelsfrom 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_servicesfrom fields.base import ResponseModel+from libs.external_api import error_responsesfrom 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.pyindex 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 DslImportRepositoryfrom repositories.app.enterprise_app_repository import EnterpriseAppRepositoryfrom repositories.app.export_repository import AppExportRepositoryfrom repositories.factory import DifyAPIRepositoryFactory+from repositories.trigger.app_repository import SQLAlchemyAppTriggerRepositoryfrom repositories.workspace.workspace_repository import WorkspaceRepositoryfrom services.agent.roster_package_exporter import RosterAgentPackageExporterfrom services.agent.roster_package_importer import RosterAgentPackageImporter@@ -32,6 +33,7 @@ from services.app_tracing_config_service import AppTracingConfigServicefrom services.oauth_server_service import OAuthServerServicefrom services.rbac.members import MemberServicefrom services.recommended_app_package_service import RecommendedAppPackageService+from services.trigger.app_trigger_store import AppTriggerStorefrom services.workflow.dsl_import import DslImportService@@ -43,6 +45,7 @@ class AppServices:discovery: AppDiscoveryServiceconsole: ConsoleAppServiceenterprise: EnterpriseAppService+ triggers: AppTriggerStoredef 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.mdindex 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. | |+#### AppUnavailableErrorApp 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__.pynew file mode 100644index 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.pynew file mode 100644index 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__.pynew file mode 100644index 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.pynew file mode 100644index 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.pyindex 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, WebhookTriggerQueryfrom machinery.context import RequestContextfrom models import App, Sitefrom models.account import Account, AccountStatusfrom models.engine import db-from models.trigger import WorkflowWebhookTriggerfrom 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.pyindex 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 dbfrom 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(+ email="[email protected]",+ 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.ENABLEDdiff --git a/api/tests/unit_tests/pyrefly.toml b/api/tests/unit_tests/pyrefly.tomlindex 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.pynew file mode 100644index 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.ENABLEDdiff --git a/packages/contracts/generated/api/console/apps/orpc.gen.ts b/packages/contracts/generated/api/console/apps/orpc.gen.tsindex 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.tsindex 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 | nullmarked_name?: string | null@@ -7378,7 +7388,7 @@ export type PostAppsByAppIdTriggerEnableData = {}export type PostAppsByAppIdTriggerEnableErrors = {- 404: AppNotFoundError | ErrorResponse+ 404: AppNotFoundError | AppTriggerNotFoundError | ErrorResponsedefault: ErrorResponse}@@ -9317,7 +9327,7 @@ export type GetAppsByAppIdWorkflowsTriggersWebhookData = {}export type GetAppsByAppIdWorkflowsTriggersWebhookErrors = {- 404: AppNotFoundError | ErrorResponse+ 404: AppNotFoundError | WebhookTriggerNotFoundError | ErrorResponsedefault: ErrorResponse}diff --git a/packages/contracts/generated/api/console/apps/zod.gen.ts b/packages/contracts/generated/api/console/apps/zod.gen.tsindex 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*/