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(openapi): route /openapi/v1 auth by subject (#41420)
Xiyuan Chenbc0636c4db14
diff --git a/api/controllers/openapi/_contract.py b/api/controllers/openapi/_contract.pyindex aa92cdf411d..eb17bacb085 100644--- a/api/controllers/openapi/_contract.py+++ b/api/controllers/openapi/_contract.py@@ -1,20 +1,18 @@-"""Request/response contract decorators for the openapi controllers.+"""``@accepts`` and ``@returns`` own one slice of the contract from a single model+reference, so the advertised and enforced contracts can't drift.-``@accepts`` and ``@returns`` own one slice of the contract from a single model-reference — emitting the Swagger schema AND doing the runtime validation/-serialisation — so the advertised and enforced contracts can't drift. Validation-failures map to a single shape: 422.--They must sit below route admission (or a direct ``@auth_router.guard``) so-authentication runs before validation and the ``view.__wrapped__`` unit-test-seam can bypass the outer admission layer.+``@endpoint`` composes both under ``subject_router.guard``, exposing+``view.__handler__`` as the one documented test seam. ``returns`` is still used+bare by the unauthenticated ``index.py`` probes, which have no auth layer to+compose with."""from __future__ import annotations-from collections.abc import Callable+import inspect+from collections.abc import Callable, Sequencefrom functools import wraps-from typing import Any+from typing import Any, castfrom flask import requestfrom flask_restx import abort@@ -23,14 +21,14 @@ from pydantic import BaseModel, ValidationErrorfrom controllers.common.schema import query_params_from_model, query_params_from_requestfrom controllers.openapi import openapi_nsfrom controllers.openapi._errors import ErrorBody+from controllers.openapi.auth.requirements import Requirement+from controllers.openapi.auth.router import subject_router+from controllers.openapi.auth.spec import EndpointSpec+from enums import DeploymentEditiondef accepts(*, query: type[BaseModel] | None = None, body: type[BaseModel] | None = None) -> Callable:- """Validate ``query``/``body`` against the models and inject them as keyword-only kwargs.-- Emits the matching Swagger schema from the same models, so doc and enforcement- stay in lockstep.- """+ """Validate ``query``/``body`` against the models and inject them as keyword-only kwargs."""def decorator(view: Callable) -> Callable:@wraps(view)@@ -84,3 +82,63 @@ def returns(code: int, model: type[BaseModel], description: str | None = None) -return wrapperreturn decorator+++_apply_returns = returns++ReturnSpec = tuple[int, type[BaseModel], str | None]+++def _normalize_returns(returns: ReturnSpec | Sequence[ReturnSpec] | None) -> tuple[ReturnSpec, ...]:+ """One ``(code, model, description)`` or several, always ending up a tuple of+ them — the one place that tells the two apart, so `decorator` below never has to.+ """+ if returns is None:+ return ()+ if isinstance(returns[0], int):+ return (cast(ReturnSpec, returns),) # pyrefly: ignore[redundant-cast]+ return tuple(cast(Sequence[ReturnSpec], returns)) # pyrefly: ignore[redundant-cast]+++def endpoint(+ *,+ requirements: Sequence[Requirement] = (),+ query: type[BaseModel] | None = None,+ body: type[BaseModel] | None = None,+ returns: ReturnSpec | Sequence[ReturnSpec] | None = None,+ edition: frozenset[DeploymentEdition] | None = None,+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:+ """The one seam a route attaches to for auth, request validation and response+ serialisation — auth, then ``accepts``, then ``returns``. Exposes+ ``view.__handler__`` (the bare handler) and ``view.__spec__`` (the exact+ `EndpointSpec` instance the router runs).++ ``returns`` takes one ``(code, model, description)`` or several; a route+ that stacked N ``@returns`` today declares them here in the same top-to-bottom+ order and gets the identical nesting back — first entry outermost, last entry+ closest to the handler — including the N-times ``"default"`` error registration+ that stacking N ``@returns`` already produces.+ """+ requirements = tuple(requirements)+ for requirement in requirements:+ if not isinstance(requirement, Requirement):+ raise TypeError(f"requirements must be instances of Requirement, not {requirement!r}")+ spec = EndpointSpec(requirements=requirements, edition=edition)+ return_specs = _normalize_returns(returns)++ def decorator(view: Callable[..., Any]) -> Callable[..., Any]:+ if "ctx" not in inspect.signature(view).parameters:+ raise TypeError(f"{view.__qualname__} must declare a 'ctx' parameter")++ decorated = view+ if query is not None or body is not None:+ decorated = accepts(query=query, body=body)(decorated)+ for return_spec in reversed(return_specs):+ decorated = _apply_returns(*return_spec)(decorated)+ decorated = subject_router.guard(spec)(decorated)++ decorated.__handler__ = view # type: ignore[attr-defined]+ decorated.__spec__ = spec # type: ignore[attr-defined]+ return decorated++ return decoratordiff --git a/api/controllers/openapi/_models.py b/api/controllers/openapi/_models.pyindex 530f2afeb0d..b54bf239789 100644--- a/api/controllers/openapi/_models.py+++ b/api/controllers/openapi/_models.py@@ -9,6 +9,7 @@ from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validafrom enums import DeploymentEditionfrom libs.helper import EmailStr, UUIDStr, UUIDStrOrEmpty, uuid_value+from libs.oauth_bearer import SubjectTypefrom models.model import AppMode# Server-side cap on `limit` query param for /openapi/v1/* list endpoints.@@ -129,7 +130,7 @@ class WorkspacePayload(BaseModel):class DeviceTokenResponse(BaseModel):token: strexpires_at: str- subject_type: Literal["account", "external_sso"]+ subject_type: SubjectTypeaccount: AccountPayload | None = Noneworkspaces: list[WorkspacePayload] = []default_workspace_id: str | None = None@@ -139,7 +140,7 @@ class DeviceTokenResponse(BaseModel):class AccountResponse(BaseModel):- subject_type: str+ subject_type: SubjectTypesubject_email: str | None = Nonesubject_issuer: str | None = Noneaccount: AccountPayload | None = Nonediff --git a/api/controllers/openapi/account.py b/api/controllers/openapi/account.pyindex 6ddd9a14ef2..d444c2bb20d 100644--- a/api/controllers/openapi/account.py+++ b/api/controllers/openapi/account.py@@ -3,11 +3,12 @@ from __future__ import annotationsfrom datetime import UTC, datetimefrom uuid import UUID+from flask import requestfrom flask_restx import Resourcefrom werkzeug.exceptions import NotFound, Unauthorizedfrom controllers.openapi import openapi_ns-from controllers.openapi._contract import accepts, returns+from controllers.openapi._contract import endpointfrom controllers.openapi._models import (AccountPayload,AccountResponse,@@ -17,10 +18,13 @@ from controllers.openapi._models import (SessionRow,WorkspacePayload,)-from controllers.openapi.flask_admission import openapi_account_admission+from controllers.openapi.auth.context import Context+from controllers.openapi.auth.requirements import CheckScope, CheckSubject+from controllers.openapi.auth.subjects import AccountSubject+from core.logging.context import get_request_id, get_trace_idfrom extensions.ext_application_services import application_servicesfrom libs.oauth_bearer import Scope-from libs.rate_limit import LIMIT_ME_PER_ACCOUNT+from libs.rate_limit import LIMIT_ME_PER_ACCOUNT, enforcefrom machinery.context import AccountRequestContextfrom services.account_errors import AccountNotFoundError, AccountSessionNotFoundErrorfrom services.entities.account_access_entities import AccountSessionSnapshot, AccountWorkspaceSnapshot@@ -29,15 +33,20 @@ from services.entities.account_entities import AccountSnapshot@openapi_ns.route("/account")class AccountApi(Resource):- @openapi_account_admission(scope=Scope.FULL, rate_limit=LIMIT_ME_PER_ACCOUNT)- @returns(200, AccountResponse, description="Account info")- def get(self, request_context: AccountRequestContext):+ @endpoint(+ requirements=(CheckSubject(allowed=(AccountSubject,)), CheckScope(Scope.FULL)),+ returns=(200, AccountResponse, "Account info"),+ )+ def get(self, ctx: Context):+ request_context = _request_context(ctx)+ enforce(LIMIT_ME_PER_ACCOUNT, key=f"account:{request_context.account_id}")+try:snapshot = application_services().accounts.access.get(request_context)except AccountNotFoundError:raise Unauthorized("account not found") from Nonereturn AccountResponse(- subject_type="account",+ subject_type=ctx.subject.subject_type,subject_email=snapshot.account.email,account=_account_payload(snapshot.account),workspaces=[_workspace_payload(workspace) for workspace in snapshot.workspaces],@@ -47,21 +56,25 @@ class AccountApi(Resource):@openapi_ns.route("/account/sessions/self")class AccountSessionsSelfApi(Resource):- @openapi_account_admission(scope=Scope.FULL)- @returns(200, RevokeResponse, description="Session revoked")- def delete(self, request_context: AccountRequestContext):- application_services().accounts.access.revoke_current_session(request_context)+ @endpoint(+ requirements=(CheckSubject(allowed=(AccountSubject,)), CheckScope(Scope.FULL)),+ returns=(200, RevokeResponse, "Session revoked"),+ )+ def delete(self, ctx: Context):+ application_services().accounts.access.revoke_current_session(_request_context(ctx))return RevokeResponse(status="revoked")@openapi_ns.route("/account/sessions")class AccountSessionsApi(Resource):- @openapi_account_admission(scope=Scope.FULL)- @returns(200, SessionListResponse, description="Session list")- @accepts(query=SessionListQuery)- def get(self, request_context: AccountRequestContext, *, query: SessionListQuery):+ @endpoint(+ requirements=(CheckSubject(allowed=(AccountSubject,)), CheckScope(Scope.FULL)),+ query=SessionListQuery,+ returns=(200, SessionListResponse, "Session list"),+ )+ def get(self, ctx: Context, *, query: SessionListQuery):page = application_services().accounts.access.list_sessions(- request_context,+ _request_context(ctx),page=query.page,limit=query.limit,)@@ -76,21 +89,32 @@ class AccountSessionsApi(Resource):@openapi_ns.route("/account/sessions/<string:session_id>")class AccountSessionByIdApi(Resource):- @openapi_account_admission(scope=Scope.FULL)- @returns(200, RevokeResponse, description="Session revoked")- def delete(self, request_context: AccountRequestContext, session_id: str):+ @endpoint(+ requirements=(CheckSubject(allowed=(AccountSubject,)), CheckScope(Scope.FULL)),+ returns=(200, RevokeResponse, "Session revoked"),+ )+ def delete(self, ctx: Context, session_id: str):try:token_id = str(UUID(session_id))except ValueError:raise NotFound("session not found") from Nonetry:- application_services().accounts.access.revoke_session(request_context, token_id=token_id)+ application_services().accounts.access.revoke_session(_request_context(ctx), token_id=token_id)except AccountSessionNotFoundError:# Do not reveal whether a token ID belongs to another account.raise NotFound("session not found") from Nonereturn RevokeResponse(status="revoked")+def _request_context(ctx: Context) -> AccountRequestContext:+ return AccountRequestContext(+ request_id=get_request_id(),+ trace_id=get_trace_id() or request.headers.get("X-Trace-Id"),+ account_id=str(ctx.subject.account_id),+ access_token_id=str(ctx.subject.token_id),+ )++def _iso(dt: datetime | None) -> str | None:if dt is None:return Nonediff --git a/api/controllers/openapi/app_dsl.py b/api/controllers/openapi/app_dsl.pyindex 0978c2c628f..665f01b0999 100644--- a/api/controllers/openapi/app_dsl.py+++ b/api/controllers/openapi/app_dsl.py@@ -1,20 +1,25 @@from __future__ import annotations-from typing import cast-from flask_restx import Resourcefrom sqlalchemy.orm import Sessionfrom werkzeug.exceptions import Forbiddenfrom controllers.common.rbac import PlainApp, RBACCheck, RBACPermission, Workspacefrom controllers.openapi import openapi_ns-from controllers.openapi._contract import accepts, returns+from controllers.openapi._contract import endpointfrom controllers.openapi._models import AppDslExportQuery, AppDslExportResponse, AppDslImportPayload-from controllers.openapi.auth.composition import auth_router-from controllers.openapi.auth.data import AuthData+from controllers.openapi.auth.context import Context+from controllers.openapi.auth.requirements import (+ CheckAppApiEnabled,+ CheckRBACPermission,+ CheckScope,+ CheckSubject,+ CheckWorkspaceMember,+ CheckWorkspaceRole,+)+from controllers.openapi.auth.subjects import AccountSubjectfrom extensions.ext_database import db-from libs.oauth_bearer import Scope, TokenType-from models import Account, App+from libs.oauth_bearer import Scopefrom models.account import TenantAccountRolefrom services.app_dsl_service import AppDslService, Importfrom services.entities.dsl_entities import CheckDependenciesResult, ImportStatus@@ -36,18 +41,23 @@ class AppDslImportApi(Resource):Returns 400 when the import failed due to invalid DSL or a business error."""- @auth_router.guard_workspace(- scope=Scope.WORKSPACE_WRITE,- allowed_token_types=frozenset({TokenType.OAUTH_ACCOUNT}),- allowed_roles=frozenset({TenantAccountRole.EDITOR, TenantAccountRole.ADMIN, TenantAccountRole.OWNER}),- rbac=RBACCheck(RBACPermission.APP_IMPORT_EXPORT_DSL, Workspace()),+ @endpoint(+ requirements=(+ CheckSubject(allowed=(AccountSubject,)),+ CheckScope(Scope.WORKSPACE_WRITE),+ CheckWorkspaceMember(),+ CheckRBACPermission(RBACCheck(RBACPermission.APP_IMPORT_EXPORT_DSL, Workspace())),+ CheckWorkspaceRole(frozenset({TenantAccountRole.EDITOR, TenantAccountRole.ADMIN, TenantAccountRole.OWNER})),+ ),+ body=AppDslImportPayload,+ returns=(+ (200, Import, "Import completed"),+ (202, Import, "Import pending confirmation"),+ (400, Import, "Import failed"),+ ),)- @returns(200, Import, "Import completed")- @returns(202, Import, "Import pending confirmation")- @returns(400, Import, "Import failed")- @accepts(body=AppDslImportPayload)- def post(self, workspace_id: str, *, auth_data: AuthData, body: AppDslImportPayload):- account = cast(Account, auth_data.caller)+ def post(self, ctx: Context, workspace_id: str, *, body: AppDslImportPayload):+ account = ctx.accountwith Session(db.engine, expire_on_commit=False) as session:service = AppDslService(session)@@ -92,16 +102,18 @@ class AppDslImportConfirmApi(Resource):Returns 400 when the pending data has expired or the import fails."""- @auth_router.guard_workspace(- scope=Scope.WORKSPACE_WRITE,- allowed_token_types=frozenset({TokenType.OAUTH_ACCOUNT}),- allowed_roles=frozenset({TenantAccountRole.EDITOR, TenantAccountRole.ADMIN, TenantAccountRole.OWNER}),- rbac=RBACCheck(RBACPermission.APP_IMPORT_EXPORT_DSL, Workspace()),+ @endpoint(+ requirements=(+ CheckSubject(allowed=(AccountSubject,)),+ CheckScope(Scope.WORKSPACE_WRITE),+ CheckWorkspaceMember(),+ CheckRBACPermission(RBACCheck(RBACPermission.APP_IMPORT_EXPORT_DSL, Workspace())),+ CheckWorkspaceRole(frozenset({TenantAccountRole.EDITOR, TenantAccountRole.ADMIN, TenantAccountRole.OWNER})),+ ),+ returns=((200, Import, "Import confirmed"), (400, Import, "Import failed")),)- @returns(200, Import, "Import confirmed")- @returns(400, Import, "Import failed")- def post(self, workspace_id: str, import_id: str, *, auth_data: AuthData):- account = cast(Account, auth_data.caller)+ def post(self, ctx: Context, workspace_id: str, import_id: str):+ account = ctx.accountwith Session(db.engine, expire_on_commit=False) as session:service = AppDslService(session)@@ -132,19 +144,22 @@ class AppDslExportApi(Resource):receive a 403; enable the API in the console first if needed."""- @auth_router.guard(- scope=Scope.APPS_READ,- allowed_token_types=frozenset({TokenType.OAUTH_ACCOUNT}),- allowed_roles=frozenset({TenantAccountRole.EDITOR, TenantAccountRole.ADMIN, TenantAccountRole.OWNER}),- rbac=RBACCheck(RBACPermission.APP_IMPORT_EXPORT_DSL, PlainApp()),+ @endpoint(+ requirements=(+ CheckSubject(allowed=(AccountSubject,)),+ CheckAppApiEnabled(),+ CheckWorkspaceMember(),+ CheckScope(Scope.APPS_READ),+ CheckRBACPermission(RBACCheck(RBACPermission.APP_IMPORT_EXPORT_DSL, PlainApp())),+ CheckWorkspaceRole(frozenset({TenantAccountRole.EDITOR, TenantAccountRole.ADMIN, TenantAccountRole.OWNER})),+ ),+ query=AppDslExportQuery,+ returns=(200, AppDslExportResponse, "Export successful"),)- @accepts(query=AppDslExportQuery)- @returns(200, AppDslExportResponse, "Export successful")- def get(self, app_id: str, *, auth_data: AuthData, query: AppDslExportQuery):- app = cast(App, auth_data.app)+ def get(self, ctx: Context, app_id: str, *, query: AppDslExportQuery):try:data = AppDslService.export_dsl(- app_model=app,+ app_model=ctx.app,session=db.session(),include_secret=query.include_secret,workflow_id=query.workflow_id,@@ -164,18 +179,20 @@ class AppDslCheckDependenciesApi(Resource):dependencies are satisfied."""- @auth_router.guard(- scope=Scope.APPS_READ,- allowed_token_types=frozenset({TokenType.OAUTH_ACCOUNT}),- allowed_roles=frozenset({TenantAccountRole.EDITOR, TenantAccountRole.ADMIN, TenantAccountRole.OWNER}),- rbac=RBACCheck(RBACPermission.APP_IMPORT_EXPORT_DSL, PlainApp()),+ @endpoint(+ requirements=(+ CheckSubject(allowed=(AccountSubject,)),+ CheckAppApiEnabled(),+ CheckWorkspaceMember(),+ CheckScope(Scope.APPS_READ),+ CheckRBACPermission(RBACCheck(RBACPermission.APP_IMPORT_EXPORT_DSL, PlainApp())),+ CheckWorkspaceRole(frozenset({TenantAccountRole.EDITOR, TenantAccountRole.ADMIN, TenantAccountRole.OWNER})),+ ),+ returns=(200, CheckDependenciesResult, "Dependencies checked"),)- @returns(200, CheckDependenciesResult, "Dependencies checked")- def get(self, app_id: str, *, auth_data: AuthData):- app = cast(App, auth_data.app)-+ def get(self, ctx: Context, app_id: str):with Session(db.engine, expire_on_commit=False) as session:service = AppDslService(session)- result = service.check_dependencies(app_model=app)+ result = service.check_dependencies(app_model=ctx.app)return result, 200diff --git a/api/controllers/openapi/app_run.py b/api/controllers/openapi/app_run.pyindex e71d3e72bba..16315d685e5 100644--- a/api/controllers/openapi/app_run.py+++ b/api/controllers/openapi/app_run.py@@ -21,13 +21,20 @@ from werkzeug.exceptions import (import servicesfrom controllers.common.fields import EventStreamResponsefrom controllers.common.rbac import PlainApp, RBACCheck, RBACPermission-from controllers.console.app.wraps import with_sessionfrom controllers.openapi import openapi_nsfrom controllers.openapi._audit import emit_app_run-from controllers.openapi._contract import accepts, returns+from controllers.openapi._contract import endpointfrom controllers.openapi._models import AppRunRequest, TaskStopResponse-from controllers.openapi.auth.composition import auth_router-from controllers.openapi.auth.data import AuthData+from controllers.openapi.auth.context import Context+from controllers.openapi.auth.requirements import (+ CheckAppAccess,+ CheckAppApiEnabled,+ CheckRBACPermission,+ CheckScope,+ CheckSubject,+ CheckWorkspaceMember,+)+from controllers.openapi.auth.subjects import AccountSubject, ExternalSsoSubjectfrom controllers.service_api.app.error import (AppUnavailableError,CompletionRequestError,@@ -146,22 +153,28 @@ _DISPATCH: dict[AppMode, Callable[[App, Any, AppRunRequest, Session], Any]] = {@openapi_ns.route("/apps/<string:app_id>:run")class AppRunApi(Resource):- @auth_router.guard(- scope=Scope.APPS_RUN,- rbac=RBACCheck(RBACPermission.APP_TEST_AND_RUN, PlainApp()),+ @endpoint(+ requirements=(+ CheckSubject(allowed=(AccountSubject, ExternalSsoSubject)),+ CheckAppApiEnabled(),+ CheckWorkspaceMember(),+ CheckScope(Scope.APPS_RUN),+ CheckRBACPermission(RBACCheck(RBACPermission.APP_TEST_AND_RUN, PlainApp())),+ CheckAppAccess(),+ ),+ body=AppRunRequest,+ returns=(200, EventStreamResponse, "Run result (SSE stream)"),)- @openapi_ns.response(200, "Run result (SSE stream)", openapi_ns.models[EventStreamResponse.__name__])- @accepts(body=AppRunRequest)- @with_session- def post(self, session: Session, app_id: str, *, auth_data: AuthData, body: AppRunRequest):- app_model, caller, caller_kind = auth_data.require_app_context()+ def post(self, ctx: Context, app_id: str, *, body: AppRunRequest):+ app_model = ctx.app+ caller = ctx.callerhandler = _DISPATCH.get(app_model.mode)if handler is None:raise UnprocessableEntity("mode_not_runnable")try:- stream_obj = handler(app_model, caller, body, session)+ stream_obj = handler(app_model, caller, body, ctx.session)except HTTPException:raiseexcept Exception:@@ -171,7 +184,7 @@ class AppRunApi(Resource):emit_app_run(app_id=app_model.id,tenant_id=app_model.tenant_id,- caller_kind=caller_kind,+ caller_kind=ctx.subject.caller_role,mode=str(app_model.mode),surface="apps",)@@ -182,13 +195,18 @@ class AppRunApi(Resource):@openapi_ns.route("/apps/<string:app_id>/tasks/<string:task_id>:stop")class AppRunTaskStopApi(Resource):- @auth_router.guard(- scope=Scope.APPS_RUN,- rbac=RBACCheck(RBACPermission.APP_TEST_AND_RUN, PlainApp()),+ @endpoint(+ requirements=(+ CheckSubject(allowed=(AccountSubject, ExternalSsoSubject)),+ CheckAppApiEnabled(),+ CheckWorkspaceMember(),+ CheckScope(Scope.APPS_RUN),+ CheckRBACPermission(RBACCheck(RBACPermission.APP_TEST_AND_RUN, PlainApp())),+ CheckAppAccess(),+ ),+ returns=(200, TaskStopResponse, "Task stopped"),)- @returns(200, TaskStopResponse, description="Task stopped")- def post(self, app_id: str, task_id: str, *, auth_data: AuthData):- app_model, caller, caller_kind = auth_data.require_app_context()+ def post(self, ctx: Context, app_id: str, task_id: str):AppQueueManager.set_stop_flag_no_user_check(task_id)GraphEngineManager(redis_client).send_stop_command(task_id)return TaskStopResponse(result="success")diff --git a/api/controllers/openapi/apps.py b/api/controllers/openapi/apps.pyindex 2675cac0400..0195bec24c0 100644--- a/api/controllers/openapi/apps.py+++ b/api/controllers/openapi/apps.py@@ -7,15 +7,13 @@ from typing import Anyfrom flask_restx import Resourcefrom sqlalchemy.orm import Session-from werkzeug.exceptions import Conflict, NotFound, UnprocessableEntityfrom configs import dify_configfrom controllers.common.app_access import AppAccessFilter, resolve_app_access_filterfrom controllers.common.fields import Parametersfrom controllers.common.rbac import PlainApp, RBACCheck, RBACPermission-from controllers.common.session import with_sessionfrom controllers.openapi import openapi_ns-from controllers.openapi._contract import accepts, returns+from controllers.openapi._contract import endpointfrom controllers.openapi._input_schema import EMPTY_INPUT_SCHEMA, build_input_schema, resolve_app_configfrom controllers.openapi._models import (SUPPORTED_APP_TYPES,@@ -26,11 +24,18 @@ from controllers.openapi._models import (AppListResponse,AppListRow,)-from controllers.openapi.auth.composition import auth_router-from controllers.openapi.auth.data import AuthData, CallerKind+from controllers.openapi.auth.context import Context+from controllers.openapi.auth.requirements import (+ CheckAppApiEnabled,+ CheckRBACPermission,+ CheckScope,+ CheckSubject,+ CheckWorkspaceMember,+)+from controllers.openapi.auth.subjects import AccountSubjectfrom controllers.service_api.app.error import AppUnavailableErrorfrom core.app.app_config.common.parameters_mapping import get_parameters_from_feature_dict-from libs.oauth_bearer import Scope, TokenType+from libs.oauth_bearer import Scopefrom models import Appfrom models.enums import AppStatusfrom models.model import AppMode@@ -52,39 +57,6 @@ _EMPTY_PARAMETERS: dict[str, Any] = {}-class AppReadResource(Resource):- """Base for per-app read endpoints; subclasses call `_load()` for membership/exists checks."""-- def _load(self, session: Session, app_id: str, workspace_id: str | None = None) -> App:- try:- parsed_uuid = _uuid.UUID(app_id)- is_uuid = True- except ValueError:- parsed_uuid = None- is_uuid = False-- if is_uuid:- # ``str(parsed_uuid)`` normalises to the canonical dashed form.- app = AppService.get_visible_app_by_id(str(parsed_uuid), session)- if app is None:- raise NotFound("app not found")- else:- if not workspace_id:- raise UnprocessableEntity("workspace_id is required for name-based lookup")- matches = AppService.find_visible_apps_by_name(session, name=app_id, tenant_id=workspace_id)- if len(matches) == 0:- raise NotFound("app not found")- if len(matches) > 1:- lines = [f"app name {app_id!r} is ambiguous — re-run with a UUID:\n\n"]- lines.append(f" {'ID':<36} {'MODE':<12} NAME\n")- for m in matches:- lines.append(f" {str(m.id):<36} {str(m.mode.value):<12} {m.name}\n")- raise Conflict("".join(lines))- app = matches[0]-- return app--def parameters_payload(app: App, *, session: Session) -> dict:"""Mirrors service_api/app/app.py::AppParameterApi response body."""features_dict, user_input_form = resolve_app_config(app, session=session)@@ -129,29 +101,37 @@ def build_app_describe_response(app: App, fields: set[str] | None, *, session: S@openapi_ns.route("/apps/<string:app_id>")-class AppDescribeApi(AppReadResource):- @auth_router.guard(- scope=Scope.APPS_READ,- allowed_token_types=frozenset({TokenType.OAUTH_ACCOUNT}),- rbac=RBACCheck(RBACPermission.APP_VIEW_LAYOUT, PlainApp()),+class AppDescribeApi(Resource):+ @endpoint(+ requirements=(+ CheckSubject(allowed=(AccountSubject,)),+ CheckAppApiEnabled(),+ CheckWorkspaceMember(),+ CheckScope(Scope.APPS_READ),+ CheckRBACPermission(RBACCheck(RBACPermission.APP_VIEW_LAYOUT, PlainApp())),+ ),+ query=AppDescribeQuery,+ returns=(200, AppDescribeResponse, "App description"),)- @returns(200, AppDescribeResponse, description="App description")- @accepts(query=AppDescribeQuery)- @with_session(write=False)- def get(self, session: Session, app_id: str, *, auth_data: AuthData, query: AppDescribeQuery):- # describe is UUID-only (workspace_id query param dropped in #37212).- app = self._load(session, app_id)- return build_app_describe_response(app, query.fields, session=session)+ def get(self, ctx: Context, app_id: str, *, query: AppDescribeQuery):+ # The pipeline has already loaded the app; project it.+ return build_app_describe_response(ctx.app, query.fields, session=ctx.session)@openapi_ns.route("/apps")class AppListApi(Resource):- @auth_router.guard_workspace(scope=Scope.APPS_READ, allowed_token_types=frozenset({TokenType.OAUTH_ACCOUNT}))- @returns(200, AppListResponse, description="App list")- @accepts(query=AppListQuery)- @with_session(write=False)- def get(self, session: Session, *, auth_data: AuthData, query: AppListQuery):+ @endpoint(+ requirements=(+ CheckSubject(allowed=(AccountSubject,)),+ CheckScope(Scope.APPS_READ),+ CheckWorkspaceMember(),+ ),+ query=AppListQuery,+ returns=(200, AppListResponse, "App list"),+ )+ def get(self, ctx: Context, *, query: AppListQuery):workspace_id = query.workspace_id+ account_id = str(ctx.subject.account_id)empty = AppListResponse.build(page=query.page, limit=query.limit, total=0, items=[])@@ -163,37 +143,26 @@ class AppListApi(Resource):else:parsed_uuid = None- # Compute RBAC-accessible app IDs when RBAC is enabled and the caller is an account.- # ``None`` means unrestricted (caller can see all apps in the workspace);- # an empty set or list means the caller has no accessible apps.- # End-users bypass RBAC here — their access is controlled by scope upstream.- apply_rbac_filter = (- dify_config.RBAC_ENABLED- and auth_data.caller_kind != CallerKind.END_USER- and auth_data.account_id is not None+ access_filter = (+ resolve_app_access_filter(workspace_id, account_id, session=ctx.session)+ if dify_config.RBAC_ENABLED+ else AppAccessFilter.unrestricted())- access_filter = AppAccessFilter.unrestricted()- if apply_rbac_filter:- access_filter = resolve_app_access_filter(- workspace_id,- str(auth_data.account_id),- session=session,- )tenant_name: str | None = Noneif parsed_uuid is not None:- app: App | None = AppService.get_visible_app_by_id(str(parsed_uuid), session)+ app: App | None = AppService.get_visible_app_by_id(str(parsed_uuid), ctx.session)if app is None or str(app.tenant_id) != workspace_id:return emptyif not _is_listable(app):return empty# Apply RBAC visibility to the UUID fast-path the same way the service# layer does for paginated queries (id in accessible set OR own app).- if apply_rbac_filter and not access_filter.is_app_accessible(- str(app.id), str(app.maintainer) if app.maintainer else None, str(auth_data.account_id)+ if not access_filter.is_app_accessible(+ str(app.id), str(app.maintainer) if app.maintainer else None, account_id):return empty- tenant_name = TenantService.get_tenant_name(workspace_id, session=session)+ tenant_name = TenantService.get_tenant_name(workspace_id, session=ctx.session)item = AppListRow(id=str(app.id),name=app.name,@@ -217,16 +186,15 @@ class AppListApi(Resource):openapi_visible=True,)- if apply_rbac_filter:- access_filter.apply_to_params(params)+ access_filter.apply_to_params(params)- pagination = AppService().get_paginate_apps(str(auth_data.account_id), workspace_id, params, session)+ pagination = AppService().get_paginate_apps(account_id, workspace_id, params, ctx.session)if pagination is None:return emptytenant_name = Noneif pagination.items:- tenant_name = TenantService.get_tenant_name(workspace_id, session=session)+ tenant_name = TenantService.get_tenant_name(workspace_id, session=ctx.session)items = [AppListRow(diff --git a/api/controllers/openapi/apps_permitted_external.py b/api/controllers/openapi/apps_permitted_external.pyindex 284ec0713d9..6d1a82f9ebc 100644--- a/api/controllers/openapi/apps_permitted_external.py+++ b/api/controllers/openapi/apps_permitted_external.py@@ -8,12 +8,9 @@ EE blueprint chain so this module is unreachable there.from __future__ import annotationsfrom flask_restx import Resource-from sqlalchemy.orm import Session-from werkzeug.exceptions import NotFound-from controllers.common.session import with_sessionfrom controllers.openapi import openapi_ns-from controllers.openapi._contract import accepts, returns+from controllers.openapi._contract import endpointfrom controllers.openapi._models import (AppDescribeQuery,AppDescribeResponse,@@ -22,28 +19,37 @@ from controllers.openapi._models import (PermittedExternalAppsListResponse,)from controllers.openapi.apps import build_app_describe_response-from controllers.openapi.auth.composition import auth_router-from controllers.openapi.auth.data import AuthData+from controllers.openapi.auth.context import Context+from controllers.openapi.auth.requirements import (+ CheckAppAccess,+ CheckAppApiEnabled,+ CheckScope,+ CheckSubject,+)+from controllers.openapi.auth.subjects import ExternalSsoSubjectfrom enums import DeploymentEdition-from libs.oauth_bearer import Scope, TokenType+from libs.oauth_bearer import Scopefrom models import Appfrom models.enums import AppStatusfrom services.account_service import TenantServicefrom services.app_service import AppServicefrom services.enterprise.app_permitted_service import list_permitted_apps+_ENTERPRISE_ONLY = frozenset({DeploymentEdition.ENTERPRISE})+@openapi_ns.route("/permitted-external-apps")class PermittedExternalAppsListApi(Resource):- @auth_router.guard(- scope=Scope.APPS_READ_PERMITTED_EXTERNAL,- allowed_token_types=frozenset({TokenType.OAUTH_EXTERNAL_SSO}),- edition=frozenset({DeploymentEdition.ENTERPRISE}),+ @endpoint(+ requirements=(+ CheckSubject(allowed=(ExternalSsoSubject,)),+ CheckScope(Scope.APPS_READ_PERMITTED_EXTERNAL),+ ),+ query=PermittedExternalAppsListQuery,+ returns=(200, PermittedExternalAppsListResponse, "Permitted external apps list"),+ edition=_ENTERPRISE_ONLY,)- @returns(200, PermittedExternalAppsListResponse, description="Permitted external apps list")- @accepts(query=PermittedExternalAppsListQuery)- @with_session(write=False)- def get(self, session: Session, *, auth_data: AuthData, query: PermittedExternalAppsListQuery):+ def get(self, ctx: Context, *, query: PermittedExternalAppsListQuery):page_result = list_permitted_apps(page=query.page,limit=query.limit,@@ -58,10 +64,10 @@ class PermittedExternalAppsListApi(Resource):return envapps_by_id: dict[str, App] = {- str(a.id): a for a in AppService.find_visible_apps_by_ids(page_result.app_ids, session)+ str(a.id): a for a in AppService.find_visible_apps_by_ids(page_result.app_ids, ctx.session)}tenant_ids = list({str(a.tenant_id) for a in apps_by_id.values()})- tenants_by_id = {str(t.id): t for t in TenantService.get_tenants_by_ids(tenant_ids, session=session)}+ tenants_by_id = {str(t.id): t for t in TenantService.get_tenants_by_ids(tenant_ids, session=ctx.session)}items: list[AppListRow] = []for app_id in page_result.app_ids:@@ -88,17 +94,17 @@ class PermittedExternalAppsListApi(Resource):@openapi_ns.route("/permitted-external-apps/<string:app_id>")class PermittedExternalAppDescribeApi(Resource):- @auth_router.guard(- scope=Scope.APPS_READ_PERMITTED_EXTERNAL,- allowed_token_types=frozenset({TokenType.OAUTH_EXTERNAL_SSO}),- edition=frozenset({DeploymentEdition.ENTERPRISE}),+ @endpoint(+ requirements=(+ CheckSubject(allowed=(ExternalSsoSubject,)),+ CheckAppApiEnabled(),+ CheckScope(Scope.APPS_READ_PERMITTED_EXTERNAL),+ CheckAppAccess(),+ ),+ query=AppDescribeQuery,+ returns=(200, AppDescribeResponse, "Permitted external app description"),+ edition=_ENTERPRISE_ONLY,)- @returns(200, AppDescribeResponse, description="Permitted external app description")- @accepts(query=AppDescribeQuery)- @with_session(write=False)- def get(self, session: Session, app_id: str, *, auth_data: AuthData, query: AppDescribeQuery):- # App already loaded and ACL-checked by the external_sso pipeline; project it.- app = auth_data.app- if app is None:- raise NotFound("app not found")- return build_app_describe_response(app, query.fields, session=session)+ def get(self, ctx: Context, app_id: str, *, query: AppDescribeQuery):+ # The pipeline has already loaded and ACL-checked the app; project it.+ return build_app_describe_response(ctx.app, query.fields, session=ctx.session)diff --git a/api/controllers/openapi/auth/__init__.py b/api/controllers/openapi/auth/__init__.pyindex 0460788c183..e69de29bb2d 100644--- a/api/controllers/openapi/auth/__init__.py+++ b/api/controllers/openapi/auth/__init__.py@@ -1,3 +0,0 @@-from controllers.openapi.auth.composition import auth_router--__all__ = ["auth_router"]diff --git a/api/controllers/openapi/auth/composition.py b/api/controllers/openapi/auth/composition.pydeleted file mode 100644index 9040058b85f..00000000000--- a/api/controllers/openapi/auth/composition.py+++ /dev/null@@ -1,82 +0,0 @@-from __future__ import annotations--from controllers.openapi.auth.conditions import (- EDITION_ENTERPRISE,- HAS_ALLOWED_ROLES,- HAS_RBAC,- LOADED_APP_IS_PRIVATE,- PATH_HAS_APP_ID,- WEBAPP_AUTH_ENABLED,- WEBAPP_RUN_SCOPED,- WORKSPACE_MEMBERSHIP_REQUIRED,- WORKSPACE_SCOPED,-)-from controllers.openapi.auth.flow import When-from controllers.openapi.auth.pipeline import AuthPipeline, PipelineRoute, PipelineRouter-from controllers.openapi.auth.prepare import (- load_account,- load_app,- load_app_access_mode,- load_tenant,- load_tenant_from_request,- load_workspace_role,- resolve_external_user,-)-from controllers.openapi.auth.verify import (- check_acl,- check_app_api_enabled,- check_private_app_permission,- check_rbac_permission,- check_scope,- check_workspace_member,- check_workspace_mismatch,- check_workspace_role,-)-from enums import DeploymentEdition-from libs.oauth_bearer import TokenType--account_pipeline = AuthPipeline(- prepare=[- When(PATH_HAS_APP_ID, then=load_app),- When(PATH_HAS_APP_ID, then=load_tenant),- When(WORKSPACE_MEMBERSHIP_REQUIRED, then=load_tenant_from_request),- load_account,- When(WORKSPACE_SCOPED, then=load_workspace_role),- When(PATH_HAS_APP_ID & EDITION_ENTERPRISE, then=load_app_access_mode),- ],- auth=[- When(PATH_HAS_APP_ID, then=check_app_api_enabled),- check_scope,- When(WORKSPACE_SCOPED, then=check_workspace_member),- When(PATH_HAS_APP_ID, then=check_workspace_mismatch),- When(HAS_ALLOWED_ROLES, then=check_workspace_role),- When(HAS_RBAC, then=check_rbac_permission),- When(PATH_HAS_APP_ID & EDITION_ENTERPRISE & WEBAPP_AUTH_ENABLED & WEBAPP_RUN_SCOPED, then=check_acl),- When(EDITION_ENTERPRISE & LOADED_APP_IS_PRIVATE & WEBAPP_RUN_SCOPED, then=check_private_app_permission),- ],-)--external_sso_pipeline = AuthPipeline(- prepare=[- When(PATH_HAS_APP_ID, then=load_app),- When(PATH_HAS_APP_ID, then=load_tenant),- When(PATH_HAS_APP_ID, then=resolve_external_user),- When(PATH_HAS_APP_ID, then=load_app_access_mode),- ],- auth=[- When(PATH_HAS_APP_ID, then=check_app_api_enabled),- check_scope,- When(PATH_HAS_APP_ID & WEBAPP_AUTH_ENABLED, then=check_acl),- When(LOADED_APP_IS_PRIVATE, then=check_private_app_permission),- ],-)--auth_router = PipelineRouter(- {- TokenType.OAUTH_ACCOUNT: PipelineRoute(account_pipeline),- TokenType.OAUTH_EXTERNAL_SSO: PipelineRoute(- external_sso_pipeline,- required_edition=frozenset({DeploymentEdition.ENTERPRISE}),- ),- }-)diff --git a/api/controllers/openapi/auth/conditions.py b/api/controllers/openapi/auth/conditions.pydeleted file mode 100644index 49da949ccab..00000000000--- a/api/controllers/openapi/auth/conditions.py+++ /dev/null@@ -1,65 +0,0 @@-from __future__ import annotations--from collections.abc import Callable--from configs import dify_config-from controllers.openapi.auth.data import AuthData, RequestContext-from enums import DeploymentEdition-from libs.oauth_bearer import Scope, TokenType-from services.enterprise.enterprise_service import WebAppAccessMode-from services.system_feature_service import SystemFeatureService--CondFn = Callable[[RequestContext, AuthData | None], bool]---class Cond:- def __init__(self, fn: CondFn) -> None:- self._fn = fn-- def __call__(self, ctx: RequestContext, data: AuthData | None = None) -> bool:- return self._fn(ctx, data)-- def __and__(self, other: Cond) -> Cond:- return Cond(lambda ctx, data: self(ctx, data) and other(ctx, data))-- def __or__(self, other: Cond) -> Cond:- return Cond(lambda ctx, data: self(ctx, data) or other(ctx, data))-- def __invert__(self) -> Cond:- return Cond(lambda ctx, data: not self(ctx, data))---def request_cond(fn: Callable[[RequestContext], bool]) -> Cond:- return Cond(lambda ctx, _: fn(ctx))---def data_cond(fn: Callable[[AuthData], bool]) -> Cond:- return Cond(lambda _, data: data is not None and fn(data))---def config_cond(fn: Callable[[], bool]) -> Cond:- return Cond(lambda _, __: fn())---TOKEN_IS_OAUTH_ACCOUNT = request_cond(lambda ctx: ctx.token_type == TokenType.OAUTH_ACCOUNT)-TOKEN_IS_OAUTH_EXTERNAL_SSO = request_cond(lambda ctx: ctx.token_type == TokenType.OAUTH_EXTERNAL_SSO)--PATH_HAS_APP_ID = request_cond(lambda ctx: "app_id" in ctx.path_params)--EDITION_COMMUNITY = config_cond(lambda: dify_config.DEPLOYMENT_EDITION == DeploymentEdition.COMMUNITY)-EDITION_ENTERPRISE = config_cond(lambda: dify_config.DEPLOYMENT_EDITION == DeploymentEdition.ENTERPRISE)-EDITION_CLOUD = config_cond(lambda: dify_config.DEPLOYMENT_EDITION == DeploymentEdition.CLOUD)--WEBAPP_AUTH_ENABLED = config_cond(lambda: SystemFeatureService.is_webapp_auth_enabled())--WEBAPP_RUN_SCOPED = request_cond(lambda ctx: ctx.scope == Scope.APPS_RUN)--WORKSPACE_MEMBERSHIP_REQUIRED = request_cond(lambda ctx: ctx.workspace_membership)-HAS_ALLOWED_ROLES = request_cond(lambda ctx: ctx.allowed_roles is not None)-HAS_RBAC = request_cond(lambda ctx: ctx.rbac is not None)--# Caller must belong to the resolved tenant: either an app-scoped path (tenant-# from the app) or an explicit workspace-membership path (tenant from request).-WORKSPACE_SCOPED = PATH_HAS_APP_ID | WORKSPACE_MEMBERSHIP_REQUIRED--LOADED_APP_IS_PRIVATE = data_cond(lambda data: data.app_access_mode == WebAppAccessMode.PRIVATE)diff --git a/api/controllers/openapi/auth/context.py b/api/controllers/openapi/auth/context.pynew file mode 100644index 00000000000..5b44d23d761--- /dev/null+++ b/api/controllers/openapi/auth/context.py@@ -0,0 +1,90 @@+"""What the request resolved, and nothing else: no fetching, no checking, no+opinion about the shape of the request. `loaders.py` fills a slot once; the+properties hand handlers the non-optional value, and raise when no requirement+on the route loaded it, so a handler can never fetch its way past a missing+declaration.++A subject resolves its caller through the loaders, so the import of `Subject`+here is type-only: a runtime one would close the cycle+`context` -> `subjects` -> `loaders` -> `context`.+"""++from __future__ import annotations++from collections.abc import Mapping+from dataclasses import dataclass, field+from typing import TYPE_CHECKING++from sqlalchemy.orm import Session++from models.account import Account, Tenant, TenantAccountRole+from models.model import App, EndUser++if TYPE_CHECKING:+ from controllers.openapi.auth.subjects import Subject++type Caller = Account | EndUser+++class RouteContractError(LookupError):+ """A route's declarations and its code disagree: a handler read a slot no+ requirement loaded, read the caller as a type the route does not admit, or+ a requirement asked for a path parameter the route does not carry. Never+ caught on purpose - it only ever means an endpoint was wired wrong.+ """+++@dataclass+class Context:+ subject: Subject+ session: Session+ view_args: Mapping[str, str]+ _app: App | None = field(default=None, init=False)+ _workspace: Tenant | None = field(default=None, init=False)+ _workspace_role: TenantAccountRole | None = field(default=None, init=False)+ _caller: Caller | None = field(default=None, init=False)++ @property+ def app(self) -> App:+ return _loaded(self._app, "app")++ @property+ def workspace(self) -> Tenant:+ return _loaded(self._workspace, "workspace")++ @property+ def workspace_role(self) -> TenantAccountRole:+ return _loaded(self._workspace_role, "workspace_role")++ @property+ def caller(self) -> Caller:+ # Spelled out: a generic over `T | None` would widen the union to its base.+ if self._caller is None:+ raise _missing("caller")+ return self._caller++ @property+ def account(self) -> Account:+ return _narrowed(self.caller, Account)++ @property+ def end_user(self) -> EndUser:+ return _narrowed(self.caller, EndUser)+++def _loaded[T](value: T | None, name: str) -> T:+ if value is None:+ raise _missing(name)+ return value+++def _missing(name: str) -> RouteContractError:+ return RouteContractError(f"{name} was not loaded: no requirement on this route asked for it")+++def _narrowed[C: Caller](caller: Caller, expected: type[C]) -> C:+ if not isinstance(caller, expected):+ raise RouteContractError(+ f"the caller is a {type(caller).__name__}, not the {expected.__name__} this handler reads"+ )+ return callerdiff --git a/api/controllers/openapi/auth/data.py b/api/controllers/openapi/auth/data.pyindex de6f6eaf0fa..372b9ebd079 100644--- a/api/controllers/openapi/auth/data.py+++ b/api/controllers/openapi/auth/data.py@@ -1,21 +1,8 @@-from __future__ import annotations--import uuid-from enum import StrEnum--from pydantic import BaseModel, ConfigDict, Field-from werkzeug.exceptions import InternalServerError--from controllers.common.rbac import RBACCheck-from libs.oauth_bearer import Scope, TokenType-from models.account import Account, Tenant, TenantAccountRole-from models.model import App, EndUser-from services.enterprise.enterprise_service import WebAppAccessMode+"""The identity an external subject carries."""+from __future__ import annotations-class CallerKind(StrEnum):- ACCOUNT = "account"- END_USER = "end_user"+from pydantic import BaseModel, ConfigDictclass ExternalIdentity(BaseModel):@@ -23,43 +10,3 @@ class ExternalIdentity(BaseModel):email: strissuer: str | None = None---class RequestContext(BaseModel):- model_config = ConfigDict(frozen=True, arbitrary_types_allowed=True)-- token_type: TokenType- scope: Scope | None = None- path_params: dict[str, str]- workspace_membership: bool = False- allowed_roles: frozenset[TenantAccountRole] | None = None- rbac: RBACCheck | None = None---class AuthData(BaseModel):- model_config = ConfigDict(arbitrary_types_allowed=True)-- required_scope: Scope | None = None- token_type: TokenType- account_id: uuid.UUID | None = None- token_id: uuid.UUID | None = None- scopes: frozenset[Scope]- external_identity: ExternalIdentity | None = None- path_params: dict[str, str] = Field(default_factory=dict)-- allowed_roles: frozenset[TenantAccountRole] | None = None- rbac: RBACCheck | None = None-- app: App | None = None- tenant: Tenant | None = None- app_access_mode: WebAppAccessMode | None = None-- tenant_role: TenantAccountRole | None = None-- caller: Account | EndUser | None = None- caller_kind: CallerKind | None = None-- def require_app_context(self) -> tuple[App, Account | EndUser, CallerKind]:- if self.app is None or self.caller is None or self.caller_kind is None:- raise InternalServerError("pipeline_invariant_violated: app context missing")- return self.app, self.caller, self.caller_kinddiff --git a/api/controllers/openapi/auth/flow.py b/api/controllers/openapi/auth/flow.pydeleted file mode 100644index eee1378cf41..00000000000--- a/api/controllers/openapi/auth/flow.py+++ /dev/null@@ -1,19 +0,0 @@-from __future__ import annotations--from collections.abc import Callable-from typing import Any--from controllers.openapi.auth.conditions import Cond-from controllers.openapi.auth.data import AuthData, RequestContext---class When:- def __init__(self, condition: Cond, *, then: Callable[[Any], None]) -> None:- self.condition = condition- self._step = then-- def applies(self, ctx: RequestContext, data: AuthData | None = None) -> bool:- return self.condition(ctx, data)-- def __call__(self, arg: Any) -> None:- self._step(arg)diff --git a/api/controllers/openapi/auth/loaders.py b/api/controllers/openapi/auth/loaders.pynew file mode 100644index 00000000000..12e5b846be6--- /dev/null+++ b/api/controllers/openapi/auth/loaders.py@@ -0,0 +1,137 @@+from __future__ import annotations++import uuid+from enum import StrEnum++from flask import request+from werkzeug.exceptions import Forbidden, NotFound++from controllers.openapi.auth.context import Caller, Context, RouteContractError+from models.account import Account, AccountStatus, Tenant, TenantAccountRole, TenantStatus+from models.enums import AppStatus+from models.model import App, EndUser+from services.account_service import TenantService+from services.app_service import AppService+++class PathParam(StrEnum):+ """The route path parameters the auth layer reads."""++ APP_ID = "app_id"+ WORKSPACE_ID = "workspace_id"+ FORM_TOKEN = "form_token"+++def route_has_app(ctx: Context) -> bool:+ """Whether the route carries an app at all, read off the path params the+ router stored. The store holds what the request resolved; the shape of the+ request is a question its readers answer for themselves.+ """+ return PathParam.APP_ID in ctx.view_args+++def load_app(ctx: Context) -> App:+ """The boundary where an unset field becomes a value: fetched once per+ request, and non-optional from here on, so nothing downstream re-checks.+ """+ if ctx._app is None:+ ctx._app = _fetch_app(ctx)+ return ctx._app+++def load_workspace(ctx: Context) -> Tenant:+ if ctx._workspace is None:+ ctx._workspace = _fetch_workspace(ctx)+ return ctx._workspace+++def load_caller(ctx: Context) -> Caller:+ if ctx._caller is None:+ ctx._caller = ctx.subject.resolve_caller(ctx, ctx.session)+ return ctx._caller+++def load_account(ctx: Context) -> Account:+ return _load_caller_as(ctx, Account)+++def load_end_user(ctx: Context) -> EndUser:+ return _load_caller_as(ctx, EndUser)+++def _load_caller_as[C: Caller](ctx: Context, expected: type[C]) -> C:+ caller = load_caller(ctx)+ if not isinstance(caller, expected):+ raise Forbidden("unsupported_token_type")+ return caller+++def load_workspace_role(ctx: Context) -> TenantAccountRole:+ if ctx._workspace_role is None:+ ctx._workspace_role = _fetch_workspace_role(ctx)+ return ctx._workspace_role+++def _path_param(ctx: Context, name: str) -> str:+ try:+ return ctx.view_args[name]+ except KeyError:+ raise RouteContractError(+ f"{name} is not a path parameter of this route: the requirement asking for it does not belong here"+ )+++def _fetch_app(ctx: Context) -> App:+ raw = _path_param(ctx, PathParam.APP_ID)+ try:+ # Canonical dashed form, so a bare-hex path parameter names the same app.+ app_id = str(uuid.UUID(raw))+ except ValueError:+ raise NotFound("app not found")+ app = AppService.get_app_by_id(app_id, ctx.session)+ if not app or app.status != AppStatus.NORMAL:+ raise NotFound("app not found")+ return app+++def _fetch_workspace(ctx: Context) -> Tenant:+ """Not a check that can be skipped, a source that follows the route: an+ app-scoped route takes its workspace from the app, every other one from the+ request. Both raise when their own source is absent.+ """+ if route_has_app(ctx):+ return _workspace_from_app(ctx)+ return _workspace_from_request(ctx)+++def _workspace_from_app(ctx: Context) -> Tenant:+ app = load_app(ctx)+ tenant = TenantService.get_tenant_by_id(str(app.tenant_id), session=ctx.session)+ if tenant is None or tenant.status == TenantStatus.ARCHIVE:+ raise Forbidden("workspace unavailable")+ return tenant+++def _workspace_from_request(ctx: Context) -> Tenant:+ workspace_id = ctx.view_args.get(PathParam.WORKSPACE_ID) or request.args.get(PathParam.WORKSPACE_ID)+ if not workspace_id:+ raise NotFound("workspace not found")+ try:+ uuid.UUID(workspace_id)+ except ValueError:+ raise NotFound("workspace not found")+ tenant = TenantService.get_tenant_by_id(workspace_id, session=ctx.session)+ if tenant is None or tenant.status == TenantStatus.ARCHIVE:+ raise NotFound("workspace not found")+ return tenant+++def _fetch_workspace_role(ctx: Context) -> TenantAccountRole:+ workspace = load_workspace(ctx)+ caller = load_caller(ctx)+ if not isinstance(caller, Account) or caller.status != AccountStatus.ACTIVE:+ raise NotFound("workspace not found")+ role = TenantService.get_account_role_in_tenant(str(ctx.subject.account_id), str(workspace.id), session=ctx.session)+ if role is None:+ raise NotFound("workspace not found")+ return rolediff --git a/api/controllers/openapi/auth/pipeline.py b/api/controllers/openapi/auth/pipeline.pydeleted file mode 100644index bb32927725d..00000000000--- a/api/controllers/openapi/auth/pipeline.py+++ /dev/null@@ -1,285 +0,0 @@-"""Auth pipeline — entry point for all openapi auth.--`PipelineRouter.guard()` is the only attachment point for endpoints.-`AuthPipeline` is a pure step-runner with no routing concerns.-`PipelineRoute` binds a pipeline to optional edition requirements.-"""--from __future__ import annotations--from collections.abc import Callable-from dataclasses import dataclass-from functools import wraps-from typing import Any--from flask import current_app, request-from flask_login import user_logged_in-from werkzeug.exceptions import Forbidden, NotFound, Unauthorized--from configs import dify_config-from controllers.common.rbac import RBACCheck-from controllers.openapi._audit import emit_wrong_surface-from controllers.openapi.auth.data import (- AuthData,- ExternalIdentity,- RequestContext,-)-from controllers.openapi.auth.flow import When-from enums import DeploymentEdition-from libs.oauth_bearer import (- AuthContext,- Scope,- TokenType,- extract_bearer,- get_authenticator,- reset_auth_ctx,- set_auth_ctx,-)-from models.account import TenantAccountRole-from services.entities.feature_entities import LicenseStatus-from services.system_feature_service import SystemFeatureService---class AuthPipeline:- """Pure step-runner — no routing, no guard.-- Both `prepare` and `auth` steps receive the same `AuthData` instance.- `prepare` steps populate it; `auth` steps validate it.- """-- def __init__(self, prepare: list, auth: list) -> None:- self._prepare = prepare- self._auth = auth-- def _run(- self,- identity: AuthContext,- args: tuple,- kwargs: dict,- view: Callable,- *,- scope: Scope | None,- workspace_membership: bool = False,- allowed_roles: frozenset[TenantAccountRole] | None = None,- rbac: RBACCheck | None = None,- ) -> Any:- req_ctx = RequestContext(- token_type=identity.token_type,- scope=scope,- path_params=dict(request.view_args or {}),- workspace_membership=workspace_membership,- allowed_roles=allowed_roles,- rbac=rbac,- )-- data = AuthData(- token_type=identity.token_type,- account_id=identity.account_id,- token_id=identity.token_id,- scopes=frozenset(identity.scopes),- required_scope=scope,- allowed_roles=allowed_roles,- rbac=rbac,- path_params=dict(req_ctx.path_params),- external_identity=(- ExternalIdentity(email=identity.subject_email, issuer=identity.subject_issuer)- if identity.subject_email- else None- ),- )-- for step in self._prepare:- if _should_run(step, req_ctx, data=None):- step(data)-- for step in self._auth:- if _should_run(step, req_ctx, data=data):- step(data)-- reset_token = set_auth_ctx(identity)- if data.caller:- _mount_flask_login(data.caller)-- try:- kwargs["auth_data"] = data- return view(*args, **kwargs)- finally:- reset_auth_ctx(reset_token)---@dataclass(frozen=True)-class PipelineRoute:- pipeline: AuthPipeline- required_edition: frozenset[DeploymentEdition] | None = None---class PipelineRouter:- """Entry point for openapi auth.-- `guard()` is the decorator that endpoints attach to. It applies- global gates (edition, license, token type) then dispatches to the- matching `PipelineRoute` for the token type.- """-- def __init__(self, routes: dict[TokenType, PipelineRoute]) -> None:- self._routes = routes-- def guard(- self,- *,- scope: Scope | None = None,- allowed_token_types: frozenset[TokenType] | None = None,- edition: frozenset[DeploymentEdition] | None = None,- require_valid_enterprise_license: bool = False,- workspace_membership: bool = False,- allowed_roles: frozenset[TenantAccountRole] | None = None,- rbac: RBACCheck | None = None,- ) -> Callable:- return self._make_decorator(- scope=scope,- allowed_token_types=allowed_token_types,- edition=edition,- require_valid_enterprise_license=require_valid_enterprise_license,- workspace_membership=workspace_membership,- allowed_roles=allowed_roles,- rbac=rbac,- )-- def guard_workspace(- self,- *,- scope: Scope | None = None,- allowed_token_types: frozenset[TokenType] | None = None,- edition: frozenset[DeploymentEdition] | None = None,- require_valid_enterprise_license: bool = False,- allowed_roles: frozenset[TenantAccountRole] | None = None,- rbac: RBACCheck | None = None,- ) -> Callable:- return self._make_decorator(- scope=scope,- allowed_token_types=allowed_token_types,- edition=edition,- require_valid_enterprise_license=require_valid_enterprise_license,- workspace_membership=True,- allowed_roles=allowed_roles,- rbac=rbac,- )-- def _make_decorator(- self,- *,- scope: Scope | None,- allowed_token_types: frozenset[TokenType] | None,- edition: frozenset[DeploymentEdition] | None,- require_valid_enterprise_license: bool,- workspace_membership: bool,- allowed_roles: frozenset[TenantAccountRole] | None,- rbac: RBACCheck | None,- ) -> Callable:- def decorator(view: Callable) -> Callable:- @wraps(view)- def decorated(*args: Any, **kwargs: Any) -> Any:- return self._execute(- args,- kwargs,- view,- scope=scope,- allowed_token_types=allowed_token_types,- edition=edition,- require_valid_enterprise_license=require_valid_enterprise_license,- workspace_membership=workspace_membership,- allowed_roles=allowed_roles,- rbac=rbac,- )-- return decorated-- return decorator-- def _execute(- self,- args: tuple,- kwargs: dict,- view: Callable,- *,- scope: Scope | None,- allowed_token_types: frozenset[TokenType] | None,- edition: frozenset[DeploymentEdition] | None,- require_valid_enterprise_license: bool,- workspace_membership: bool = False,- allowed_roles: frozenset[TenantAccountRole] | None = None,- rbac: RBACCheck | None = None,- ) -> Any:- # 404 not 403 — this edition doesn't expose the feature at all- if edition is not None and dify_config.DEPLOYMENT_EDITION not in edition:- raise NotFound()-- license_checked = False- if dify_config.DEPLOYMENT_EDITION == DeploymentEdition.ENTERPRISE and (- require_valid_enterprise_license or (edition is not None and DeploymentEdition.ENTERPRISE in edition)- ):- _check_license()- license_checked = True-- token = extract_bearer(request)- if not token:- raise Unauthorized("bearer required")-- identity = get_authenticator().authenticate(token)-- if allowed_token_types is not None and identity.token_type not in allowed_token_types:- emit_wrong_surface(- subject_type=_subject_type_str(identity),- attempted_path=request.path,- client_id=getattr(identity, "client_id", None),- token_id=str(identity.token_id) if identity.token_id else None,- )- raise Forbidden("unsupported_token_type")-- route = self._routes.get(identity.token_type)- if route is None:- raise Forbidden("unsupported_token_type")-- if route.required_edition is not None:- if dify_config.DEPLOYMENT_EDITION not in route.required_edition:- raise Forbidden("external_sso_requires_ee")- if not license_checked and DeploymentEdition.ENTERPRISE in route.required_edition:- _check_license()-- return route.pipeline._run(- identity,- args,- kwargs,- view,- scope=scope,- workspace_membership=workspace_membership,- allowed_roles=allowed_roles,- rbac=rbac,- )---def _should_run(step: Any, req_ctx: RequestContext, data: AuthData | None) -> bool:- if isinstance(step, When):- return step.applies(req_ctx, data)- return True---def _subject_type_str(identity: Any) -> str | None:- subject = getattr(identity, "subject_type", None)- if subject is None:- return None- return subject.value if hasattr(subject, "value") else str(subject)---def _check_license() -> None:- if SystemFeatureService.get_license_status() in {- LicenseStatus.INACTIVE,- LicenseStatus.EXPIRED,- LicenseStatus.LOST,- }:- raise Forbidden("license_invalid")---def _mount_flask_login(user: Any) -> None:- current_app.login_manager._update_request_context_with_user(user) # type: ignore[attr-defined]- user_logged_in.send(current_app._get_current_object(), user=user) # type: ignore[attr-defined]diff --git a/api/controllers/openapi/auth/pipelines.py b/api/controllers/openapi/auth/pipelines.pynew file mode 100644index 00000000000..32faec7176a--- /dev/null+++ b/api/controllers/openapi/auth/pipelines.py@@ -0,0 +1,102 @@+from __future__ import annotations++from collections.abc import Callable, Generator+from contextlib import contextmanager+from typing import Any, ClassVar, override++from flask import current_app+from flask_login import user_logged_in+from sqlalchemy.orm import Session+from werkzeug.exceptions import Forbidden++from configs import dify_config+from controllers.openapi.auth.context import Context+from controllers.openapi.auth.loaders import load_caller+from controllers.openapi.auth.requirements import (+ Rank,+ Requirement,+ ResolveCaller,+)+from controllers.openapi.auth.spec import EndpointSpec+from controllers.openapi.auth.subjects import AccountSubject, ExternalSsoSubject, Subject+from enums import DeploymentEdition+from libs.oauth_bearer import AuthContext, reset_auth_ctx, set_auth_ctx+from models.account import Account+from models.model import EndUser++_PIPELINES: dict[type[Subject], Pipeline] = {}+++class Pipeline:+ fixed: ClassVar[tuple[Requirement, ...]] = ()++ def __init_subclass__(cls, serves: type[Subject] | None = None, **kwargs: object) -> None:+ super().__init_subclass__(**kwargs)+ if serves is not None:+ _PIPELINES[serves] = cls()++ def run(+ self,+ *,+ subject: Subject,+ auth: AuthContext,+ spec: EndpointSpec,+ ctx: Context,+ session: Session,+ call: Callable[..., Any],+ ) -> Any:+ """Endpoint-declared requirements are merged ahead of the fixed ones,+ so a stable sort leaves them first at equal rank — which is what keeps+ `CheckSubject` ahead of `_RequiresEnterprise`.+ """+ for requirement in sorted(spec.requirements + self.fixed, key=lambda item: item.rank):+ requirement.run(subject, ctx, session)+ with mounted(subject, auth, ctx):+ return call(ctx=ctx)+++def pipeline_for_subject(subject: Subject) -> Pipeline:+ return _PIPELINES[type(subject)]+++class AccountPipeline(Pipeline, serves=AccountSubject):+ fixed = (ResolveCaller(),)+++class _RequiresEnterprise(Requirement):+ """A gate on the token kind, not on a route, so no endpoint declares it.+ It runs after `authenticate` on purpose: a `dfoe_` string no row backs+ answers 401 like any bad bearer, so the edition cannot be probed. The+ licence is the router's, checked before any bearer is read.+ """++ rank = Rank.FIRST++ @override+ def run(self, subject: Subject, ctx: Context, session: Session) -> None:+ if dify_config.DEPLOYMENT_EDITION != DeploymentEdition.ENTERPRISE:+ raise Forbidden("external_sso_requires_ee")+++class ExternalSsoPipeline(Pipeline, serves=ExternalSsoSubject):+ fixed = (+ _RequiresEnterprise(),+ ResolveCaller(),+ )+++@contextmanager+def mounted(subject: Subject, auth: AuthContext, ctx: Context) -> Generator[None]:+ user = load_caller(ctx) if subject.mounts_caller(ctx) else None+ reset_token = set_auth_ctx(auth)+ try:+ if user is not None:+ _mount_flask_login(user)+ yield+ finally:+ reset_auth_ctx(reset_token)+++def _mount_flask_login(user: Account | EndUser) -> None:+ current_app.login_manager._update_request_context_with_user(user) # type: ignore[attr-defined]+ user_logged_in.send(current_app._get_current_object(), user=user) # type: ignore[attr-defined]diff --git a/api/controllers/openapi/auth/prepare.py b/api/controllers/openapi/auth/prepare.pydeleted file mode 100644index 8cf63fd1c9a..00000000000--- a/api/controllers/openapi/auth/prepare.py+++ /dev/null@@ -1,112 +0,0 @@-from __future__ import annotations--import uuid--from flask import request-from werkzeug.exceptions import Forbidden, InternalServerError, NotFound, Unauthorized--from controllers.openapi.auth.data import AuthData, CallerKind-from core.db.session_factory import session_factory-from models.account import AccountStatus, TenantStatus-from models.enums import AppStatus, EndUserType-from services.account_service import AccountService, TenantService-from services.app_service import AppService-from services.end_user_service import EndUserService-from services.enterprise.enterprise_service import EnterpriseService, WebAppAccessMode---def load_app(data: AuthData) -> None:- if data.app is not None:- return- app_id = data.path_params["app_id"]- try:- uuid.UUID(app_id)- except ValueError:- raise NotFound("app not found")- with session_factory.create_session() as session:- app = AppService.get_app_by_id(app_id, session)- if not app or app.status != AppStatus.NORMAL:- raise NotFound("app not found")- data.app = app---def load_tenant(data: AuthData) -> None:- if data.tenant is not None:- return- if data.app is None:- raise InternalServerError("pipeline_invariant_violated: app not loaded before load_tenant")- with session_factory.create_session() as session:- tenant = TenantService.get_tenant_by_id(str(data.app.tenant_id), session=session)- if tenant is None or tenant.status == TenantStatus.ARCHIVE:- raise Forbidden("workspace unavailable")- data.tenant = tenant---def load_tenant_from_request(data: AuthData) -> None:- if data.tenant is not None:- return- workspace_id = data.path_params.get("workspace_id") or request.args.get("workspace_id")- if not workspace_id:- raise NotFound("workspace not found")- try:- uuid.UUID(workspace_id)- except ValueError:- raise NotFound("workspace not found")- with session_factory.create_session() as session:- tenant = TenantService.get_tenant_by_id(workspace_id, session=session)- if tenant is None or tenant.status == TenantStatus.ARCHIVE:- raise NotFound("workspace not found")- data.tenant = tenant---def load_account(data: AuthData) -> None:- if data.caller is not None:- return- with session_factory.create_session() as session:- account = AccountService.get_account_by_id(str(data.account_id), session=session)- if account is None:- raise Unauthorized("account not found")- if data.tenant:- account.set_current_tenant_with_session(data.tenant, session=session)- data.caller = account- data.caller_kind = CallerKind.ACCOUNT---def load_workspace_role(data: AuthData) -> None:- if data.tenant_role is not None:- return- if data.tenant is None or data.account_id is None:- return- if data.caller is not None and getattr(data.caller, "status", None) != AccountStatus.ACTIVE:- return- with session_factory.create_session() as session:- role = TenantService.get_account_role_in_tenant(str(data.account_id), str(data.tenant.id), session=session)- if role is None:- return- data.tenant_role = role---def resolve_external_user(data: AuthData) -> None:- if data.tenant is None or data.app is None or data.external_identity is None:- raise Unauthorized("missing context for external user resolution")- end_user = EndUserService.get_or_create_end_user_by_type(- EndUserType.OPENAPI,- tenant_id=str(data.tenant.id),- app_id=str(data.app.id),- user_id=data.external_identity.email,- )- data.caller = end_user- data.caller_kind = CallerKind.END_USER---def load_app_access_mode(data: AuthData) -> None:- if data.app is None:- return- try:- settings = EnterpriseService.WebAppAuth.get_app_access_mode_by_id(app_id=str(data.app.id))- if settings is None:- data.app_access_mode = None- return- data.app_access_mode = WebAppAccessMode(settings.access_mode)- except ValueError:- data.app_access_mode = Nonediff --git a/api/controllers/openapi/auth/requirements.py b/api/controllers/openapi/auth/requirements.pynew file mode 100644index 00000000000..a6446cadabd--- /dev/null+++ b/api/controllers/openapi/auth/requirements.py@@ -0,0 +1,208 @@+"""Self-contained authorization requirements.++Requirements are process-lifetime singletons: built once at import, shared by+every request and every thread. Config belongs in `__init__`, and `run` must+neither cache nor mutate — a cache here would outlive the fact it recorded.+Per-request caching belongs in `loaders.py`, which stores into `Context`.+"""++from __future__ import annotations++from abc import ABC, abstractmethod+from collections.abc import Sequence+from enum import IntEnum+from typing import ClassVar, override++from flask import request+from sqlalchemy.orm import Session+from werkzeug.exceptions import Forbidden++from configs import dify_config+from controllers.common.rbac import RBACCheck, enforce_rbac_checks+from controllers.openapi._audit import emit_wrong_surface+from controllers.openapi.auth.context import Context+from controllers.openapi.auth.loaders import load_app, load_caller, load_workspace, load_workspace_role+from controllers.openapi.auth.subjects import Subject+from enums import DeploymentEdition+from libs.oauth_bearer import Scope+from models.account import TenantAccountRole+from models.enums import CreatorUserRole+from services.enterprise.enterprise_service import EnterpriseService, WebAppAccessMode+from services.entities.feature_entities import LicenseStatus+from services.system_feature_service import SystemFeatureService++_DEAD_LICENSE_STATUSES = frozenset({LicenseStatus.INACTIVE, LicenseStatus.EXPIRED, LicenseStatus.LOST})+++class Rank(IntEnum):+ """Three bands, coarsest first. Ties fall back to declaration order —+ endpoint-declared ahead of pipeline-fixed — so `Pipeline.run`'s sort stays+ stable rather than needing every requirement in its own band.+ """++ FIRST = 0 # reject the caller before anything touches data+ EARLY = 10 # must precede permission checks+ NORMAL = 20 # default - declared order decides+++class Requirement(ABC):+ rank: ClassVar[Rank] = Rank.NORMAL++ @abstractmethod+ def run(self, subject: Subject, ctx: Context, session: Session) -> None: ...+++class CheckSubject(Requirement):+ rank = Rank.FIRST++ def __init__(self, *, allowed: Sequence[type[Subject]]) -> None:+ self.allowed = tuple(allowed)++ @override+ def run(self, subject: Subject, ctx: Context, session: Session) -> None:+ if isinstance(subject, self.allowed):+ return+ emit_wrong_surface(+ subject_type=subject.subject_type.value,+ attempted_path=request.path,+ client_id=subject.client_id,+ token_id=str(subject.token_id) if subject.token_id else None,+ )+ raise Forbidden("unsupported_token_type")+++def assert_license_valid() -> None:+ """The router's deployment-wide gate, answered before `extract_bearer`."""+ if SystemFeatureService.get_public_system_features().license.status in _DEAD_LICENSE_STATUSES:+ raise Forbidden("license_invalid")+++class CheckAppApiEnabled(Requirement):+ rank = Rank.EARLY++ @override+ def run(self, subject: Subject, ctx: Context, session: Session) -> None:+ if not load_app(ctx).enable_api:+ raise Forbidden("service_api_disabled")+++class CheckWorkspaceMember(Requirement):+ """Resolving the role *is* the check: `load_workspace_role` 404s a non-member.++ Which workspace that is follows from the route — the app's on an app-scoped+ one, the path or query parameter otherwise — so this one requirement serves+ both. It cannot be inferred and left implicit: `GET /apps` takes its+ workspace from the query string, and `GET /workspaces/<workspace_id>` has+ the path parameter but gets no membership check.+ """++ rank = Rank.EARLY++ @override+ def run(self, subject: Subject, ctx: Context, session: Session) -> None:+ if subject.caller_role is not CreatorUserRole.ACCOUNT:+ return+ load_workspace_role(ctx)+++class CheckScope(Requirement):+ def __init__(self, scope: Scope) -> None:+ self.scope = scope++ @override+ def run(self, subject: Subject, ctx: Context, session: Session) -> None:+ if Scope.FULL in subject.scopes or self.scope in subject.scopes:+ return+ raise Forbidden("insufficient_scope")+++class CheckRBACPermission(Requirement):+ """The same check bundles the console's `rbac_permission_required` takes.+ Inert wherever RBAC is off; a route that needs a check there declares a+ `CheckWorkspaceRole` beside this.+ """++ def __init__(self, *checks: RBACCheck) -> None:+ if not checks:+ raise ValueError("CheckRBACPermission requires at least one RBACCheck")+ self.checks = checks++ @override+ def run(self, subject: Subject, ctx: Context, session: Session) -> None:+ if subject.caller_role is not CreatorUserRole.ACCOUNT:+ return+ if not dify_config.RBAC_ENABLED:+ return+ enforce_rbac_checks(+ tenant_id=str(load_workspace(ctx).id),+ account_id=str(subject.account_id),+ checks=self.checks,+ path_args=dict(ctx.view_args),+ )+++class CheckWorkspaceRole(Requirement):+ """The workspace-role gate that predates RBAC. Inert wherever RBAC is on;+ a route that needs a check there declares a `CheckRBACPermission` beside this.+ """++ def __init__(self, allowed_roles: frozenset[TenantAccountRole]) -> None:+ self.allowed_roles = allowed_roles++ @override+ def run(self, subject: Subject, ctx: Context, session: Session) -> None:+ if subject.caller_role is not CreatorUserRole.ACCOUNT:+ return+ if dify_config.RBAC_ENABLED:+ return+ if load_workspace_role(ctx) not in self.allowed_roles:+ raise Forbidden("insufficient workspace role")+++class CheckAppAccess(Requirement):+ """Run-scope comes from the declaration site, so it is not re-checked here.++ The ACL is gated on `webapp_auth.enabled` and the private-app check is not:+ the asymmetry is deliberate, not an oversight.+ """++ @override+ def run(self, subject: Subject, ctx: Context, session: Session) -> None:+ if dify_config.DEPLOYMENT_EDITION != DeploymentEdition.ENTERPRISE:+ return+ access_mode = self._access_mode(str(load_app(ctx).id))+ if SystemFeatureService.get_public_system_features().webapp_auth.enabled:+ self._assert_mode_allowed(subject, access_mode)+ if access_mode == WebAppAccessMode.PRIVATE:+ self._assert_private_app_permission(subject, ctx, session)++ def _access_mode(self, app_id: str) -> WebAppAccessMode | None:+ try:+ settings = EnterpriseService.WebAppAuth.get_app_access_mode_by_id(app_id=app_id)+ if settings is None:+ return None+ return WebAppAccessMode(settings.access_mode)+ except ValueError:+ return None++ def _assert_mode_allowed(self, subject: Subject, access_mode: WebAppAccessMode | None) -> None:+ if access_mode is None:+ raise Forbidden("app or access mode not loaded")+ if access_mode not in subject.webapp_modes:+ raise Forbidden("subject_not_allowed_for_access_mode")++ def _assert_private_app_permission(self, subject: Subject, ctx: Context, session: Session) -> None:+ user_id = subject.webapp_user_id(session)+ if user_id is None:+ raise Forbidden("cannot resolve user for private app check")+ app_id = load_app(ctx).id+ if not EnterpriseService.WebAppAuth.is_user_allowed_to_access_webapp(user_id=user_id, app_id=app_id):+ raise Forbidden("user_not_allowed_for_private_app")+++class ResolveCaller(Requirement):+ @override+ def run(self, subject: Subject, ctx: Context, session: Session) -> None:+ if not subject.mounts_caller(ctx):+ return+ load_caller(ctx)diff --git a/api/controllers/openapi/auth/router.py b/api/controllers/openapi/auth/router.pynew file mode 100644index 00000000000..a2c3714f41d--- /dev/null+++ b/api/controllers/openapi/auth/router.py@@ -0,0 +1,81 @@+from __future__ import annotations++from collections.abc import Callable+from functools import partial, wraps+from typing import Any++from flask import request+from werkzeug.exceptions import NotFound, Unauthorized++from configs import dify_config+from controllers.openapi.auth.context import Context+from controllers.openapi.auth.pipelines import pipeline_for_subject+from controllers.openapi.auth.requirements import assert_license_valid+from controllers.openapi.auth.spec import EndpointSpec+from controllers.openapi.auth.subjects import subject_from_auth+from core.db.session_factory import session_factory+from enums import DeploymentEdition+from libs.oauth_bearer import InvalidBearerError, assert_bearer_feature_enabled, extract_bearer, get_authenticator+++class AuthRouter:+ def guard(self, spec: EndpointSpec) -> Callable[[Callable[..., Any]], Callable[..., Any]]:+ def decorator(view: Callable[..., Any]) -> Callable[..., Any]:+ @wraps(view)+ def decorated(*args: Any, **kwargs: Any) -> Any:+ return self._execute(spec, partial(view, *args, **kwargs))++ return decorated++ return decorator++ def _execute(self, spec: EndpointSpec, call: Callable[..., Any]) -> Any:+ """The order is the contract. An endpoint the edition does not expose+ answers 404 before anything reveals whether the bearer was valid, and+ an enterprise deployment's licence answers 403 before the missing-bearer+ 401. The licence is a fact about the deployment, not the route or the+ caller, so this is the one place it is checked. The bearer feature flag+ is the same kind of fact and answers 503 next.+ """+ if spec.edition is not None and dify_config.DEPLOYMENT_EDITION not in spec.edition:+ raise NotFound()+ if dify_config.DEPLOYMENT_EDITION == DeploymentEdition.ENTERPRISE:+ assert_license_valid()+ assert_bearer_feature_enabled()++ token = extract_bearer(request)+ if not token:+ raise Unauthorized("bearer required")++ try:+ auth = get_authenticator().authenticate(token)+ except InvalidBearerError:+ # One answer for every rejection reason - unknown prefix, no live row,+ # expired - so a caller cannot probe which one it hit. Same reasoning as+ # the 404-not-403 elsewhere on this surface.+ raise Unauthorized("invalid bearer")+ subject = subject_from_auth(auth)+ pipeline = pipeline_for_subject(subject)++ # One session spans the loaders and the handler, so the objects the+ # requirements load stay attached while the handler reads them. It is+ # finalised here, like `with_session` does, until repositories own it.+ with session_factory.create_session() as session:+ ctx = Context(subject, session, dict(request.view_args or {}))+ try:+ result = pipeline.run(+ subject=subject,+ auth=auth,+ spec=spec,+ ctx=ctx,+ session=session,+ call=call,+ )+ except Exception:+ session.rollback() # guard-ignore: no-new-controller-sqlalchemy -- the router owns the rollback+ raise+ session.commit()+ return result+++subject_router = AuthRouter()diff --git a/api/controllers/openapi/auth/spec.py b/api/controllers/openapi/auth/spec.pynew file mode 100644index 00000000000..1fa69fd482e--- /dev/null+++ b/api/controllers/openapi/auth/spec.py@@ -0,0 +1,23 @@+"""`@endpoint` builds one at decoration time and attaches it as `view.__spec__`;+the router reads nothing else off the view. It lives in `auth/` so the+dependency runs `_contract.py` -> `auth/` and never back.+"""++from __future__ import annotations++from dataclasses import dataclass++from controllers.openapi.auth.requirements import Requirement+from enums import DeploymentEdition+++@dataclass(frozen=True, slots=True)+class EndpointSpec:+ """`edition` is the endpoint-level gate — a 404 raised before any bearer+ is read, because the route is not exposed on this edition at all. It is+ not `ExternalSsoPipeline`'s own gate, which 403s a token kind after+ authentication.+ """++ requirements: tuple[Requirement, ...]+ edition: frozenset[DeploymentEdition] | None = Nonediff --git a/api/controllers/openapi/auth/subjects.py b/api/controllers/openapi/auth/subjects.pynew file mode 100644index 00000000000..2bac031e0bb--- /dev/null+++ b/api/controllers/openapi/auth/subjects.py@@ -0,0 +1,150 @@+"""`TokenType` in `libs/oauth_bearer` owns the mint-time facts (prefix, subject,+scopes); a `Subject` owns the request-time behaviour, so `libs/` never has to+import the auth layer.+"""++from __future__ import annotations++import uuid+from abc import ABC, abstractmethod+from typing import ClassVar, override++from sqlalchemy.orm import Session+from werkzeug.exceptions import Unauthorized++from controllers.openapi.auth.context import Context+from controllers.openapi.auth.data import ExternalIdentity+from controllers.openapi.auth.loaders import load_app, load_workspace, route_has_app+from libs.oauth_bearer import AuthContext, Scope, SubjectType+from models.account import Account+from models.enums import CreatorUserRole, EndUserType+from models.model import EndUser+from services.account_service import AccountService+from services.end_user_service import EndUserService+from services.enterprise.enterprise_service import WebAppAccessMode++_SUBJECT_CLASSES: dict[SubjectType, type[Subject]] = {}+++class Subject(ABC):+ subject_type: ClassVar[SubjectType]+ caller_role: ClassVar[CreatorUserRole]+ webapp_modes: ClassVar[frozenset[WebAppAccessMode]]++ def __init_subclass__(cls, **kwargs: object) -> None:+ super().__init_subclass__(**kwargs)+ _SUBJECT_CLASSES[cls.subject_type] = cls++ def __init__(self, auth: AuthContext) -> None:+ self._auth = auth++ @property+ def auth(self) -> AuthContext:+ return self._auth++ @property+ def account_id(self) -> uuid.UUID | None:+ return self._auth.account_id++ @property+ def client_id(self) -> str | None:+ return self._auth.client_id++ @property+ def token_id(self) -> uuid.UUID:+ return self._auth.token_id++ @property+ def scopes(self) -> frozenset[Scope]:+ return self._auth.scopes++ @abstractmethod+ def resolve_caller(self, ctx: Context, session: Session) -> Account | EndUser:+ """Loads whatever workspace or app it needs itself, so a subject that+ lands on a route carrying neither fails where the requirement is,+ rather than silently resolving a caller bound to nothing.+ """++ @abstractmethod+ def mounts_caller(self, ctx: Context) -> bool: ...++ @abstractmethod+ def webapp_user_id(self, session: Session) -> str | None: ...+++class AccountSubject(Subject):+ subject_type = SubjectType.ACCOUNT+ caller_role = CreatorUserRole.ACCOUNT+ webapp_modes = frozenset(+ {+ WebAppAccessMode.PUBLIC,+ WebAppAccessMode.SSO_VERIFIED,+ WebAppAccessMode.PRIVATE_ALL,+ WebAppAccessMode.PRIVATE,+ }+ )++ @override+ def resolve_caller(self, ctx: Context, session: Session) -> Account:+ account = AccountService.get_account_by_id(str(self.account_id), session=session)+ if account is None:+ raise Unauthorized("account not found")+ if ctx._workspace is not None:+ account.set_current_tenant_with_session(ctx._workspace, session=session)+ return account++ @override+ def mounts_caller(self, ctx: Context) -> bool:+ return True++ @override+ def webapp_user_id(self, session: Session) -> str | None:+ return str(self.account_id) if self.account_id is not None else None+++class ExternalSsoSubject(Subject):+ subject_type = SubjectType.EXTERNAL_SSO+ caller_role = CreatorUserRole.END_USER+ webapp_modes = frozenset(+ {+ WebAppAccessMode.PUBLIC,+ WebAppAccessMode.SSO_VERIFIED,+ }+ )++ @property+ def external_identity(self) -> ExternalIdentity | None:+ if not self._auth.subject_email:+ return None+ return ExternalIdentity(email=self._auth.subject_email, issuer=self._auth.subject_issuer)++ @override+ def resolve_caller(self, ctx: Context, session: Session) -> EndUser:+ identity = self.external_identity+ if identity is None:+ raise Unauthorized("missing context for external user resolution")+ return EndUserService.get_or_create_end_user_by_type(+ EndUserType.OPENAPI,+ tenant_id=str(load_workspace(ctx).id),+ app_id=str(load_app(ctx).id),+ user_id=identity.email,+ )++ @override+ def mounts_caller(self, ctx: Context) -> bool:+ """An external caller is an end user *of an app*; off an app-scoped+ route it has no caller to resolve at all.+ """+ return route_has_app(ctx)++ @override+ def webapp_user_id(self, session: Session) -> str | None:+ identity = self.external_identity+ if identity is None:+ return None+ account = AccountService.get_account_by_email(identity.email, session=session)+ return str(account.id) if account is not None else None+++def subject_from_auth(auth: AuthContext) -> Subject:+ return _SUBJECT_CLASSES[auth.subject_type](auth)diff --git a/api/controllers/openapi/auth/verify.py b/api/controllers/openapi/auth/verify.pydeleted file mode 100644index c669bfaecd9..00000000000--- a/api/controllers/openapi/auth/verify.py+++ /dev/null@@ -1,122 +0,0 @@-from __future__ import annotations--from flask import request-from werkzeug.exceptions import Forbidden, NotFound, UnprocessableEntity--from configs import dify_config-from controllers.common.rbac import enforce_rbac_checks-from controllers.openapi.auth.data import AuthData, CallerKind-from extensions.ext_database import db-from libs.oauth_bearer import Scope, TokenType-from services.account_service import AccountService-from services.enterprise.enterprise_service import EnterpriseService, WebAppAccessMode---def check_scope(data: AuthData) -> None:- if data.required_scope is None:- return- if Scope.FULL in data.scopes or data.required_scope in data.scopes:- return- raise Forbidden("insufficient_scope")---def check_workspace_member(data: AuthData) -> None:- """Assert the caller belongs to the resolved tenant.-- `load_workspace_role` stashes the membership role (None when the caller is- not a member or is inactive). A missing membership surfaces as 404, not- 403, so workspace IDs don't leak across tenants.- """- if data.tenant_role is None:- raise NotFound("workspace not found")---def check_workspace_mismatch(data: AuthData) -> None:- if data.tenant is None:- return- request_workspace_id = data.path_params.get("workspace_id") or request.args.get("workspace_id")- if request_workspace_id and request_workspace_id != str(data.tenant.id):- raise UnprocessableEntity("workspace_id does not match app's workspace")---def check_workspace_role(data: AuthData) -> None:- if dify_config.RBAC_ENABLED and data.rbac is not None:- # fine-grained permission check is performed by RBAC- return- if data.allowed_roles is None:- return- if data.tenant_role is None:- raise NotFound("workspace not found")- if data.tenant_role not in data.allowed_roles:- raise Forbidden("insufficient workspace role")---def check_rbac_permission(data: AuthData) -> None:- req = data.rbac- if req is None:- return- if not dify_config.RBAC_ENABLED:- return- # Only account callers are subject to RBAC; end_user access is scope-controlled.- if data.caller_kind != CallerKind.ACCOUNT:- return- if data.account_id is None or data.tenant is None:- raise Forbidden("rbac context missing")- enforce_rbac_checks(- tenant_id=str(data.tenant.id),- account_id=str(data.account_id),- checks=[req],- path_args=dict(data.path_params),- )---def check_app_api_enabled(data: AuthData) -> None:- if data.app is None:- return- if not data.app.enable_api:- raise Forbidden("service_api_disabled")---_ALLOWED_MODES_BY_TOKEN_TYPE: dict[TokenType, frozenset[WebAppAccessMode]] = {- TokenType.OAUTH_ACCOUNT: frozenset(- {- WebAppAccessMode.PUBLIC,- WebAppAccessMode.SSO_VERIFIED,- WebAppAccessMode.PRIVATE_ALL,- WebAppAccessMode.PRIVATE,- }- ),- TokenType.OAUTH_EXTERNAL_SSO: frozenset(- {- WebAppAccessMode.PUBLIC,- WebAppAccessMode.SSO_VERIFIED,- }- ),-}---def check_acl(data: AuthData) -> None:- if data.app is None or data.app_access_mode is None:- raise Forbidden("app or access mode not loaded")- allowed_modes = _ALLOWED_MODES_BY_TOKEN_TYPE.get(data.token_type, frozenset())- if data.app_access_mode not in allowed_modes:- raise Forbidden("subject_not_allowed_for_access_mode")---def check_private_app_permission(data: AuthData) -> None:- if data.app is None:- raise Forbidden("app not loaded")- user_id = _resolve_user_id(data)- if user_id is None:- raise Forbidden("cannot resolve user for private app check")- if not EnterpriseService.WebAppAuth.is_user_allowed_to_access_webapp(user_id=user_id, app_id=data.app.id):- raise Forbidden("user_not_allowed_for_private_app")---def _resolve_user_id(data: AuthData) -> str | None:- if data.token_type == TokenType.OAUTH_ACCOUNT:- return str(data.account_id) if data.account_id is not None else None- if data.external_identity is None:- return None- account = AccountService.get_account_by_email(data.external_identity.email, session=db.session())- return str(account.id) if account is not None else Nonediff --git a/api/controllers/openapi/files.py b/api/controllers/openapi/files.pyindex ab9e3455bb3..53bed421ca6 100644--- a/api/controllers/openapi/files.py+++ b/api/controllers/openapi/files.py@@ -4,7 +4,6 @@ from __future__ import annotationsfrom flask import requestfrom flask_restx import Resource-from flask_restx.api import HTTPStatusfrom werkzeug.exceptions import BadRequestimport services@@ -16,10 +15,17 @@ from controllers.common.errors import (UnsupportedFileTypeError,)from controllers.openapi import openapi_ns-from controllers.openapi._contract import returns+from controllers.openapi._contract import endpointfrom controllers.openapi._errors import FilenameNotExists-from controllers.openapi.auth.composition import auth_router-from controllers.openapi.auth.data import AuthData+from controllers.openapi.auth.context import Context+from controllers.openapi.auth.requirements import (+ CheckAppAccess,+ CheckAppApiEnabled,+ CheckScope,+ CheckSubject,+ CheckWorkspaceMember,+)+from controllers.openapi.auth.subjects import AccountSubject, ExternalSsoSubjectfrom extensions.ext_application_services import application_servicesfrom fields.file_fields import FileResponsefrom libs.oauth_bearer import Scope@@ -38,10 +44,17 @@ class AppFileUploadApi(Resource):415: "Unsupported file type",})- @auth_router.guard(scope=Scope.APPS_RUN)- @returns(HTTPStatus.CREATED, FileResponse, description="File uploaded")- def post(self, app_id: str, *, auth_data: AuthData) -> FileResponse:- _app_model, caller, _caller_kind = auth_data.require_app_context()+ @endpoint(+ requirements=(+ CheckSubject(allowed=(AccountSubject, ExternalSsoSubject)),+ CheckAppApiEnabled(),+ CheckWorkspaceMember(),+ CheckScope(Scope.APPS_RUN),+ CheckAppAccess(),+ ),+ returns=(201, FileResponse, "File uploaded"),+ )+ def post(self, ctx: Context, app_id: str):if "file" not in request.files:raise NoFileUploadedError()if len(request.files) > 1:@@ -58,7 +71,7 @@ class AppFileUploadApi(Resource):filename=file.filename,content=file.stream.read(),mimetype=file.mimetype,- user=caller,+ user=ctx.caller,)except services.errors.file.FileTooLargeError as exc:raise FileTooLargeError(exc.description) from excdiff --git a/api/controllers/openapi/flask_admission.py b/api/controllers/openapi/flask_admission.pydeleted file mode 100644index 7e485c70db6..00000000000--- a/api/controllers/openapi/flask_admission.py+++ /dev/null@@ -1,88 +0,0 @@-"""Flask adapter for account-authenticated OpenAPI admission."""--from __future__ import annotations--from collections.abc import Callable-from functools import wraps-from typing import Concatenate--from flask import Response, request-from werkzeug.exceptions import Unauthorized--from controllers.openapi.auth.composition import auth_router-from controllers.openapi.auth.data import AuthData-from core.logging.context import get_request_id, get_trace_id-from enums import DeploymentEdition-from libs.oauth_bearer import Scope, TokenType-from libs.rate_limit import RateLimit, enforce-from machinery.context import AccountRequestContext-from models.account import Account, AccountStatus---def openapi_account_admission[T, **P, R](- *,- scope: Scope,- editions: frozenset[DeploymentEdition] | None = None,- require_initialized: bool = True,- require_valid_enterprise_license: bool = True,- rate_limit: RateLimit | None = None,-) -> Callable[- [Callable[Concatenate[T, AccountRequestContext, P], R]],- Callable[Concatenate[T, P], R | Response],-]:- """Authenticate an account bearer and inject framework-neutral identity.-- Client-version admission remains attached to the OpenAPI blueprint so it- can also reject requests for removed routes. Edition and Enterprise- license checks are delegated to the shared auth router before the stable- context is constructed.- """-- def decorator(- view: Callable[Concatenate[T, AccountRequestContext, P], R],- ) -> Callable[Concatenate[T, P], R | Response]:- @wraps(view)- def inject_request_context(- self: T,- /,- *args: P.args,- **kwargs: P.kwargs,- ) -> R:- auth_data = kwargs.pop("auth_data", None)- if not isinstance(auth_data, AuthData):- raise RuntimeError("OpenAPI auth pipeline did not provide valid AuthData")- account = auth_data.caller- if not isinstance(account, Account) or auth_data.account_id is None:- raise Unauthorized("account not found")- if require_initialized and account.status == AccountStatus.UNINITIALIZED:- raise Unauthorized("account not initialized")-- account_id = str(auth_data.account_id)- if rate_limit is not None:- enforce(rate_limit, key=f"account:{account_id}")-- context = AccountRequestContext(- request_id=get_request_id(),- trace_id=get_trace_id() or request.headers.get("X-Trace-Id"),- account_id=account_id,- access_token_id=str(auth_data.token_id) if auth_data.token_id is not None else None,- )- return view(self, context, *args, **kwargs)-- authenticated = auth_router.guard(- scope=scope,- allowed_token_types=frozenset({TokenType.OAUTH_ACCOUNT}),- edition=editions,- require_valid_enterprise_license=require_valid_enterprise_license,- )(inject_request_context)-- # Keep one stable test seam: one ``__wrapped__`` skips route admission- # and reaches input parsing/response handling. Client-version admission- # stays blueprint-wide by design.- @wraps(view)- def admitted(self: T, /, *args: P.args, **kwargs: P.kwargs) -> R | Response:- return authenticated(self, *args, **kwargs)-- return admitted-- return decoratordiff --git a/api/controllers/openapi/human_input_form.py b/api/controllers/openapi/human_input_form.pyindex af3fcb8d85f..58eb3c80ce3 100644--- a/api/controllers/openapi/human_input_form.py+++ b/api/controllers/openapi/human_input_form.py@@ -1,35 +1,39 @@-"""-OpenAPI bearer-authed human input form endpoints.--GET /apps/<app_id>/human-input-forms/<form_token> — fetch paused form definition-POST /apps/<app_id>/human-input-forms/<form_token>:submit — submit form response-"""-from __future__ import annotationsimport jsonimport logging+from typing import overridefrom flask import Responsefrom flask_restx import Resource+from sqlalchemy.orm import Sessionfrom werkzeug.exceptions import BadRequestfrom controllers.common.human_input import HumanInputFormSubmitPayload, stringify_form_default_valuesfrom controllers.common.rbac import PlainApp, RBACCheck, RBACPermissionfrom controllers.common.schema import register_schema_modelsfrom controllers.openapi import openapi_ns-from controllers.openapi._contract import accepts, returns+from controllers.openapi._contract import endpointfrom controllers.openapi._errors import HumanInputFormNotFound, RecipientSurfaceMismatchfrom controllers.openapi._models import FormSubmitResponse, HumanInputFormDefinitionResponse-from controllers.openapi.auth.composition import auth_router-from controllers.openapi.auth.data import AuthData, CallerKind-from core.workflow.human_input_policy import (- HumanInputSurface,- is_recipient_type_allowed_for_surface,+from controllers.openapi.auth.context import Context+from controllers.openapi.auth.loaders import PathParam, load_app+from controllers.openapi.auth.requirements import (+ CheckAppAccess,+ CheckAppApiEnabled,+ CheckRBACPermission,+ CheckScope,+ CheckSubject,+ CheckWorkspaceMember,+ Requirement,)+from controllers.openapi.auth.subjects import AccountSubject, ExternalSsoSubject, Subject+from core.db.session_factory import session_factory+from core.workflow.human_input_policy import HumanInputSurface, is_recipient_type_allowed_for_surfacefrom extensions.ext_database import dbfrom libs.helper import to_timestampfrom libs.oauth_bearer import Scope+from models.enums import CreatorUserRolefrom models.model import Appfrom services.human_input_service import FormNotFoundError, HumanInputService@@ -38,6 +42,30 @@ logger = logging.getLogger(__name__)register_schema_models(openapi_ns, HumanInputFormSubmitPayload)+class CheckFormSurface(Requirement):+ """`/openapi/v1` is allowed only the recipient types `human_input_policy` lists+ for it, so a console-bound form is refused before any handler body runs. It+ lives here rather than in `auth/requirements.py` so the auth layer never has+ to import this feature's domain.++ A form the caller could not have found anyway — missing, or belonging to+ another app — is left to the handler's own 404: answering 403 here would tell+ an outsider the form token exists.+ """++ @override+ def run(self, subject: Subject, ctx: Context, session: Session) -> None:+ form_token = ctx.view_args[PathParam.FORM_TOKEN]+ app = load_app(ctx)+ # `HumanInputService` takes an engine or a maker, never a `Session`, so this+ # read is a separate transaction from the handler's — as it was before the move.+ form = HumanInputService(session_factory.get_session_maker()).get_form_by_token(form_token)+ if form is None or form.app_id != app.id or form.tenant_id != app.tenant_id:+ return+ if not is_recipient_type_allowed_for_surface(form.recipient_type, HumanInputSurface.OPENAPI):+ raise RecipientSurfaceMismatch()++def _jsonify_form_definition(form) -> Response:definition_payload = form.get_definition().model_dump()payload = {@@ -55,56 +83,60 @@ def _ensure_form_belongs_to_app(form, app_model: App) -> None:raise HumanInputFormNotFound()-def _ensure_form_is_allowed_for_openapi(form) -> None:- if not is_recipient_type_allowed_for_surface(form.recipient_type, HumanInputSurface.OPENAPI):- raise RecipientSurfaceMismatch()--@openapi_ns.route("/apps/<string:app_id>/human-input-forms/<string:form_token>")class OpenApiWorkflowHumanInputFormApi(Resource):- @openapi_ns.response(200, "Form definition", openapi_ns.models[HumanInputFormDefinitionResponse.__name__])- @auth_router.guard(- scope=Scope.APPS_RUN,- rbac=RBACCheck(RBACPermission.APP_TEST_AND_RUN, PlainApp()),+ @endpoint(+ requirements=(+ CheckSubject(allowed=(AccountSubject, ExternalSsoSubject)),+ CheckAppApiEnabled(),+ CheckWorkspaceMember(),+ CheckScope(Scope.APPS_RUN),+ CheckRBACPermission(RBACCheck(RBACPermission.APP_TEST_AND_RUN, PlainApp())),+ CheckAppAccess(),+ CheckFormSurface(),+ ),+ returns=(200, HumanInputFormDefinitionResponse, "Form definition"),)- def get(self, app_id: str, form_token: str, *, auth_data: AuthData):- app_model, _caller, _caller_kind = auth_data.require_app_context()+ def get(self, ctx: Context, app_id: str, form_token: str):service = HumanInputService(db.engine)form = service.get_form_by_token(form_token)if form is None:raise HumanInputFormNotFound()- _ensure_form_belongs_to_app(form, app_model)- _ensure_form_is_allowed_for_openapi(form)+ _ensure_form_belongs_to_app(form, ctx.app)service.ensure_form_active(form)return _jsonify_form_definition(form)@openapi_ns.route("/apps/<string:app_id>/human-input-forms/<string:form_token>:submit")class OpenApiWorkflowHumanInputFormSubmitApi(Resource):- @auth_router.guard(- scope=Scope.APPS_RUN,- rbac=RBACCheck(RBACPermission.APP_TEST_AND_RUN, PlainApp()),+ @endpoint(+ requirements=(+ CheckSubject(allowed=(AccountSubject, ExternalSsoSubject)),+ CheckAppApiEnabled(),+ CheckWorkspaceMember(),+ CheckScope(Scope.APPS_RUN),+ CheckRBACPermission(RBACCheck(RBACPermission.APP_TEST_AND_RUN, PlainApp())),+ CheckAppAccess(),+ CheckFormSurface(),+ ),+ body=HumanInputFormSubmitPayload,+ returns=(200, FormSubmitResponse, "Form submitted"),)- @returns(200, FormSubmitResponse, description="Form submitted")- @accepts(body=HumanInputFormSubmitPayload)- def post(self, app_id: str, form_token: str, *, auth_data: AuthData, body: HumanInputFormSubmitPayload):- app_model, caller, caller_kind = auth_data.require_app_context()-+ def post(self, ctx: Context, app_id: str, form_token: str, *, body: HumanInputFormSubmitPayload):service = HumanInputService(db.engine)form = service.get_form_by_token(form_token)if form is None:raise HumanInputFormNotFound()- _ensure_form_belongs_to_app(form, app_model)- _ensure_form_is_allowed_for_openapi(form)+ _ensure_form_belongs_to_app(form, ctx.app)submission_user_id: str | None = Nonesubmission_end_user_id: str | None = None- if caller_kind == CallerKind.ACCOUNT:- submission_user_id = caller.id+ if ctx.subject.caller_role is CreatorUserRole.ACCOUNT:+ submission_user_id = ctx.account.idelse:- submission_end_user_id = caller.id+ submission_end_user_id = ctx.end_user.idif form.recipient_type is None:logger.warning("Recipient type is None for form, form_token=%s", form_token)diff --git a/api/controllers/openapi/oauth_device.py b/api/controllers/openapi/oauth_device.pyindex 3ba5f2ee207..2c418150fe3 100644--- a/api/controllers/openapi/oauth_device.py+++ b/api/controllers/openapi/oauth_device.py@@ -48,7 +48,7 @@ from controllers.openapi._models import (from extensions.ext_database import dbfrom extensions.ext_redis import redis_clientfrom libs.helper import extract_remote_ip-from libs.oauth_bearer import MINTABLE_PROFILES, SubjectType, bearer_feature_required+from libs.oauth_bearer import SubjectType, TokenType, bearer_feature_requiredfrom libs.rate_limit import (LIMIT_DEVICE_CODE_PER_IP,LIMIT_DEVICE_FLOW_APPROVE,@@ -70,7 +70,6 @@ from services.oauth_device_flow import (mint_oauth_token,oauth_ttl_days,)-from services.openapi.mint_policy import MintPolicyViolation, validate_mint_policylogger = logging.getLogger(__name__)@@ -236,15 +235,6 @@ class DeviceApproveApi(Resource):return {"error": "approve_in_progress"}, 409try:- profile = MINTABLE_PROFILES[SubjectType.ACCOUNT]- try:- validate_mint_policy(- subject_type=profile.subject_type,- prefix=profile.prefix,- scopes=profile.scopes,- )- except MintPolicyViolation as e:- raise BadRequest(description=str(e)) from Nonettl_days = oauth_ttl_days(tenant_id=tenant)mint = mint_oauth_token(redis_client,@@ -253,7 +243,7 @@ class DeviceApproveApi(Resource):account_id=str(account.id),client_id=state.client_id,device_label=state.device_label,- prefix=profile.prefix,+ token_type=TokenType.OAUTH_ACCOUNT,ttl_days=ttl_days,session=db.session(),)diff --git a/api/controllers/openapi/oauth_device_sso.py b/api/controllers/openapi/oauth_device_sso.pyindex fbf7bfa6295..99519fa1890 100644--- a/api/controllers/openapi/oauth_device_sso.py+++ b/api/controllers/openapi/oauth_device_sso.py@@ -46,7 +46,7 @@ from libs.device_flow_security import (mint_approval_grant,verify_approval_grant,)-from libs.oauth_bearer import MINTABLE_PROFILES, SubjectType+from libs.oauth_bearer import SubjectType, TokenTypefrom libs.rate_limit import (LIMIT_APPROVE_EXT_PER_EMAIL,LIMIT_SSO_INITIATE_PER_IP,@@ -64,7 +64,6 @@ from services.oauth_device_flow import (mint_oauth_token,oauth_ttl_days,)-from services.openapi.mint_policy import MintPolicyViolation, validate_mint_policylogger = logging.getLogger(__name__)@@ -281,16 +280,6 @@ def approve_external():if not consume_approval_grant_nonce(redis_client, claims.nonce):raise Unauthorized("session_already_consumed")- profile = MINTABLE_PROFILES[SubjectType.EXTERNAL_SSO]- try:- validate_mint_policy(- subject_type=profile.subject_type,- prefix=profile.prefix,- scopes=profile.scopes,- )- except MintPolicyViolation as e:- raise BadRequest(description=str(e)) from None-ttl_days = oauth_ttl_days(tenant_id=None)mint = mint_oauth_token(redis_client,@@ -299,7 +288,7 @@ def approve_external():account_id=None,client_id=state.client_id,device_label=state.device_label,- prefix=profile.prefix,+ token_type=TokenType.OAUTH_EXTERNAL_SSO,ttl_days=ttl_days,session=db.session(),)diff --git a/api/controllers/openapi/workflow_events.py b/api/controllers/openapi/workflow_events.pyindex 5e54c301fba..67286a820a7 100644--- a/api/controllers/openapi/workflow_events.py+++ b/api/controllers/openapi/workflow_events.py@@ -14,25 +14,32 @@ from collections.abc import Generatorfrom flask import Response, requestfrom flask_restx import Resourcefrom pydantic import BaseModel, Field-from sqlalchemy.orm import sessionmakerfrom werkzeug.exceptions import NotFound, UnprocessableEntityfrom controllers.common.fields import EventStreamResponsefrom controllers.common.rbac import PlainApp, RBACCheck, RBACPermissionfrom controllers.common.schema import query_params_from_modelfrom controllers.openapi import openapi_ns-from controllers.openapi.auth.composition import auth_router-from controllers.openapi.auth.data import AuthData, CallerKind+from controllers.openapi._contract import endpoint+from controllers.openapi.auth.context import Context+from controllers.openapi.auth.requirements import (+ CheckAppAccess,+ CheckAppApiEnabled,+ CheckRBACPermission,+ CheckScope,+ CheckSubject,+ CheckWorkspaceMember,+)+from controllers.openapi.auth.subjects import AccountSubject, ExternalSsoSubjectfrom core.app.apps.advanced_chat.app_generator import AdvancedChatAppGeneratorfrom core.app.apps.base_app_generator import BaseAppGeneratorfrom core.app.apps.common.workflow_response_converter import WorkflowResponseConverterfrom core.app.apps.message_generator import MessageGeneratorfrom core.app.apps.workflow.app_generator import WorkflowAppGeneratorfrom core.app.entities.task_entities import StreamEvent+from core.db.session_factory import session_factoryfrom core.workflow.human_input_policy import HumanInputSurface-from extensions.ext_database import dbfrom libs.oauth_bearer import Scope-from models.enums import CreatorUserRolefrom models.model import AppModefrom repositories.factory import DifyAPIRepositoryFactoryfrom services.workflow_event_snapshot_service import build_workflow_event_stream@@ -46,18 +53,31 @@ class WorkflowEventsQuery(BaseModel):@openapi_ns.route("/apps/<string:app_id>/tasks/<string:task_id>/events")class OpenApiWorkflowEventsApi(Resource):@openapi_ns.doc(params=query_params_from_model(WorkflowEventsQuery))- @openapi_ns.response(200, "SSE event stream", openapi_ns.models[EventStreamResponse.__name__])- @auth_router.guard(- scope=Scope.APPS_RUN,- rbac=RBACCheck(RBACPermission.APP_TEST_AND_RUN, PlainApp()),+ @endpoint(+ requirements=(+ CheckSubject(allowed=(AccountSubject, ExternalSsoSubject)),+ CheckAppApiEnabled(),+ CheckWorkspaceMember(),+ CheckScope(Scope.APPS_RUN),+ CheckRBACPermission(RBACCheck(RBACPermission.APP_TEST_AND_RUN, PlainApp())),+ CheckAppAccess(),+ ),+ returns=(200, EventStreamResponse, "SSE event stream"),)- def get(self, app_id: str, task_id: str, *, auth_data: AuthData):- app_model, caller, caller_kind = auth_data.require_app_context()+ def get(self, ctx: Context, app_id: str, task_id: str):+ # The router's session closes as soon as this returns, so everything the SSE+ # body needs is read off `ctx` here and the generators below close over plain+ # values only.+ app_model = ctx.app+ caller = ctx.caller+app_mode = AppMode.value_of(app_model.mode)if app_mode not in {AppMode.WORKFLOW, AppMode.ADVANCED_CHAT}:raise UnprocessableEntity("mode_not_supported_for_event_reconnect")- session_maker = sessionmaker(db.engine)+ # The event stream outlives `ctx.session`, so this route needs a maker of its+ # own — the guard's, not a fresh one bound straight to the engine.+ session_maker = session_factory.get_session_maker()repo = DifyAPIRepositoryFactory.create_api_workflow_run_repository(session_maker)workflow_run = repo.get_workflow_run_by_id_and_tenant_id(tenant_id=app_model.tenant_id,@@ -70,14 +90,14 @@ class OpenApiWorkflowEventsApi(Resource):if workflow_run.app_id != app_model.id:raise NotFound("Workflow run not found")- if caller_kind == CallerKind.ACCOUNT:- if workflow_run.created_by_role != CreatorUserRole.ACCOUNT or workflow_run.created_by != caller.id:- raise NotFound("Workflow run not found")- else:- if workflow_run.created_by_role != CreatorUserRole.END_USER or workflow_run.created_by != caller.id:- raise NotFound("Workflow run not found")+ # Ownership is a property of the run row, not of the app, so no pipeline+ # requirement can answer it — the caller may only reconnect to its own run.+ if workflow_run.created_by_role != ctx.subject.caller_role or workflow_run.created_by != caller.id:+ raise NotFound("Workflow run not found")workflow_run_entity = workflow_run+ tenant_id = app_model.tenant_id+ owning_app_id = app_model.idif workflow_run_entity.finished_at is not None:response = WorkflowResponseConverter.workflow_run_result_to_finish_response(@@ -110,8 +130,8 @@ class OpenApiWorkflowEventsApi(Resource):build_workflow_event_stream(app_mode=app_mode,workflow_run=workflow_run_entity,- tenant_id=app_model.tenant_id,- app_id=app_model.id,+ tenant_id=tenant_id,+ app_id=owning_app_id,session_maker=session_maker,human_input_surface=HumanInputSurface.OPENAPI,close_on_pause=not continue_on_pause,diff --git a/api/controllers/openapi/workspaces.py b/api/controllers/openapi/workspaces.pyindex 6053e09bf28..c2436a5a3c6 100644--- a/api/controllers/openapi/workspaces.py+++ b/api/controllers/openapi/workspaces.py@@ -5,8 +5,9 @@ endpoints. Account bearers (dfoa_) see every tenant they're a member of.External SSO bearers (dfoe_) have no account_id and so see an empty list —that matches /openapi/v1/account.-Member-management endpoints use ``guard_workspace`` which enforces-workspace membership and optional role requirements via the auth pipeline.+Member management declares both authorization arms; ``RBAC_ENABLED`` picks one.+``GET /workspaces/<workspace_id>`` deliberately declares neither: it admits any+account bearer and lets the view's own membership-scoped lookup answer 404."""from __future__ import annotations@@ -15,13 +16,12 @@ from itertools import starmapfrom urllib import parsefrom flask_restx import Resource-from sqlalchemy.orm import Sessionfrom werkzeug.exceptions import BadRequest, NotFoundfrom configs import dify_config-from controllers.common.session import with_session+from controllers.common.rbac import RBACCheck, RBACPermission, Workspacefrom controllers.openapi import openapi_ns-from controllers.openapi._contract import accepts, returns+from controllers.openapi._contract import endpointfrom controllers.openapi._errors import MemberLicenseExceeded, MemberLimitExceededfrom controllers.openapi._models import (MemberActionResponse,@@ -35,12 +35,19 @@ from controllers.openapi._models import (WorkspaceListResponse,WorkspaceSummaryResponse,)-from controllers.openapi.auth.composition import auth_router-from controllers.openapi.auth.data import AuthData+from controllers.openapi.auth.context import Context+from controllers.openapi.auth.requirements import (+ CheckRBACPermission,+ CheckScope,+ CheckSubject,+ CheckWorkspaceMember,+ CheckWorkspaceRole,+)+from controllers.openapi.auth.subjects import AccountSubjectfrom enums import DeploymentEdition-from libs.oauth_bearer import Scope, TokenType+from libs.oauth_bearer import Scopefrom models import Account, Tenant, TenantAccountJoin-from models.account import TenantAccountRole, TenantStatus+from models.account import TenantAccountRolefrom services.account_service import AccountService, RegisterService, TenantServicefrom services.errors.account import (AccountAlreadyInTenantError,@@ -66,20 +73,6 @@ def _member_response(account: Account) -> MemberResponse:)-def _load_tenant(session: Session, workspace_id: str) -> Tenant:- tenant = TenantService.get_tenant_by_id(workspace_id, session=session)- if tenant is None or tenant.status != TenantStatus.NORMAL:- raise NotFound("workspace not found")- return tenant---def _load_account(session: Session, account_id: object) -> Account:- account = AccountService.get_account_by_id(str(account_id), session=session) if account_id else None- if account is None:- raise RuntimeError("authenticated account_id has no Account row")- return account--def _check_member_invite_quota(tenant_id: str) -> None:features = FeatureService.get_features(tenant_id)@@ -94,23 +87,24 @@ def _check_member_invite_quota(tenant_id: str) -> None:@openapi_ns.route("/workspaces")class WorkspacesApi(Resource):- @auth_router.guard(scope=Scope.WORKSPACE_READ, allowed_token_types=frozenset({TokenType.OAUTH_ACCOUNT}))- @returns(200, WorkspaceListResponse, description="Workspace list")- @with_session(write=False)- def get(self, session: Session, *, auth_data: AuthData):- rows = TenantService.get_workspaces_for_account(str(auth_data.account_id), session=session)+ @endpoint(+ requirements=(CheckSubject(allowed=(AccountSubject,)), CheckScope(Scope.WORKSPACE_READ)),+ returns=(200, WorkspaceListResponse, "Workspace list"),+ )+ def get(self, ctx: Context):+ rows = TenantService.get_workspaces_for_account(str(ctx.subject.account_id), session=ctx.session)return WorkspaceListResponse(workspaces=list(starmap(_workspace_summary, rows)))@openapi_ns.route("/workspaces/<string:workspace_id>")class WorkspaceByIdApi(Resource):- @auth_router.guard(scope=Scope.WORKSPACE_READ, allowed_token_types=frozenset({TokenType.OAUTH_ACCOUNT}))- @returns(200, WorkspaceDetailResponse, description="Workspace detail")- @with_session(write=False)- def get(self, session: Session, workspace_id: str, *, auth_data: AuthData):- row = TenantService.find_workspace_for_account(str(auth_data.account_id), workspace_id, session=session)- # 404 (not 403) on non-member so workspace IDs don't leak across tenants.+ @endpoint(+ requirements=(CheckSubject(allowed=(AccountSubject,)), CheckScope(Scope.WORKSPACE_READ)),+ returns=(200, WorkspaceDetailResponse, "Workspace detail"),+ )+ def get(self, ctx: Context, workspace_id: str):+ row = TenantService.find_workspace_for_account(str(ctx.subject.account_id), workspace_id, session=ctx.session)if row is None:raise NotFound("workspace not found")@@ -127,18 +121,21 @@ class WorkspaceSwitchApi(Resource):that ``hosts.yml`` never diverges from the server's ``current`` state."""- @auth_router.guard_workspace(scope=Scope.WORKSPACE_READ, allowed_token_types=frozenset({TokenType.OAUTH_ACCOUNT}))- @returns(200, WorkspaceDetailResponse, description="Workspace detail")- @with_session- def post(self, session: Session, workspace_id: str, *, auth_data: AuthData):- account = _load_account(session, auth_data.account_id)-+ @endpoint(+ requirements=(+ CheckSubject(allowed=(AccountSubject,)),+ CheckScope(Scope.WORKSPACE_READ),+ CheckWorkspaceMember(),+ ),+ returns=(200, WorkspaceDetailResponse, "Workspace detail"),+ )+ def post(self, ctx: Context, workspace_id: str):try:- TenantService.switch_tenant(account, workspace_id, session=session)+ TenantService.switch_tenant(ctx.account, workspace_id, session=ctx.session)except AccountNotLinkTenantError:raise NotFound("workspace not found")- row = TenantService.find_workspace_for_account(str(auth_data.account_id), workspace_id, session=session)+ row = TenantService.find_workspace_for_account(str(ctx.subject.account_id), workspace_id, session=ctx.session)if row is None:raise NotFound("workspace not found")tenant, membership = row@@ -153,13 +150,17 @@ class WorkspaceMembersApi(Resource):assigned through invite (ownership transfer is console-only)."""- @auth_router.guard_workspace(scope=Scope.WORKSPACE_READ, allowed_token_types=frozenset({TokenType.OAUTH_ACCOUNT}))- @returns(200, MemberListResponse, description="Member list")- @accepts(query=MemberListQuery)- @with_session(write=False)- def get(self, session: Session, workspace_id: str, *, auth_data: AuthData, query: MemberListQuery):- tenant = _load_tenant(session, workspace_id)- members = TenantService.get_tenant_members(tenant, session=session)+ @endpoint(+ requirements=(+ CheckSubject(allowed=(AccountSubject,)),+ CheckScope(Scope.WORKSPACE_READ),+ CheckWorkspaceMember(),+ ),+ query=MemberListQuery,+ returns=(200, MemberListResponse, "Member list"),+ )+ def get(self, ctx: Context, workspace_id: str, *, query: MemberListQuery):+ members = TenantService.get_tenant_members(ctx.workspace, session=ctx.session)total = len(members)start = (query.page - 1) * query.limitpage_items = members[start : start + query.limit]@@ -170,17 +171,19 @@ class WorkspaceMembersApi(Resource):items=[_member_response(m) for m in page_items],)- @auth_router.guard_workspace(- scope=Scope.WORKSPACE_WRITE,- allowed_token_types=frozenset({TokenType.OAUTH_ACCOUNT}),- allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN}),+ @endpoint(+ requirements=(+ CheckSubject(allowed=(AccountSubject,)),+ CheckScope(Scope.WORKSPACE_WRITE),+ CheckWorkspaceMember(),+ CheckRBACPermission(RBACCheck(RBACPermission.WORKSPACE_MEMBER_MANAGE, Workspace())),+ CheckWorkspaceRole(frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN})),+ ),+ body=MemberInvitePayload,+ returns=(201, MemberInviteResponse, "Member invited"),)- @returns(201, MemberInviteResponse, description="Member invited")- @accepts(body=MemberInvitePayload)- @with_session- def post(self, session: Session, workspace_id: str, *, auth_data: AuthData, body: MemberInvitePayload):- inviter = _load_account(session, auth_data.account_id)- tenant = _load_tenant(session, workspace_id)+ def post(self, ctx: Context, workspace_id: str, *, body: MemberInvitePayload):+ tenant = ctx.workspace_check_member_invite_quota(str(tenant.id))@@ -190,8 +193,8 @@ class WorkspaceMembersApi(Resource):email=body.email,language=None,role=body.role,- inviter=inviter,- session=session,+ inviter=ctx.account,+ session=ctx.session,)except AccountAlreadyInTenantError as exc:raise BadRequest(str(exc))@@ -203,9 +206,8 @@ class WorkspaceMembersApi(Resource):raise BadRequest(str(exc))normalized_email = body.email.lower()- member = AccountService.get_account_by_email_with_case_fallback(normalized_email, session=session)+ member = AccountService.get_account_by_email_with_case_fallback(normalized_email, session=ctx.session)if member is None:- # invite_new_member just created or fetched this account.raise RuntimeError("invited member missing from DB after invite")encoded_email = parse.quote(normalized_email)@@ -229,22 +231,23 @@ class WorkspaceMemberApi(Resource):assigned via PATCH (closed enum); admin cannot demote the standing owner."""- @auth_router.guard_workspace(- scope=Scope.WORKSPACE_WRITE,- allowed_token_types=frozenset({TokenType.OAUTH_ACCOUNT}),- allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN}),+ @endpoint(+ requirements=(+ CheckSubject(allowed=(AccountSubject,)),+ CheckScope(Scope.WORKSPACE_WRITE),+ CheckWorkspaceMember(),+ CheckRBACPermission(RBACCheck(RBACPermission.WORKSPACE_MEMBER_MANAGE, Workspace())),+ CheckWorkspaceRole(frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN})),+ ),+ returns=(200, MemberActionResponse, "Member removed"),)- @returns(200, MemberActionResponse, description="Member removed")- @with_session- def delete(self, session: Session, workspace_id: str, member_id: str, *, auth_data: AuthData):- operator = _load_account(session, auth_data.account_id)- tenant = _load_tenant(session, workspace_id)- member = AccountService.get_account_by_id(member_id, session=session)+ def delete(self, ctx: Context, workspace_id: str, member_id: str):+ member = AccountService.get_account_by_id(member_id, session=ctx.session)if member is None:raise NotFound("member not found")try:- TenantService.remove_member_from_tenant(tenant, member, operator, session=session)+ TenantService.remove_member_from_tenant(ctx.workspace, member, ctx.account, session=ctx.session)except CannotOperateSelfError as exc:raise BadRequest(str(exc))except NoPermissionError as exc:@@ -254,31 +257,24 @@ class WorkspaceMemberApi(Resource):return MemberActionResponse()- @auth_router.guard_workspace(- scope=Scope.WORKSPACE_WRITE,- allowed_token_types=frozenset({TokenType.OAUTH_ACCOUNT}),- allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN}),+ @endpoint(+ requirements=(+ CheckSubject(allowed=(AccountSubject,)),+ CheckScope(Scope.WORKSPACE_WRITE),+ CheckWorkspaceMember(),+ CheckRBACPermission(RBACCheck(RBACPermission.WORKSPACE_ROLE_MANAGE, Workspace())),+ CheckWorkspaceRole(frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN})),+ ),+ body=MemberRoleUpdatePayload,+ returns=(200, MemberActionResponse, "Role updated"),)- @returns(200, MemberActionResponse, description="Role updated")- @accepts(body=MemberRoleUpdatePayload)- @with_session- def patch(- self,- session: Session,- workspace_id: str,- member_id: str,- *,- auth_data: AuthData,- body: MemberRoleUpdatePayload,- ):- operator = _load_account(session, auth_data.account_id)- tenant = _load_tenant(session, workspace_id)- member = AccountService.get_account_by_id(member_id, session=session)+ def patch(self, ctx: Context, workspace_id: str, member_id: str, *, body: MemberRoleUpdatePayload):+ member = AccountService.get_account_by_id(member_id, session=ctx.session)if member is None:raise NotFound("member not found")try:- TenantService.update_member_role(tenant, member, body.role, operator, session=session)+ TenantService.update_member_role(ctx.workspace, member, body.role, ctx.account, session=ctx.session)except CannotOperateSelfError as exc:raise BadRequest(str(exc))except NoPermissionError as exc:diff --git a/api/libs/oauth_bearer.py b/api/libs/oauth_bearer.pyindex bfd96650b8d..f29064bda51 100644--- a/api/libs/oauth_bearer.py+++ b/api/libs/oauth_bearer.py@@ -6,7 +6,7 @@ import hashlibimport jsonimport loggingimport uuid-from collections.abc import Callable, Iterable+from collections.abc import Callable, Mappingfrom contextvars import ContextVar, Tokenfrom dataclasses import dataclassfrom datetime import UTC, datetime@@ -30,16 +30,6 @@ logger = logging.getLogger(__name__)# ============================================================================-class SubjectType(StrEnum):- ACCOUNT = "account"- EXTERNAL_SSO = "external_sso"---class TokenType(StrEnum):- OAUTH_ACCOUNT = "oauth_account"- OAUTH_EXTERNAL_SSO = "oauth_external_sso"--class Scope(StrEnum):"""Catalog of bearer scopes recognised by the openapi surface.@@ -56,24 +46,70 @@ class Scope(StrEnum):WORKSPACE_WRITE = "workspace:write"+class SubjectType(StrEnum):+ # Annotation-only names are not members; they declare what `__new__` attaches.+ scopes: frozenset[Scope]+ # Whether the subject's token rows carry an `account_id`. A subject that does+ # not is keyed by its external issuer instead.+ bound_to_account: bool++ ACCOUNT = ("account", frozenset({Scope.FULL}), True)+ EXTERNAL_SSO = ("external_sso", frozenset({Scope.APPS_RUN, Scope.APPS_READ_PERMITTED_EXTERNAL}), False)++ def __new__(cls, value: str, scopes: frozenset[Scope], bound_to_account: bool) -> SubjectType:+ obj = str.__new__(cls, value)+ obj._value_ = value+ obj.scopes = scopes+ obj.bound_to_account = bound_to_account+ return obj+++class TokenType(StrEnum):+ """Many token types may serve one subject; the prefix is the only thing a+ bearer string reveals, so it lives here and nowhere else.+ """++ prefix: str+ subject: SubjectType++ OAUTH_ACCOUNT = ("oauth_account", "dfoa_", SubjectType.ACCOUNT)+ OAUTH_EXTERNAL_SSO = ("oauth_external_sso", "dfoe_", SubjectType.EXTERNAL_SSO)++ def __new__(cls, value: str, prefix: str, subject: SubjectType) -> TokenType:+ obj = str.__new__(cls, value)+ obj._value_ = value+ obj.prefix = prefix+ obj.subject = subject+ return obj++ @classmethod+ def for_token(cls, token: str) -> TokenType | None:+ return next((token_type for token_type in cls if token.startswith(token_type.prefix)), None)++@dataclass(frozen=True, slots=True)class AuthContext:- """Per-request identity published via :data:`_auth_ctx_var`- (see :func:`set_auth_ctx` / :func:`get_auth_ctx`). ``scopes`` /- ``subject_type`` / ``token_type`` come from the TokenKind, not the DB —- corrupt rows can't elevate scope.+ """Per-request identity published via :data:`_auth_ctx_var`. Subject and+ scopes derive from the token type, never from the row, so a corrupt row+ cannot elevate scope."""- subject_type: SubjectType+ token_type: TokenTypesubject_email: str | Nonesubject_issuer: str | Noneaccount_id: uuid.UUID | Noneclient_id: str | None- scopes: frozenset[Scope]token_id: uuid.UUID- token_type: TokenTypeexpires_at: datetime | None+ @property+ def subject_type(self) -> SubjectType:+ return self.token_type.subject++ @property+ def scopes(self) -> frozenset[Scope]:+ return self.token_type.subject.scopes+_auth_ctx_var: ContextVar[AuthContext] = ContextVar("openapi_auth_ctx")@@ -130,82 +166,10 @@ class Resolver(Protocol):...-@dataclass(frozen=True, slots=True)-class TokenKind:- prefix: str- subject_type: SubjectType- scopes: frozenset[Scope]- token_type: TokenType- resolver: Resolver-- def matches(self, token: str) -> bool:- return token.startswith(self.prefix)---@dataclass(frozen=True, slots=True)-class MintProfile:- """Single source of truth for (subject_type, prefix, scopes) at mint time.-- Consumers:- - ``build_registry`` reads scopes here so the resolve-time TokenKind- cannot drift from the mint-time intent.- - Device-flow ``approve`` / ``approve-external`` read prefix + scopes- here when calling ``mint_oauth_token`` and ``validate_mint_policy``.- - ``services.openapi.mint_policy.validate_mint_policy`` cross-checks- the (subject_type, prefix, scopes) triple a caller intends to mint- against this table — a caller that assembles its own scope set- from a non-canonical source will fail closed at approve time.- """-- subject_type: SubjectType- prefix: str- scopes: frozenset[Scope]---MINTABLE_PROFILES: dict[SubjectType, MintProfile] = {- SubjectType.ACCOUNT: MintProfile(- subject_type=SubjectType.ACCOUNT,- prefix="dfoa_",- scopes=frozenset({Scope.FULL}),- ),- SubjectType.EXTERNAL_SSO: MintProfile(- subject_type=SubjectType.EXTERNAL_SSO,- prefix="dfoe_",- scopes=frozenset({Scope.APPS_RUN, Scope.APPS_READ_PERMITTED_EXTERNAL}),- ),-}--class InvalidBearerError(Exception):"""Token missing, unknown prefix, or no live row."""-class TokenExpiredError(Exception):- """Hard-expire bookkeeping is the resolver's job before raising."""---# ============================================================================-# Registry-# ============================================================================---class TokenKindRegistry:- def __init__(self, kinds: Iterable[TokenKind]) -> None:- self._kinds: tuple[TokenKind, ...] = tuple(kinds)- prefixes = [k.prefix for k in self._kinds]- if len(set(prefixes)) != len(prefixes):- raise ValueError(f"duplicate prefix in registry: {prefixes}")-- def find(self, token: str) -> TokenKind | None:- for k in self._kinds:- if k.matches(token):- return k- return None-- def kinds(self) -> tuple[TokenKind, ...]:- return self._kinds--# ============================================================================# Authenticator# ============================================================================@@ -216,12 +180,8 @@ def sha256_hex(token: str) -> str:class BearerAuthenticator:- def __init__(self, registry: TokenKindRegistry) -> None:- self._registry = registry-- @property- def registry(self) -> TokenKindRegistry:- return self._registry+ def __init__(self, resolvers: Mapping[TokenType, Resolver]) -> None:+ self._resolvers = resolversdef authenticate(self, token: str) -> AuthContext:"""Identity + per-token rate limit (single source).@@ -229,23 +189,21 @@ class BearerAuthenticator:The openapi auth pipeline is the only caller, so the rate limit firesexactly once per request."""- kind = self._registry.find(token)- if kind is None:+ token_type = TokenType.for_token(token)+ if token_type is None or token_type not in self._resolvers:raise InvalidBearerError("invalid_bearer")token_hash = sha256_hex(token)enforce_bearer_rate_limit(token_hash)- row = kind.resolver.resolve(token_hash)+ row = self._resolvers[token_type].resolve(token_hash)if row is None:raise InvalidBearerError("invalid_bearer")return AuthContext(- subject_type=kind.subject_type,+ token_type=token_type,subject_email=row.subject_email,subject_issuer=row.subject_issuer,account_id=row.account_id,client_id=row.client_id,- scopes=kind.scopes,token_id=row.token_id,- token_type=kind.token_type,expires_at=row.expires_at,)@@ -259,8 +217,6 @@ POSITIVE_TTL_SECONDS = 60NEGATIVE_TTL_SECONDS = 10AUDIT_OAUTH_EXPIRED = "oauth.token_expired"-ScopeVariant = Literal["account", "external_sso"]-class _TokenCacheClient(Protocol):def delete(self, *names: str | bytes) -> object: ...@@ -271,9 +227,7 @@ def invalidate_oauth_token_cache(client: _TokenCacheClient, token_hash: str) ->class OAuthAccessTokenResolver:- """``.for_account()`` / ``.for_external_sso()`` are variant-scoped views- sharing DB + cache plumbing.- """+ """``for_token_type()`` returns a view scoped to one token type, sharing DB + cache plumbing."""def __init__(self,@@ -287,11 +241,8 @@ class OAuthAccessTokenResolver:self._positive_ttl = positive_ttlself._negative_ttl = negative_ttl- def for_account(self) -> Resolver:- return _VariantResolver(self, variant="account")-- def for_external_sso(self) -> Resolver:- return _VariantResolver(self, variant="external_sso")+ def for_token_type(self, token_type: TokenType) -> Resolver:+ return _TokenTypeResolver(self, token_type)def _cache_key(self, token_hash: str) -> str:return TOKEN_CACHE_KEY_FMT.format(hash=token_hash)@@ -341,17 +292,17 @@ class OAuthAccessTokenResolver:self.cache_set_negative(token_hash)-class _VariantResolver:- def __init__(self, parent: OAuthAccessTokenResolver, variant: ScopeVariant) -> None:+class _TokenTypeResolver:+ def __init__(self, parent: OAuthAccessTokenResolver, token_type: TokenType) -> None:self._parent = parent- self._variant = variant+ self._token_type = token_typedef resolve(self, token_hash: str) -> ResolvedRow | None:cached = self._parent.cache_get(token_hash)if cached == "invalid":return Noneif cached is not None and not isinstance(cached, str):- if not self._matches_variant(cached):+ if not self._matches_subject(cached):return Nonereturn cached@@ -368,7 +319,7 @@ class _VariantResolver:self._parent.hard_expire(session, row.id, token_hash)return None- if not self._matches_variant_model(row):+ if not (self._matches_subject(row) and row.prefix == self._token_type.prefix):logger.error("internal_state_invariant: account_id/prefix mismatch token_id=%s prefix=%s",row.id,@@ -387,17 +338,8 @@ class _VariantResolver:self._parent.cache_set_positive(token_hash, resolved)return resolved- def _matches_variant(self, row: ResolvedRow) -> bool:- has_account = row.account_id is not None- if self._variant == "account":- return has_account- return not has_account-- def _matches_variant_model(self, row: OAuthAccessToken) -> bool:- has_account = row.account_id is not None- if self._variant == "account":- return has_account and row.prefix == "dfoa_"- return (not has_account) and row.prefix == "dfoe_"+ def _matches_subject(self, row: ResolvedRow | OAuthAccessToken) -> bool:+ return (row.account_id is not None) == self._token_type.subject.bound_to_accountdef _load_from_db(self, session: Session, token_hash: str) -> OAuthAccessToken | None:return (@@ -443,15 +385,18 @@ def extract_bearer(req) -> str | None:return value.strip()-def bearer_feature_required[**P, R](fn: Callable[P, R]) -> Callable[P, R]:- """503 if ENABLE_OAUTH_BEARER is off — minted tokens would be unusable- without the authenticator, so fail fast instead of approving silently.+def assert_bearer_feature_enabled() -> None:+ """503 if ENABLE_OAUTH_BEARER is off: the authenticator is never bound then,+ so minted tokens would be unusable and guarded routes would 500."""+ if not dify_config.ENABLE_OAUTH_BEARER:+ raise ServiceUnavailable("bearer_auth_disabled: set ENABLE_OAUTH_BEARER=true to enable")++def bearer_feature_required[**P, R](fn: Callable[P, R]) -> Callable[P, R]:@wraps(fn)def inner(*args: P.args, **kwargs: P.kwargs) -> R:- if not dify_config.ENABLE_OAUTH_BEARER:- raise ServiceUnavailable("bearer_auth_disabled: set ENABLE_OAUTH_BEARER=true to enable")+ assert_bearer_feature_enabled()return fn(*args, **kwargs)return inner@@ -462,32 +407,17 @@ def bearer_feature_required[**P, R](fn: Callable[P, R]) -> Callable[P, R]:# ============================================================================-def build_registry(session_factory, redis_client) -> TokenKindRegistry:+def build_authenticator(session_factory, redis_client) -> BearerAuthenticator:oauth = OAuthAccessTokenResolver(session_factory, redis_client)- account = MINTABLE_PROFILES[SubjectType.ACCOUNT]- external = MINTABLE_PROFILES[SubjectType.EXTERNAL_SSO]- return TokenKindRegistry(- [- TokenKind(- prefix=account.prefix,- subject_type=account.subject_type,- scopes=account.scopes,- token_type=TokenType.OAUTH_ACCOUNT,- resolver=oauth.for_account(),- ),- TokenKind(- prefix=external.prefix,- subject_type=external.subject_type,- scopes=external.scopes,- token_type=TokenType.OAUTH_EXTERNAL_SSO,- resolver=oauth.for_external_sso(),- ),- ]+ return BearerAuthenticator(+ {+ TokenType.OAUTH_ACCOUNT: oauth.for_token_type(TokenType.OAUTH_ACCOUNT),+ TokenType.OAUTH_EXTERNAL_SSO: oauth.for_token_type(TokenType.OAUTH_EXTERNAL_SSO),+ })def build_and_bind(session_factory, redis_client) -> BearerAuthenticator:- registry = build_registry(session_factory, redis_client)- auth = BearerAuthenticator(registry)+ auth = build_authenticator(session_factory, redis_client)bind_authenticator(auth)return authdiff --git a/api/openapi/markdown/openapi-openapi.md b/api/openapi/markdown/openapi-openapi.mdindex a793cbcd2b9..cbb8b6faa84 100644--- a/api/openapi/markdown/openapi-openapi.md+++ b/api/openapi/markdown/openapi-openapi.md@@ -173,6 +173,7 @@ Upload a file to use as an input variable when running the app| Code | Description | Schema || ---- | ----------- | ------ || 200 | Form definition | **application/json**: [HumanInputFormDefinitionResponse](#humaninputformdefinitionresponse)<br> |+| default | Error | **application/json**: [ErrorBody](#errorbody)<br> |### [POST] /apps/{app_id}/human-input-forms/{form_token}:submit#### Parameters@@ -211,6 +212,7 @@ Upload a file to use as an input variable when running the app| Code | Description | Schema || ---- | ----------- | ------ || 200 | SSE event stream | **application/json**: [EventStreamResponse](#eventstreamresponse)<br> |+| default | Error | **application/json**: [ErrorBody](#errorbody)<br> |### [POST] /apps/{app_id}/tasks/{task_id}:stop#### Parameters@@ -246,6 +248,7 @@ Upload a file to use as an input variable when running the app| ---- | ----------- | ------ || 200 | Run result (SSE stream) | **application/json**: [EventStreamResponse](#eventstreamresponse)<br> || 422 | Validation error | **application/json**: [ErrorBody](#errorbody)<br> |+| default | Error | **application/json**: [ErrorBody](#errorbody)<br> |### [POST] /oauth/device/approve#### Request Body@@ -515,7 +518,7 @@ Upload a file to use as an input variable when running the app| default_workspace_id | string | | No || subject_email | string | | No || subject_issuer | string | | No |-| subject_type | string | | Yes |+| subject_type | [SubjectType](#subjecttype) | | Yes || workspaces | [ [WorkspacePayload](#workspacepayload) ], <br>**Default:** | | No |#### AppDescribeInfo@@ -715,7 +718,7 @@ Enum representing the deployment edition of the platform.| expires_at | string | | Yes || subject_email | string | | No || subject_issuer | string | | No |-| subject_type | string, <br>**Available values:** "account", "external_sso" | *Enum:* `"account"`, `"external_sso"` | Yes |+| subject_type | [SubjectType](#subjecttype) | | Yes || token | string | | Yes || token_id | string | | Yes || workspaces | [ [WorkspacePayload](#workspacepayload) ], <br>**Default:** | | No |@@ -1022,6 +1025,12 @@ Pagination for GET /account/sessions. Strict (extra='forbid').| ---- | ---- | ----------- | -------- || result | string | Operation result. | Yes |+#### SubjectType++| Name | Type | Description | Required |+| ---- | ---- | ----------- | -------- |+| SubjectType | string | | |+#### SupportedAppTypeApp types the ``app`` usage face (``get app``) lists and filters.diff --git a/api/services/account_service.py b/api/services/account_service.pyindex 81ee3aeb037..c907b421fb7 100644--- a/api/services/account_service.py+++ b/api/services/account_service.py@@ -1231,8 +1231,8 @@ class TenantService:@staticmethoddef account_belongs_to_tenant(account_id: uuid.UUID | str | None, tenant_id: str, *, session: Session) -> bool:"""Existence check for ``TenantAccountJoin(account_id, tenant_id)``.- Backs the CE-deployment membership fallback in- ``controllers.openapi.auth.strategies.MembershipStrategy``.+ Membership without the role: where the openapi auth layer needs the role+ itself it reads ``Context.workspace_role`` instead.``None``/empty ``account_id`` short-circuits to ``False`` so SSObearers (no account) and missing identity collapse cleanly.@@ -1253,9 +1253,9 @@ class TenantService:) -> TenantAccountRole | None:"""Return the caller's role in ``tenant_id``, or ``None`` if not a member.- Backs the openapi auth pipeline's ``load_workspace_role`` prepare step:- ``None`` is treated as non-member (the pipeline maps it to 404 — no- cross-tenant ID leak) and an out-of-set role to 403.+ Backs the openapi auth layer's ``Context.workspace_role``: ``None`` is+ treated as non-member (mapped to 404 — no cross-tenant ID leak) and an+ out-of-set role to 403.``None``/empty ``account_id`` short-circuits to ``None`` so SSObearers (no account) collapse to the non-member path. Mirrors thediff --git a/api/services/app_service.py b/api/services/app_service.pyindex 859f87c09a7..f829bcc3f24 100644--- a/api/services/app_service.py+++ b/api/services/app_service.py@@ -365,25 +365,6 @@ class AppService:return []return list(session.execute(apply_openapi_gate(select(App).where(App.id.in_(list(app_ids))))).scalars().all())- @staticmethod- def find_visible_apps_by_name(- session: Session,- *,- name: str,- tenant_id: str,- ) -> list[App]:- return list(- session.execute(- apply_openapi_gate(- select(App).where(- App.name == name,- App.tenant_id == tenant_id,- App.status == "normal",- )- )- ).scalars()- )-def get_paginate_apps(self,user_id: str,diff --git a/api/services/oauth_device_flow.py b/api/services/oauth_device_flow.pyindex f3967026aad..2704fade27d 100644--- a/api/services/oauth_device_flow.py+++ b/api/services/oauth_device_flow.py@@ -15,7 +15,7 @@ from typing import NotRequired, TypedDictfrom sqlalchemy import func, select, updatefrom sqlalchemy.orm import Session-from libs.oauth_bearer import SubjectType, invalidate_oauth_token_cache+from libs.oauth_bearer import SubjectType, TokenType, invalidate_oauth_token_cachefrom models.oauth import OAuthAccessTokenlogger = logging.getLogger(__name__)@@ -300,8 +300,6 @@ class DeviceFlowRedis:OAUTH_BODY_BYTES = 32 # ~256 bits entropy-PREFIX_OAUTH_ACCOUNT = "dfoa_"-PREFIX_OAUTH_EXTERNAL_SSO = "dfoe_"# Sentinel issuer for account-flow rows. Postgres' default partial unique# index treats NULLs as distinct, which would let two live `dfoa_` rows@@ -342,7 +340,7 @@ def mint_oauth_token(account_id: str | None,client_id: str,device_label: str,- prefix: str,+ token_type: TokenType,ttl_days: int,session: Session,) -> MintResult:@@ -351,21 +349,18 @@ def mint_oauth_token(index predicate so re-login INSERTs fresh. Pre-rotate Redis entry isdeleted so stale AuthContext drops immediately."""- if prefix == PREFIX_OAUTH_ACCOUNT:- # Account flow always writes the sentinel — caller may pass None+ if token_type.subject.bound_to_account:+ # Account-bound flows always write the sentinel — caller may pass None# (for clarity) or the sentinel itself; nothing else is valid.if subject_issuer not in (None, ACCOUNT_ISSUER_SENTINEL):raise ValueError(f"account-flow token must use ACCOUNT_ISSUER_SENTINEL, got {subject_issuer!r}")subject_issuer = ACCOUNT_ISSUER_SENTINEL- elif prefix == PREFIX_OAUTH_EXTERNAL_SSO:+ elif not subject_issuer or not subject_issuer.strip():# Defense in depth: enterprise canonicalises + rejects empty,# but a regression there must not yield a NULL composite key here.- if not subject_issuer or not subject_issuer.strip():- raise ValueError("external-SSO token requires non-empty subject_issuer")- else:- raise ValueError(f"unknown oauth prefix: {prefix!r}")+ raise ValueError("external-SSO token requires non-empty subject_issuer")- token = generate_token(prefix)+ token = generate_token(token_type.prefix)new_hash = sha256_hex(token)expires_at = datetime.now(UTC) + timedelta(days=ttl_days)@@ -376,7 +371,7 @@ def mint_oauth_token(account_id=account_id,client_id=client_id,device_label=device_label,- prefix=prefix,+ prefix=token_type.prefix,new_hash=new_hash,expires_at=expires_at,)diff --git a/api/services/openapi/mint_policy.py b/api/services/openapi/mint_policy.pydeleted file mode 100644index 303ecc3209c..00000000000--- a/api/services/openapi/mint_policy.py+++ /dev/null@@ -1,47 +0,0 @@-"""Hard mint policy.--``validate_mint_policy`` cross-checks a (subject_type, prefix, scopes)-triple a caller intends to mint against ``MINTABLE_PROFILES`` —-the single source of truth in ``libs.oauth_bearer``.--The defense-in-depth value: if a future caller assembles ``prefix`` or-``scopes`` from a non-canonical source (env, request body, plug-in-contribution), the mismatch fails closed at approve time before any-row hits the DB. When the caller reads straight from-``MINTABLE_PROFILES``, the check is a structural pin — it confirms the-table entry is well-formed and the caller picked the right key.-"""--from __future__ import annotations--from libs.oauth_bearer import MINTABLE_PROFILES, Scope, SubjectType---class MintPolicyViolation(Exception): # noqa: N818 — spec-defined name, used in BadRequest message- """Raised on a (subject_type, prefix, scopes) mismatch. Callers translate- to 400 ``mint_policy_violation``."""---def validate_mint_policy(- *,- subject_type: SubjectType,- prefix: str,- scopes: frozenset[Scope],-) -> None:- """Raise ``MintPolicyViolation`` when the triple does not match the- canonical ``MINTABLE_PROFILES`` entry for ``subject_type``.- """- profile = MINTABLE_PROFILES.get(subject_type)- if profile is None:- raise MintPolicyViolation(f"mint_policy_violation: unknown subject_type={subject_type!r}")-- drift = []- if profile.prefix != prefix:- drift.append(f"prefix got={prefix!r} expected={profile.prefix!r}")- if frozenset(scopes) != profile.scopes:- got = sorted(s.value for s in scopes)- want = sorted(s.value for s in profile.scopes)- drift.append(f"scopes got={got} expected={want}")-- if drift:- raise MintPolicyViolation(f"mint_policy_violation: subject_type={subject_type.value} — " + "; ".join(drift))diff --git a/api/tests/integration_tests/controllers/openapi/conftest.py b/api/tests/integration_tests/controllers/openapi/conftest.pyindex d9357e81551..7b7e4f5bdac 100644--- a/api/tests/integration_tests/controllers/openapi/conftest.py+++ b/api/tests/integration_tests/controllers/openapi/conftest.py@@ -13,6 +13,7 @@ from flask import Flaskfrom enums import DeploymentEditionfrom extensions.ext_database import dbfrom extensions.ext_redis import redis_client+from libs.oauth_bearer import TokenTypefrom models import Account, App, OAuthAccessToken, Tenant, TenantAccountJoinfrom models.account import AccountStatus@@ -101,11 +102,11 @@ def mint_token(flask_app: Flask):@pytest.fixturedef account_token(workspace_account, mint_token) -> str:account, _, _ = workspace_account- token = "dfoa_" + uuid.uuid4().hex+ token = TokenType.OAUTH_ACCOUNT.prefix + uuid.uuid4().hexmint_token(token,account_id=account.id,- prefix="dfoa_",+ prefix=TokenType.OAUTH_ACCOUNT.prefix,subject_email=account.email,subject_issuer="dify:account",)diff --git a/api/tests/test_containers_integration_tests/controllers/openapi/conftest.py b/api/tests/test_containers_integration_tests/controllers/openapi/conftest.pyindex 1b7894bcb8a..91612174a21 100644--- a/api/tests/test_containers_integration_tests/controllers/openapi/conftest.py+++ b/api/tests/test_containers_integration_tests/controllers/openapi/conftest.py@@ -2,7 +2,6 @@ from __future__ import annotationsimport uuidfrom collections.abc import Callable-from typing import Literalfrom unittest.mock import patchimport pytest@@ -10,13 +9,17 @@ from faker import Fakerfrom flask import Flaskfrom sqlalchemy.orm import Session-from controllers.openapi.auth.data import AuthData-from libs.oauth_bearer import Scope, TokenType-from machinery.context import AccountRequestContext+from controllers.openapi.auth.context import Context+from controllers.openapi.auth.loaders import PathParam, load_app+from controllers.openapi.auth.requirements import ResolveCaller+from controllers.openapi.auth.subjects import subject_from_auth+from libs.oauth_bearer import AuthContext, TokenTypefrom models import Account, Tenantfrom services.account_service import AccountService, TenantServicefrom tests.test_containers_integration_tests.helpers import generate_valid_password+_CLIENT_ID = "integration-cli"+@pytest.fixturedef app(flask_app_with_containers: Flask) -> Flask:@@ -67,37 +70,51 @@ def add_tenant_for_account(return tenant-def auth_for(+def _account_auth(account: Account,*,- app_model: object | None = None,token_id: uuid.UUID | None = None,- caller_kind: Literal["account", "end_user"] | None = None,-) -> AuthData:- """Build an AuthData for ``account`` (and optionally an app context).-- ``token_id`` is needed by the self-revoke endpoint, and ``caller_kind`` by- any handler calling ``require_app_context`` (e.g. file upload / task stop).- """- return AuthData(- token_type=TokenType.OAUTH_ACCOUNT,+ client_id: str = _CLIENT_ID,+) -> AuthContext:+ """The ``AuthContext`` a live ``dfoa_`` token for ``account`` would carry."""+ return AuthContext(+ subject_email=account.email,+ subject_issuer=None,account_id=uuid.UUID(str(account.id)),- token_id=token_id,- scopes=frozenset({Scope.FULL}),- caller=account,- caller_kind=caller_kind,- app=app_model, # type: ignore[arg-type]+ client_id=client_id,+ token_id=token_id or uuid.uuid4(),+ token_type=TokenType.OAUTH_ACCOUNT,+ expires_at=None,)-def request_context_for(+def context_for(account: Account,*,+ session: Session,+ view_args: dict[str, str] | None = None,token_id: uuid.UUID | None = None,-) -> AccountRequestContext:- return AccountRequestContext(- request_id="integration-request",- trace_id="integration-trace",- account_id=str(account.id),- access_token_id=str(token_id) if token_id is not None else None,- )+) -> Context:+ """Build the ``Context`` a handler is given after the pipeline ran.++ The subject comes from a real ``AuthContext`` through ``subject_from_auth``,+ so the helper walks the same resolution path the router does. ``view_args``+ is the route's path params — the app and the workspace are loaded from it,+ so a route carrying ``<app_id>`` needs ``{"app_id": ...}`` here.+ ``token_id`` only matters to the ``/account/sessions*`` family, which reads+ it back off the subject.++ It runs ``ResolveCaller`` itself — the requirement every pipeline fixes+ last — rather than the wider set a route's own requirements would ask for,+ so a handler sees exactly what the thinnest pipeline would give it. On a+ route carrying ``<app_id>`` that thinnest pipeline is ``CheckAppApiEnabled``,+ which loads the app; handlers read ``ctx.app`` and never load it themselves,+ so the helper loads it through the same loader. Running the real pieces is+ what keeps this CI-only helper from drifting away from the pipeline it+ stands in for.+ """+ ctx = Context(subject_from_auth(_account_auth(account, token_id=token_id)), session, view_args or {})+ if PathParam.APP_ID in ctx.view_args:+ load_app(ctx)+ ResolveCaller().run(ctx.subject, ctx, session)+ return ctxdiff --git a/api/tests/test_containers_integration_tests/controllers/openapi/test_account.py b/api/tests/test_containers_integration_tests/controllers/openapi/test_account.pyindex d2181b8398d..3211b6d9cd3 100644--- a/api/tests/test_containers_integration_tests/controllers/openapi/test_account.py+++ b/api/tests/test_containers_integration_tests/controllers/openapi/test_account.py@@ -1,7 +1,6 @@from __future__ import annotationsfrom collections.abc import Callable-from inspect import unwrapfrom flask import Flaskfrom sqlalchemy.orm import Session@@ -9,21 +8,20 @@ from sqlalchemy.orm import Sessionfrom controllers.openapi.account import AccountApifrom models import Accountfrom models.account import TenantAccountRole-from tests.test_containers_integration_tests.controllers.openapi.conftest import (- add_tenant_for_account,- request_context_for,-)+from tests.test_containers_integration_tests.controllers.openapi.conftest import add_tenant_for_account, context_forclass TestAccountInfo:- def test_returns_account_and_owner_workspace(self, app: Flask, make_account: Callable[..., Account]) -> None:+ def test_returns_account_and_owner_workspace(+ self, app: Flask, db_session_with_containers: Session, make_account: Callable[..., Account]+ ) -> None:account = make_account()owner_tenant = account.current_tenantassert owner_tenant is not Noneapi = AccountApi()with app.test_request_context("/openapi/v1/account"):- result = unwrap(api.get)(api, request_context_for(account))+ result = api.get.__handler__(api, context_for(account, session=db_session_with_containers))assert result.subject_type == "account"assert result.subject_email == account.email@@ -48,7 +46,7 @@ class TestAccountInfo:api = AccountApi()with app.test_request_context("/openapi/v1/account"):- result = unwrap(api.get)(api, request_context_for(account))+ result = api.get.__handler__(api, context_for(account, session=db_session_with_containers))assert {w.id for w in result.workspaces} == {owner_tenant.id, second.id}roles = {w.id: w.role for w in result.workspaces}diff --git a/api/tests/test_containers_integration_tests/controllers/openapi/test_account_sessions.py b/api/tests/test_containers_integration_tests/controllers/openapi/test_account_sessions.pyindex d2e339c565e..bed322888a3 100644--- a/api/tests/test_containers_integration_tests/controllers/openapi/test_account_sessions.py+++ b/api/tests/test_containers_integration_tests/controllers/openapi/test_account_sessions.py@@ -1,8 +1,6 @@from __future__ import annotationsfrom collections.abc import Callable-from inspect import unwrap-from uuid import uuid4import pytestfrom flask import Flask@@ -16,9 +14,10 @@ from controllers.openapi.account import (AccountSessionsSelfApi,)from extensions.ext_redis import redis_client+from libs.oauth_bearer import TokenTypefrom models import Account-from services.oauth_device_flow import PREFIX_OAUTH_ACCOUNT, MintResult, mint_oauth_token-from tests.test_containers_integration_tests.controllers.openapi.conftest import request_context_for+from services.oauth_device_flow import MintResult, mint_oauth_token+from tests.test_containers_integration_tests.controllers.openapi.conftest import context_fordef _mint_account_token(@@ -36,7 +35,7 @@ def _mint_account_token(account_id=str(account.id),client_id=client_id,device_label=device_label,- prefix=PREFIX_OAUTH_ACCOUNT,+ token_type=TokenType.OAUTH_ACCOUNT,ttl_days=14,session=db_session,)@@ -51,16 +50,16 @@ class TestSessionList:api = AccountSessionsApi()with app.test_request_context("/openapi/v1/account/sessions"):- result = unwrap(api.get)(+ result = api.get.__handler__(api,- request_context_for(account, token_id=mint.token_id),+ context_for(account, session=db_session_with_containers, token_id=mint.token_id),query=SessionListQuery(),)assert result.total == 1row = result.data[0]assert row.id == str(mint.token_id)- assert row.prefix == PREFIX_OAUTH_ACCOUNT+ assert row.prefix == TokenType.OAUTH_ACCOUNT.prefixassert row.device_label == "Laptop"def test_excludes_other_accounts_sessions(@@ -74,9 +73,9 @@ class TestSessionList:api = AccountSessionsApi()with app.test_request_context("/openapi/v1/account/sessions"):- result = unwrap(api.get)(+ result = api.get.__handler__(api,- request_context_for(account, token_id=mine.token_id),+ context_for(account, session=db_session_with_containers, token_id=mine.token_id),query=SessionListQuery(),)@@ -92,16 +91,18 @@ class TestSessionRevoke:revoke_api = AccountSessionsSelfApi()with app.test_request_context("/openapi/v1/account/sessions/self", method="DELETE"):- result = unwrap(revoke_api.delete)(revoke_api, request_context_for(account, token_id=mint.token_id))+ result = revoke_api.delete.__handler__(+ revoke_api, context_for(account, session=db_session_with_containers, token_id=mint.token_id)+ )assert result.status == "revoked"# Revocation persisted: the real list path no longer returns it.list_api = AccountSessionsApi()with app.test_request_context("/openapi/v1/account/sessions"):- listing = unwrap(list_api.get)(+ listing = list_api.get.__handler__(list_api,- request_context_for(account, token_id=mint.token_id),+ context_for(account, session=db_session_with_containers, token_id=mint.token_id),query=SessionListQuery(),)assert listing.total == 0@@ -114,12 +115,14 @@ class TestSessionRevoke:session_id = str(mint.token_id)api = AccountSessionByIdApi()+ ctx = context_for(+ account,+ session=db_session_with_containers,+ view_args={"session_id": session_id},+ token_id=mint.token_id,+ )with app.test_request_context(f"/openapi/v1/account/sessions/{session_id}", method="DELETE"):- result = unwrap(api.delete)(- api,- request_context_for(account, token_id=mint.token_id),- session_id=session_id,- )+ result = api.delete.__handler__(api, ctx, session_id)assert result.status == "revoked"@@ -127,17 +130,15 @@ class TestSessionRevoke:self, app: Flask, db_session_with_containers: Session, make_account: Callable[..., Account]) -> None:"""A token id owned by another subject must be indistinguishable from a- missing one (404), so token ids can't be probed across subjects."""+ missing one (404), so token ids can't be probed across subjects. The+ access service makes that call; the handler only maps it to 404."""owner = make_account()outsider = make_account()foreign = _mint_account_token(db_session_with_containers, owner)- api = AccountSessionByIdApi()session_id = str(foreign.token_id)+ ctx = context_for(outsider, session=db_session_with_containers, view_args={"session_id": session_id})with app.test_request_context(f"/openapi/v1/account/sessions/{session_id}", method="DELETE"):+ api = AccountSessionByIdApi()with pytest.raises(NotFound):- unwrap(api.delete)(- api,- request_context_for(outsider, token_id=uuid4()),- session_id=session_id,- )+ api.delete.__handler__(api, ctx, session_id)diff --git a/api/tests/test_containers_integration_tests/controllers/openapi/test_app_dsl.py b/api/tests/test_containers_integration_tests/controllers/openapi/test_app_dsl.pyindex 3e4ca88288c..39e9ef61be2 100644--- a/api/tests/test_containers_integration_tests/controllers/openapi/test_app_dsl.py+++ b/api/tests/test_containers_integration_tests/controllers/openapi/test_app_dsl.py@@ -2,7 +2,6 @@ from __future__ import annotationsimport jsonfrom collections.abc import Callable, Generator-from inspect import unwrapfrom unittest.mock import patchfrom uuid import uuid4@@ -25,7 +24,7 @@ from services.account_service import AccountService, TenantServicefrom services.app_dsl_service import CURRENT_DSL_VERSIONfrom services.app_service import AppService, CreateAppParamsfrom services.entities.dsl_entities import ImportStatus-from tests.test_containers_integration_tests.controllers.openapi.conftest import auth_for+from tests.test_containers_integration_tests.controllers.openapi.conftest import context_forfrom tests.test_containers_integration_tests.helpers import generate_valid_password@@ -111,7 +110,12 @@ class TestDslImport:api = AppDslImportApi()body = AppDslImportPayload(mode="yaml-content", yaml_content="[]") # not a mappingwith app.test_request_context(f"/openapi/v1/workspaces/{tenant.id}/apps/imports", method="POST"):- result, code = unwrap(api.post)(api, workspace_id=tenant.id, auth_data=auth_for(account), body=body)+ result, code = api.post.__handler__(+ api,+ context_for(account, session=db_session_with_containers, view_args={"workspace_id": tenant.id}),+ tenant.id,+ body=body,+ )assert code == 400assert result.status == ImportStatus.FAILED@@ -128,7 +132,12 @@ class TestDslImport:api = AppDslImportApi()body = AppDslImportPayload(mode="yaml-content", yaml_content=_workflow_yaml(version="99.0.0"))with app.test_request_context(f"/openapi/v1/workspaces/{tenant.id}/apps/imports", method="POST"):- result, code = unwrap(api.post)(api, workspace_id=tenant.id, auth_data=auth_for(account), body=body)+ result, code = api.post.__handler__(+ api,+ context_for(account, session=db_session_with_containers, view_args={"workspace_id": tenant.id}),+ tenant.id,+ body=body,+ )assert code == 202assert result.status == ImportStatus.PENDING@@ -148,7 +157,12 @@ class TestDslImport:api = AppDslImportApi()body = AppDslImportPayload(mode="yaml-content", yaml_content=_workflow_yaml(name="Imported"))with app.test_request_context(f"/openapi/v1/workspaces/{tenant.id}/apps/imports", method="POST"):- result, code = unwrap(api.post)(api, workspace_id=tenant.id, auth_data=auth_for(account), body=body)+ result, code = api.post.__handler__(+ api,+ context_for(account, session=db_session_with_containers, view_args={"workspace_id": tenant.id}),+ tenant.id,+ body=body,+ )assert code == 200assert result.status in (ImportStatus.COMPLETED, ImportStatus.COMPLETED_WITH_WARNINGS)@@ -169,8 +183,15 @@ class TestDslImportConfirm:with app.test_request_context(f"/openapi/v1/workspaces/{tenant.id}/apps/imports/{import_id}:confirm", method="POST"):- result, code = unwrap(api.post)(- api, workspace_id=tenant.id, import_id=import_id, auth_data=auth_for(account)+ result, code = api.post.__handler__(+ api,+ context_for(+ account,+ session=db_session_with_containers,+ view_args={"workspace_id": tenant.id, "import_id": import_id},+ ),+ tenant.id,+ import_id,)assert code == 400@@ -199,8 +220,11 @@ class TestDslExport:api = AppDslExportApi()with app.test_request_context(f"/openapi/v1/apps/{app_model.id}/dsl"):- response, code = unwrap(api.get)(- api, app_id=app_model.id, auth_data=auth_for(account, app_model=app_model), query=AppDslExportQuery()+ response, code = api.get.__handler__(+ api,+ context_for(account, session=db_session_with_containers, view_args={"app_id": app_model.id}),+ app_model.id,+ query=AppDslExportQuery(),)assert code == 200@@ -217,8 +241,11 @@ class TestDslExport:api = AppDslExportApi()with app.test_request_context(f"/openapi/v1/apps/{app_model.id}/dsl"):- result, code = unwrap(api.get)(- api, app_id=app_model.id, auth_data=auth_for(account, app_model=app_model), query=AppDslExportQuery()+ result, code = api.get.__handler__(+ api,+ context_for(account, session=db_session_with_containers, view_args={"app_id": app_model.id}),+ app_model.id,+ query=AppDslExportQuery(),)assert code == 404@@ -233,7 +260,11 @@ class TestDslCheckDependencies:api = AppDslCheckDependenciesApi()with app.test_request_context(f"/openapi/v1/apps/{app_model.id}/dependencies:check"):- result, code = unwrap(api.get)(api, app_id=app_model.id, auth_data=auth_for(account, app_model=app_model))+ result, code = api.get.__handler__(+ api,+ context_for(account, session=db_session_with_containers, view_args={"app_id": app_model.id}),+ app_model.id,+ )assert code == 200assert result.leaked_dependencies == []diff --git a/api/tests/test_containers_integration_tests/controllers/openapi/test_app_run.py b/api/tests/test_containers_integration_tests/controllers/openapi/test_app_run.pyindex df4f3873b1e..92b7f91f7b2 100644--- a/api/tests/test_containers_integration_tests/controllers/openapi/test_app_run.py+++ b/api/tests/test_containers_integration_tests/controllers/openapi/test_app_run.py@@ -1,7 +1,6 @@from __future__ import annotationsfrom collections.abc import Callable-from inspect import unwrapfrom uuid import uuid4from flask import Flask@@ -10,7 +9,7 @@ from sqlalchemy.orm import Sessionfrom controllers.openapi.app_run import AppRunTaskStopApifrom models import Account, Appfrom services.app_service import AppService, CreateAppParams-from tests.test_containers_integration_tests.controllers.openapi.conftest import auth_for+from tests.test_containers_integration_tests.controllers.openapi.conftest import context_fordef _create_app(db_session: Session, account: Account, *, name: str = "Runner") -> App:@@ -39,11 +38,15 @@ class TestAppRunTaskStop:api = AppRunTaskStopApi()with app.test_request_context(f"/openapi/v1/apps/{app_model.id}/tasks/{task_id}:stop", method="POST"):- result = unwrap(api.post)(+ result = api.post.__handler__(api,- app_id=app_model.id,- task_id=task_id,- auth_data=auth_for(account, app_model=app_model, caller_kind="account"),+ context_for(+ account,+ session=db_session_with_containers,+ view_args={"app_id": app_model.id, "task_id": task_id},+ ),+ app_model.id,+ task_id,)assert result.result == "success"diff --git a/api/tests/test_containers_integration_tests/controllers/openapi/test_apps.py b/api/tests/test_containers_integration_tests/controllers/openapi/test_apps.pyindex 52f70b9d590..959c9fadb0c 100644--- a/api/tests/test_containers_integration_tests/controllers/openapi/test_apps.py+++ b/api/tests/test_containers_integration_tests/controllers/openapi/test_apps.py@@ -1,7 +1,6 @@from __future__ import annotationsfrom collections.abc import Callable-from inspect import unwrapfrom uuid import uuid4import pytest@@ -13,7 +12,7 @@ from controllers.openapi._models import AppDescribeQuery, AppListQueryfrom controllers.openapi.apps import AppDescribeApi, AppListApifrom models import Account, Appfrom services.app_service import AppService, CreateAppParams-from tests.test_containers_integration_tests.controllers.openapi.conftest import auth_for+from tests.test_containers_integration_tests.controllers.openapi.conftest import context_fordef _create_app(@@ -61,10 +60,9 @@ class TestAppList:api = AppListApi()with app.test_request_context(f"/openapi/v1/apps?workspace_id={tenant.id}"):- result = unwrap(api.get)(+ result = api.get.__handler__(api,- db_session_with_containers,- auth_data=auth_for(account),+ context_for(account, session=db_session_with_containers),query=AppListQuery(workspace_id=str(tenant.id)),)@@ -84,10 +82,9 @@ class TestAppList:api = AppListApi()with app.test_request_context(f"/openapi/v1/apps?workspace_id={tenant.id}&name={target.id}"):- result = unwrap(api.get)(+ result = api.get.__handler__(api,- db_session_with_containers,- auth_data=auth_for(account),+ context_for(account, session=db_session_with_containers),query=AppListQuery(workspace_id=str(tenant.id), name=str(target.id)),)@@ -108,10 +105,9 @@ class TestAppList:api = AppListApi()with app.test_request_context(f"/openapi/v1/apps?workspace_id={outsider_tenant.id}&name={foreign_app.id}"):- result = unwrap(api.get)(+ result = api.get.__handler__(api,- db_session_with_containers,- auth_data=auth_for(outsider),+ context_for(outsider, session=db_session_with_containers),query=AppListQuery(workspace_id=str(outsider_tenant.id), name=str(foreign_app.id)),)@@ -128,11 +124,10 @@ class TestAppDescribe:api = AppDescribeApi()with app.test_request_context(f"/openapi/v1/apps/{app_model.id}?fields=info"):- result = unwrap(api.get)(+ result = api.get.__handler__(api,- db_session_with_containers,- app_id=app_model.id,- auth_data=auth_for(account),+ context_for(account, session=db_session_with_containers, view_args={"app_id": app_model.id}),+ app_model.id,query=AppDescribeQuery(fields="info"),)@@ -153,29 +148,9 @@ class TestAppDescribe:api = AppDescribeApi()with app.test_request_context(f"/openapi/v1/apps/{missing_id}"):with pytest.raises(NotFound):- unwrap(api.get)(+ api.get.__handler__(api,- db_session_with_containers,- app_id=missing_id,- auth_data=auth_for(account),- query=AppDescribeQuery(),- )-- def test_describe_api_disabled_app_is_404(- self, app: Flask, db_session_with_containers: Session, make_account: Callable[..., Account]- ) -> None:- """An api-disabled app fails the openapi visibility gate, so describe- must behave as if it doesn't exist (404), not expose it."""- account = make_account()- hidden = _create_app(db_session_with_containers, account, name="Hidden", enable_api=False)-- api = AppDescribeApi()- with app.test_request_context(f"/openapi/v1/apps/{hidden.id}"):- with pytest.raises(NotFound):- unwrap(api.get)(- api,- db_session_with_containers,- app_id=hidden.id,- auth_data=auth_for(account),+ context_for(account, session=db_session_with_containers, view_args={"app_id": missing_id}),+ missing_id,query=AppDescribeQuery(),)diff --git a/api/tests/test_containers_integration_tests/controllers/openapi/test_files.py b/api/tests/test_containers_integration_tests/controllers/openapi/test_files.pyindex 31a5485d2b3..45079c1ee7e 100644--- a/api/tests/test_containers_integration_tests/controllers/openapi/test_files.py+++ b/api/tests/test_containers_integration_tests/controllers/openapi/test_files.py@@ -1,7 +1,6 @@from __future__ import annotationsfrom collections.abc import Callable-from inspect import unwrapfrom io import BytesIOfrom flask import Flask@@ -10,7 +9,7 @@ from sqlalchemy.orm import Sessionfrom controllers.openapi.files import AppFileUploadApifrom models import Account, Appfrom services.app_service import AppService, CreateAppParams-from tests.test_containers_integration_tests.controllers.openapi.conftest import auth_for+from tests.test_containers_integration_tests.controllers.openapi.conftest import context_fordef _create_app(db_session: Session, account: Account, *, name: str = "Uploader") -> App:@@ -48,10 +47,10 @@ class TestAppFileUpload:data=data,content_type="multipart/form-data",):- result = unwrap(api.post)(+ result = api.post.__handler__(api,- app_id=app_model.id,- auth_data=auth_for(account, app_model=app_model, caller_kind="account"),+ context_for(account, session=db_session_with_containers, view_args={"app_id": app_model.id}),+ app_model.id,)assert result.iddiff --git a/api/tests/test_containers_integration_tests/controllers/openapi/test_workspaces.py b/api/tests/test_containers_integration_tests/controllers/openapi/test_workspaces.pyindex 1346e013e66..ebe58bef716 100644--- a/api/tests/test_containers_integration_tests/controllers/openapi/test_workspaces.py+++ b/api/tests/test_containers_integration_tests/controllers/openapi/test_workspaces.py@@ -1,7 +1,6 @@from __future__ import annotationsfrom collections.abc import Callable-from inspect import unwrapimport pytestfrom flask import Flask@@ -11,7 +10,7 @@ from werkzeug.exceptions import NotFoundfrom controllers.openapi.workspaces import WorkspaceByIdApi, WorkspacesApi, WorkspaceSwitchApifrom models import Accountfrom models.account import TenantAccountRole-from tests.test_containers_integration_tests.controllers.openapi.conftest import add_tenant_for_account, auth_for+from tests.test_containers_integration_tests.controllers.openapi.conftest import add_tenant_for_account, context_forclass TestWorkspacesList:@@ -24,7 +23,7 @@ class TestWorkspacesList:api = WorkspacesApi()with app.test_request_context("/openapi/v1/workspaces"):- result = unwrap(api.get)(api, db_session_with_containers, auth_data=auth_for(account))+ result = api.get.__handler__(api, context_for(account, session=db_session_with_containers))ids = {w.id for w in result.workspaces}assert ids == {owner_tenant.id}@@ -45,7 +44,7 @@ class TestWorkspacesList:api = WorkspacesApi()with app.test_request_context("/openapi/v1/workspaces"):- result = unwrap(api.get)(api, db_session_with_containers, auth_data=auth_for(account))+ result = api.get.__handler__(api, context_for(account, session=db_session_with_containers))assert {w.id for w in result.workspaces} == {owner_tenant.id, second.id}@@ -60,8 +59,10 @@ class TestWorkspaceDetail:api = WorkspaceByIdApi()with app.test_request_context(f"/openapi/v1/workspaces/{tenant.id}"):- detail = unwrap(api.get)(- api, db_session_with_containers, workspace_id=tenant.id, auth_data=auth_for(account)+ detail = api.get.__handler__(+ api,+ context_for(account, session=db_session_with_containers, view_args={"workspace_id": tenant.id}),+ tenant.id,)assert detail.id == tenant.id@@ -82,8 +83,14 @@ class TestWorkspaceDetail:api = WorkspaceByIdApi()with app.test_request_context(f"/openapi/v1/workspaces/{someone_elses_ws.id}"):with pytest.raises(NotFound):- unwrap(api.get)(- api, db_session_with_containers, workspace_id=someone_elses_ws.id, auth_data=auth_for(outsider)+ api.get.__handler__(+ api,+ context_for(+ outsider,+ session=db_session_with_containers,+ view_args={"workspace_id": someone_elses_ws.id},+ ),+ someone_elses_ws.id,)@@ -100,8 +107,10 @@ class TestWorkspaceSwitch:api = WorkspaceSwitchApi()with app.test_request_context(f"/openapi/v1/workspaces/{target.id}/switch", method="POST"):- detail = unwrap(api.post)(- api, db_session_with_containers, workspace_id=target.id, auth_data=auth_for(account)+ detail = api.post.__handler__(+ api,+ context_for(account, session=db_session_with_containers, view_args={"workspace_id": target.id}),+ target.id,)# Response reflects the post-switch state.@@ -110,10 +119,9 @@ class TestWorkspaceSwitch:# And the switch persisted: the previously-current owner workspace is no# longer current (verified through the real read path).+ listing_api = WorkspacesApi()with app.test_request_context("/openapi/v1/workspaces"):- listing = unwrap(WorkspacesApi().get)(- WorkspacesApi(), db_session_with_containers, auth_data=auth_for(account)- )+ listing = listing_api.get.__handler__(listing_api, context_for(account, session=db_session_with_containers))by_id = {w.id: w for w in listing.workspaces}assert by_id[target.id].current is Trueassert by_id[owner_tenant.id].current is False@@ -128,6 +136,10 @@ class TestWorkspaceSwitch:api = WorkspaceSwitchApi()with app.test_request_context(f"/openapi/v1/workspaces/{outsider_ws.id}:switch", method="POST"):with pytest.raises(NotFound):- unwrap(api.post)(- api, db_session_with_containers, workspace_id=outsider_ws.id, auth_data=auth_for(account)+ api.post.__handler__(+ api,+ context_for(+ account, session=db_session_with_containers, view_args={"workspace_id": outsider_ws.id}+ ),+ outsider_ws.id,)diff --git a/api/tests/test_containers_integration_tests/pyrefly.toml b/api/tests/test_containers_integration_tests/pyrefly.tomlindex bf1701447c7..7c0feb1323f 100644--- a/api/tests/test_containers_integration_tests/pyrefly.toml+++ b/api/tests/test_containers_integration_tests/pyrefly.toml@@ -15,6 +15,13 @@ project-excludes = ["controllers/console/test_api_based_extension.py","controllers/console/test_apikey.py","controllers/console/workspace/test_workspace_wraps.py",+ "controllers/openapi/test_account.py",+ "controllers/openapi/test_account_sessions.py",+ "controllers/openapi/test_app_dsl.py",+ "controllers/openapi/test_app_run.py",+ "controllers/openapi/test_apps.py",+ "controllers/openapi/test_files.py",+ "controllers/openapi/test_workspaces.py","controllers/service_api/dataset/test_dataset.py","controllers/web/test_conversation.py","controllers/web/test_site.py",diff --git a/api/tests/unit_tests/.ruff.toml b/api/tests/unit_tests/.ruff.tomlindex 09056d4e952..b7fcaba4b7a 100644--- a/api/tests/unit_tests/.ruff.toml+++ b/api/tests/unit_tests/.ruff.toml@@ -66,9 +66,6 @@ extend-select = ["ANN401", "ARG"]"controllers/inner_api/plugin/test_plugin_wraps.py" = ["ARG001", "ARG002", "ARG003", "TID251"]"controllers/inner_api/test_runtime_credentials.py" = ["ARG001"]"controllers/mcp/test_mcp.py" = ["ARG002"]-"controllers/openapi/auth/test_conditions.py" = ["ARG005"]-"controllers/openapi/auth/test_flow.py" = ["ARG005"]-"controllers/openapi/auth/test_pipeline.py" = ["ARG001"]"controllers/openapi/conftest.py" = ["ARG001"]"controllers/openapi/test_account.py" = ["ARG005"]"controllers/openapi/test_app_describe_builder.py" = ["ARG001"]diff --git a/api/tests/unit_tests/controllers/openapi/auth/_world.py b/api/tests/unit_tests/controllers/openapi/auth/_world.pynew file mode 100644index 00000000000..1337cea7872--- /dev/null+++ b/api/tests/unit_tests/controllers/openapi/auth/_world.py@@ -0,0 +1,127 @@+"""The rows, tokens and subjects the auth-layer tests build their worlds from.++One copy: every module under `auth/` was carrying its own identical `App`,+`Tenant`, `Account` and `AuthContext` builders, so a column added to any of+those models had to be chased through six files.+"""++from __future__ import annotations++import uuid+from typing import NoReturn++from sqlalchemy.orm import Session++from controllers.openapi.auth.context import Context+from controllers.openapi.auth.subjects import AccountSubject, ExternalSsoSubject, Subject+from enums import DeploymentEdition+from libs.oauth_bearer import AuthContext, SubjectType, TokenType+from models import Account, App, Tenant, TenantAccountJoin+from models.account import AccountStatus, TenantAccountRole, TenantStatus+from models.enums import AppStatus+from models.model import AppMode, IconType+from services.enterprise.enterprise_service import WebAppSettings+from services.entities.feature_entities import (+ LicenseStatus,+ LicenseStatusModel,+ SystemFeatureModel,+ WebAppAuthModel,+)++APP_ID = "00000000-0000-0000-0000-000000000001"+TENANT_ID = "00000000-0000-0000-0000-000000000002"+ACCOUNT_ID = "00000000-0000-0000-0000-000000000003"+TOKEN_ID = "00000000-0000-0000-0000-000000000004"+SESSION_ID = "00000000-0000-0000-0000-000000000005"+OTHER_TENANT_ID = "00000000-0000-0000-0000-000000000006"+CLIENT_ID = "openapi-client"+ACCOUNT_EMAIL = "[email protected]"+SSO_EMAIL = "[email protected]"+SSO_ISSUER = "https://idp.example"+++def make_auth(token_type: TokenType, **overrides: object) -> AuthContext:+ """A live token of either kind. `overrides` names the one field a test varies."""+ is_account = token_type.subject is SubjectType.ACCOUNT+ fields: dict[str, object] = {+ "token_type": token_type,+ "subject_email": None if is_account else SSO_EMAIL,+ "subject_issuer": None if is_account else SSO_ISSUER,+ "account_id": uuid.UUID(ACCOUNT_ID) if is_account else None,+ "client_id": CLIENT_ID,+ "token_id": uuid.UUID(TOKEN_ID),+ "expires_at": None,+ }+ fields.update(overrides)+ return AuthContext(**fields) # type: ignore[arg-type]+++def account_subject(**overrides: object) -> AccountSubject:+ return AccountSubject(make_auth(TokenType.OAUTH_ACCOUNT, **overrides))+++def sso_subject(**overrides: object) -> ExternalSsoSubject:+ return ExternalSsoSubject(make_auth(TokenType.OAUTH_EXTERNAL_SSO, **overrides))+++def make_app(*, app_id: str = APP_ID, tenant_id: str = TENANT_ID, enable_api: bool = True) -> App:+ return App(+ id=app_id,+ tenant_id=tenant_id,+ name="OpenAPI app",+ description="",+ mode=AppMode.CHAT,+ icon_type=IconType.EMOJI,+ icon="robot",+ icon_background="#FFFFFF",+ status=AppStatus.NORMAL,+ enable_site=True,+ enable_api=enable_api,+ max_active_requests=None,+ )+++def make_tenant(*, tenant_id: str = TENANT_ID, status: TenantStatus = TenantStatus.NORMAL) -> Tenant:+ tenant = Tenant(name="OpenAPI tenant", status=status)+ tenant.id = tenant_id+ return tenant+++def make_account(*, status: AccountStatus = AccountStatus.ACTIVE, email: str = ACCOUNT_EMAIL) -> Account:+ account = Account(name="OpenAPI account", email=email, status=status)+ account.id = ACCOUNT_ID+ return account+++def make_membership(role: TenantAccountRole = TenantAccountRole.NORMAL) -> TenantAccountJoin:+ return TenantAccountJoin(tenant_id=TENANT_ID, account_id=ACCOUNT_ID, current=True, role=role)+++def persist(session: Session, *models: object) -> None:+ session.add_all(models)+ session.commit()+++def make_ctx(session: Session, subject: Subject | None = None, **view_args: str) -> Context:+ return Context(subject or account_subject(), session, dict(view_args))+++def system_features(+ *,+ license_status: LicenseStatus = LicenseStatus.ACTIVE,+ webapp_auth: bool = False,+) -> SystemFeatureModel:+ return SystemFeatureModel(+ deployment_edition=DeploymentEdition.ENTERPRISE,+ license=LicenseStatusModel(status=license_status),+ webapp_auth=WebAppAuthModel(enabled=webapp_auth),+ )+++def webapp_settings(access_mode: str) -> WebAppSettings:+ return WebAppSettings.model_validate({"accessMode": access_mode})+++def never_reached(*_args: object, **_kwargs: object) -> NoReturn:+ """Stand-in for anything a test's own setup says the code under test must not reach."""+ raise AssertionError("reached a call this test's setup says nothing should have made")diff --git a/api/tests/unit_tests/controllers/openapi/auth/test_composition.py b/api/tests/unit_tests/controllers/openapi/auth/test_composition.pydeleted file mode 100644index e77bb15c9cc..00000000000--- a/api/tests/unit_tests/controllers/openapi/auth/test_composition.py+++ /dev/null@@ -1,223 +0,0 @@-import uuid--from controllers.common.rbac import PlainApp, RBACCheck-from controllers.openapi.auth.composition import account_pipeline, auth_router, external_sso_pipeline-from controllers.openapi.auth.data import RequestContext-from controllers.openapi.auth.flow import When-from controllers.openapi.auth.pipeline import AuthPipeline, PipelineRoute, PipelineRouter-from controllers.openapi.auth.verify import (- check_acl,- check_private_app_permission,- check_rbac_permission,- check_workspace_member,- check_workspace_mismatch,- check_workspace_role,-)-from core.rbac import RBACPermission-from enums import DeploymentEdition-from libs.oauth_bearer import Scope, TokenType-from models.account import TenantAccountRole-from services.enterprise.enterprise_service import WebAppAccessMode-from tests.unit_tests.config_override import config_overrides_context---def test_account_pipeline_is_auth_pipeline():- assert isinstance(account_pipeline, AuthPipeline)---def test_external_sso_pipeline_is_auth_pipeline():- assert isinstance(external_sso_pipeline, AuthPipeline)---def test_auth_router_is_pipeline_router():- assert isinstance(auth_router, PipelineRouter)---def test_account_pipeline_prepare_has_six_entries():- assert len(account_pipeline._prepare) == 6---def test_account_auth_list_has_eight_entries():- assert len(account_pipeline._auth) == 8---def test_external_sso_pipeline_prepare_has_four_entries():- assert len(external_sso_pipeline._prepare) == 4---def test_external_sso_auth_list_has_four_entries():- assert len(external_sso_pipeline._auth) == 4---def test_account_pipeline_has_unconditional_load_account():- non_when = [s for s in account_pipeline._prepare if not isinstance(s, When)]- assert len(non_when) == 1---def test_external_sso_pipeline_all_prepare_entries_are_when():- assert all(isinstance(s, When) for s in external_sso_pipeline._prepare)---def test_account_pipeline_has_one_unconditional_auth_step():- non_when = [s for s in account_pipeline._auth if not isinstance(s, When)]- assert len(non_when) == 1---def test_external_sso_pipeline_has_one_unconditional_auth_step():- non_when = [s for s in external_sso_pipeline._auth if not isinstance(s, When)]- assert len(non_when) == 1---def test_router_routes_contain_both_token_types():- assert TokenType.OAUTH_ACCOUNT in auth_router._routes- assert TokenType.OAUTH_EXTERNAL_SSO in auth_router._routes---def test_external_sso_route_requires_enterprise_edition():- route = auth_router._routes[TokenType.OAUTH_EXTERNAL_SSO]- assert isinstance(route, PipelineRoute)- assert route.required_edition == frozenset({DeploymentEdition.ENTERPRISE})---def test_account_route_has_no_required_edition():- route = auth_router._routes[TokenType.OAUTH_ACCOUNT]- assert isinstance(route, PipelineRoute)- assert route.required_edition is None---def _selected_auth_steps(*, app_id: bool, workspace_membership: bool, allowed_roles):- ctx = RequestContext(- token_type=TokenType.OAUTH_ACCOUNT,- scope=None,- path_params={"app_id": str(uuid.uuid4())} if app_id else {},- workspace_membership=workspace_membership,- allowed_roles=allowed_roles,- )- selected = []- for step in account_pipeline._auth:- if isinstance(step, When):- if step.applies(ctx, None):- selected.append(step._step)- else:- selected.append(step)- return selected---_ALL_ROLES = frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.NORMAL})---def test_workspace_path_selects_membership_check():- steps = _selected_auth_steps(app_id=False, workspace_membership=True, allowed_roles=None)- assert check_workspace_member in steps- assert check_workspace_role not in steps---def test_app_path_selects_membership_check():- steps = _selected_auth_steps(app_id=True, workspace_membership=False, allowed_roles=None)- assert check_workspace_member in steps- assert check_workspace_role not in steps---def test_roles_set_selects_both_membership_and_role_check():- steps = _selected_auth_steps(app_id=False, workspace_membership=True, allowed_roles=_ALL_ROLES)- assert check_workspace_member in steps- assert check_workspace_role in steps---def test_plain_path_selects_no_membership_or_role_step():- steps = _selected_auth_steps(app_id=False, workspace_membership=False, allowed_roles=None)- assert check_workspace_member not in steps- assert check_workspace_role not in steps---def test_app_path_selects_workspace_mismatch_check():- steps = _selected_auth_steps(app_id=True, workspace_membership=False, allowed_roles=None)- assert check_workspace_mismatch in steps---def test_workspace_path_skips_workspace_mismatch_check():- steps = _selected_auth_steps(app_id=False, workspace_membership=True, allowed_roles=None)- assert check_workspace_mismatch not in steps---def _selected_webapp_steps(*, scope, app_access_mode):- """Select auth steps for an EE, webapp-auth-enabled, app-scoped request.-- Patches the config-backed conditions (edition + webapp_auth) so the gating- reduces to PATH_HAS_APP_ID, LOADED_APP_IS_PRIVATE, and the request scope.- """- from unittest.mock import patch-- from controllers.openapi.auth.data import AuthData-- ctx = RequestContext(- token_type=TokenType.OAUTH_ACCOUNT,- scope=scope,- path_params={"app_id": str(uuid.uuid4())},- )- data = AuthData(- token_type=TokenType.OAUTH_ACCOUNT,- scopes=frozenset({scope}) if scope is not None else frozenset(),- app_access_mode=app_access_mode,- )- selected = []- with (- config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.ENTERPRISE),- patch("controllers.openapi.auth.conditions.SystemFeatureService.is_webapp_auth_enabled", return_value=True),- ):- for step in account_pipeline._auth:- if isinstance(step, When):- if step.applies(ctx, data):- selected.append(step._step)- else:- selected.append(step)- return selected---def test_apps_run_scope_selects_webapp_checks():- steps = _selected_webapp_steps(scope=Scope.APPS_RUN, app_access_mode=WebAppAccessMode.PRIVATE)- assert check_acl in steps- assert check_private_app_permission in steps---def test_management_scope_skips_webapp_checks_on_private_app():- # Export DSL et al. carry an app_id but use a management scope; the webapp- # end-user ACL / private-app gate must not block workspace members.- steps = _selected_webapp_steps(scope=Scope.APPS_READ, app_access_mode=WebAppAccessMode.PRIVATE)- assert check_acl not in steps- assert check_private_app_permission not in steps---def _selected_auth_steps_with_rbac(rbac):- ctx = RequestContext(- token_type=TokenType.OAUTH_ACCOUNT,- scope=Scope.APPS_READ,- path_params={"app_id": str(uuid.uuid4())},- rbac=rbac,- )- selected = []- for step in account_pipeline._auth:- if isinstance(step, When):- if step.applies(ctx, None):- selected.append(step._step)- else:- selected.append(step)- return selected---def test_account_pipeline_selects_rbac_step_when_required():- rbac = RBACCheck(RBACPermission.APP_VIEW_LAYOUT, PlainApp())- assert check_rbac_permission in _selected_auth_steps_with_rbac(rbac)---def test_account_pipeline_skips_rbac_step_without_requirement():- assert check_rbac_permission not in _selected_auth_steps_with_rbac(None)---def test_external_sso_pipeline_never_enforces_rbac():- # RBAC is a console (account) concern; external SSO callers are scope-gated.- rbac_steps = [- s._step for s in external_sso_pipeline._auth if isinstance(s, When) and s._step is check_rbac_permission- ]- assert rbac_steps == []- assert check_rbac_permission not in external_sso_pipeline._authdiff --git a/api/tests/unit_tests/controllers/openapi/auth/test_conditions.py b/api/tests/unit_tests/controllers/openapi/auth/test_conditions.pydeleted file mode 100644index 8c3f1bc20ed..00000000000--- a/api/tests/unit_tests/controllers/openapi/auth/test_conditions.py+++ /dev/null@@ -1,208 +0,0 @@-import uuid-from unittest.mock import patch--from controllers.common.rbac import PlainApp, RBACCheck-from controllers.openapi.auth.conditions import (- EDITION_CLOUD,- EDITION_COMMUNITY,- EDITION_ENTERPRISE,- HAS_ALLOWED_ROLES,- HAS_RBAC,- LOADED_APP_IS_PRIVATE,- PATH_HAS_APP_ID,- TOKEN_IS_OAUTH_ACCOUNT,- TOKEN_IS_OAUTH_EXTERNAL_SSO,- WEBAPP_AUTH_ENABLED,- WEBAPP_RUN_SCOPED,- WORKSPACE_MEMBERSHIP_REQUIRED,- Cond,- config_cond,- data_cond,- request_cond,-)-from controllers.openapi.auth.data import AuthData, RequestContext-from core.rbac import RBACPermission-from enums import DeploymentEdition-from libs.oauth_bearer import Scope, TokenType-from models.account import TenantAccountRole-from services.enterprise.enterprise_service import WebAppAccessMode-from tests.unit_tests.config_override import config_overrides_context--PROBE_ID = uuid.uuid4()-OTHER_ID = uuid.uuid4()---def _ctx(token_type=TokenType.OAUTH_ACCOUNT, path_params=None, **kwargs):- return RequestContext(- token_type=token_type,- path_params=path_params or {},- **kwargs,- )---def _data(**kwargs):- defaults: dict = {"token_type": TokenType.OAUTH_ACCOUNT, "scopes": frozenset()}- defaults.update(kwargs)- return AuthData(**defaults)---def test_and_both_true():- a = Cond(lambda ctx, _: True)- b = Cond(lambda ctx, _: True)- assert (a & b)(_ctx()) is True---def test_and_one_false():- a = Cond(lambda ctx, _: True)- b = Cond(lambda ctx, _: False)- assert (a & b)(_ctx()) is False---def test_or_one_true():- a = Cond(lambda ctx, _: False)- b = Cond(lambda ctx, _: True)- assert (a | b)(_ctx()) is True---def test_or_both_false():- a = Cond(lambda ctx, _: False)- b = Cond(lambda ctx, _: False)- assert (a | b)(_ctx()) is False---def test_invert():- a = Cond(lambda ctx, _: True)- assert (~a)(_ctx()) is False---def test_chain_and_or():- always_true = Cond(lambda ctx, _: True)- always_false = Cond(lambda ctx, _: False)- assert ((always_true | always_false) & always_true)(_ctx()) is True---def test_request_cond_ignores_data():- c = request_cond(lambda ctx: ctx.token_type == TokenType.OAUTH_ACCOUNT)- assert c(_ctx(TokenType.OAUTH_ACCOUNT)) is True- assert c(_ctx(TokenType.OAUTH_EXTERNAL_SSO)) is False---def test_data_cond_returns_false_when_data_none():- c = data_cond(lambda data: True)- assert c(_ctx(), None) is False---def test_data_cond_evaluates_when_data_present():- c = data_cond(lambda data: data.token_id == PROBE_ID)- assert c(_ctx(), _data(token_id=PROBE_ID)) is True- assert c(_ctx(), _data(token_id=OTHER_ID)) is False---def test_config_cond_ignores_ctx_and_data():- c = config_cond(lambda: True)- assert c(_ctx()) is True- c2 = config_cond(lambda: False)- assert c2(_ctx(), _data()) is False---def test_token_is_oauth_account():- assert TOKEN_IS_OAUTH_ACCOUNT(_ctx(TokenType.OAUTH_ACCOUNT)) is True- assert TOKEN_IS_OAUTH_ACCOUNT(_ctx(TokenType.OAUTH_EXTERNAL_SSO)) is False---def test_token_is_oauth_external_sso():- assert TOKEN_IS_OAUTH_EXTERNAL_SSO(_ctx(TokenType.OAUTH_EXTERNAL_SSO)) is True---def test_path_has_app_id_true():- assert PATH_HAS_APP_ID(_ctx(path_params={"app_id": "abc"})) is True---def test_path_has_app_id_false():- assert PATH_HAS_APP_ID(_ctx(path_params={})) is False---def test_edition_community():- with config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY):- assert EDITION_COMMUNITY(_ctx()) is True- assert EDITION_ENTERPRISE(_ctx()) is False- assert EDITION_CLOUD(_ctx()) is False---def test_edition_enterprise():- with config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.ENTERPRISE):- assert EDITION_ENTERPRISE(_ctx()) is True- assert EDITION_COMMUNITY(_ctx()) is False---def test_edition_cloud():- with config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD):- assert EDITION_CLOUD(_ctx()) is True---def test_webapp_auth_enabled():- with patch("controllers.openapi.auth.conditions.SystemFeatureService.is_webapp_auth_enabled", return_value=True):- assert WEBAPP_AUTH_ENABLED(_ctx()) is True---def test_webapp_run_scoped_true_for_apps_run():- assert WEBAPP_RUN_SCOPED(_ctx(scope=Scope.APPS_RUN)) is True---def test_webapp_run_scoped_false_for_management_scope():- assert WEBAPP_RUN_SCOPED(_ctx(scope=Scope.APPS_READ)) is False---def test_webapp_run_scoped_false_when_scope_none():- assert WEBAPP_RUN_SCOPED(_ctx()) is False---def _rbac_req():- return RBACCheck(RBACPermission.APP_TEST_AND_RUN, PlainApp())---def test_has_rbac_true():- assert HAS_RBAC(_ctx(rbac=_rbac_req())) is True---def test_has_rbac_false():- assert HAS_RBAC(_ctx(rbac=None)) is False---def test_has_rbac_default():- assert HAS_RBAC(_ctx()) is False---def test_loaded_app_is_private():- data_private = _data(app_access_mode=WebAppAccessMode.PRIVATE)- data_public = _data(app_access_mode=WebAppAccessMode.PUBLIC)- data_none = _data(app_access_mode=None)- assert LOADED_APP_IS_PRIVATE(_ctx(), data_private) is True- assert LOADED_APP_IS_PRIVATE(_ctx(), data_public) is False- assert LOADED_APP_IS_PRIVATE(_ctx(), data_none) is False- assert LOADED_APP_IS_PRIVATE(_ctx(), None) is False---def test_workspace_membership_required_true():- assert WORKSPACE_MEMBERSHIP_REQUIRED(_ctx(workspace_membership=True)) is True---def test_workspace_membership_required_false():- assert WORKSPACE_MEMBERSHIP_REQUIRED(_ctx(workspace_membership=False)) is False---def test_workspace_membership_required_default():- assert WORKSPACE_MEMBERSHIP_REQUIRED(_ctx()) is False---def test_has_allowed_roles_true():- ctx = _ctx(allowed_roles=frozenset({TenantAccountRole.OWNER}))- assert HAS_ALLOWED_ROLES(ctx) is True---def test_has_allowed_roles_false():- assert HAS_ALLOWED_ROLES(_ctx(allowed_roles=None)) is False---def test_has_allowed_roles_default():- assert HAS_ALLOWED_ROLES(_ctx()) is Falsediff --git a/api/tests/unit_tests/controllers/openapi/auth/test_context.py b/api/tests/unit_tests/controllers/openapi/auth/test_context.pynew file mode 100644index 00000000000..ae654e2f599--- /dev/null+++ b/api/tests/unit_tests/controllers/openapi/auth/test_context.py@@ -0,0 +1,35 @@+"""The store hands handlers what the route loaded, and nothing else."""++from __future__ import annotations++from collections.abc import Callable++import pytest+from sqlalchemy.orm import Session++from controllers.openapi.auth.context import Context, RouteContractError+from models.model import EndUser+from tests.unit_tests.controllers.openapi.auth._world import make_ctx++READERS: dict[str, Callable[[Context], object]] = {+ "app": lambda ctx: ctx.app,+ "workspace": lambda ctx: ctx.workspace,+ "workspace_role": lambda ctx: ctx.workspace_role,+ "caller": lambda ctx: ctx.caller,+ "account": lambda ctx: ctx.account,+ "end_user": lambda ctx: ctx.end_user,+}++[email protected]("read", READERS.values(), ids=READERS.keys())+def test_an_unloaded_slot_is_an_error_not_a_fetch(sqlite_session: Session, read: Callable[[Context], object]) -> None:+ ctx = make_ctx(sqlite_session)+ with pytest.raises(RouteContractError, match="was not loaded"):+ read(ctx)+++def test_the_caller_is_read_as_what_it_is(sqlite_session: Session) -> None:+ ctx = make_ctx(sqlite_session)+ ctx._caller = EndUser()+ with pytest.raises(RouteContractError, match="not the Account"):+ _ = ctx.accountdiff --git a/api/tests/unit_tests/controllers/openapi/auth/test_data.py b/api/tests/unit_tests/controllers/openapi/auth/test_data.pydeleted file mode 100644index 73aed7bd615..00000000000--- a/api/tests/unit_tests/controllers/openapi/auth/test_data.py+++ /dev/null@@ -1,141 +0,0 @@-import uuid--import pytest-from pydantic import ValidationError--from controllers.openapi.auth.data import (- AuthData,- ExternalIdentity,- RequestContext,-)-from libs.oauth_bearer import Scope, TokenType---def test_external_identity_frozen():- ei = ExternalIdentity(email="[email protected]", issuer="idp")- with pytest.raises(ValidationError):- ei.email = "[email protected]" # type: ignore[misc]---def test_external_identity_issuer_optional():- ei = ExternalIdentity(email="[email protected]")- assert ei.issuer is None---def test_request_context_frozen():- ctx = RequestContext(- token_type=TokenType.OAUTH_ACCOUNT,- path_params={"app_id": "123"},- )- with pytest.raises(ValidationError):- ctx.token_type = TokenType.OAUTH_EXTERNAL_SSO # type: ignore[misc]---def test_request_context_scope_optional():- ctx = RequestContext(token_type=TokenType.OAUTH_ACCOUNT, path_params={})- assert ctx.scope is None---def test_auth_data_is_mutable():- data = AuthData(- token_type=TokenType.OAUTH_ACCOUNT,- scopes=frozenset({Scope.FULL}),- )- data.token_type = TokenType.OAUTH_EXTERNAL_SSO- assert data.token_type == TokenType.OAUTH_EXTERNAL_SSO---def test_auth_data_path_params_defaults_empty():- data = AuthData(- token_type=TokenType.OAUTH_ACCOUNT,- scopes=frozenset(),- )- assert data.path_params == {}---def test_auth_data_account_id_optional():- data = AuthData(- token_type=TokenType.OAUTH_EXTERNAL_SSO,- scopes=frozenset({Scope.APPS_RUN}),- external_identity=ExternalIdentity(email="[email protected]"),- )- assert data.account_id is None---def test_auth_data_external_identity_none_for_account():- data = AuthData(- token_type=TokenType.OAUTH_ACCOUNT,- account_id=uuid.uuid4(),- scopes=frozenset({Scope.FULL}),- )- assert data.external_identity is None---def test_auth_data_token_id_optional():- data = AuthData(- token_type=TokenType.OAUTH_ACCOUNT,- scopes=frozenset(),- )- assert data.token_id is None---def test_request_context_workspace_membership_default_false():- ctx = RequestContext(token_type=TokenType.OAUTH_ACCOUNT, path_params={})- assert ctx.workspace_membership is False---def test_request_context_workspace_membership_set():- ctx = RequestContext(token_type=TokenType.OAUTH_ACCOUNT, path_params={}, workspace_membership=True)- assert ctx.workspace_membership is True---def test_request_context_allowed_roles_default_none():- ctx = RequestContext(token_type=TokenType.OAUTH_ACCOUNT, path_params={})- assert ctx.allowed_roles is None---def test_request_context_allowed_roles_set():- from models.account import TenantAccountRole-- roles = frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN})- ctx = RequestContext(token_type=TokenType.OAUTH_ACCOUNT, path_params={}, allowed_roles=roles)- assert ctx.allowed_roles == roles---def test_auth_data_allowed_roles_default_none():- data = AuthData(- token_type=TokenType.OAUTH_ACCOUNT,- scopes=frozenset(),- )- assert data.allowed_roles is None---def test_auth_data_allowed_roles_set():- from models.account import TenantAccountRole-- roles = frozenset({TenantAccountRole.ADMIN})- data = AuthData(- token_type=TokenType.OAUTH_ACCOUNT,- scopes=frozenset(),- allowed_roles=roles,- )- assert data.allowed_roles == roles---def test_auth_data_tenant_role_default_none():- data = AuthData(- token_type=TokenType.OAUTH_ACCOUNT,- scopes=frozenset(),- )- assert data.tenant_role is None---def test_auth_data_tenant_role_set():- from models.account import TenantAccountRole-- data = AuthData(- token_type=TokenType.OAUTH_ACCOUNT,- scopes=frozenset(),- tenant_role=TenantAccountRole.ADMIN,- )- assert data.tenant_role == TenantAccountRole.ADMINdiff --git a/api/tests/unit_tests/controllers/openapi/auth/test_flow.py b/api/tests/unit_tests/controllers/openapi/auth/test_flow.pydeleted file mode 100644index 1c87c3b6450..00000000000--- a/api/tests/unit_tests/controllers/openapi/auth/test_flow.py+++ /dev/null@@ -1,42 +0,0 @@-import inspect--from controllers.openapi.auth.conditions import Cond-from controllers.openapi.auth.data import AuthData, RequestContext-from controllers.openapi.auth.flow import When-from libs.oauth_bearer import TokenType---def _ctx():- return RequestContext(token_type=TokenType.OAUTH_ACCOUNT, path_params={})---def _data():- return AuthData(token_type=TokenType.OAUTH_ACCOUNT, scopes=frozenset())---def test_applies_returns_true_when_condition_true():- w = When(Cond(lambda ctx, _: True), then=lambda b: None)- assert w.applies(_ctx()) is True---def test_applies_returns_false_when_condition_false():- w = When(Cond(lambda ctx, _: False), then=lambda b: None)- assert w.applies(_ctx()) is False---def test_applies_with_data():- w = When(Cond(lambda ctx, data: data is not None), then=lambda b: None)- assert w.applies(_ctx(), _data()) is True- assert w.applies(_ctx(), None) is False---def test_call_invokes_step():- calls = []- w = When(Cond(lambda ctx, _: True), then=lambda arg: calls.append(arg))- w("payload")- assert calls == ["payload"]---def test_then_is_keyword_only():- sig = inspect.signature(When.__init__)- assert sig.parameters["then"].kind.name == "KEYWORD_ONLY"diff --git a/api/tests/unit_tests/controllers/openapi/auth/test_loaders.py b/api/tests/unit_tests/controllers/openapi/auth/test_loaders.pynew file mode 100644index 00000000000..9c1d222b9ff--- /dev/null+++ b/api/tests/unit_tests/controllers/openapi/auth/test_loaders.py@@ -0,0 +1,208 @@+from __future__ import annotations++from collections.abc import Callable+from typing import cast, override++import pytest+from flask import Flask+from sqlalchemy.orm import Session+from werkzeug.exceptions import Forbidden, NotFound++from controllers.openapi.auth.context import Context+from controllers.openapi.auth.loaders import (+ load_app,+ load_end_user,+ load_workspace,+ load_workspace_role,+)+from controllers.openapi.auth.subjects import Subject+from models import App+from models.account import TenantAccountRole, TenantStatus+from services.account_service import TenantService+from services.app_service import AppService++from ._world import (+ ACCOUNT_ID,+ APP_ID,+ OTHER_TENANT_ID,+ TENANT_ID,+ make_account,+ make_app,+ make_membership,+ make_tenant,+ never_reached,+ persist,+)+++class _StubSubject:+ def __init__(self, caller: object | None = None, account_id: str = ACCOUNT_ID) -> None:+ self.calls: list[tuple[object, Session]] = []+ self.caller = caller if caller is not None else object()+ self.account_id = account_id++ def resolve_caller(self, ctx: object, session: Session) -> object:+ self.calls.append((ctx, session))+ return self.caller+++def _subject(caller: object | None = None) -> Subject:+ """`_StubSubject` stands in for `Subject` structurally — the loaders only+ ever call `resolve_caller` on it and read `account_id`. Cast once here+ rather than annotating every `Context(...)` call site against the concrete+ stub type.+ """+ return cast(Subject, _StubSubject(caller))+++def _archived_app() -> App:+ app = make_app()+ app.status = "archived" # type: ignore[assignment]+ return app+++class TestLoadApp:+ @pytest.mark.parametrize(+ ("app_id", "fetched"),+ [+ ("not-a-uuid", never_reached),+ (APP_ID, lambda: None),+ (APP_ID, _archived_app),+ ],+ ids=["malformed uuid", "missing", "not normal"],+ )+ def test_404s_when_the_app_cannot_be_served(+ self,+ sqlite_session: Session,+ monkeypatch: pytest.MonkeyPatch,+ app_id: str,+ fetched: Callable[[], App | None],+ ) -> None:+ monkeypatch.setattr(AppService, "get_app_by_id", lambda *_a, **_k: fetched())+ ctx = Context(_subject(), sqlite_session, {"app_id": app_id})++ with pytest.raises(NotFound, match="app not found"):+ load_app(ctx)++ def test_a_bare_hex_app_id_names_the_same_app(self, sqlite_session: Session) -> None:+ """The path parameter is whatever the caller typed; the row is keyed by the+ canonical dashed form. Normalising here is what lets one spelling of a UUID+ reach the app another spelling stored.+ """+ persist(sqlite_session, make_app())+ ctx = Context(_subject(), sqlite_session, {"app_id": APP_ID.replace("-", "")})++ assert load_app(ctx).id == APP_ID++ @pytest.mark.parametrize("persist_archived", [True, False])+ def test_forbidden_when_the_apps_tenant_is_missing_or_archived(+ self, sqlite_session: Session, persist_archived: bool+ ) -> None:+ models: list[object] = [make_app()]+ if persist_archived:+ models.append(make_tenant(status=TenantStatus.ARCHIVE))+ persist(sqlite_session, *models)+ ctx = Context(_subject(), sqlite_session, {"app_id": APP_ID})++ with pytest.raises(Forbidden, match="workspace unavailable"):+ load_workspace(ctx)+++class TestWorkspaceFromRequest:+ @pytest.mark.parametrize(+ ("view_args", "persisted_status"),+ [+ ({}, None),+ ({"workspace_id": "not-a-uuid"}, None),+ ({"workspace_id": TENANT_ID}, None),+ ({"workspace_id": TENANT_ID}, TenantStatus.ARCHIVE),+ ],+ ids=["no workspace_id", "malformed workspace_id", "missing tenant", "archived tenant"],+ )+ def test_not_found_when_the_workspace_cannot_be_served(+ self,+ app: Flask,+ sqlite_session: Session,+ view_args: dict[str, str],+ persisted_status: TenantStatus | None,+ ) -> None:+ if persisted_status is not None:+ persist(sqlite_session, make_tenant(status=persisted_status))+ ctx = Context(_subject(), sqlite_session, view_args)++ with app.test_request_context("/test"), pytest.raises(NotFound, match="workspace not found"):+ load_workspace(ctx)+++class TestWorkspaceRuleSelection:+ def test_app_id_wins_the_tie_when_both_app_id_and_workspace_id_are_present(+ self, app: Flask, sqlite_session: Session+ ) -> None:+ """Both a nonexistent app tenant and an existing workspace_id tenant are+ present; `route_has_app` must select the app-derived rule (and its+ `Forbidden` status), never fall through to the request-derived `NotFound`+ rule.+ """+ persist(sqlite_session, make_app(), make_tenant(tenant_id=OTHER_TENANT_ID))+ ctx = Context(_subject(), sqlite_session, {"app_id": APP_ID, "workspace_id": OTHER_TENANT_ID})++ with app.test_request_context("/test"), pytest.raises(Forbidden, match="workspace unavailable"):+ load_workspace(ctx)+++class TestLoadWorkspaceRole:+ def test_the_role_is_read_once_per_request(self, sqlite_session: Session, monkeypatch: pytest.MonkeyPatch) -> None:+ """Membership and the RBAC role floor both call this; the request pays+ for one SELECT, not one each.+ """+ persist(sqlite_session, make_app(), make_tenant(), make_account(), make_membership(TenantAccountRole.ADMIN))+ calls: list[int] = []++ def _counted(*_args: object, **_kwargs: object) -> TenantAccountRole:+ calls.append(1)+ return TenantAccountRole.ADMIN++ monkeypatch.setattr(TenantService, "get_account_role_in_tenant", _counted)+ ctx = Context(_subject(make_account()), sqlite_session, {"app_id": APP_ID})++ assert load_workspace_role(ctx) is TenantAccountRole.ADMIN+ assert load_workspace_role(ctx) is TenantAccountRole.ADMIN+ assert len(calls) == 1++ def test_404s_a_caller_that_is_not_an_account(+ self, sqlite_session: Session, monkeypatch: pytest.MonkeyPatch+ ) -> None:+ persist(sqlite_session, make_app(), make_tenant(), make_membership(TenantAccountRole.ADMIN))+ monkeypatch.setattr(TenantService, "get_account_role_in_tenant", never_reached)+ ctx = Context(_subject(), sqlite_session, {"app_id": APP_ID})++ with pytest.raises(NotFound, match="workspace not found"):+ load_workspace_role(ctx)++ def test_loads_the_workspace_before_the_caller(self, sqlite_session: Session) -> None:+ """A subject binds the account's current tenant while resolving it, so+ the workspace has to be there already — loading the caller first would+ leave the account mounted with no current tenant, silently.+ """+ persist(sqlite_session, make_app(), make_tenant(), make_account(), make_membership())+ loaded_when_called: list[bool] = []++ class _Recording(_StubSubject):+ @override+ def resolve_caller(self, ctx: object, session: Session) -> object:+ loaded_when_called.append(cast(Context, ctx).workspace is not None)+ return super().resolve_caller(ctx, session)++ ctx = Context(cast(Subject, _Recording(make_account())), sqlite_session, {"app_id": APP_ID})++ load_workspace_role(ctx)++ assert loaded_when_called == [True]+++class TestNarrowingLoaders:+ def test_load_end_user_refuses_an_account(self, sqlite_session: Session) -> None:+ ctx = Context(cast(Subject, _StubSubject(caller=make_account())), sqlite_session, {})++ with pytest.raises(Forbidden, match="unsupported_token_type"):+ load_end_user(ctx)diff --git a/api/tests/unit_tests/controllers/openapi/auth/test_pipeline.py b/api/tests/unit_tests/controllers/openapi/auth/test_pipeline.pydeleted file mode 100644index fc215fa4dd1..00000000000--- a/api/tests/unit_tests/controllers/openapi/auth/test_pipeline.py+++ /dev/null@@ -1,321 +0,0 @@-import uuid-from unittest.mock import MagicMock, patch--import pytest-from flask import Flask-from werkzeug.exceptions import Forbidden, NotFound, Unauthorized--from controllers.openapi.auth.data import AuthData-from controllers.openapi.auth.pipeline import AuthPipeline, PipelineRoute, PipelineRouter-from enums import DeploymentEdition-from libs.oauth_bearer import Scope, TokenType-from tests.unit_tests.config_override import config_overrides_context---def _make_identity(- token_type=TokenType.OAUTH_ACCOUNT,- account_id=None,- scopes=None,- subject_email=None,- subject_issuer=None,- token_id=None,-):- identity = MagicMock()- identity.token_type = token_type- identity.account_id = account_id or uuid.uuid4()- identity.scopes = scopes or frozenset({Scope.FULL})- identity.subject_email = subject_email- identity.subject_issuer = subject_issuer- identity.token_id = token_id or uuid.uuid4()- return identity---def app():- return Flask(__name__)---def _make_router(token_type=TokenType.OAUTH_ACCOUNT, prepare=None, auth=None):- pipeline = AuthPipeline(prepare=prepare or [], auth=auth or [])- return PipelineRouter({token_type: PipelineRoute(pipeline)})---def _fake_identity():- return _make_identity()---# --- PipelineRouter.guard ------def test_guard_passes_auth_data_to_view(app):- router = _make_router()- received = {}-- with app.test_request_context("/test", headers={"Authorization": "Bearer tok"}):- with (- patch("controllers.openapi.auth.pipeline.extract_bearer", return_value="tok"),- patch("controllers.openapi.auth.pipeline.get_authenticator") as mock_auth,- patch("controllers.openapi.auth.pipeline.set_auth_ctx", return_value=MagicMock()),- patch("controllers.openapi.auth.pipeline.reset_auth_ctx"),- ):- mock_auth.return_value.authenticate.return_value = _fake_identity()-- @router.guard(scope=Scope.FULL, allowed_token_types=frozenset({TokenType.OAUTH_ACCOUNT}))- def view(*, auth_data):- received["data"] = auth_data-- view()-- assert isinstance(received["data"], AuthData)---def test_guard_edition_gate_returns_404(app):- router = _make_router()-- with app.test_request_context("/test"):- with config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY):-- @router.guard(scope=Scope.FULL, edition=frozenset({DeploymentEdition.ENTERPRISE}))- def view(*, auth_data):- pass-- with pytest.raises(NotFound):- view()---def test_guard_token_type_gate_returns_403(app):- router = _make_router()-- with app.test_request_context("/test", headers={"Authorization": "Bearer tok"}):- with (- patch("controllers.openapi.auth.pipeline.extract_bearer", return_value="tok"),- patch("controllers.openapi.auth.pipeline.get_authenticator") as mock_auth,- patch("controllers.openapi.auth.pipeline.emit_wrong_surface"),- config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY),- ):- identity = _fake_identity()- identity.token_type = TokenType.OAUTH_EXTERNAL_SSO- mock_auth.return_value.authenticate.return_value = identity-- @router.guard(scope=Scope.FULL, allowed_token_types=frozenset({TokenType.OAUTH_ACCOUNT}))- def view(*, auth_data):- pass-- with pytest.raises(Forbidden):- view()---def test_guard_unregistered_token_type_returns_403(app):- router = _make_router(token_type=TokenType.OAUTH_ACCOUNT)-- with app.test_request_context("/test", headers={"Authorization": "Bearer tok"}):- with (- patch("controllers.openapi.auth.pipeline.extract_bearer", return_value="tok"),- patch("controllers.openapi.auth.pipeline.get_authenticator") as mock_auth,- config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY),- ):- identity = _fake_identity()- identity.token_type = TokenType.OAUTH_EXTERNAL_SSO- mock_auth.return_value.authenticate.return_value = identity-- @router.guard(scope=Scope.FULL)- def view(*, auth_data):- pass-- with pytest.raises(Forbidden):- view()---def test_guard_no_bearer_returns_401(app):- router = _make_router()-- with app.test_request_context("/test"):- with patch("controllers.openapi.auth.pipeline.extract_bearer", return_value=None):-- @router.guard(scope=Scope.FULL)- def view(*, auth_data):- pass-- with pytest.raises(Unauthorized):- view()---def test_guard_runs_prepare_steps_in_order(app):- order = []-- def p1(b):- order.append("p1")-- def p2(b):- order.append("p2")-- router = _make_router(prepare=[p1, p2])-- with app.test_request_context("/test", headers={"Authorization": "Bearer tok"}):- with (- patch("controllers.openapi.auth.pipeline.extract_bearer", return_value="tok"),- patch("controllers.openapi.auth.pipeline.get_authenticator") as mock_auth,- patch("controllers.openapi.auth.pipeline.set_auth_ctx", return_value=MagicMock()),- patch("controllers.openapi.auth.pipeline.reset_auth_ctx"),- ):- mock_auth.return_value.authenticate.return_value = _fake_identity()-- @router.guard(scope=Scope.FULL)- def view(*, auth_data):- pass-- view()-- assert order == ["p1", "p2"]---def test_guard_resets_auth_ctx_on_exception(app):- router = _make_router()- reset_called = []-- with app.test_request_context("/test", headers={"Authorization": "Bearer tok"}):- with (- patch("controllers.openapi.auth.pipeline.extract_bearer", return_value="tok"),- patch("controllers.openapi.auth.pipeline.get_authenticator") as mock_auth,- patch("controllers.openapi.auth.pipeline.set_auth_ctx", return_value="tok"),- patch("controllers.openapi.auth.pipeline.reset_auth_ctx", side_effect=lambda t: reset_called.append(t)),- ):- mock_auth.return_value.authenticate.return_value = _fake_identity()-- @router.guard(scope=Scope.FULL)- def view(*, auth_data):- raise RuntimeError("boom")-- with pytest.raises(RuntimeError):- view()-- assert reset_called == ["tok"]---def test_router_rejects_token_type_on_wrong_edition(app):- pipeline = AuthPipeline(prepare=[], auth=[])- route = PipelineRoute(pipeline, required_edition=frozenset({DeploymentEdition.ENTERPRISE}))- router = PipelineRouter({TokenType.OAUTH_EXTERNAL_SSO: route})-- with app.test_request_context("/test", headers={"Authorization": "Bearer tok"}):- with (- patch("controllers.openapi.auth.pipeline.extract_bearer", return_value="tok"),- patch("controllers.openapi.auth.pipeline.get_authenticator") as mock_auth,- config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY),- ):- identity = _make_identity(token_type=TokenType.OAUTH_EXTERNAL_SSO)- mock_auth.return_value.authenticate.return_value = identity-- @router.guard(scope=Scope.APPS_RUN)- def view(*, auth_data):- pass-- with pytest.raises(Forbidden):- view()---def test_guard_populates_external_identity_from_subject_email(app):- from controllers.openapi.auth.data import ExternalIdentity-- router = _make_router(token_type=TokenType.OAUTH_EXTERNAL_SSO)- received = {}-- with app.test_request_context("/test", headers={"Authorization": "Bearer tok"}):- with (- patch("controllers.openapi.auth.pipeline.extract_bearer", return_value="tok"),- patch("controllers.openapi.auth.pipeline.get_authenticator") as mock_auth,- patch("controllers.openapi.auth.pipeline.set_auth_ctx", return_value=MagicMock()),- patch("controllers.openapi.auth.pipeline.reset_auth_ctx"),- ):- identity = _make_identity(- token_type=TokenType.OAUTH_EXTERNAL_SSO,- subject_email="[email protected]",- subject_issuer="https://idp.example.com",- )- mock_auth.return_value.authenticate.return_value = identity-- @router.guard(scope=Scope.FULL, allowed_token_types=frozenset({TokenType.OAUTH_EXTERNAL_SSO}))- def view(*, auth_data):- received["data"] = auth_data-- view()-- assert isinstance(received["data"].external_identity, ExternalIdentity)- assert received["data"].external_identity.email == "[email protected]"- assert received["data"].external_identity.issuer == "https://idp.example.com"---def test_guard_workspace_sets_membership_and_roles(app):- from models.account import TenantAccountRole-- router = _make_router()- received = {}-- with app.test_request_context("/test", headers={"Authorization": "Bearer tok"}):- with (- patch("controllers.openapi.auth.pipeline.extract_bearer", return_value="tok"),- patch("controllers.openapi.auth.pipeline.get_authenticator") as mock_auth,- patch("controllers.openapi.auth.pipeline.set_auth_ctx", return_value=MagicMock()),- patch("controllers.openapi.auth.pipeline.reset_auth_ctx"),- ):- mock_auth.return_value.authenticate.return_value = _fake_identity()-- roles = frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN})-- @router.guard_workspace(- scope=Scope.FULL,- allowed_token_types=frozenset({TokenType.OAUTH_ACCOUNT}),- allowed_roles=roles,- )- def view(*, auth_data):- received["data"] = auth_data-- view()-- assert isinstance(received["data"], AuthData)- assert received["data"].allowed_roles == roles---def test_guard_workspace_without_roles(app):- router = _make_router()- received = {}-- with app.test_request_context("/test", headers={"Authorization": "Bearer tok"}):- with (- patch("controllers.openapi.auth.pipeline.extract_bearer", return_value="tok"),- patch("controllers.openapi.auth.pipeline.get_authenticator") as mock_auth,- patch("controllers.openapi.auth.pipeline.set_auth_ctx", return_value=MagicMock()),- patch("controllers.openapi.auth.pipeline.reset_auth_ctx"),- ):- mock_auth.return_value.authenticate.return_value = _fake_identity()-- @router.guard_workspace(scope=Scope.FULL)- def view(*, auth_data):- received["data"] = auth_data-- view()-- assert isinstance(received["data"], AuthData)- assert received["data"].allowed_roles is None---def test_guard_no_external_identity_when_subject_email_absent(app):- router = _make_router()- received = {}-- with app.test_request_context("/test", headers={"Authorization": "Bearer tok"}):- with (- patch("controllers.openapi.auth.pipeline.extract_bearer", return_value="tok"),- patch("controllers.openapi.auth.pipeline.get_authenticator") as mock_auth,- patch("controllers.openapi.auth.pipeline.set_auth_ctx", return_value=MagicMock()),- patch("controllers.openapi.auth.pipeline.reset_auth_ctx"),- ):- mock_auth.return_value.authenticate.return_value = _make_identity(subject_email=None)-- @router.guard(scope=Scope.FULL, allowed_token_types=frozenset({TokenType.OAUTH_ACCOUNT}))- def view(*, auth_data):- received["data"] = auth_data-- view()-- assert received["data"].external_identity is Nonediff --git a/api/tests/unit_tests/controllers/openapi/auth/test_pipelines.py b/api/tests/unit_tests/controllers/openapi/auth/test_pipelines.pynew file mode 100644index 00000000000..283542def02--- /dev/null+++ b/api/tests/unit_tests/controllers/openapi/auth/test_pipelines.py@@ -0,0 +1,239 @@+from __future__ import annotations++from collections.abc import Callable+from typing import override+from unittest.mock import patch++import pytest+from flask import Flask+from sqlalchemy.orm import Session+from werkzeug.exceptions import Forbidden, Unauthorized++from controllers.openapi.auth.context import Context+from controllers.openapi.auth.pipelines import (+ _PIPELINES,+ AccountPipeline,+ ExternalSsoPipeline,+ Pipeline,+)+from controllers.openapi.auth.requirements import (+ CheckAppAccess,+ CheckAppApiEnabled,+ CheckSubject,+ CheckWorkspaceMember,+ Rank,+ Requirement,+)+from controllers.openapi.auth.spec import EndpointSpec+from controllers.openapi.auth.subjects import _SUBJECT_CLASSES, AccountSubject, Subject+from enums import DeploymentEdition+from libs.oauth_bearer import AuthContext, try_get_auth_ctx+from services.account_service import AccountService, TenantService+from services.app_service import AppService+from services.end_user_service import EndUserService+from services.enterprise.enterprise_service import WebAppAccessMode++from ._world import (+ APP_ID,+ account_subject,+ make_account,+ make_app,+ make_ctx,+ make_membership,+ make_tenant,+ never_reached,+ persist,+ sso_subject,+ system_features,+ webapp_settings,+)++MOUNT = "controllers.openapi.auth.pipelines._mount_flask_login"+FEATURES = "controllers.openapi.auth.requirements.SystemFeatureService.get_public_system_features"+ACCESS_MODE = "controllers.openapi.auth.requirements.EnterpriseService.WebAppAuth.get_app_access_mode_by_id"+++class _Recorded(Requirement):+ """Shared plumbing for the ordering test doubles. Declares no rank of its+ own, so a bare instance proves `Requirement`'s default applies.+ """++ def __init__(self, log: list[str], name: str) -> None:+ self._log = log+ self._name = name++ @override+ def run(self, subject: Subject, ctx: Context, session: Session) -> None:+ self._log.append(self._name)+++class _AtFirst(_Recorded):+ rank = Rank.FIRST+++class _AtEarly(_Recorded):+ rank = Rank.EARLY+++class _NoFixed(Pipeline):+ pass+++def _run(+ pipeline: Pipeline,+ subject: Subject,+ ctx: Context,+ session: Session,+ *,+ requirements: tuple[Requirement, ...] = (),+ call: Callable[..., object] = lambda **_kwargs: None,+) -> object:+ return pipeline.run(+ subject=subject,+ auth=subject.auth,+ spec=EndpointSpec(requirements=requirements),+ ctx=ctx,+ session=session,+ call=call,+ )+++def test_requirements_run_in_rank_order(sqlite_session: Session) -> None:+ log: list[str] = []+ subject = sso_subject()+ requirements = (_Recorded(log, "normal"), _AtEarly(log, "early"), _AtFirst(log, "first"))++ _run(_NoFixed(), subject, make_ctx(sqlite_session, subject), sqlite_session, requirements=requirements)++ assert log == ["first", "early", "normal"]+++def test_equal_ranks_keep_declared_order(sqlite_session: Session) -> None:+ """Endpoint-declared before pipeline-fixed at equal rank — the property+ that keeps `CheckSubject` ahead of `_RequiresEnterprise`, and the reason the sort+ has to stay stable.+ """+ log: list[str] = []++ class _FixedRecorders(Pipeline):+ fixed = (_Recorded(log, "fixed-a"), _Recorded(log, "fixed-b"))++ subject = sso_subject()+ requirements = (_Recorded(log, "spec-a"), _Recorded(log, "spec-b"))++ _run(_FixedRecorders(), subject, make_ctx(sqlite_session, subject), sqlite_session, requirements=requirements)++ assert log == ["spec-a", "spec-b", "fixed-a", "fixed-b"]++[email protected]("view_raises", [False, True])+def test_auth_ctx_is_published_for_the_view_and_reset_after_it(+ sqlite_session: Session,+ view_raises: bool,+) -> None:+ subject = sso_subject()+ seen: list[AuthContext | None] = []++ def call(**_kwargs: object) -> None:+ seen.append(try_get_auth_ctx())+ if view_raises:+ raise RuntimeError("boom")++ ctx = make_ctx(sqlite_session, subject)+ if view_raises:+ with pytest.raises(RuntimeError):+ _run(_NoFixed(), subject, ctx, sqlite_session, call=call)+ else:+ _run(_NoFixed(), subject, ctx, sqlite_session, call=call)++ assert seen == [subject.auth]+ assert try_get_auth_ctx() is None+++def test_a_caller_that_cannot_be_resolved_leaves_the_auth_ctx_unset(+ sqlite_session: Session,+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ """A token outliving its account raises inside `ResolveCaller`, which is a+ requirement and so runs before `mounted`. Resolving after `set_auth_ctx`+ would strand the identity on the ContextVar that `libs/rate_limit` buckets+ on, with no reset to undo it.+ """+ monkeypatch.setattr(MOUNT, never_reached)+ subject = account_subject()++ with pytest.raises(Unauthorized, match="account not found"):+ _run(AccountPipeline(), subject, make_ctx(sqlite_session, subject), sqlite_session)++ assert try_get_auth_ctx() is None+++def test_the_requirements_that_share_a_datum_fetch_it_once(+ sqlite_session: Session,+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ """Both declared requirements need the app — `CheckAppApiEnabled` directly,+ `CheckWorkspaceMember` through the workspace it hangs off — and the+ membership check and `ResolveCaller` both need the caller. Each is fetched once.+ """+ persist(sqlite_session, make_app(), make_tenant(), make_account(), make_membership())+ monkeypatch.setattr(MOUNT, lambda _user: None)+ subject = account_subject()++ with (+ patch.object(AppService, "get_app_by_id", wraps=AppService.get_app_by_id) as app_fetch,+ patch.object(TenantService, "get_tenant_by_id", wraps=TenantService.get_tenant_by_id) as workspace_fetch,+ patch.object(AccountService, "get_account_by_id", wraps=AccountService.get_account_by_id) as caller_fetch,+ ):+ _run(+ AccountPipeline(),+ subject,+ make_ctx(sqlite_session, subject, app_id=APP_ID),+ sqlite_session,+ requirements=(CheckAppApiEnabled(), CheckWorkspaceMember()),+ )++ assert (app_fetch.call_count, workspace_fetch.call_count, caller_fetch.call_count) == (1, 1, 1)+++ ("requirements", "enable_api", "webapp_auth", "message"),+ [+ ((CheckSubject(allowed=[AccountSubject]),), True, False, "unsupported_token_type"),+ ((CheckAppApiEnabled(),), False, False, "service_api_disabled"),+ ((CheckAppAccess(),), True, True, "subject_not_allowed_for_access_mode"),+ ],+ ids=["wrong subject (FIRST)", "api disabled (EARLY)", "webapp acl (NORMAL)"],+)+def test_a_refused_sso_request_never_creates_an_end_user(+ app: Flask,+ sqlite_session: Session,+ monkeypatch: pytest.MonkeyPatch,+ config_overrides: Callable[..., None],+ requirements: tuple[Requirement, ...],+ enable_api: bool,+ webapp_auth: bool,+ message: str,+) -> None:+ """`ResolveCaller` mints an `EndUser` row, so it has to run after every+ requirement that can refuse — one refusal per band, because a rank that+ moved it earlier would side-effect before the gate that exists to stop it.+ """+ config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.ENTERPRISE)+ persist(sqlite_session, make_app(enable_api=enable_api), make_tenant())+ monkeypatch.setattr(MOUNT, never_reached)+ monkeypatch.setattr(EndUserService, "get_or_create_end_user_by_type", never_reached)+ subject = sso_subject()+ ctx = make_ctx(sqlite_session, subject, app_id=APP_ID)++ with app.test_request_context(f"/openapi/v1/apps/{APP_ID}:run"):+ with patch(FEATURES, return_value=system_features(webapp_auth=webapp_auth)):+ with patch(ACCESS_MODE, return_value=webapp_settings(WebAppAccessMode.PRIVATE_ALL.value)):+ with pytest.raises(Forbidden, match=message):+ _run(ExternalSsoPipeline(), subject, ctx, sqlite_session, requirements=requirements)++ assert ctx._caller is None+++def test_every_registrable_subject_has_a_pipeline() -> None:+ assert set(_SUBJECT_CLASSES.values()) == set(_PIPELINES)diff --git a/api/tests/unit_tests/controllers/openapi/auth/test_prepare.py b/api/tests/unit_tests/controllers/openapi/auth/test_prepare.pydeleted file mode 100644index fa844520e3e..00000000000--- a/api/tests/unit_tests/controllers/openapi/auth/test_prepare.py+++ /dev/null@@ -1,346 +0,0 @@-import uuid-from types import SimpleNamespace-from unittest.mock import PropertyMock, patch--import pytest-from flask import Flask-from sqlalchemy import Engine, select-from sqlalchemy.orm import Session-from werkzeug.exceptions import Forbidden, InternalServerError, NotFound, Unauthorized--from controllers.openapi.auth.data import AuthData, ExternalIdentity-from controllers.openapi.auth.prepare import (- load_account,- load_app,- load_app_access_mode,- load_tenant,- load_tenant_from_request,- load_workspace_role,- resolve_external_user,-)-from libs.oauth_bearer import TokenType-from models import Account, App, EndUser, Tenant, TenantAccountJoin-from models.account import AccountStatus, TenantAccountRole, TenantStatus-from services import end_user_service-from services.enterprise.enterprise_service import WebAppAccessMode-from tests.unit_tests.model_factories import make_account, make_app, make_tenant--APP_ID = "00000000-0000-0000-0000-000000000001"-TENANT_ID = "00000000-0000-0000-0000-000000000002"-ACCOUNT_ID = "00000000-0000-0000-0000-000000000003"---def _make_auth_data(**kwargs: object) -> AuthData:- return AuthData(- token_type=kwargs.pop("token_type", TokenType.OAUTH_ACCOUNT),- scopes=kwargs.pop("scopes", frozenset()),- **kwargs,- )---def _app(- *,- app_id: str = APP_ID,- tenant_id: str = TENANT_ID,- enable_api: bool = True,-) -> App:- return make_app(app_id=app_id, tenant_id=tenant_id, name="OpenAPI app", enable_api=enable_api)---def _tenant(*, tenant_id: str = TENANT_ID, status: TenantStatus = TenantStatus.NORMAL) -> Tenant:- return make_tenant(tenant_id=tenant_id, name="OpenAPI tenant", status=status)---def _account(*, status: AccountStatus = AccountStatus.ACTIVE) -> Account:- return make_account(account_id=ACCOUNT_ID, name="OpenAPI account", email="[email protected]", status=status)---def _persist(session: Session, *models: object) -> None:- session.add_all(models)- session.commit()---class TestLoadApp:- def test_writes_persisted_app_to_data(self, sqlite_session: Session) -> None:- _persist(sqlite_session, _app())- data = _make_auth_data(path_params={"app_id": APP_ID})-- load_app(data)-- assert data.app is not None- assert data.app.id == APP_ID-- def test_rejects_non_uuid_and_missing_app(self) -> None:- with pytest.raises(NotFound, match="app not found"):- load_app(_make_auth_data(path_params={"app_id": "not-a-uuid"}))- with pytest.raises(NotFound, match="app not found"):- load_app(_make_auth_data(path_params={"app_id": APP_ID}))-- def test_rejects_non_normal_app(self) -> None:- app = _app()- app.status = "archived" # type: ignore[assignment]-- with (- patch("controllers.openapi.auth.prepare.AppService.get_app_by_id", return_value=app),- pytest.raises(NotFound, match="app not found"),- ):- load_app(_make_auth_data(path_params={"app_id": APP_ID}))-- def test_stashes_app_even_when_api_disabled(self, sqlite_session: Session) -> None:- _persist(sqlite_session, _app(enable_api=False))- data = _make_auth_data(path_params={"app_id": APP_ID})-- load_app(data)-- assert data.app is not None- assert data.app.enable_api is False-- def test_skips_when_already_set(self) -> None:- existing_app = _app()- data = _make_auth_data(app=existing_app, path_params={"app_id": "invalid"})-- load_app(data)-- assert data.app is existing_app---class TestLoadTenant:- def test_writes_persisted_tenant(self, sqlite_session: Session) -> None:- app = _app()- _persist(sqlite_session, app, _tenant())- data = _make_auth_data(app=app)-- load_tenant(data)-- assert data.tenant is not None- assert data.tenant.id == TENANT_ID-- def test_skips_when_already_set(self) -> None:- tenant = _tenant()- data = _make_auth_data(app=_app(), tenant=tenant)-- load_tenant(data)-- assert data.tenant is tenant-- @pytest.mark.parametrize("persist_archived", [True, False])- def test_rejects_archived_or_missing_tenant(self, sqlite_session: Session, persist_archived: bool) -> None:- app = _app()- models: list[object] = [app]- if persist_archived:- models.append(_tenant(status=TenantStatus.ARCHIVE))- _persist(sqlite_session, *models)-- with pytest.raises(Forbidden, match="workspace unavailable"):- load_tenant(_make_auth_data(app=app))-- def test_rejects_missing_app_context(self) -> None:- with pytest.raises(InternalServerError, match="app not loaded"):- load_tenant(_make_auth_data())---class TestLoadAccount:- def test_writes_persisted_caller(self, sqlite_session: Session) -> None:- _persist(sqlite_session, _account())- data = _make_auth_data(account_id=uuid.UUID(ACCOUNT_ID))-- load_account(data)-- assert data.caller is not None- assert data.caller.id == ACCOUNT_ID- assert data.caller_kind == "account"-- def test_sets_current_tenant_from_real_membership(self, sqlite_session: Session) -> None:- account = _account()- tenant = _tenant()- membership = TenantAccountJoin(- tenant_id=tenant.id,- account_id=account.id,- current=True,- role=TenantAccountRole.ADMIN,- )- _persist(sqlite_session, account, tenant, membership)- data = _make_auth_data(account_id=uuid.UUID(ACCOUNT_ID), tenant=tenant)-- load_account(data)-- assert isinstance(data.caller, Account)- assert data.caller.current_tenant_id == TENANT_ID- assert data.caller.role == TenantAccountRole.ADMIN-- def test_skips_when_caller_already_set(self) -> None:- account = _account()- data = _make_auth_data(account_id=uuid.UUID(ACCOUNT_ID), caller=account)-- load_account(data)-- assert data.caller is account-- def test_rejects_missing_account(self) -> None:- with pytest.raises(Unauthorized, match="account not found"):- load_account(_make_auth_data(account_id=uuid.UUID(ACCOUNT_ID)))---class TestResolveExternalUser:- def test_persists_and_writes_end_user(- self,- sqlite_engine: Engine,- sqlite_session: Session,- ) -> None:- app = _app()- tenant = _tenant()- _persist(sqlite_session, app, tenant)- data = _make_auth_data(- tenant=tenant,- app=app,- external_identity=ExternalIdentity(email="[email protected]"),- )-- with patch.object(type(end_user_service.db), "engine", new_callable=PropertyMock) as engine:- engine.return_value = sqlite_engine- resolve_external_user(data)-- assert isinstance(data.caller, EndUser)- assert data.caller_kind == "end_user"- with Session(sqlite_engine) as observer:- persisted = observer.scalar(select(EndUser).where(EndUser.session_id == "[email protected]"))- assert persisted is not None- assert persisted.tenant_id == TENANT_ID- assert persisted.app_id == APP_ID-- def test_rejects_missing_context(self) -> None:- data = _make_auth_data(app=_app(), external_identity=ExternalIdentity(email="[email protected]"))-- with pytest.raises(Unauthorized, match="missing context"):- resolve_external_user(data)---class TestLoadAppAccessMode:- def test_writes_mode(self) -> None:- data = _make_auth_data(app=_app())- settings = SimpleNamespace(access_mode="public")-- with patch(- "controllers.openapi.auth.prepare.EnterpriseService.WebAppAuth.get_app_access_mode_by_id",- return_value=settings,- ):- load_app_access_mode(data)-- assert data.app_access_mode == WebAppAccessMode.PUBLIC-- def test_writes_none_when_provider_raises(self) -> None:- data = _make_auth_data(app=_app())- with patch(- "controllers.openapi.auth.prepare.EnterpriseService.WebAppAuth.get_app_access_mode_by_id",- side_effect=ValueError("No data found."),- ):- load_app_access_mode(data)- assert data.app_access_mode is None-- def test_noop_without_app(self) -> None:- data = _make_auth_data()- load_app_access_mode(data)- assert data.app_access_mode is None---class TestLoadTenantFromRequest:- def test_loads_from_path_or_query(- self,- app: Flask,- sqlite_session: Session,- ) -> None:- _persist(sqlite_session, _tenant())- for path_params, path in (({"workspace_id": TENANT_ID}, "/test"), ({}, f"/test?workspace_id={TENANT_ID}")):- data = _make_auth_data(path_params=path_params)- with app.test_request_context(path):- load_tenant_from_request(data)- assert data.tenant is not None- assert data.tenant.id == TENANT_ID-- def test_skips_when_already_set(self, app: Flask) -> None:- tenant = _tenant()- data = _make_auth_data(tenant=tenant)- with app.test_request_context("/test"):- load_tenant_from_request(data)- assert data.tenant is tenant-- def test_rejects_missing_or_invalid_id(self, app: Flask) -> None:- for path_params in ({}, {"workspace_id": "not-a-uuid"}):- with app.test_request_context("/test"), pytest.raises(NotFound, match="workspace not found"):- load_tenant_from_request(_make_auth_data(path_params=path_params))-- @pytest.mark.parametrize("tenant_status", [None, TenantStatus.ARCHIVE])- def test_rejects_missing_or_archived_tenant(- self,- app: Flask,- sqlite_session: Session,- tenant_status: TenantStatus | None,- ) -> None:- if tenant_status is not None:- _persist(sqlite_session, _tenant(status=tenant_status))- data = _make_auth_data(path_params={"workspace_id": TENANT_ID})-- with app.test_request_context("/test"), pytest.raises(NotFound, match="workspace not found"):- load_tenant_from_request(data)---class TestLoadWorkspaceRole:- def test_loads_real_membership_role(self, sqlite_session: Session) -> None:- account = _account()- tenant = _tenant()- membership = TenantAccountJoin(- tenant_id=tenant.id,- account_id=account.id,- current=True,- role=TenantAccountRole.ADMIN,- )- _persist(sqlite_session, account, tenant, membership)- data = _make_auth_data(- account_id=uuid.UUID(ACCOUNT_ID),- tenant=tenant,- caller=account,- )-- load_workspace_role(data)-- assert data.tenant_role == TenantAccountRole.ADMIN-- def test_none_when_not_member(self, sqlite_session: Session) -> None:- account = _account()- tenant = _tenant()- _persist(sqlite_session, account, tenant)- data = _make_auth_data(account_id=uuid.UUID(ACCOUNT_ID), tenant=tenant, caller=account)-- load_workspace_role(data)-- assert data.tenant_role is None-- def test_none_when_account_inactive(self) -> None:- data = _make_auth_data(- account_id=uuid.UUID(ACCOUNT_ID),- tenant=_tenant(),- caller=_account(status=AccountStatus.BANNED),- )- load_workspace_role(data)- assert data.tenant_role is None-- def test_skips_when_already_set(self) -> None:- data = _make_auth_data(- account_id=uuid.UUID(ACCOUNT_ID),- tenant=_tenant(),- caller=_account(),- tenant_role=TenantAccountRole.OWNER,- )- load_workspace_role(data)- assert data.tenant_role == TenantAccountRole.OWNER-- @pytest.mark.parametrize(- "data",- [- _make_auth_data(account_id=uuid.UUID(ACCOUNT_ID)),- _make_auth_data(tenant=_tenant(), account_id=None),- ],- )- def test_skips_without_tenant_or_account(self, data: AuthData) -> None:- load_workspace_role(data)- assert data.tenant_role is Nonediff --git a/api/tests/unit_tests/controllers/openapi/auth/test_requirements.py b/api/tests/unit_tests/controllers/openapi/auth/test_requirements.pynew file mode 100644index 00000000000..75505a94a15--- /dev/null+++ b/api/tests/unit_tests/controllers/openapi/auth/test_requirements.py@@ -0,0 +1,229 @@+from __future__ import annotations++from collections.abc import Callable+from unittest.mock import patch++import pytest+from flask import Flask+from sqlalchemy.orm import Session+from werkzeug.exceptions import Forbidden, NotFound++from controllers.common.rbac import PlainApp, RBACCheck, RBACPermission+from controllers.openapi.auth.context import RouteContractError+from controllers.openapi.auth.requirements import (+ CheckAppAccess,+ CheckAppApiEnabled,+ CheckRBACPermission,+ CheckSubject,+ CheckWorkspaceRole,+ assert_license_valid,+)+from controllers.openapi.auth.subjects import AccountSubject+from enums import DeploymentEdition+from models.account import AccountStatus, TenantAccountRole+from services.enterprise.enterprise_service import WebAppAccessMode, WebAppSettings+from services.entities.feature_entities import (+ LicenseStatus,+)++from ._world import (+ APP_ID,+ CLIENT_ID,+ TOKEN_ID,+ account_subject,+ make_account,+ make_app,+ make_ctx,+ make_membership,+ make_tenant,+ never_reached,+ persist,+ sso_subject,+ system_features,+ webapp_settings,+)++FEATURES = "controllers.openapi.auth.requirements.SystemFeatureService.get_public_system_features"+WEBAPP_AUTH = "controllers.openapi.auth.requirements.EnterpriseService.WebAppAuth"+ACCESS_MODE = f"{WEBAPP_AUTH}.get_app_access_mode_by_id"+ENFORCE_RBAC = "controllers.openapi.auth.requirements.enforce_rbac_checks"+APP_FETCH = "controllers.openapi.auth.loaders.AppService.get_app_by_id"+++def test_subject_check_emits_the_wrong_surface_audit(app: Flask, sqlite_session: Session) -> None:+ subject = sso_subject()++ with app.test_request_context("/openapi/v1/account"):+ with patch("controllers.openapi.auth.requirements.emit_wrong_surface") as emit:+ requirement = CheckSubject(allowed=[AccountSubject])+ with pytest.raises(Forbidden, match="unsupported_token_type"):+ requirement.run(subject, make_ctx(sqlite_session, subject=subject), sqlite_session)++ emit.assert_called_once_with(+ subject_type="external_sso",+ attempted_path="/openapi/v1/account",+ client_id=CLIENT_ID,+ token_id=TOKEN_ID,+ )+++ ("status", "denied"),+ [+ (LicenseStatus.INACTIVE, True),+ (LicenseStatus.LOST, True),+ (LicenseStatus.NONE, False),+ ],+)+def test_assert_license_valid_denies_only_dead_licences(status: LicenseStatus, denied: bool) -> None:+ with patch(FEATURES, return_value=system_features(license_status=status)):+ if denied:+ with pytest.raises(Forbidden, match="license_invalid"):+ assert_license_valid()+ else:+ assert_license_valid()+++def test_an_app_requirement_off_an_app_route_is_a_wiring_bug(+ sqlite_session: Session, monkeypatch: pytest.MonkeyPatch+) -> None:+ """App requirements are declared per endpoint, so a route with no `app_id`+ can only carry one by mistake. It raises rather than passing quietly:+ skipping would turn a misdeclaration into a check that silently never runs.+ """+ monkeypatch.setattr(APP_FETCH, never_reached)+ subject = account_subject()++ with pytest.raises(RouteContractError, match="app_id is not a path parameter"):+ CheckAppApiEnabled().run(subject, make_ctx(sqlite_session, subject=subject), sqlite_session)+++class TestCheckRBACPermission:+ @staticmethod+ def _requirement() -> CheckRBACPermission:+ return CheckRBACPermission(RBACCheck(RBACPermission.APP_VIEW_LAYOUT, PlainApp()))++ def test_skips_a_non_account_caller(self, sqlite_session: Session, config_overrides: Callable[..., None]) -> None:+ """No matrix row reaches this: on the routes an SSO token can address,+ RBAC permission either does not apply or no permission is declared, so an SSO caller falling+ into account-scoped RBAC is invisible there.+ """+ config_overrides(RBAC_ENABLED=True)+ subject = sso_subject()++ with patch(ENFORCE_RBAC) as enforce:+ self._requirement().run(subject, make_ctx(sqlite_session, subject=subject, app_id=APP_ID), sqlite_session)++ enforce.assert_not_called()++ def test_is_inert_wherever_rbac_is_off(+ self, app: Flask, sqlite_session: Session, config_overrides: Callable[..., None]+ ) -> None:+ """No matrix row reaches this: every row runs against a stubbed RBAC+ backend, so a permission that enforced where RBAC is switched off would still+ be admitted there. Standing down is what leaves the `CheckWorkspaceRole`+ beside it as the only arm there.+ """+ config_overrides(RBAC_ENABLED=False)+ persist(sqlite_session, make_app(), make_tenant(), make_account())+ subject = account_subject()+ ctx = make_ctx(sqlite_session, subject=subject, app_id=APP_ID)++ with app.test_request_context(f"/openapi/v1/apps/{APP_ID}"):+ with patch(ENFORCE_RBAC) as enforce:+ self._requirement().run(subject, ctx, sqlite_session)++ enforce.assert_not_called()+++class TestCheckWorkspaceRole:+ admin_only = frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN})++ def test_skips_a_non_account_caller(self, sqlite_session: Session, monkeypatch: pytest.MonkeyPatch) -> None:+ """No matrix row reaches this either — and the workspace role check must not even fetch+ the app to decide it.+ """+ monkeypatch.setattr(APP_FETCH, never_reached)+ subject = sso_subject()++ CheckWorkspaceRole(self.admin_only).run(+ subject, make_ctx(sqlite_session, subject=subject, app_id=APP_ID), sqlite_session+ )++ def test_the_workspace_role_reads_the_role_through_the_loader(+ self, app: Flask, sqlite_session: Session, config_overrides: Callable[..., None]+ ) -> None:+ """The answer is `load_workspace_role`'s, not a direct role read's: an+ account that is not `ACTIVE` is a non-member, and hears 404 rather than+ the workspace role check's own 403.++ No matrix row reaches this. An `EARLY` membership check pre-empts the+ `NORMAL` workspace role check on every shipped route, and the matrix mints only `ACTIVE`+ accounts — so this is the only thing standing between the workspace role check and a+ refactor that calls `get_account_role_in_tenant` itself, which would+ re-admit a banned admin and answer 403 where the surface answers 404.+ """+ config_overrides(RBAC_ENABLED=False)+ persist(+ sqlite_session,+ make_app(),+ make_tenant(),+ make_account(status=AccountStatus.BANNED),+ make_membership(TenantAccountRole.ADMIN),+ )+ subject = account_subject()+ ctx = make_ctx(sqlite_session, subject=subject, app_id=APP_ID)++ with app.test_request_context(f"/openapi/v1/apps/{APP_ID}"):+ with pytest.raises(NotFound, match="workspace not found"):+ CheckWorkspaceRole(self.admin_only).run(subject, ctx, sqlite_session)+++class TestCheckAppAccess:+ @pytest.fixture(autouse=True)+ def _enterprise(self, config_overrides: Callable[..., None]) -> None:+ config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.ENTERPRISE)++ def test_no_ops_outside_enterprise(+ self, sqlite_session: Session, config_overrides: Callable[..., None], monkeypatch: pytest.MonkeyPatch+ ) -> None:+ """The named guard for the CE contract: the access-mode service is never+ reached at all. Dropping the early return is otherwise only caught+ incidentally, by an unrelated test that happens not to stub it.+ """+ config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY)+ monkeypatch.setattr(ACCESS_MODE, never_reached)+ persist(sqlite_session, make_app())+ subject = account_subject()++ CheckAppAccess().run(subject, make_ctx(sqlite_session, subject=subject, app_id=APP_ID), sqlite_session)++ @pytest.mark.parametrize(+ ("settings", "failure"),+ [+ (webapp_settings("a-mode-this-build-has-never-heard-of"), None),+ (None, ValueError("enterprise said no")),+ ],+ ids=["unknown mode", "service error"],+ )+ def test_rejects_an_access_mode_it_could_not_load(+ self, sqlite_session: Session, settings: WebAppSettings | None, failure: Exception | None+ ) -> None:+ persist(sqlite_session, make_app())+ subject = account_subject()+ ctx = make_ctx(sqlite_session, subject=subject, app_id=APP_ID)++ with patch(FEATURES, return_value=system_features(webapp_auth=True)):+ with patch(ACCESS_MODE, return_value=settings, side_effect=failure):+ with pytest.raises(Forbidden, match="app or access mode not loaded"):+ CheckAppAccess().run(subject, ctx, sqlite_session)++ def test_refuses_a_private_app_when_the_user_cannot_be_resolved(self, sqlite_session: Session) -> None:+ persist(sqlite_session, make_app())+ subject = account_subject(account_id=None)+ ctx = make_ctx(sqlite_session, subject=subject, app_id=APP_ID)++ with patch(FEATURES, return_value=system_features(webapp_auth=True)):+ with patch(ACCESS_MODE, return_value=webapp_settings(WebAppAccessMode.PRIVATE.value)):+ with pytest.raises(Forbidden, match="cannot resolve user for private app check"):+ CheckAppAccess().run(subject, ctx, sqlite_session)diff --git a/api/tests/unit_tests/controllers/openapi/auth/test_router.py b/api/tests/unit_tests/controllers/openapi/auth/test_router.pynew file mode 100644index 00000000000..14afc86d260--- /dev/null+++ b/api/tests/unit_tests/controllers/openapi/auth/test_router.py@@ -0,0 +1,364 @@+from __future__ import annotations++from collections.abc import Callable+from datetime import UTC, datetime, timedelta+from types import SimpleNamespace+from typing import NoReturn+from unittest.mock import MagicMock++import pytest+from flask import Flask+from sqlalchemy.orm import Session, sessionmaker+from werkzeug.exceptions import Forbidden, NotFound, ServiceUnavailable, Unauthorized++import libs.rate_limit as rate_limit_module+from controllers.openapi.auth.context import Context+from controllers.openapi.auth.requirements import Requirement+from controllers.openapi.auth.router import subject_router+from controllers.openapi.auth.spec import EndpointSpec+from controllers.openapi.auth.subjects import AccountSubject+from enums import DeploymentEdition+from libs.oauth_bearer import (+ AuthContext,+ BearerAuthenticator,+ OAuthAccessTokenResolver,+ Resolver,+ TokenType,+)+from models import Account+from models.oauth import OAuthAccessToken+from services.entities.feature_entities import (+ LicenseStatus,+)++from ._world import (+ ACCOUNT_ID,+ TOKEN_ID,+ make_account,+ make_auth,+ persist,+ system_features,+)++ROUTER = "controllers.openapi.auth.router"+FEATURES = "controllers.openapi.auth.requirements.SystemFeatureService.get_public_system_features"+MOUNT = "controllers.openapi.auth.pipelines._mount_flask_login"+ENTERPRISE_ONLY = frozenset({DeploymentEdition.ENTERPRISE})+++def never_reached(*_args: object, **_kwargs: object) -> NoReturn:+ raise AssertionError("reached a step the router should have answered before")+++def _authenticates(monkeypatch: pytest.MonkeyPatch, auth: AuthContext) -> None:+ authenticator = SimpleNamespace(authenticate=lambda _token: auth)+ monkeypatch.setattr(f"{ROUTER}.get_authenticator", lambda: authenticator)+++def _guard(+ view: Callable[..., object],+ *,+ requirements: tuple[Requirement, ...] = (),+ edition: frozenset[DeploymentEdition] | None = None,+) -> Callable[..., object]:+ return subject_router.guard(EndpointSpec(requirements=requirements, edition=edition))(view)+++def _nothing(**_kwargs: object) -> None:+ return None+++def test_endpoint_edition_gate_404s_before_the_bearer_is_read(+ app: Flask,+ config_overrides: Callable[..., None],+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY)+ monkeypatch.setattr(f"{ROUTER}.extract_bearer", never_reached)+ view = _guard(_nothing, edition=ENTERPRISE_ONLY)++ with app.test_request_context("/openapi/v1/permitted-external-apps"):+ with pytest.raises(NotFound):+ view()+++def test_a_dead_licence_403s_an_unauthenticated_caller_on_every_route_in_enterprise(+ app: Flask,+ config_overrides: Callable[..., None],+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ """The licence is a fact about the deployment, so the router checks it once,+ for every route, before `extract_bearer` - a caller with no bearer at all+ sees 403, not 401.+ """+ config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.ENTERPRISE)+ monkeypatch.setattr(FEATURES, lambda: system_features(license_status=LicenseStatus.EXPIRED))+ monkeypatch.setattr(f"{ROUTER}.extract_bearer", never_reached)+ view = _guard(_nothing)++ with app.test_request_context("/openapi/v1/account"):+ with pytest.raises(Forbidden, match="license_invalid"):+ view()+++def test_a_disabled_bearer_feature_503s_before_the_bearer_is_read(+ app: Flask,+ config_overrides: Callable[..., None],+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ """Off means no authenticator is bound, so the router answers the same 503+ the device endpoints do instead of a 500 from the unbound authenticator.+ """+ config_overrides(ENABLE_OAUTH_BEARER=False)+ monkeypatch.setattr(f"{ROUTER}.extract_bearer", never_reached)+ view = _guard(_nothing)++ with app.test_request_context("/openapi/v1/account"):+ with pytest.raises(ServiceUnavailable, match="bearer_auth_disabled"):+ view()+++INVALID_BEARER = "invalid bearer"+"""The one answer the router gives a bearer it will not accept.++`InvalidBearerError` is a plain `Exception`, so uncaught at this seam it reaches+`errorhandler(Exception)` and answers 500 — telling a caller whose token expired+that the server broke, when difyctl maps only 401/403 to re-authenticate. Every+rejection reason shares this one message: a caller that can tell them apart can+probe which tokens ever existed, the same reasoning as the 404-not-403 elsewhere+on this surface.+"""+++_ResolverAndUpdates = tuple[Resolver, list[object]]+"""A resolver plus the row updates it issued while refusing."""+++def _resolver_never_asked() -> _ResolverAndUpdates:+ """An unknown prefix is refused by the registry, before any resolver runs."""+ resolver = MagicMock()+ resolver.resolve.side_effect = AssertionError("an unknown prefix must not reach a resolver")+ return resolver, []+++def _resolver_with_no_live_row() -> _ResolverAndUpdates:+ """`None` is what the shipped resolver answers for a token with no usable row —+ never minted, revoked, or minted under the other variant's prefix.+ """+ resolver = MagicMock()+ resolver.resolve.return_value = None+ return resolver, []+++class _FakeRedis:+ def __init__(self) -> None:+ self.store: dict[str, object] = {}++ def get(self, key: str) -> object | None:+ return self.store.get(key)++ def setex(self, key: str, _ttl: int, value: object) -> None:+ self.store[key] = value++ def delete(self, key: str) -> None:+ self.store.pop(key, None)+++class _OneRowSession:+ """Enough `Session` for `_TokenTypeResolver` to read one row and expire it.++ SQLite hands `expires_at` back naive while the resolver compares it against+ an aware `now`, so the expiry branch cannot be driven through the real+ sqlite fixture — same reason `test_auth_matrix._MemoryResolver` exists.+ """++ def __init__(self, row: OAuthAccessToken) -> None:+ self._row = row+ self.updates: list[object] = []++ def query(self, _model: object) -> _OneRowSession:+ return self++ def filter(self, *_criteria: object) -> _OneRowSession:+ return self++ def one_or_none(self) -> OAuthAccessToken:+ return self._row++ def execute(self, statement: object) -> SimpleNamespace:+ self.updates.append(statement)+ return SimpleNamespace(rowcount=1)++ def commit(self) -> None:+ return None+++def _expired_row() -> OAuthAccessToken:+ """Live in every respect but its expiry, so expiry is the only refusal."""+ row = OAuthAccessToken(+ subject_email="[email protected]",+ client_id="openapi-client",+ device_label="laptop",+ prefix=TokenType.OAUTH_ACCOUNT.prefix,+ expires_at=datetime.now(UTC) - timedelta(seconds=1),+ subject_issuer="dify:account",+ account_id=ACCOUNT_ID,+ token_hash="deadbeef",+ )+ row.id = TOKEN_ID+ return row+++def _resolver_for_an_expired_row() -> _ResolverAndUpdates:+ """The shipped resolver, over a row whose expiry has passed."""+ session = _OneRowSession(_expired_row())+ resolver = OAuthAccessTokenResolver(lambda: session, _FakeRedis())+ return resolver.for_token_type(TokenType.OAUTH_ACCOUNT), session.updates+++def _authenticates_for_real(+ monkeypatch: pytest.MonkeyPatch, resolver: Resolver, *, token_type: TokenType = TokenType.OAUTH_ACCOUNT+) -> None:+ """The real `BearerAuthenticator`, so the refusals are its own, not a stub's."""+ monkeypatch.setattr(+ rate_limit_module,+ "LIMIT_BEARER_PER_TOKEN",+ rate_limit_module.RateLimit(+ 0,+ rate_limit_module.LIMIT_BEARER_PER_TOKEN.window,+ rate_limit_module.LIMIT_BEARER_PER_TOKEN.scopes,+ ),+ )+ authenticator = BearerAuthenticator({token_type: resolver})+ monkeypatch.setattr(f"{ROUTER}.get_authenticator", lambda: authenticator)+++def _refuse(app: Flask, token: str) -> Unauthorized:+ view = _guard(_nothing)+ with app.test_request_context("/openapi/v1/account", headers={"Authorization": f"Bearer {token}"}):+ with pytest.raises(Unauthorized) as raised:+ view()+ return raised.value+++ ("resolver_factory", "token", "rows_expired"),+ [+ (_resolver_never_asked, "zzz_notatokenkind", 0),+ (_resolver_with_no_live_row, f"{TokenType.OAUTH_ACCOUNT.prefix}revoked", 0),+ (_resolver_for_an_expired_row, f"{TokenType.OAUTH_ACCOUNT.prefix}stale", 1),+ ],+ ids=["unknown prefix", "no live row", "expired"],+)+def test_every_way_authenticate_rejects_a_bearer_answers_the_same_401(+ app: Flask,+ monkeypatch: pytest.MonkeyPatch,+ resolver_factory: Callable[[], _ResolverAndUpdates],+ token: str,+ rows_expired: int,+) -> None:+ """`rows_expired` pins that the expired row really took the expiry branch,+ rather than reaching the same answer as a token that was never minted.+ """+ resolver, updates = resolver_factory()+ _authenticates_for_real(monkeypatch, resolver)++ refusal = _refuse(app, token)++ assert (refusal.code, refusal.description) == (401, INVALID_BEARER)+ assert len(updates) == rows_expired+++def test_an_unresolvable_external_bearer_on_community_is_refused_as_a_bearer_not_an_edition(+ app: Flask, config_overrides: Callable[..., None], monkeypatch: pytest.MonkeyPatch+) -> None:+ """`_RequiresEnterprise` runs after `authenticate`. A `dfoe_` string with no+ live row must hear the same 401 as any bad bearer; a 403+ `external_sso_requires_ee` first would let an unauthenticated caller+ learn the deployment edition.+ """+ config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY)+ resolver, _ = _resolver_with_no_live_row()+ _authenticates_for_real(monkeypatch, resolver, token_type=TokenType.OAUTH_EXTERNAL_SSO)++ refusal = _refuse(app, f"{TokenType.OAUTH_EXTERNAL_SSO.prefix}garbage")++ assert (refusal.code, refusal.description) == (401, INVALID_BEARER)+++def test_an_account_token_reaches_the_view_with_a_resolved_context(+ app: Flask,+ sqlite_session: Session,+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ persist(sqlite_session, make_account())+ _authenticates(monkeypatch, make_auth(TokenType.OAUTH_ACCOUNT))+ mounted: list[object] = []+ monkeypatch.setattr(MOUNT, mounted.append)+ seen: dict[str, object] = {}++ def handler(resource: str, *, ctx: Context) -> str:+ seen.update(resource=resource, ctx=ctx)+ return "answered"++ view = _guard(handler)++ with app.test_request_context("/openapi/v1/account", headers={"Authorization": "Bearer tok"}):+ result = view("self")++ assert result == "answered"+ assert isinstance(seen["ctx"], Context)+ assert isinstance(seen["ctx"].subject, AccountSubject)+ assert seen["resource"] == "self"+ assert [type(user) for user in mounted] == [Account]+++def _rename_handler(*, ctx: Context) -> str:+ ctx.caller.name = "renamed"+ return "ok"+++def test_a_mutation_is_committed_when_the_view_returns(+ app: Flask,+ sqlite_session: Session,+ sqlite_session_factory: sessionmaker[Session],+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ persist(sqlite_session, make_account())+ _authenticates(monkeypatch, make_auth(TokenType.OAUTH_ACCOUNT))+ monkeypatch.setattr(MOUNT, lambda _user: None)+ view = _guard(_rename_handler)++ with app.test_request_context("/openapi/v1/account", headers={"Authorization": "Bearer tok"}):+ view()++ with sqlite_session_factory() as verify:+ renamed = verify.get(Account, ACCOUNT_ID)+ assert renamed is not None+ assert renamed.name == "renamed"+++def _rename_then_fail(*, ctx: Context) -> str:+ _rename_handler(ctx=ctx)+ raise RuntimeError("after the write")+++def test_a_mutation_is_rolled_back_when_the_view_raises(+ app: Flask,+ sqlite_session: Session,+ sqlite_session_factory: sessionmaker[Session],+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ persist(sqlite_session, make_account())+ _authenticates(monkeypatch, make_auth(TokenType.OAUTH_ACCOUNT))+ monkeypatch.setattr(MOUNT, lambda _user: None)+ view = _guard(_rename_then_fail)++ with app.test_request_context("/openapi/v1/account", headers={"Authorization": "Bearer tok"}):+ with pytest.raises(RuntimeError, match="after the write"):+ view()++ with sqlite_session_factory() as verify:+ unchanged = verify.get(Account, ACCOUNT_ID)+ assert unchanged is not None+ assert unchanged.name == "OpenAPI account"diff --git a/api/tests/unit_tests/controllers/openapi/auth/test_subjects.py b/api/tests/unit_tests/controllers/openapi/auth/test_subjects.pynew file mode 100644index 00000000000..ce73594e2cc--- /dev/null+++ b/api/tests/unit_tests/controllers/openapi/auth/test_subjects.py@@ -0,0 +1,127 @@+from __future__ import annotations++from unittest.mock import patch++import pytest+from sqlalchemy.orm import Session+from werkzeug.exceptions import Unauthorized++from controllers.openapi.auth.subjects import AccountSubject, ExternalSsoSubject+from libs.oauth_bearer import TokenType+from models import Account, EndUser, TenantAccountJoin+from models.account import TenantAccountRole+from models.enums import EndUserType++from ._world import (+ ACCOUNT_ID,+ APP_ID,+ SSO_EMAIL,+ TENANT_ID,+ make_account,+ make_app,+ make_auth,+ make_ctx,+ make_tenant,+ persist,+)++[email protected](("has_app", "expected"), [(False, False), (True, True)], ids=["app-less", "app route"])+def test_external_sso_mounts_a_caller_only_on_app_routes(+ has_app: bool, expected: bool, sqlite_session: Session+) -> None:+ subject = ExternalSsoSubject(make_auth(TokenType.OAUTH_EXTERNAL_SSO))+ view_args: dict[str, str] = {"app_id": APP_ID} if has_app else {}++ assert subject.mounts_caller(make_ctx(sqlite_session, subject, **view_args)) is expected+++class TestAccountResolveCaller:+ def test_binds_the_current_tenant_to_the_workspace_the_route_resolved(self, sqlite_session: Session) -> None:+ """A loaded workspace is the whole signal. `app_id` in the path says one+ *can* be resolved, never that anything did — and binding on that would+ read a workspace no requirement asked for.+ """+ account = make_account()+ tenant = make_tenant()+ persist(+ sqlite_session,+ account,+ tenant,+ TenantAccountJoin(+ tenant_id=tenant.id,+ account_id=account.id,+ current=True,+ role=TenantAccountRole.ADMIN,+ ),+ )+ subject = AccountSubject(make_auth(TokenType.OAUTH_ACCOUNT))+ ctx = make_ctx(sqlite_session, subject, app_id=APP_ID)+ ctx._workspace = tenant++ caller = subject.resolve_caller(ctx, sqlite_session)++ assert isinstance(caller, Account)+ assert caller.current_tenant_id == TENANT_ID+ assert caller.role == TenantAccountRole.ADMIN++ def test_never_resolves_a_workspace_the_request_did_not_need(self, sqlite_session: Session) -> None:+ persist(sqlite_session, make_account())+ subject = AccountSubject(make_auth(TokenType.OAUTH_ACCOUNT))++ caller = subject.resolve_caller(make_ctx(sqlite_session, subject, app_id=APP_ID), sqlite_session)++ assert isinstance(caller, Account)+ assert caller.current_tenant_id is None+++class TestExternalSsoResolveCaller:+ def test_resolves_the_end_user_against_the_apps_workspace(self, sqlite_session: Session) -> None:+ """It loads both itself. Nothing before it on an SSO route needs a+ workspace, so a subject that expected one to be there already would+ resolve an end user against nothing.+ """+ persist(sqlite_session, make_app(), make_tenant())+ subject = ExternalSsoSubject(make_auth(TokenType.OAUTH_EXTERNAL_SSO))+ ctx = make_ctx(sqlite_session, subject, app_id=APP_ID)+ end_user = EndUser(+ tenant_id=TENANT_ID,+ app_id=APP_ID,+ type=EndUserType.OPENAPI,+ is_anonymous=False,+ session_id=SSO_EMAIL,+ )++ with patch(+ "controllers.openapi.auth.subjects.EndUserService.get_or_create_end_user_by_type",+ return_value=end_user,+ ) as get_or_create:+ assert subject.resolve_caller(ctx, sqlite_session) is end_user++ get_or_create.assert_called_once_with(+ EndUserType.OPENAPI,+ tenant_id=TENANT_ID,+ app_id=APP_ID,+ user_id=SSO_EMAIL,+ )++ def test_rejects_a_token_without_an_external_identity(self, sqlite_session: Session) -> None:+ subject = ExternalSsoSubject(make_auth(TokenType.OAUTH_EXTERNAL_SSO, subject_email=None))+ ctx = make_ctx(sqlite_session, subject, app_id=APP_ID)++ with pytest.raises(Unauthorized, match="missing context for external user resolution"):+ subject.resolve_caller(ctx, sqlite_session)+++class TestExternalSsoWebappUserId:+ def test_resolves_the_account_behind_the_sso_email(self, sqlite_session: Session) -> None:+ persist(sqlite_session, make_account(email=SSO_EMAIL))+ subject = ExternalSsoSubject(make_auth(TokenType.OAUTH_EXTERNAL_SSO))++ assert subject.webapp_user_id(sqlite_session) == ACCOUNT_ID++ def test_refuses_to_guess_when_the_email_matches_no_account(self, sqlite_session: Session) -> None:+ assert ExternalSsoSubject(make_auth(TokenType.OAUTH_EXTERNAL_SSO)).webapp_user_id(sqlite_session) is None++ identityless = ExternalSsoSubject(make_auth(TokenType.OAUTH_EXTERNAL_SSO, subject_email=None))+ assert identityless.webapp_user_id(sqlite_session) is Nonediff --git a/api/tests/unit_tests/controllers/openapi/auth/test_verify.py b/api/tests/unit_tests/controllers/openapi/auth/test_verify.pydeleted file mode 100644index baad1264abf..00000000000--- a/api/tests/unit_tests/controllers/openapi/auth/test_verify.py+++ /dev/null@@ -1,268 +0,0 @@-import uuid-from collections.abc import Callable-from unittest.mock import patch--import pytest-from flask import Flask-from werkzeug.exceptions import Forbidden, NotFound--from controllers.common.rbac import PlainApp, RBACCheck-from controllers.openapi.auth.data import AuthData-from controllers.openapi.auth.verify import (- check_acl,- check_app_api_enabled,- check_private_app_permission,- check_rbac_permission,- check_scope,- check_workspace_member,- check_workspace_mismatch,- check_workspace_role,-)-from core.rbac import RBACPermission-from libs.oauth_bearer import Scope, TokenType-from models.account import Tenant, TenantAccountRole-from models.model import App-from services.enterprise.enterprise_service import WebAppAccessMode--[email protected](autouse=True)-def _rbac_config(config_overrides: Callable[..., None]) -> None:- config_overrides(RBAC_ENABLED=True)---def _data(**kwargs) -> AuthData:- defaults: dict = {"token_type": TokenType.OAUTH_ACCOUNT, "scopes": frozenset({Scope.FULL})}- defaults.update(kwargs)- return AuthData(**defaults)---def test_check_scope_passes_when_required_is_none():- check_scope(_data(required_scope=None))---def test_check_scope_passes_when_full_in_scopes():- check_scope(_data(required_scope=Scope.APPS_RUN, scopes=frozenset({Scope.FULL})))---def test_check_scope_passes_when_exact_scope_present():- check_scope(_data(required_scope=Scope.APPS_RUN, scopes=frozenset({Scope.APPS_RUN})))---def test_check_scope_raises_forbidden_when_scope_missing():- with pytest.raises(Forbidden, match="insufficient_scope"):- check_scope(_data(required_scope=Scope.APPS_RUN, scopes=frozenset({Scope.APPS_READ})))---def test_check_workspace_member_raises_not_found_when_no_role():- with pytest.raises(NotFound, match="workspace not found"):- check_workspace_member(_data(tenant_role=None))---def test_check_workspace_member_passes_when_role_present():- check_workspace_member(_data(tenant_role=TenantAccountRole.NORMAL))---# --- check_rbac_permission -----_RBAC_REQ = RBACCheck(RBACPermission.APP_VIEW_LAYOUT, PlainApp())---def test_check_rbac_noop_when_no_requirement():- with patch("controllers.openapi.auth.verify.enforce_rbac_checks") as mock_enforce:- check_rbac_permission(_data(rbac=None, caller_kind="account"))- mock_enforce.assert_not_called()---def test_check_rbac_noop_when_rbac_disabled(config_overrides: Callable[..., None]):- config_overrides(RBAC_ENABLED=False)- with patch("controllers.openapi.auth.verify.enforce_rbac_checks") as mock_enforce:- check_rbac_permission(_data(rbac=_RBAC_REQ, caller_kind="account"))- mock_enforce.assert_not_called()---def test_check_rbac_skips_end_user_caller():- with (- patch("controllers.openapi.auth.verify.enforce_rbac_checks") as mock_enforce,- ):- check_rbac_permission(_data(rbac=_RBAC_REQ, caller_kind="end_user"))- mock_enforce.assert_not_called()---def test_check_rbac_raises_when_context_missing():- with pytest.raises(Forbidden, match="rbac context missing"):- check_rbac_permission(_data(rbac=_RBAC_REQ, caller_kind="account", account_id=None, tenant=None))---def test_check_rbac_enforces_for_account_caller():- tenant = Tenant(name="Test Tenant")- tenant.id = "t1"- account_id = uuid.uuid4()- data = _data(- rbac=_RBAC_REQ,- caller_kind="account",- account_id=account_id,- tenant=tenant,- path_params={"app_id": "app-1"},- )- with (- patch("controllers.openapi.auth.verify.enforce_rbac_checks") as mock_enforce,- ):- check_rbac_permission(data)- mock_enforce.assert_called_once()- call_kwargs = mock_enforce.call_args.kwargs- assert call_kwargs["tenant_id"] == "t1"- assert call_kwargs["account_id"] == str(account_id)- assert call_kwargs["path_args"] == {"app_id": "app-1"}- (check,) = call_kwargs["checks"]- assert isinstance(check, RBACCheck)- assert check.scene is RBACPermission.APP_VIEW_LAYOUT- assert isinstance(check.locator, PlainApp)---def test_check_acl_raises_when_app_or_mode_missing():- with pytest.raises(Forbidden):- check_acl(_data(app=None, app_access_mode=None))---def test_check_acl_account_allowed_for_public():- app = App()- data = _data(token_type=TokenType.OAUTH_ACCOUNT, app=app, app_access_mode=WebAppAccessMode.PUBLIC)- check_acl(data)---def test_check_acl_external_sso_blocked_for_private():- app = App()- data = _data(- token_type=TokenType.OAUTH_EXTERNAL_SSO,- app=app,- app_access_mode=WebAppAccessMode.PRIVATE,- )- with pytest.raises(Forbidden, match="subject_not_allowed_for_access_mode"):- check_acl(data)---def test_check_acl_external_sso_allowed_for_sso_verified():- app = App()- data = _data(- token_type=TokenType.OAUTH_EXTERNAL_SSO,- app=app,- app_access_mode=WebAppAccessMode.SSO_VERIFIED,- )- check_acl(data)---def test_check_private_app_permission_raises_when_app_none():- with pytest.raises(Forbidden):- check_private_app_permission(_data(app=None))---def test_check_private_app_permission_raises_when_user_not_allowed():- app = App(- id="app-1",- )- data = _data(account_id=uuid.uuid4(), app=app)- target = "controllers.openapi.auth.verify.EnterpriseService.WebAppAuth.is_user_allowed_to_access_webapp"- with patch(target, return_value=False):- with pytest.raises(Forbidden, match="user_not_allowed_for_private_app"):- check_private_app_permission(data)---def test_check_private_app_permission_passes_when_allowed():- app = App(- id="app-1",- )- data = _data(account_id=uuid.uuid4(), app=app)- target = "controllers.openapi.auth.verify.EnterpriseService.WebAppAuth.is_user_allowed_to_access_webapp"- with patch(target, return_value=True):- check_private_app_permission(data)---# --- check_workspace_mismatch ------def flask_app():- return Flask(__name__)---def test_check_workspace_mismatch_passes_when_tenant_none(flask_app):- with flask_app.test_request_context("/test"):- check_workspace_mismatch(_data(tenant=None))---def test_check_workspace_mismatch_passes_when_ids_match(flask_app):- tenant = Tenant(name="Test Tenant")- tid = uuid.uuid4()- tenant.id = tid- with flask_app.test_request_context(f"/test?workspace_id={tid}"):- check_workspace_mismatch(_data(tenant=tenant, path_params={}))---def test_check_workspace_mismatch_raises_422_on_mismatch(flask_app):- from werkzeug.exceptions import UnprocessableEntity-- tenant = Tenant(name="Test Tenant")- tenant.id = uuid.uuid4()- other_id = uuid.uuid4()- with flask_app.test_request_context(f"/test?workspace_id={other_id}"):- with pytest.raises(UnprocessableEntity):- check_workspace_mismatch(_data(tenant=tenant, path_params={}))---def test_check_workspace_mismatch_passes_when_no_request_workspace_id(flask_app):- tenant = Tenant(name="Test Tenant")- tenant.id = uuid.uuid4()- with flask_app.test_request_context("/test"):- check_workspace_mismatch(_data(tenant=tenant, path_params={}))---# --- check_workspace_role ------def test_check_workspace_role_passes_when_allowed_roles_none():- check_workspace_role(_data(allowed_roles=None))---def test_check_workspace_role_raises_not_found_when_not_member():- data = _data(tenant_role=None, allowed_roles=frozenset({TenantAccountRole.ADMIN}))- with pytest.raises(NotFound):- check_workspace_role(data)---def test_check_workspace_role_raises_forbidden_when_wrong_role():- data = _data(- tenant_role=TenantAccountRole.EDITOR,- allowed_roles=frozenset({TenantAccountRole.OWNER}),- )- with pytest.raises(Forbidden, match="insufficient workspace role"):- check_workspace_role(data)---def test_check_workspace_role_passes_when_role_allowed():- data = _data(- tenant_role=TenantAccountRole.ADMIN,- allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN}),- )- check_workspace_role(data)---# --- check_app_api_enabled ------def test_check_app_api_enabled_passes_when_enabled():- app = App(- enable_api=True,- )- check_app_api_enabled(_data(app=app))---def test_check_app_api_enabled_raises_forbidden_when_disabled():- app = App(- enable_api=False,- )- with pytest.raises(Forbidden, match="service_api_disabled"):- check_app_api_enabled(_data(app=app))---def test_check_app_api_enabled_passes_when_app_none():- check_app_api_enabled(_data(app=None))diff --git a/api/tests/unit_tests/controllers/openapi/conftest.py b/api/tests/unit_tests/controllers/openapi/conftest.pyindex f77e35a3b7f..5368d88c70f 100644--- a/api/tests/unit_tests/controllers/openapi/conftest.py+++ b/api/tests/unit_tests/controllers/openapi/conftest.py@@ -1,51 +1,23 @@+from __future__ import annotations+import uuid+from collections.abc import Callable+from dataclasses import dataclass+from types import SimpleNamespaceimport pytestfrom flask import Flask+from flask.testing import FlaskClient+from sqlalchemy.orm import Sessionfrom app_factory import create_flask_app_with_configsfrom controllers.openapi import bp as openapi_bp-from controllers.openapi.auth.data import AuthData-from controllers.openapi.auth.pipeline import PipelineRouter-from libs.oauth_bearer import Scope, TokenType---def _stub_execute(- self,- args,- kwargs,- view,- *,- scope=None,- allowed_token_types=None,- edition=None,- require_valid_enterprise_license=False,- workspace_membership=False,- allowed_roles=None,- rbac=None,-):- """Bypass all auth logic; inject minimal AuthData and call the view directly."""- kwargs["auth_data"] = AuthData(- token_type=TokenType.OAUTH_ACCOUNT,- account_id=uuid.uuid4(),- token_id=uuid.uuid4(),- scopes=frozenset({Scope.FULL}),- required_scope=scope,- allowed_roles=allowed_roles,- rbac=rbac,- )- return view(*args, **kwargs)---def bypass_pipeline(monkeypatch: pytest.MonkeyPatch):- """Stub PipelineRouter._execute so endpoints skip real auth at request time.-- Module-level @auth_router.guard(...) captures the real router at import- time — patching guard itself does nothing. Patching _execute on the class- is the seam that fires at request time.- """- monkeypatch.setattr(PipelineRouter, "_execute", _stub_execute)+from enums import DeploymentEdition+from libs.oauth_bearer import AuthContext, TokenType+from models import Account, App, Tenant, TenantAccountJoin+from models.account import AccountStatus, TenantAccountRole, TenantStatus+from models.enums import AppStatus+from models.model import AppMode, IconType@pytest.fixture@@ -62,3 +34,89 @@ def app():a = Flask(__name__)a.config["TESTING"] = Truereturn a+++@dataclass(frozen=True, slots=True)+class AdmittedWorld:+ """The ids a request needs to address the world `admitted_bearer` built."""++ client: FlaskClient+ workspace_id: str+ app_id: str+ member_id: str+ headers: dict[str, str]+++def admitted_bearer(+ openapi_app: Flask,+ sqlite_session: Session,+ config_overrides: Callable[..., None],+ monkeypatch: pytest.MonkeyPatch,+) -> AdmittedWorld:+ """A caller every guarded route admits, so a request reaches `@accepts`.++ `@endpoint` stacks `@accepts` *inside* the guard, so a 422 is only observable+ on the wire once auth has passed. Everything here is world — one owner account+ in one workspace owning one API-enabled app — plus the two process seams the+ router already treats as pluggable: the bound authenticator, and the+ flask-login mount, which needs a real Flask login manager it has no reason to+ carry here.+ """+ config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY, RBAC_ENABLED=False)++ account_id, workspace_id, app_id = (str(uuid.uuid4()) for _ in range(3))+ account = Account(name="caller", email="[email protected]", status=AccountStatus.ACTIVE)+ account.id = account_id+ workspace = Tenant(name="caller workspace", status=TenantStatus.NORMAL)+ workspace.id = workspace_id+ sqlite_session.add_all(+ [+ account,+ workspace,+ TenantAccountJoin(+ tenant_id=workspace_id,+ account_id=account_id,+ current=True,+ role=TenantAccountRole.OWNER,+ ),+ App(+ id=app_id,+ tenant_id=workspace_id,+ name="caller app",+ description="",+ mode=AppMode.WORKFLOW,+ icon_type=IconType.EMOJI,+ icon="robot",+ icon_background="#FFFFFF",+ status=AppStatus.NORMAL,+ enable_site=True,+ enable_api=True,+ max_active_requests=None,+ ),+ ]+ )+ sqlite_session.commit()++ token = AuthContext(+ subject_email=account.email,+ subject_issuer="dify:account",+ account_id=uuid.UUID(account_id),+ client_id="difyctl",+ token_id=uuid.uuid4(),+ token_type=TokenType.OAUTH_ACCOUNT,+ expires_at=None,+ )+ monkeypatch.setattr(+ "controllers.openapi.auth.router.get_authenticator",+ lambda: SimpleNamespace(authenticate=lambda _token: token),+ )+ monkeypatch.setattr("controllers.openapi.auth.pipelines._mount_flask_login", lambda _user: None)++ return AdmittedWorld(+ client=openapi_app.test_client(),+ workspace_id=workspace_id,+ app_id=app_id,+ member_id=str(uuid.uuid4()),+ headers={"Authorization": "Bearer dfoa_admitted"},+ )diff --git a/api/tests/unit_tests/controllers/openapi/test_account.py b/api/tests/unit_tests/controllers/openapi/test_account.pyindex a623d29ca69..13f86049a3c 100644--- a/api/tests/unit_tests/controllers/openapi/test_account.py+++ b/api/tests/unit_tests/controllers/openapi/test_account.py@@ -2,119 +2,58 @@import builtinsimport sys+import uuidfrom types import SimpleNamespaceimport pytestfrom flask import Flaskfrom flask.views import MethodView-from werkzeug.exceptions import NotFound, UnprocessableEntity--from controllers.openapi import bp as openapi_bp-from controllers.openapi.account import (- AccountApi,- AccountSessionByIdApi,- AccountSessionsApi,- AccountSessionsSelfApi,-)+from pydantic import ValidationError+from werkzeug.exceptions import NotFound++from controllers.openapi._models import SessionListQuery+from controllers.openapi.account import AccountSessionByIdApi, AccountSessionsApifrom machinery.context import AccountRequestContext+from services.account_errors import AccountSessionNotFoundErrorfrom services.entities.account_access_entities import AccountSessionPageif not hasattr(builtins, "MethodView"):builtins.MethodView = MethodView # type: ignore[attr-defined]-def openapi_app() -> Flask:- app = Flask(__name__)- app.config["TESTING"] = True- app.register_blueprint(openapi_bp)- return app---def _rule(app: Flask, path: str):- return next(r for r in app.url_map.iter_rules() if r.rule == path)---def test_account_route_registered(openapi_app: Flask):- rules = {r.rule for r in openapi_app.url_map.iter_rules()}- assert "/openapi/v1/account" in rules---def test_account_dispatches_to_class(openapi_app: Flask):- rule = _rule(openapi_app, "/openapi/v1/account")- assert openapi_app.view_functions[rule.endpoint].view_class is AccountApi---def test_account_sessions_self_route_registered(openapi_app: Flask):- rules = {r.rule for r in openapi_app.url_map.iter_rules()}- assert "/openapi/v1/account/sessions/self" in rules---def test_sessions_self_dispatches_to_class(openapi_app: Flask):- rule = _rule(openapi_app, "/openapi/v1/account/sessions/self")- assert openapi_app.view_functions[rule.endpoint].view_class is AccountSessionsSelfApi---def test_account_methods(openapi_app: Flask):- rule = _rule(openapi_app, "/openapi/v1/account")- assert "GET" in rule.methods---def test_sessions_self_methods(openapi_app: Flask):- rule = _rule(openapi_app, "/openapi/v1/account/sessions/self")- assert "DELETE" in rule.methods---def test_sessions_list_route_registered(openapi_app: Flask):- rules = {r.rule for r in openapi_app.url_map.iter_rules()}- assert "/openapi/v1/account/sessions" in rules---def test_sessions_list_dispatches_to_sessions_api(openapi_app: Flask):- rule = _rule(openapi_app, "/openapi/v1/account/sessions")- assert openapi_app.view_functions[rule.endpoint].view_class is AccountSessionsApi- assert "GET" in rule.methods---def test_session_by_id_route_registered(openapi_app: Flask):- rules = {r.rule for r in openapi_app.url_map.iter_rules()}- assert "/openapi/v1/account/sessions/<string:session_id>" in rules---def test_session_by_id_dispatches_to_correct_class(openapi_app: Flask):- rule = _rule(openapi_app, "/openapi/v1/account/sessions/<string:session_id>")- assert openapi_app.view_functions[rule.endpoint].view_class is AccountSessionByIdApi- assert "DELETE" in rule.methods---def test_session_by_id_rejects_malformed_uuid(app: Flask) -> None:[email protected]("session_id", [str(uuid.uuid4()), "not-a-uuid"], ids=["foreign", "malformed"])+def test_revoke_by_id_hides_a_session_the_caller_does_not_own(+ app: Flask, monkeypatch: pytest.MonkeyPatch, session_id: str+) -> None:+ """The access service refuses a token id owned by another account, and a+ malformed id never reaches it; the route answers 404 either way, not 403,+ so session ids cannot be probed across accounts.+ """api = AccountSessionByIdApi()- with app.test_request_context("/openapi/v1/account/sessions/not-a-uuid", method="DELETE"):+ _stub_account_service(monkeypatch)+ with app.test_request_context(f"/openapi/v1/account/sessions/{session_id}", method="DELETE"):with pytest.raises(NotFound, match="session not found"):- api.delete.__wrapped__(api, _request_context(), session_id="not-a-uuid")+ api.delete.__handler__(api, _ctx(), session_id=session_id)-# --- GET /account/sessions query validation (the handler routes ?page/?limit through-# SessionListQuery so the server enforces the bounds the contract advertises). The application-# service is replaced with a small fake so these exercise only parsing and serialization;-# __wrapped__ skips the complete Admission boundary. ---+# --- GET /account/sessions query validation. The application service is replaced+# with a small fake so these exercise only the handler's projection; `__handler__`+# receives an already-validated query, so the bounds are pinned at the model. ---_ACCOUNT_MOD = "controllers.openapi.account"-def _request_context() -> AccountRequestContext:- return AccountRequestContext(- request_id="request-1",- trace_id="trace-1",- account_id="account-1",- access_token_id="token-1",- )+def _ctx() -> SimpleNamespace:+ return SimpleNamespace(subject=SimpleNamespace(account_id=uuid.uuid4(), token_id=uuid.uuid4()))class _SessionListService:def list_sessions(self, _context: AccountRequestContext, *, page: int, limit: int) -> AccountSessionPage:return AccountSessionPage(page=page, limit=limit, total=0, items=())+ def revoke_session(self, _context: AccountRequestContext, *, token_id: str) -> None:+ raise AccountSessionNotFoundError(token_id)+def _stub_account_service(monkeypatch: pytest.MonkeyPatch) -> None:mod = sys.modules[_ACCOUNT_MOD]@@ -123,44 +62,26 @@ def _stub_account_service(monkeypatch: pytest.MonkeyPatch) -> None:def test_sessions_list_valid_query_parses_page_and_limit(app: Flask, monkeypatch: pytest.MonkeyPatch):- """A valid ?page&limit round-trips through SessionListQuery into the response envelope."""+ """A valid page/limit round-trips through SessionListQuery into the response envelope."""api = AccountSessionsApi()_stub_account_service(monkeypatch)with app.test_request_context("/openapi/v1/account/sessions?page=2&limit=5"):- body, status = api.get.__wrapped__(api, _request_context())- assert status == 200- assert body["page"] == 2- assert body["limit"] == 5- assert body["total"] == 0- assert body["data"] == []---def test_sessions_list_defaults_when_query_omitted(app: Flask, monkeypatch: pytest.MonkeyPatch):- """No query → the model's defaults (page=1, limit=100) drive the envelope."""- api = AccountSessionsApi()- _stub_account_service(monkeypatch)- with app.test_request_context("/openapi/v1/account/sessions"):- body, status = api.get.__wrapped__(api, _request_context())- assert status == 200- assert body["page"] == 1- assert body["limit"] == 100+ result = api.get.__handler__(api, _ctx(), query=SessionListQuery(page=2, limit=5))+ assert result.page == 2+ assert result.limit == 5+ assert result.total == 0+ assert result.data == []@pytest.mark.parametrize(- "query",+ "params",[- "page=0", # below ge=1 (previously coerced to a silent empty slice)- "page=-3",- "limit=0", # below ge=1- "limit=999", # above le=MAX_PAGE_LIMIT- "page=abc", # not an integer (previously a 500)- "foo=bar", # extra='forbid'+ {"page": "0"},+ {"limit": "0"},+ {"limit": "999"},+ {"foo": "bar"},],)-def test_sessions_list_rejects_out_of_bounds_query(app: Flask, monkeypatch: pytest.MonkeyPatch, query):- """Out-of-range / unknown query params raise 422 instead of being silently coerced."""- api = AccountSessionsApi()- _stub_account_service(monkeypatch)- with app.test_request_context(f"/openapi/v1/account/sessions?{query}"):- with pytest.raises(UnprocessableEntity):- api.get.__wrapped__(api, _request_context())+def test_session_list_query_rejects_out_of_bounds(params):+ with pytest.raises(ValidationError):+ SessionListQuery.model_validate(params)diff --git a/api/tests/unit_tests/controllers/openapi/test_app_dsl.py b/api/tests/unit_tests/controllers/openapi/test_app_dsl.pyindex 25b0cd85917..6b75a179a35 100644--- a/api/tests/unit_tests/controllers/openapi/test_app_dsl.py+++ b/api/tests/unit_tests/controllers/openapi/test_app_dsl.py@@ -1,5 +1,6 @@-from inspect import unwrap+from collections.abc import Callablefrom types import SimpleNamespace+from typing import Protocol, castfrom unittest.mock import Mockimport pytest@@ -10,9 +11,18 @@ from werkzeug.exceptions import Forbiddenfrom controllers.openapi import app_dsl as app_dsl_modulefrom controllers.openapi._models import AppDslImportPayloadfrom controllers.openapi.app_dsl import AppDslImportApi, AppDslImportConfirmApi+from controllers.openapi.auth.spec import EndpointSpec+from models import Accountfrom services.errors.account import NoPermissionError+class _EndpointView(Protocol):+ """Structural stand-in for a `view` carrying the attributes `@endpoint` attaches."""++ __spec__: EndpointSpec+ __handler__: Callable[..., object]++@pytest.mark.parametrize(("api", "kwargs"),[@@ -44,6 +54,6 @@ def test_permission_denial_maps_to_forbidden(with app.test_request_context("/openapi/v1/workspaces/workspace-1/apps/imports", method="POST"):with pytest.raises(Forbidden, match="denied") as exc_info:- unwrap(api.post)(api, auth_data=SimpleNamespace(caller=Mock()), **kwargs)+ cast(_EndpointView, api.post).__handler__(api, SimpleNamespace(account=Mock(spec=Account)), **kwargs)assert isinstance(exc_info.value.__cause__, NoPermissionError)diff --git a/api/tests/unit_tests/controllers/openapi/test_app_payloads.py b/api/tests/unit_tests/controllers/openapi/test_app_payloads.pyindex 2f548714484..6ce3476808f 100644--- a/api/tests/unit_tests/controllers/openapi/test_app_payloads.py+++ b/api/tests/unit_tests/controllers/openapi/test_app_payloads.py@@ -9,16 +9,15 @@ from sqlalchemy.orm import Sessionfrom controllers.openapi.apps import ( # pyright: ignore[reportPrivateUsage]_EMPTY_PARAMETERS,- _is_listable,parameters_payload,)from controllers.service_api.app.error import AppUnavailableError-from models.model import App, AppMode+from models.model import Appfrom tests.unit_tests.model_factories import make_app-def _app(*, mode: AppMode = AppMode.CHAT) -> App:- return make_app(app_id="app1", name="X", description="d", mode=mode, enable_site=False, max_active_requests=0)+def _app() -> App:+ return make_app(app_id="app1", name="X", description="d", enable_site=False, max_active_requests=0)def test_parameters_payload_raises_app_unavailable_when_no_config(unbound_session: Session):@@ -44,16 +43,3 @@ def test_empty_parameters_constant_matches_describe_fallback_shape():assert _EMPTY_PARAMETERS["opening_statement"] is Noneassert _EMPTY_PARAMETERS["file_upload"] is Noneassert _EMPTY_PARAMETERS["system_parameters"] == {}--- "mode",- [AppMode.COMPLETION, AppMode.CHAT, AppMode.ADVANCED_CHAT, AppMode.WORKFLOW, AppMode.AGENT_CHAT],-)-def test_is_listable_accepts_supported_app_types(mode):- assert _is_listable(_app(mode=mode)) is True--[email protected]("mode", [AppMode.AGENT, AppMode.CHANNEL, AppMode.RAG_PIPELINE])-def test_is_listable_hides_non_app_modes(mode):- assert _is_listable(_app(mode=mode)) is Falsediff --git a/api/tests/unit_tests/controllers/openapi/test_app_run_streaming.py b/api/tests/unit_tests/controllers/openapi/test_app_run_streaming.pyindex 88af3d3ff8f..fba3e9d91f6 100644--- a/api/tests/unit_tests/controllers/openapi/test_app_run_streaming.py+++ b/api/tests/unit_tests/controllers/openapi/test_app_run_streaming.py@@ -4,13 +4,16 @@ from __future__ import annotationsimport sysimport uuid+from types import SimpleNamespacefrom unittest.mock import Mockimport pytestfrom flask import Flask-from controllers.openapi._models import AppRunRequest+from controllers.openapi._models import AppRunRequest, TaskStopResponse+from controllers.openapi.app_run import AppRunApi, AppRunTaskStopApifrom models import Account+from models.enums import CreatorUserRolefrom models.model import App, AppMode_TEST_APP_ID = str(uuid.uuid4())@@ -36,94 +39,75 @@ def _make_account() -> Account:def test_app_run_request_has_no_response_mode_field():- """response_mode must not be a declared field."""+ """Not a declared field, and a body carrying it is accepted and ignored."""assert "response_mode" not in AppRunRequest.model_fields---def test_app_run_request_ignores_response_mode_in_payload():- """Sending response_mode in JSON body is silently ignored (Pydantic extra='ignore')."""req = AppRunRequest.model_validate({"inputs": {}, "response_mode": "blocking"})assert not hasattr(req, "response_mode")-def test_app_run_request_valid_minimal():- req = AppRunRequest.model_validate({"inputs": {}})- assert req.inputs == {}-+def test_stop_task_calls_queue_manager_and_graph_engine(app: Flask, monkeypatch: pytest.MonkeyPatch):+ queue_mock = Mock()+ graph_mock = Mock()+ graph_instance = Mock()+ graph_mock.return_value = graph_instance-def test_app_run_request_with_query():- req = AppRunRequest.model_validate({"inputs": {}, "query": "hello"})- assert req.query == "hello"+ run_module = sys.modules["controllers.openapi.app_run"]+ monkeypatch.setattr(run_module, "AppQueueManager", queue_mock)+ monkeypatch.setattr(run_module, "GraphEngineManager", graph_mock)+ monkeypatch.setattr(run_module, "redis_client", object())+ api = AppRunTaskStopApi()+ with app.test_request_context("/openapi/v1/apps/app-1/tasks/task-1:stop", method="POST"):+ result = api.post.__handler__(api, _SealableContext(), app_id="app-1", task_id="task-1")-def test_run_chat_always_calls_generate_with_streaming_true(- app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch-):- """_run_chat must always invoke AppGenerateService.generate with streaming=True."""- from controllers.openapi.app_run import _run_chat+ queue_mock.set_stop_flag_no_user_check.assert_called_once_with("task-1")+ graph_instance.send_stop_command.assert_called_once_with("task-1")+ assert result == TaskStopResponse(result="success")- generate_mock = Mock(return_value=iter([]))- class GenerateService:- generate = generate_mock+class _SealableContext:+ """A `Context` stand-in that refuses reads once `seal()` is called.- monkeypatch.setattr(- sys.modules["controllers.openapi.app_run"],- "AppGenerateService",- GenerateService,- )- with app.test_request_context(f"/openapi/v1/apps/{_TEST_APP_ID}:run", method="POST"):- _run_chat(- _make_app(),- _make_account(),- AppRunRequest(inputs={}, query="hello"),- Mock(),- )- _, kwargs = generate_mock.call_args- assert kwargs["streaming"] is True+ The router's session closes when the handler returns, so anything the SSE+ body still needs off `ctx` would be read through a closed session.+ """+ def __init__(self, **values: object) -> None:+ self._values = values+ self._sealed = False-def test_stop_task_endpoint_registered(openapi_app):- """POST /openapi/v1/apps/<id>/tasks/<task_id>:stop must be registered."""- rules = {r.rule for r in openapi_app.url_map.iter_rules()}- assert "/openapi/v1/apps/<string:app_id>/tasks/<string:task_id>:stop" in rules+ def seal(self) -> None:+ self._sealed = True+ def __getattr__(self, name: str) -> object:+ if self._sealed:+ raise AssertionError(f"ctx.{name} was read after the handler returned")+ return self._values[name]-def test_stop_task_calls_queue_manager_and_graph_engine(app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch):- import uuid- from controllers.openapi.app_run import AppRunTaskStopApi- from controllers.openapi.auth.data import AuthData- from libs.oauth_bearer import Scope, TokenType+def test_run_reads_everything_off_the_context_before_streaming(app: Flask, monkeypatch: pytest.MonkeyPatch):+ """The SSE body runs after the router's session is gone, and the generator+ is always asked to stream.+ """+ generate_mock = Mock(return_value=iter(["event: a\n\n", "event: b\n\n"]))- queue_mock = Mock()- graph_mock = Mock()- graph_instance = Mock()- graph_mock.return_value = graph_instance+ class GenerateService:+ generate = generate_mock- run_module = sys.modules["controllers.openapi.app_run"]- monkeypatch.setattr(run_module, "AppQueueManager", queue_mock)- monkeypatch.setattr(run_module, "GraphEngineManager", graph_mock)- monkeypatch.setattr(run_module, "redis_client", object())+ monkeypatch.setattr(sys.modules["controllers.openapi.app_run"], "AppGenerateService", GenerateService)- auth_data = AuthData.model_construct(- token_type=TokenType.OAUTH_ACCOUNT,- account_id=uuid.UUID(_TEST_ACCOUNT_ID),- scopes=frozenset({Scope.FULL}),+ ctx = _SealableContext(app=_make_app(),caller=_make_account(),- caller_kind="account",+ session=Mock(),+ subject=SimpleNamespace(caller_role=CreatorUserRole.ACCOUNT),)- api = AppRunTaskStopApi()- with app.test_request_context("/openapi/v1/apps/app-1/tasks/task-1:stop", method="POST"):- result = api.post.__wrapped__(- api,- app_id="app-1",- task_id="task-1",- auth_data=auth_data,- )+ api = AppRunApi()+ with app.test_request_context(f"/openapi/v1/apps/{_TEST_APP_ID}:run", method="POST"):+ response = api.post.__handler__(api, ctx, app_id=_TEST_APP_ID, body=AppRunRequest(inputs={}, query="hello"))+ ctx.seal()+ body = "".join(response.response)- queue_mock.set_stop_flag_no_user_check.assert_called_once_with("task-1")- graph_instance.send_stop_command.assert_called_once_with("task-1")- assert result == ({"result": "success"}, 200)+ assert body == "event: a\n\nevent: b\n\n"+ assert generate_mock.call_args.kwargs["streaming"] is Truediff --git a/api/tests/unit_tests/controllers/openapi/test_apps_permitted_external_query.py b/api/tests/unit_tests/controllers/openapi/test_apps_permitted_external_query.pyindex b8d077e5df5..475333927c1 100644--- a/api/tests/unit_tests/controllers/openapi/test_apps_permitted_external_query.py+++ b/api/tests/unit_tests/controllers/openapi/test_apps_permitted_external_query.py@@ -1,14 +1,15 @@-"""Unit tests for PermittedExternalAppsListQuery — the-/permitted-external-apps query validator.+"""Unit tests for the /permitted-external-apps routes.-Strict ConfigDict(extra='forbid'): cross-tenant tag/workspace_id are-unresolvable, so the model must reject them as 422 instead of silently-dropping them. Mode/name/page/limit have the same shape as AppListQuery.+`PermittedExternalAppsListQuery` is strict (`ConfigDict(extra='forbid')`):+cross-tenant tag/workspace_id are unresolvable, so the model must reject them as+422 instead of silently dropping them. Mode/name/page/limit have the same shape+as AppListQuery.++The allow/deny answers live in `test_auth_matrix.py`."""from __future__ import annotations-import inspectfrom types import SimpleNamespacefrom unittest.mock import patch@@ -22,8 +23,6 @@ from controllers.openapi.apps_permitted_external import ()from models.model import App, AppMode-from ._mode_constants import NON_LISTABLE_MODES-def test_query_defaults_match_apps_list():q = PermittedExternalAppsListQuery.model_validate({})@@ -41,40 +40,18 @@ def test_query_rejects_workspace_id():PermittedExternalAppsListQuery.model_validate({"workspace_id": "ws-1"})-def test_query_rejects_tag():- """Tags are tenant-scoped; cross-tenant tag resolution is undefined."""- with pytest.raises(ValidationError):- PermittedExternalAppsListQuery.model_validate({"tag": "prod"})--def test_query_validates_mode_against_supported_app_type():with pytest.raises(ValidationError):PermittedExternalAppsListQuery.model_validate({"mode": "not-a-mode"})[email protected]("mode", NON_LISTABLE_MODES)-def test_query_rejects_non_listable_app_modes(mode: str):- """Non-app runtime modes and roster-owned agent are not listable here."""- with pytest.raises(ValidationError):- PermittedExternalAppsListQuery.model_validate({"mode": mode})--def test_query_clamps_limit_at_max():with pytest.raises(ValidationError):PermittedExternalAppsListQuery.model_validate({"limit": 500})-def test_query_accepts_valid_mode():- """Pin the happy path: AppMode values pass."""- q = PermittedExternalAppsListQuery.model_validate({"mode": "chat"})- assert q.mode is not None- assert q.mode.value == "chat"--def test_describe_forwards_request_session_to_response_builder(unbound_session: Session):api = PermittedExternalAppDescribeApi()- method = inspect.unwrap(api.get)- session = unbound_sessionapp = App(id="app-id",tenant_id="tenant-1",@@ -83,7 +60,7 @@ def test_describe_forwards_request_session_to_response_builder(unbound_session:enable_site=True,enable_api=True,)- auth_data = SimpleNamespace(app=app)+ ctx = SimpleNamespace(app=app, session=unbound_session)query = SimpleNamespace(fields={"info"})response = object()@@ -91,7 +68,7 @@ def test_describe_forwards_request_session_to_response_builder(unbound_session:"controllers.openapi.apps_permitted_external.build_app_describe_response",return_value=response,) as build_response:- result = method(api, session, "app-id", auth_data=auth_data, query=query)+ result = api.get.__handler__(api, ctx, "app-id", query=query)assert result is response- build_response.assert_called_once_with(app, query.fields, session=session)+ build_response.assert_called_once_with(app, query.fields, session=unbound_session)diff --git a/api/tests/unit_tests/controllers/openapi/test_auth_matrix.py b/api/tests/unit_tests/controllers/openapi/test_auth_matrix.pynew file mode 100644index 00000000000..69c82d1e883--- /dev/null+++ b/api/tests/unit_tests/controllers/openapi/test_auth_matrix.py@@ -0,0 +1,1342 @@+"""The /openapi/v1 allow/deny matrix, and a snapshot of the generated document.++The matrix is derived from what actually runs, not from what a route declares: a+route's own requirements are merged with the fixed ones its subject's pipeline+carries, a `CheckWorkspaceRole` applies only where RBAC is off and a `CheckRBACPermission` only where it is on,+and `CheckAppAccess` applies the private-app check whether+or not `webapp_auth.enabled` gates the ACL. Reading declarations alone under-counts+every one of those.++Requests run through the real Flask blueprint with the real router, the real+pipeline and real database rows. The only substitutions are at process seams the+router already treats as pluggable: the bound `BearerAuthenticator` (so a token's+subject kind and scope set are chosen per row), the enterprise HTTP clients, and+the flask-login mount. The RBAC backend and the enterprise web-app service are+stubbed per row, so those rows pin how *this* code handles each answer they can+give — never what the real services decide.++Cases are never gated on whether a route declares a check. A row that asserts+`ADMIT` where RBAC, a workspace role check or a licence gate does not fire is pinning the+check's *absence*: losing a check is caught by the deny rows, and gaining one is+caught by these. `files.upload` is the route the design says must never acquire an+RBAC permission, and `files.upload-rbac_on_denied` is the row that says so.++Admission is observed as HTTP 418: a `user_logged_in` receiver raises `ImATeapot`+at the moment the pipeline mounts the caller, which is after every requirement has+passed and before the view body runs. That keeps a row from depending on whether a+view could complete (several stream SSE or invoke a workflow). One route mounts no+caller — `permitted_external.list` resolves no end user because it carries no+`app_id` — so its admission row says so and asserts the view's own 200 instead.++Two answers in the table are worth reading twice, because they are what the code+does rather than what a route's declaration suggests:++* `workspaces.describe` declares no membership requirement, so a non-member is+ *admitted* by auth and refused by the view's own lookup. `workspaces.switch`,+ one path segment away, declares one and is refused by auth.+* No token the shipped registry mints can fail `CheckScope` — `dfoa_` carries+ `Scope.FULL` and `dfoe_` carries exactly the two scopes its routes ask for — so+ the scope rows mint from a deliberately narrowed registry. Those rows are not+ dead weight and must not be simplified away: `CheckScope` is live code on every+ request, and the day a narrower token kind is minted it is the only thing+ standing between that token and every route it was not scoped for.++`Case.NON_MEMBER_AND_INSUFFICIENT_SCOPE` is the one case that combines a real+membership failure with a real scope failure on the same request. Neither+`INSUFFICIENT_SCOPE` nor `NON_MEMBER` alone proves which one a doubly-broken request+hears; membership runs EARLY and scope NORMAL, so it hears membership.++Routes that declare the same requirement tuple answer every case the same way,+so `MATRIX` runs the cases on one representative per tuple and `DECLARED` pins+which tuple each of the 25 routes carries. A route that changes its tuple fails+the wiring test; a tuple that changes its answers fails its representative's rows.+"""++from __future__ import annotations++import contextvars+import uuid+from collections.abc import Callable, Iterator+from contextlib import ExitStack+from dataclasses import dataclass, field+from datetime import UTC, datetime, timedelta+from enum import StrEnum, auto+from functools import singledispatch+from unittest.mock import patch++import pytest+from flask import Flask+from flask_login import LoginManager, user_logged_in+from sqlalchemy.orm import Session, sessionmaker+from werkzeug.exceptions import ImATeapot+from werkzeug.routing import Rule+from werkzeug.test import TestResponse++import libs.oauth_bearer as oauth_bearer_module+import libs.rate_limit as rate_limit_module+from app_factory import create_flask_app_with_configs+from controllers.common.rbac import PlainApp, RBACCheck, RBACPermission, Workspace+from controllers.openapi import bp as openapi_bp+from controllers.openapi.auth.requirements import (+ CheckAppAccess,+ CheckAppApiEnabled,+ CheckRBACPermission,+ CheckScope,+ CheckSubject,+ CheckWorkspaceMember,+ CheckWorkspaceRole,+ Requirement,+)+from controllers.openapi.auth.spec import EndpointSpec+from controllers.openapi.auth.subjects import AccountSubject, ExternalSsoSubject+from controllers.openapi.human_input_form import CheckFormSurface+from enums import DeploymentEdition, WebAppAccessMode+from libs.oauth_bearer import (+ BearerAuthenticator,+ ResolvedRow,+ Scope,+ TokenType,+ sha256_hex,+)+from models.account import Account, AccountStatus, Tenant, TenantAccountJoin, TenantAccountRole+from models.enums import EndUserType+from models.model import App, EndUser+from models.oauth import OAuthAccessToken+from services.account_service import AccountService+from services.end_user_service import EndUserService+from services.enterprise.enterprise_service import EnterpriseService+from services.entities.feature_entities import LicenseStatus, SystemFeatureModel+from services.rbac_resource_service import RBACResourceService+from services.system_feature_service import SystemFeatureService+from tests.unit_tests.config_override import apply_config_overrides++ADMITTED = 418+++class Trait(StrEnum):+ """Structural facts about a route, used only to decide which cases can reach it.++ Every member here is a fact about the *shape* of the request — is there an+ `app_id` in the path, can a `dfoe_` token address this route at all. None is+ read off a route's declared requirements, deliberately: gating a+ case on a declared check means a route that *gains* that check during migration+ simply loses the row, and gaining a check is the hazard this plan cares about+ most. Cases like `RBAC_ON_DENIED` therefore run on every route an account+ caller can reach, and assert `ADMIT` where the check does not exist today.+ """++ APP_SCOPED = auto()+ ACCOUNT_PRIMARY = auto()+ EXTERNAL_REACHABLE = auto()+ ENTERPRISE_ONLY = auto()+++class Case(StrEnum):+ NO_BEARER = auto()+ MEMBER = auto()+ WRONG_SUBJECT = auto()+ INSUFFICIENT_SCOPE = auto()+ NON_MEMBER = auto()+ NON_MEMBER_AND_INSUFFICIENT_SCOPE = auto()+ LOW_ROLE = auto()+ APP_API_DISABLED = auto()+ UNKNOWN_APP = auto()+ FOREIGN_WORKSPACE_QUERY = auto()+ EDITION_NOT_ENTERPRISE = auto()+ LICENSE_INVALID = auto()+ EE_LICENSE_INVALID = auto()+ EE_ACCOUNT_PUBLIC = auto()+ EE_ACCOUNT_SSO_VERIFIED = auto()+ EE_ACCOUNT_PRIVATE_ALL = auto()+ EE_ACCOUNT_PRIVATE_PERMITTED = auto()+ EE_ACCOUNT_PRIVATE_REFUSED = auto()+ EE_ACCOUNT_PRIVATE_REFUSED_WEBAPP_AUTH_OFF = auto()+ EE_ACCOUNT_MODE_UNRESOLVED = auto()+ EE_EXTERNAL_PUBLIC = auto()+ EE_EXTERNAL_SSO_VERIFIED = auto()+ EE_EXTERNAL_PRIVATE_ALL = auto()+ EE_EXTERNAL_PRIVATE = auto()+ EE_EXTERNAL_PRIVATE_REFUSED_WEBAPP_AUTH_OFF = auto()+ EE_EXTERNAL_MODE_UNRESOLVED = auto()+ RBAC_ON_LOW_ROLE = auto()+ RBAC_ON_DENIED = auto()+++class Bearer(StrEnum):+ NONE = auto()+ ACCOUNT_MEMBER = auto()+ ACCOUNT_LOW_ROLE = auto()+ ACCOUNT_OUTSIDER = auto()+ EXTERNAL = auto()+ OTHER_SUBJECT = auto()+ PRIMARY = auto()+++@dataclass(frozen=True, slots=True)+class Route:+ id: str+ method: str+ path: str+ traits: frozenset[Trait]+ query: str = ""+++@dataclass(frozen=True, slots=True)+class Expect:+ """`message` is the canonical ErrorBody message; `None` means it is not pinned."""++ status: int+ message: str | None = None+ note: str = ""+++@dataclass(frozen=True, slots=True)+class Scenario:+ """The world a case runs in. `edition=None` means the route's native edition."""++ bearer: Bearer+ edition: DeploymentEdition | None = None+ narrow_scopes: bool = False+ app_api_enabled: bool = True+ unknown_app: bool = False+ foreign_workspace_query: bool = False+ webapp_auth: bool = False+ access_mode: WebAppAccessMode | None = WebAppAccessMode.PUBLIC+ private_app_permitted: bool = True+ license_status: LicenseStatus = LicenseStatus.ACTIVE+ rbac_enabled: bool = False+ rbac_allows: bool = True+++ADMIT = Expect(ADMITTED)+DENY_NO_BEARER = Expect(401, "bearer required")+DENY_WRONG_SUBJECT = Expect(403, "unsupported_token_type")+DENY_SSO_NEEDS_EE = Expect(403, "external_sso_requires_ee")+DENY_SCOPE = Expect(403, "insufficient_scope")+DENY_NON_MEMBER = Expect(404, "workspace not found")+DENY_ROLE = Expect(403, "insufficient workspace role")+DENY_API_DISABLED = Expect(403, "service_api_disabled")+DENY_UNKNOWN_APP = Expect(404, "app not found")+DENY_ACCESS_MODE = Expect(403, "subject_not_allowed_for_access_mode")+DENY_MODE_UNRESOLVED = Expect(403, "app or access mode not loaded")+DENY_PRIVATE_APP = Expect(403, "user_not_allowed_for_private_app")+DENY_EDITION = Expect(404, note="endpoint-level edition gate, raised before the bearer is read")+DENY_LICENSE = Expect(403, "license_invalid")+DENY_RBAC = Expect(403, note="bare werkzeug Forbidden from enforce_rbac_checks")+ADMIT_NO_RBAC_PERMISSION = Expect(+ ADMITTED,+ note=(+ "pins a check this route does NOT have: RBAC is on and denying, and the route still "+ "admits because it declares no scene. Attaching one during migration turns this 403. "+ "files.upload is the route the design says must never gain a scene"+ ),+)+ADMIT_NO_WORKSPACE_ROLE = Expect(+ ADMITTED,+ note="pins a check this route does NOT have: RBAC is on and a NORMAL member is still admitted",+)+ADMIT_NO_LICENCE_GATE = Expect(+ ADMITTED,+ note="pins a check this route does NOT have: the licence is dead and the route still admits",+)+ADMIT_NO_MOUNT = Expect(+ 200,+ note="external subject mounts no caller on an app-less route, so admission shows as the view's own 200",+)+++ROUTES: tuple[Route, ...] = (+ Route("account.get", "GET", "/account", frozenset({Trait.ACCOUNT_PRIMARY})),+ Route("account.sessions.revoke_self", "DELETE", "/account/sessions/self", frozenset({Trait.ACCOUNT_PRIMARY})),+ Route("account.sessions.list", "GET", "/account/sessions", frozenset({Trait.ACCOUNT_PRIMARY})),+ Route(+ "account.sessions.revoke_one",+ "DELETE",+ "/account/sessions/{session_id}",+ frozenset({Trait.ACCOUNT_PRIMARY}),+ ),+ Route(+ "apps.describe",+ "GET",+ "/apps/{app_id}",+ frozenset({Trait.ACCOUNT_PRIMARY, Trait.APP_SCOPED}),+ ),+ Route("apps.list", "GET", "/apps", frozenset({Trait.ACCOUNT_PRIMARY}), query="workspace_id={workspace_id}"),+ Route("workspaces.list", "GET", "/workspaces", frozenset({Trait.ACCOUNT_PRIMARY})),+ Route("workspaces.describe", "GET", "/workspaces/{workspace_id}", frozenset({Trait.ACCOUNT_PRIMARY})),+ Route("workspaces.switch", "POST", "/workspaces/{workspace_id}:switch", frozenset({Trait.ACCOUNT_PRIMARY})),+ Route("workspaces.members.list", "GET", "/workspaces/{workspace_id}/members", frozenset({Trait.ACCOUNT_PRIMARY})),+ Route(+ "workspaces.members.invite",+ "POST",+ "/workspaces/{workspace_id}/members",+ frozenset({Trait.ACCOUNT_PRIMARY}),+ ),+ Route(+ "workspaces.members.remove",+ "DELETE",+ "/workspaces/{workspace_id}/members/{member_id}",+ frozenset({Trait.ACCOUNT_PRIMARY}),+ ),+ Route(+ "workspaces.members.update_role",+ "PATCH",+ "/workspaces/{workspace_id}/members/{member_id}",+ frozenset({Trait.ACCOUNT_PRIMARY}),+ ),+ Route(+ "app_dsl.import",+ "POST",+ "/workspaces/{workspace_id}/apps/imports",+ frozenset({Trait.ACCOUNT_PRIMARY}),+ ),+ Route(+ "app_dsl.import_confirm",+ "POST",+ "/workspaces/{workspace_id}/apps/imports/{import_id}:confirm",+ frozenset({Trait.ACCOUNT_PRIMARY}),+ ),+ Route(+ "app_dsl.export",+ "GET",+ "/apps/{app_id}/dsl",+ frozenset({Trait.ACCOUNT_PRIMARY, Trait.APP_SCOPED}),+ ),+ Route(+ "app_dsl.check_dependencies",+ "GET",+ "/apps/{app_id}/dependencies:check",+ frozenset({Trait.ACCOUNT_PRIMARY, Trait.APP_SCOPED}),+ ),+ Route(+ "app_run.run",+ "POST",+ "/apps/{app_id}:run",+ frozenset({Trait.ACCOUNT_PRIMARY, Trait.APP_SCOPED, Trait.EXTERNAL_REACHABLE}),+ ),+ Route(+ "app_run.stop",+ "POST",+ "/apps/{app_id}/tasks/{task_id}:stop",+ frozenset({Trait.ACCOUNT_PRIMARY, Trait.APP_SCOPED, Trait.EXTERNAL_REACHABLE}),+ ),+ Route(+ "files.upload",+ "POST",+ "/apps/{app_id}/files",+ frozenset({Trait.ACCOUNT_PRIMARY, Trait.APP_SCOPED, Trait.EXTERNAL_REACHABLE}),+ ),+ Route(+ "human_input_form.get",+ "GET",+ "/apps/{app_id}/human-input-forms/{form_token}",+ frozenset({Trait.ACCOUNT_PRIMARY, Trait.APP_SCOPED, Trait.EXTERNAL_REACHABLE}),+ ),+ Route(+ "human_input_form.submit",+ "POST",+ "/apps/{app_id}/human-input-forms/{form_token}:submit",+ frozenset({Trait.ACCOUNT_PRIMARY, Trait.APP_SCOPED, Trait.EXTERNAL_REACHABLE}),+ ),+ Route(+ "workflow_events.stream",+ "GET",+ "/apps/{app_id}/tasks/{task_id}/events",+ frozenset({Trait.ACCOUNT_PRIMARY, Trait.APP_SCOPED, Trait.EXTERNAL_REACHABLE}),+ ),+ Route(+ "permitted_external.list",+ "GET",+ "/permitted-external-apps",+ frozenset({Trait.EXTERNAL_REACHABLE, Trait.ENTERPRISE_ONLY}),+ ),+ Route(+ "permitted_external.describe",+ "GET",+ "/permitted-external-apps/{app_id}",+ frozenset({Trait.APP_SCOPED, Trait.EXTERNAL_REACHABLE, Trait.ENTERPRISE_ONLY}),+ ),+)+++CASE_REQUIRES: dict[Case, frozenset[Trait]] = {+ Case.NO_BEARER: frozenset(),+ Case.MEMBER: frozenset(),+ Case.WRONG_SUBJECT: frozenset(),+ Case.INSUFFICIENT_SCOPE: frozenset(),+ Case.NON_MEMBER: frozenset({Trait.ACCOUNT_PRIMARY}),+ # frozenset() rather than {ACCOUNT_PRIMARY}: this one also has to reach the+ # SSO-only routes, to pin that they answer on the subject axis, not this one.+ Case.NON_MEMBER_AND_INSUFFICIENT_SCOPE: frozenset(),+ Case.LOW_ROLE: frozenset({Trait.ACCOUNT_PRIMARY}),+ Case.APP_API_DISABLED: frozenset({Trait.APP_SCOPED}),+ Case.UNKNOWN_APP: frozenset({Trait.APP_SCOPED}),+ Case.FOREIGN_WORKSPACE_QUERY: frozenset({Trait.APP_SCOPED}),+ Case.EDITION_NOT_ENTERPRISE: frozenset({Trait.ENTERPRISE_ONLY}),+ Case.LICENSE_INVALID: frozenset(),+ Case.EE_LICENSE_INVALID: frozenset(),+ Case.EE_ACCOUNT_PUBLIC: frozenset({Trait.APP_SCOPED, Trait.ACCOUNT_PRIMARY}),+ Case.EE_ACCOUNT_SSO_VERIFIED: frozenset({Trait.APP_SCOPED, Trait.ACCOUNT_PRIMARY}),+ Case.EE_ACCOUNT_PRIVATE_ALL: frozenset({Trait.APP_SCOPED, Trait.ACCOUNT_PRIMARY}),+ Case.EE_ACCOUNT_PRIVATE_PERMITTED: frozenset({Trait.APP_SCOPED, Trait.ACCOUNT_PRIMARY}),+ Case.EE_ACCOUNT_PRIVATE_REFUSED: frozenset({Trait.APP_SCOPED, Trait.ACCOUNT_PRIMARY}),+ Case.EE_ACCOUNT_PRIVATE_REFUSED_WEBAPP_AUTH_OFF: frozenset({Trait.APP_SCOPED, Trait.ACCOUNT_PRIMARY}),+ Case.EE_ACCOUNT_MODE_UNRESOLVED: frozenset({Trait.APP_SCOPED, Trait.ACCOUNT_PRIMARY}),+ Case.EE_EXTERNAL_PUBLIC: frozenset({Trait.APP_SCOPED, Trait.EXTERNAL_REACHABLE}),+ Case.EE_EXTERNAL_SSO_VERIFIED: frozenset({Trait.APP_SCOPED, Trait.EXTERNAL_REACHABLE}),+ Case.EE_EXTERNAL_PRIVATE_ALL: frozenset({Trait.APP_SCOPED, Trait.EXTERNAL_REACHABLE}),+ Case.EE_EXTERNAL_PRIVATE: frozenset({Trait.APP_SCOPED, Trait.EXTERNAL_REACHABLE}),+ Case.EE_EXTERNAL_PRIVATE_REFUSED_WEBAPP_AUTH_OFF: frozenset({Trait.APP_SCOPED, Trait.EXTERNAL_REACHABLE}),+ Case.EE_EXTERNAL_MODE_UNRESOLVED: frozenset({Trait.APP_SCOPED, Trait.EXTERNAL_REACHABLE}),+ Case.RBAC_ON_LOW_ROLE: frozenset({Trait.ACCOUNT_PRIMARY}),+ Case.RBAC_ON_DENIED: frozenset({Trait.ACCOUNT_PRIMARY}),+}+++SCENARIOS: dict[Case, Scenario] = {+ Case.NO_BEARER: Scenario(bearer=Bearer.NONE),+ Case.MEMBER: Scenario(bearer=Bearer.PRIMARY),+ Case.WRONG_SUBJECT: Scenario(bearer=Bearer.OTHER_SUBJECT),+ Case.INSUFFICIENT_SCOPE: Scenario(bearer=Bearer.PRIMARY, narrow_scopes=True),+ Case.NON_MEMBER: Scenario(bearer=Bearer.ACCOUNT_OUTSIDER),+ Case.NON_MEMBER_AND_INSUFFICIENT_SCOPE: Scenario(bearer=Bearer.ACCOUNT_OUTSIDER, narrow_scopes=True),+ Case.LOW_ROLE: Scenario(bearer=Bearer.ACCOUNT_LOW_ROLE),+ Case.APP_API_DISABLED: Scenario(bearer=Bearer.PRIMARY, app_api_enabled=False),+ Case.UNKNOWN_APP: Scenario(bearer=Bearer.PRIMARY, unknown_app=True),+ Case.FOREIGN_WORKSPACE_QUERY: Scenario(bearer=Bearer.PRIMARY, foreign_workspace_query=True),+ Case.EDITION_NOT_ENTERPRISE: Scenario(bearer=Bearer.PRIMARY, edition=DeploymentEdition.COMMUNITY),+ Case.LICENSE_INVALID: Scenario(bearer=Bearer.PRIMARY, license_status=LicenseStatus.EXPIRED),+ Case.EE_LICENSE_INVALID: Scenario(+ bearer=Bearer.PRIMARY, edition=DeploymentEdition.ENTERPRISE, license_status=LicenseStatus.EXPIRED+ ),+ Case.EE_ACCOUNT_PUBLIC: Scenario(+ bearer=Bearer.ACCOUNT_MEMBER,+ edition=DeploymentEdition.ENTERPRISE,+ webapp_auth=True,+ access_mode=WebAppAccessMode.PUBLIC,+ ),+ Case.EE_ACCOUNT_SSO_VERIFIED: Scenario(+ bearer=Bearer.ACCOUNT_MEMBER,+ edition=DeploymentEdition.ENTERPRISE,+ webapp_auth=True,+ access_mode=WebAppAccessMode.SSO_VERIFIED,+ ),+ Case.EE_ACCOUNT_PRIVATE_ALL: Scenario(+ bearer=Bearer.ACCOUNT_MEMBER,+ edition=DeploymentEdition.ENTERPRISE,+ webapp_auth=True,+ access_mode=WebAppAccessMode.PRIVATE_ALL,+ ),+ Case.EE_ACCOUNT_PRIVATE_PERMITTED: Scenario(+ bearer=Bearer.ACCOUNT_MEMBER,+ edition=DeploymentEdition.ENTERPRISE,+ webapp_auth=True,+ access_mode=WebAppAccessMode.PRIVATE,+ private_app_permitted=True,+ ),+ Case.EE_ACCOUNT_PRIVATE_REFUSED: Scenario(+ bearer=Bearer.ACCOUNT_MEMBER,+ edition=DeploymentEdition.ENTERPRISE,+ webapp_auth=True,+ access_mode=WebAppAccessMode.PRIVATE,+ private_app_permitted=False,+ ),+ Case.EE_ACCOUNT_PRIVATE_REFUSED_WEBAPP_AUTH_OFF: Scenario(+ bearer=Bearer.ACCOUNT_MEMBER,+ edition=DeploymentEdition.ENTERPRISE,+ webapp_auth=False,+ access_mode=WebAppAccessMode.PRIVATE,+ private_app_permitted=False,+ ),+ Case.EE_ACCOUNT_MODE_UNRESOLVED: Scenario(+ bearer=Bearer.ACCOUNT_MEMBER,+ edition=DeploymentEdition.ENTERPRISE,+ webapp_auth=True,+ access_mode=None,+ ),+ Case.EE_EXTERNAL_PUBLIC: Scenario(+ bearer=Bearer.EXTERNAL,+ edition=DeploymentEdition.ENTERPRISE,+ webapp_auth=True,+ access_mode=WebAppAccessMode.PUBLIC,+ ),+ Case.EE_EXTERNAL_SSO_VERIFIED: Scenario(+ bearer=Bearer.EXTERNAL,+ edition=DeploymentEdition.ENTERPRISE,+ webapp_auth=True,+ access_mode=WebAppAccessMode.SSO_VERIFIED,+ ),+ Case.EE_EXTERNAL_PRIVATE_ALL: Scenario(+ bearer=Bearer.EXTERNAL,+ edition=DeploymentEdition.ENTERPRISE,+ webapp_auth=True,+ access_mode=WebAppAccessMode.PRIVATE_ALL,+ ),+ Case.EE_EXTERNAL_PRIVATE: Scenario(+ bearer=Bearer.EXTERNAL,+ edition=DeploymentEdition.ENTERPRISE,+ webapp_auth=True,+ access_mode=WebAppAccessMode.PRIVATE,+ ),+ Case.EE_EXTERNAL_PRIVATE_REFUSED_WEBAPP_AUTH_OFF: Scenario(+ bearer=Bearer.EXTERNAL,+ edition=DeploymentEdition.ENTERPRISE,+ webapp_auth=False,+ access_mode=WebAppAccessMode.PRIVATE,+ private_app_permitted=False,+ ),+ Case.EE_EXTERNAL_MODE_UNRESOLVED: Scenario(+ bearer=Bearer.EXTERNAL,+ edition=DeploymentEdition.ENTERPRISE,+ webapp_auth=True,+ access_mode=None,+ ),+ Case.RBAC_ON_LOW_ROLE: Scenario(bearer=Bearer.ACCOUNT_LOW_ROLE, rbac_enabled=True, rbac_allows=True),+ Case.RBAC_ON_DENIED: Scenario(bearer=Bearer.ACCOUNT_MEMBER, rbac_enabled=True, rbac_allows=False),+}+++ROUTER_CASE_ROUTE = "account.get"+ROUTER_CASES: dict[Case, Expect] = {+ Case.NO_BEARER: DENY_NO_BEARER,+ Case.LICENSE_INVALID: ADMIT_NO_LICENCE_GATE,+ Case.EE_LICENSE_INVALID: DENY_LICENSE,+}+"""Answered by the router before any route-specific requirement runs, so pinned once."""+++_ACCOUNT_ONLY_NO_WORKSPACE: dict[Case, Expect] = {+ Case.MEMBER: ADMIT,+ Case.WRONG_SUBJECT: DENY_WRONG_SUBJECT,+ Case.INSUFFICIENT_SCOPE: DENY_SCOPE,+ Case.NON_MEMBER: ADMIT,+ # No live membership check on this route, so the outsider's only failure is+ # scope — same answer pre- and post-PR.+ Case.NON_MEMBER_AND_INSUFFICIENT_SCOPE: DENY_SCOPE,+ Case.LOW_ROLE: ADMIT,+ Case.RBAC_ON_LOW_ROLE: ADMIT_NO_WORKSPACE_ROLE,+ Case.RBAC_ON_DENIED: ADMIT_NO_RBAC_PERMISSION,+}++_ACCOUNT_MEMBER_NO_ROLE: dict[Case, Expect] = {+ Case.MEMBER: ADMIT,+ Case.WRONG_SUBJECT: DENY_WRONG_SUBJECT,+ Case.INSUFFICIENT_SCOPE: DENY_SCOPE,+ Case.NON_MEMBER: DENY_NON_MEMBER,+ Case.NON_MEMBER_AND_INSUFFICIENT_SCOPE: DENY_NON_MEMBER,+ Case.LOW_ROLE: ADMIT,+ Case.RBAC_ON_LOW_ROLE: ADMIT_NO_WORKSPACE_ROLE,+ Case.RBAC_ON_DENIED: ADMIT_NO_RBAC_PERMISSION,+}++_ACCOUNT_MEMBER_WITH_ROLE: dict[Case, Expect] = {+ Case.MEMBER: ADMIT,+ Case.WRONG_SUBJECT: DENY_WRONG_SUBJECT,+ Case.INSUFFICIENT_SCOPE: DENY_SCOPE,+ Case.NON_MEMBER: DENY_NON_MEMBER,+ Case.NON_MEMBER_AND_INSUFFICIENT_SCOPE: DENY_NON_MEMBER,+ Case.LOW_ROLE: DENY_ROLE,+ Case.RBAC_ON_LOW_ROLE: ADMIT,+ Case.RBAC_ON_DENIED: DENY_RBAC,+}++_DUAL_SUBJECT_RUN: dict[Case, Expect] = {+ Case.MEMBER: ADMIT,+ Case.WRONG_SUBJECT: DENY_SSO_NEEDS_EE,+ Case.INSUFFICIENT_SCOPE: DENY_SCOPE,+ Case.NON_MEMBER: DENY_NON_MEMBER,+ Case.NON_MEMBER_AND_INSUFFICIENT_SCOPE: DENY_NON_MEMBER,+ Case.LOW_ROLE: ADMIT,+ Case.APP_API_DISABLED: DENY_API_DISABLED,+ Case.UNKNOWN_APP: DENY_UNKNOWN_APP,+ Case.FOREIGN_WORKSPACE_QUERY: ADMIT,+ Case.EE_ACCOUNT_PUBLIC: ADMIT,+ Case.EE_ACCOUNT_SSO_VERIFIED: ADMIT,+ Case.EE_ACCOUNT_PRIVATE_ALL: ADMIT,+ Case.EE_ACCOUNT_PRIVATE_PERMITTED: ADMIT,+ Case.EE_ACCOUNT_PRIVATE_REFUSED: DENY_PRIVATE_APP,+ Case.EE_ACCOUNT_PRIVATE_REFUSED_WEBAPP_AUTH_OFF: DENY_PRIVATE_APP,+ Case.EE_ACCOUNT_MODE_UNRESOLVED: DENY_MODE_UNRESOLVED,+ Case.EE_EXTERNAL_PUBLIC: ADMIT,+ Case.EE_EXTERNAL_SSO_VERIFIED: ADMIT,+ Case.EE_EXTERNAL_PRIVATE_ALL: DENY_ACCESS_MODE,+ Case.EE_EXTERNAL_PRIVATE: DENY_ACCESS_MODE,+ Case.EE_EXTERNAL_PRIVATE_REFUSED_WEBAPP_AUTH_OFF: DENY_PRIVATE_APP,+ Case.EE_EXTERNAL_MODE_UNRESOLVED: DENY_MODE_UNRESOLVED,+ Case.RBAC_ON_DENIED: DENY_RBAC,+ Case.RBAC_ON_LOW_ROLE: ADMIT_NO_WORKSPACE_ROLE,+}+++MATRIX: dict[str, dict[Case, Expect]] = {+ "account.get": dict(_ACCOUNT_ONLY_NO_WORKSPACE),+ "workspaces.list": dict(_ACCOUNT_ONLY_NO_WORKSPACE),+ "apps.list": dict(_ACCOUNT_MEMBER_NO_ROLE),+ "workspaces.switch": dict(_ACCOUNT_MEMBER_NO_ROLE),+ # invite/remove check WORKSPACE_MEMBER_MANAGE; update_role checks WORKSPACE_ROLE_MANAGE+ # (matches check_member_permission's own add/remove vs update split)+ "workspaces.members.invite": dict(_ACCOUNT_MEMBER_WITH_ROLE),+ "workspaces.members.update_role": dict(_ACCOUNT_MEMBER_WITH_ROLE),+ "app_dsl.import": dict(_ACCOUNT_MEMBER_WITH_ROLE),+ "apps.describe": {+ Case.MEMBER: ADMIT,+ Case.WRONG_SUBJECT: DENY_WRONG_SUBJECT,+ Case.INSUFFICIENT_SCOPE: DENY_SCOPE,+ Case.NON_MEMBER: DENY_NON_MEMBER,+ Case.NON_MEMBER_AND_INSUFFICIENT_SCOPE: DENY_NON_MEMBER,+ Case.LOW_ROLE: ADMIT,+ Case.APP_API_DISABLED: DENY_API_DISABLED,+ Case.UNKNOWN_APP: DENY_UNKNOWN_APP,+ Case.FOREIGN_WORKSPACE_QUERY: ADMIT,+ Case.EE_ACCOUNT_PUBLIC: ADMIT,+ Case.EE_ACCOUNT_SSO_VERIFIED: ADMIT,+ Case.EE_ACCOUNT_PRIVATE_ALL: ADMIT,+ Case.EE_ACCOUNT_PRIVATE_PERMITTED: ADMIT,+ Case.EE_ACCOUNT_PRIVATE_REFUSED: ADMIT,+ Case.EE_ACCOUNT_PRIVATE_REFUSED_WEBAPP_AUTH_OFF: ADMIT,+ Case.EE_ACCOUNT_MODE_UNRESOLVED: ADMIT,+ Case.RBAC_ON_DENIED: DENY_RBAC,+ Case.RBAC_ON_LOW_ROLE: ADMIT_NO_WORKSPACE_ROLE,+ },+ "app_dsl.export": {+ Case.MEMBER: ADMIT,+ Case.WRONG_SUBJECT: DENY_WRONG_SUBJECT,+ Case.INSUFFICIENT_SCOPE: DENY_SCOPE,+ Case.NON_MEMBER: DENY_NON_MEMBER,+ Case.NON_MEMBER_AND_INSUFFICIENT_SCOPE: DENY_NON_MEMBER,+ Case.LOW_ROLE: DENY_ROLE,+ Case.APP_API_DISABLED: DENY_API_DISABLED,+ Case.UNKNOWN_APP: DENY_UNKNOWN_APP,+ Case.FOREIGN_WORKSPACE_QUERY: ADMIT,+ Case.EE_ACCOUNT_PUBLIC: ADMIT,+ Case.EE_ACCOUNT_SSO_VERIFIED: ADMIT,+ Case.EE_ACCOUNT_PRIVATE_ALL: ADMIT,+ Case.EE_ACCOUNT_PRIVATE_PERMITTED: ADMIT,+ Case.EE_ACCOUNT_PRIVATE_REFUSED: ADMIT,+ Case.EE_ACCOUNT_PRIVATE_REFUSED_WEBAPP_AUTH_OFF: ADMIT,+ Case.EE_ACCOUNT_MODE_UNRESOLVED: ADMIT,+ Case.RBAC_ON_LOW_ROLE: ADMIT,+ Case.RBAC_ON_DENIED: DENY_RBAC,+ },+ "app_run.run": dict(_DUAL_SUBJECT_RUN),+ "human_input_form.get": dict(_DUAL_SUBJECT_RUN),+ "files.upload": {+ **_DUAL_SUBJECT_RUN,+ Case.RBAC_ON_DENIED: ADMIT_NO_RBAC_PERMISSION,+ },+ "permitted_external.list": {+ Case.MEMBER: ADMIT_NO_MOUNT,+ Case.WRONG_SUBJECT: DENY_WRONG_SUBJECT,+ Case.INSUFFICIENT_SCOPE: DENY_SCOPE,+ # An account bearer answers on the subject axis here, before scope or+ # membership: this route's CheckSubject allows only ExternalSsoSubject.+ Case.NON_MEMBER_AND_INSUFFICIENT_SCOPE: DENY_WRONG_SUBJECT,+ Case.EDITION_NOT_ENTERPRISE: DENY_EDITION,+ },+ "permitted_external.describe": {+ Case.MEMBER: ADMIT,+ Case.WRONG_SUBJECT: DENY_WRONG_SUBJECT,+ Case.INSUFFICIENT_SCOPE: DENY_SCOPE,+ Case.NON_MEMBER_AND_INSUFFICIENT_SCOPE: DENY_WRONG_SUBJECT,+ Case.EDITION_NOT_ENTERPRISE: DENY_EDITION,+ Case.APP_API_DISABLED: DENY_API_DISABLED,+ Case.UNKNOWN_APP: DENY_UNKNOWN_APP,+ Case.FOREIGN_WORKSPACE_QUERY: Expect(+ ADMITTED,+ note="a foreign ?workspace_id= is ignored on every app-scoped route (spec 2.9)",+ ),+ Case.EE_EXTERNAL_PUBLIC: ADMIT,+ Case.EE_EXTERNAL_SSO_VERIFIED: ADMIT,+ Case.EE_EXTERNAL_PRIVATE_ALL: DENY_ACCESS_MODE,+ Case.EE_EXTERNAL_PRIVATE: DENY_ACCESS_MODE,+ Case.EE_EXTERNAL_PRIVATE_REFUSED_WEBAPP_AUTH_OFF: DENY_PRIVATE_APP,+ Case.EE_EXTERNAL_MODE_UNRESOLVED: DENY_MODE_UNRESOLVED,+ },+}+"""One representative per distinct declared requirement tuple; `DECLARED` pins the rest."""+++_ACCOUNT = (AccountSubject,)+_ACCOUNT_OR_EXTERNAL = (AccountSubject, ExternalSsoSubject)+_OWNER_ADMIN = frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN})+_EDITOR_UP = frozenset({TenantAccountRole.EDITOR, TenantAccountRole.ADMIN, TenantAccountRole.OWNER})++_REQ_ACCOUNT_FULL = (CheckSubject(allowed=_ACCOUNT), CheckScope(Scope.FULL))+_REQ_ACCOUNT_WORKSPACE_READ = (CheckSubject(allowed=_ACCOUNT), CheckScope(Scope.WORKSPACE_READ))+_REQ_ACCOUNT_APPS_READ_MEMBER = (+ CheckSubject(allowed=_ACCOUNT),+ CheckScope(Scope.APPS_READ),+ CheckWorkspaceMember(),+)+_REQ_ACCOUNT_WORKSPACE_READ_MEMBER = (+ CheckSubject(allowed=_ACCOUNT),+ CheckScope(Scope.WORKSPACE_READ),+ CheckWorkspaceMember(),+)+_REQ_MEMBER_MANAGE = (+ CheckSubject(allowed=_ACCOUNT),+ CheckScope(Scope.WORKSPACE_WRITE),+ CheckWorkspaceMember(),+ CheckRBACPermission(RBACCheck(RBACPermission.WORKSPACE_MEMBER_MANAGE, Workspace())),+ CheckWorkspaceRole(_OWNER_ADMIN),+)+_REQ_ROLE_MANAGE = (+ CheckSubject(allowed=_ACCOUNT),+ CheckScope(Scope.WORKSPACE_WRITE),+ CheckWorkspaceMember(),+ CheckRBACPermission(RBACCheck(RBACPermission.WORKSPACE_ROLE_MANAGE, Workspace())),+ CheckWorkspaceRole(_OWNER_ADMIN),+)+_REQ_DSL_WORKSPACE = (+ CheckSubject(allowed=_ACCOUNT),+ CheckScope(Scope.WORKSPACE_WRITE),+ CheckWorkspaceMember(),+ CheckRBACPermission(RBACCheck(RBACPermission.APP_IMPORT_EXPORT_DSL, Workspace())),+ CheckWorkspaceRole(_EDITOR_UP),+)+_REQ_DSL_APP = (+ CheckSubject(allowed=_ACCOUNT),+ CheckAppApiEnabled(),+ CheckWorkspaceMember(),+ CheckScope(Scope.APPS_READ),+ CheckRBACPermission(RBACCheck(RBACPermission.APP_IMPORT_EXPORT_DSL, PlainApp())),+ CheckWorkspaceRole(_EDITOR_UP),+)+_REQ_APP_DESCRIBE = (+ CheckSubject(allowed=_ACCOUNT),+ CheckAppApiEnabled(),+ CheckWorkspaceMember(),+ CheckScope(Scope.APPS_READ),+ CheckRBACPermission(RBACCheck(RBACPermission.APP_VIEW_LAYOUT, PlainApp())),+)+_REQ_RUN = (+ CheckSubject(allowed=_ACCOUNT_OR_EXTERNAL),+ CheckAppApiEnabled(),+ CheckWorkspaceMember(),+ CheckScope(Scope.APPS_RUN),+ CheckRBACPermission(RBACCheck(RBACPermission.APP_TEST_AND_RUN, PlainApp())),+ CheckAppAccess(),+)+_REQ_RUN_FORM = (*_REQ_RUN, CheckFormSurface())+_REQ_FILES = (+ CheckSubject(allowed=_ACCOUNT_OR_EXTERNAL),+ CheckAppApiEnabled(),+ CheckWorkspaceMember(),+ CheckScope(Scope.APPS_RUN),+ CheckAppAccess(),+)+_REQ_EXTERNAL_LIST = (+ CheckSubject(allowed=(ExternalSsoSubject,)),+ CheckScope(Scope.APPS_READ_PERMITTED_EXTERNAL),+)+_REQ_EXTERNAL_DESCRIBE = (+ CheckSubject(allowed=(ExternalSsoSubject,)),+ CheckAppApiEnabled(),+ CheckScope(Scope.APPS_READ_PERMITTED_EXTERNAL),+ CheckAppAccess(),+)++DECLARED: dict[str, tuple[Requirement, ...]] = {+ "account.get": _REQ_ACCOUNT_FULL,+ "account.sessions.revoke_self": _REQ_ACCOUNT_FULL,+ "account.sessions.list": _REQ_ACCOUNT_FULL,+ "account.sessions.revoke_one": _REQ_ACCOUNT_FULL,+ "apps.describe": _REQ_APP_DESCRIBE,+ "apps.list": _REQ_ACCOUNT_APPS_READ_MEMBER,+ "workspaces.list": _REQ_ACCOUNT_WORKSPACE_READ,+ "workspaces.describe": _REQ_ACCOUNT_WORKSPACE_READ,+ "workspaces.switch": _REQ_ACCOUNT_WORKSPACE_READ_MEMBER,+ "workspaces.members.list": _REQ_ACCOUNT_WORKSPACE_READ_MEMBER,+ "workspaces.members.invite": _REQ_MEMBER_MANAGE,+ "workspaces.members.remove": _REQ_MEMBER_MANAGE,+ "workspaces.members.update_role": _REQ_ROLE_MANAGE,+ "app_dsl.import": _REQ_DSL_WORKSPACE,+ "app_dsl.import_confirm": _REQ_DSL_WORKSPACE,+ "app_dsl.export": _REQ_DSL_APP,+ "app_dsl.check_dependencies": _REQ_DSL_APP,+ "app_run.run": _REQ_RUN,+ "app_run.stop": _REQ_RUN,+ "files.upload": _REQ_FILES,+ "human_input_form.get": _REQ_RUN_FORM,+ "human_input_form.submit": _REQ_RUN_FORM,+ "workflow_events.stream": _REQ_RUN,+ "permitted_external.list": _REQ_EXTERNAL_LIST,+ "permitted_external.describe": _REQ_EXTERNAL_DESCRIBE,+}+"""Every route's `@endpoint(requirements=...)`, in declared order. A route that+shares a tuple with a `MATRIX` representative is covered by that representative's+rows only while this table says it still declares the same tuple."""+++ROUTES_BY_ID = {route.id: route for route in ROUTES}+++def _applicable(route: Route, case: Case) -> bool:+ return CASE_REQUIRES[case] <= route.traits+++def _rows(route: Route) -> Iterator[tuple[Route, Case, Expect]]:+ for case in Case:+ if not _applicable(route, case):+ continue+ if case not in ROUTER_CASES:+ yield route, case, MATRIX[route.id][case]+ elif route.id == ROUTER_CASE_ROUTE:+ yield route, case, ROUTER_CASES[case]+++ROWS: tuple[tuple[Route, Case, Expect], ...] = tuple(+ row for route in ROUTES if route.id in MATRIX for row in _rows(route)+)+++@dataclass(slots=True)+class World:+ """Persisted rows and the tokens that address them."""++ workspace_id: str+ other_workspace_id: str+ app_id: str+ disabled_app_id: str+ member_account_id: str+ low_role_account_id: str+ outsider_account_id: str+ tokens: dict[Bearer, str] = field(default_factory=dict)+ session_ids: dict[Bearer, str] = field(default_factory=dict)+++def _admit_on_mount(*_args: object, **_kwargs: object) -> None:+ raise ImATeapot("admitted")+++class _MemoryResolver:+ """Stands in for the DB-backed token resolver.++ Token resolution is an input to the matrix, not part of it, and the shipped+ resolver compares a timezone-aware expiry against a column SQLite hands back+ naive.+ """++ def __init__(self, rows: dict[str, ResolvedRow]) -> None:+ self._rows = rows++ def resolve(self, token_hash: str) -> ResolvedRow | None:+ return self._rows.get(token_hash)+++def _authenticator(rows: dict[str, ResolvedRow]) -> BearerAuthenticator:+ resolver = _MemoryResolver(rows)+ return BearerAuthenticator({TokenType.OAUTH_ACCOUNT: resolver, TokenType.OAUTH_EXTERNAL_SSO: resolver})+++def token_rows() -> dict[str, ResolvedRow]:+ return {}+++def matrix_app(monkeypatch: pytest.MonkeyPatch) -> Iterator[Flask]:+ """The openapi blueprint on the real factory app with a login manager and the admission probe."""+ app = create_flask_app_with_configs()+ app.config["TESTING"] = True+ app.secret_key = "openapi-auth-matrix"+ LoginManager(app)+ app.register_blueprint(openapi_bp)++ monkeypatch.setattr(+ rate_limit_module,+ "LIMIT_BEARER_PER_TOKEN",+ rate_limit_module.RateLimit(+ 0,+ rate_limit_module.LIMIT_BEARER_PER_TOKEN.window,+ rate_limit_module.LIMIT_BEARER_PER_TOKEN.scopes,+ ),+ )++ user_logged_in.connect(_admit_on_mount)+ try:+ yield app+ finally:+ user_logged_in.disconnect(_admit_on_mount)+++def world(sqlite_session_factory: sessionmaker[Session], token_rows: dict[str, ResolvedRow]) -> World:+ """One workspace with an owner, a normal member and an outsider; two apps."""+ built = World(+ workspace_id=str(uuid.uuid4()),+ other_workspace_id=str(uuid.uuid4()),+ app_id=str(uuid.uuid4()),+ disabled_app_id=str(uuid.uuid4()),+ member_account_id=str(uuid.uuid4()),+ low_role_account_id=str(uuid.uuid4()),+ outsider_account_id=str(uuid.uuid4()),+ )++ def account(account_id: str, email: str) -> Account:+ row = Account(name=email, email=email, avatar="", status=AccountStatus.ACTIVE)+ row.id = account_id+ return row++ def application(app_id: str, *, enable_api: bool) -> App:+ return App(+ id=app_id,+ tenant_id=built.workspace_id,+ name="matrix app",+ description="",+ mode="workflow",+ enable_site=False,+ enable_api=enable_api,+ )++ workspace = Tenant(name="matrix workspace")+ workspace.id = built.workspace_id+ other_workspace = Tenant(name="other workspace")+ other_workspace.id = built.other_workspace_id++ with sqlite_session_factory() as session:+ session.add_all(+ [+ workspace,+ other_workspace,+ account(built.member_account_id, "[email protected]"),+ account(built.low_role_account_id, "[email protected]"),+ account(built.outsider_account_id, "[email protected]"),+ application(built.app_id, enable_api=True),+ application(built.disabled_app_id, enable_api=False),+ TenantAccountJoin(+ tenant_id=built.workspace_id,+ account_id=built.member_account_id,+ role=TenantAccountRole.OWNER,+ ),+ TenantAccountJoin(+ tenant_id=built.workspace_id,+ account_id=built.low_role_account_id,+ role=TenantAccountRole.NORMAL,+ ),+ ]+ )+ session.commit()++ def mint(bearer: Bearer, prefix: str, *, account_id: str | None, email: str) -> None:+ """Register a bearer with the fake resolver *and* persist the session row it+ names, so the access service's ownership check has something real to match against.+ """+ raw = prefix + uuid.uuid4().hex+ token_id = uuid.uuid4()+ issuer = "dify:account" if account_id else "https://idp.example"+ token_rows[sha256_hex(raw)] = ResolvedRow(+ subject_email=email,+ subject_issuer=issuer,+ account_id=uuid.UUID(account_id) if account_id else None,+ client_id="difyctl",+ token_id=token_id,+ expires_at=None,+ )+ row = OAuthAccessToken(+ token_hash=sha256_hex(raw),+ prefix=prefix,+ account_id=account_id,+ subject_email=email,+ subject_issuer=issuer,+ client_id="difyctl",+ device_label="matrix",+ expires_at=datetime.now(UTC) + timedelta(days=365),+ )+ row.id = str(token_id)+ with sqlite_session_factory() as session:+ session.add(row)+ session.commit()+ built.tokens[bearer] = raw+ built.session_ids[bearer] = str(token_id)++ mint(+ Bearer.ACCOUNT_MEMBER,+ TokenType.OAUTH_ACCOUNT.prefix,+ account_id=built.member_account_id,+ email="[email protected]",+ )+ mint(+ Bearer.ACCOUNT_LOW_ROLE,+ TokenType.OAUTH_ACCOUNT.prefix,+ account_id=built.low_role_account_id,+ email="[email protected]",+ )+ mint(+ Bearer.ACCOUNT_OUTSIDER,+ TokenType.OAUTH_ACCOUNT.prefix,+ account_id=built.outsider_account_id,+ email="[email protected]",+ )+ mint(Bearer.EXTERNAL, TokenType.OAUTH_EXTERNAL_SSO.prefix, account_id=None, email="[email protected]")+ return built+++def _system_features(+ *, edition: DeploymentEdition, webapp_auth: bool, license_status: LicenseStatus+) -> SystemFeatureModel:+ features = SystemFeatureModel(deployment_edition=edition)+ features.webapp_auth.enabled = webapp_auth+ features.license.status = license_status+ return features+++@dataclass(frozen=True, slots=True)+class _WebAppSettings:+ access_mode: str+++def _access_mode_settings(access_mode: WebAppAccessMode | None) -> _WebAppSettings | None:+ if access_mode is None:+ return None+ return _WebAppSettings(access_mode=access_mode.value)+++def _webapp_account() -> Account:+ """The account an external-SSO subject's email resolves to for the private-app check."""+ row = Account(name="external", email="[email protected]", avatar="", status=AccountStatus.ACTIVE)+ row.id = str(uuid.uuid4())+ return row+++def _end_user(_type: EndUserType, tenant_id: str, app_id: str, user_id: str | None = None) -> EndUser:+ row = EndUser(+ tenant_id=tenant_id,+ app_id=app_id,+ type=EndUserType.OPENAPI,+ is_anonymous=False,+ session_id=user_id or "",+ )+ row.external_user_id = user_id+ return row+++def _bearer_for(route: Route, scenario: Scenario) -> Bearer | None:+ account_primary = Trait.ACCOUNT_PRIMARY in route.traits+ match scenario.bearer:+ case Bearer.NONE:+ return None+ case Bearer.PRIMARY:+ return Bearer.ACCOUNT_MEMBER if account_primary else Bearer.EXTERNAL+ case Bearer.OTHER_SUBJECT:+ return Bearer.EXTERNAL if account_primary else Bearer.ACCOUNT_MEMBER+ case _:+ return scenario.bearer+++def _url(route: Route, world: World, scenario: Scenario, bearer: Bearer | None) -> str:+ if scenario.unknown_app:+ app_id = str(uuid.uuid4())+ elif not scenario.app_api_enabled:+ app_id = world.disabled_app_id+ else:+ app_id = world.app_id+ ids = {+ "app_id": app_id,+ "workspace_id": world.workspace_id,+ # The caller's own session: the access service 404s any other id.+ "session_id": world.session_ids.get(bearer, str(uuid.uuid4())) if bearer else str(uuid.uuid4()),+ "member_id": str(uuid.uuid4()),+ "import_id": str(uuid.uuid4()),+ "task_id": str(uuid.uuid4()),+ "form_token": uuid.uuid4().hex,+ }+ query = route.query.format(**ids)+ if scenario.foreign_workspace_query:+ extra = f"workspace_id={world.other_workspace_id}"+ query = f"{query}&{extra}" if query else extra+ path = route.path.format(**ids)+ return f"/openapi/v1{path}?{query}" if query else f"/openapi/v1{path}"+++def _run_case(+ *,+ route: Route,+ scenario: Scenario,+ app: Flask,+ world: World,+ token_rows: dict[str, ResolvedRow],+ monkeypatch: pytest.MonkeyPatch,+) -> TestResponse:++ edition = scenario.edition or (+ DeploymentEdition.ENTERPRISE if Trait.ENTERPRISE_ONLY in route.traits else DeploymentEdition.COMMUNITY+ )+ apply_config_overrides(monkeypatch, DEPLOYMENT_EDITION=edition, RBAC_ENABLED=scenario.rbac_enabled)+ monkeypatch.setattr(oauth_bearer_module, "_authenticator", _authenticator(token_rows))+ if scenario.narrow_scopes:+ # No shipped token can fail `CheckScope`: `dfoa_` carries `Scope.FULL` and+ # `dfoe_` exactly the scopes its routes ask for. Scopes are a constant of+ # the subject, so the only way to reach the refusal is to blank them here.+ # Keep these rows: they are what catches a third token kind routed+ # somewhere it was not scoped for.+ monkeypatch.setattr(oauth_bearer_module.AuthContext, "scopes", property(lambda _self: frozenset()))++ features = _system_features(+ edition=edition, webapp_auth=scenario.webapp_auth, license_status=scenario.license_status+ )+ settings = _access_mode_settings(scenario.access_mode)++ headers: dict[str, str] = {}+ bearer = _bearer_for(route, scenario)+ if bearer is not None:+ headers["Authorization"] = f"Bearer {world.tokens[bearer]}"++ with ExitStack() as stack:+ stack.enter_context(patch.object(SystemFeatureService, "get_public_system_features", return_value=features))+ stack.enter_context(+ patch.object(EnterpriseService.WebAppAuth, "get_app_access_mode_by_id", return_value=settings)+ )+ stack.enter_context(+ patch.object(+ EnterpriseService.WebAppAuth,+ "is_user_allowed_to_access_webapp",+ return_value=scenario.private_app_permitted,+ )+ )+ stack.enter_context(+ patch.object(+ EnterpriseService.WebAppAuth,+ "list_externally_accessible_apps",+ return_value={"data": [], "total": 0, "hasMore": False},+ )+ )+ stack.enter_context(+ patch.object(+ EndUserService,+ "get_or_create_end_user_by_type",+ side_effect=_end_user,+ )+ )+ stack.enter_context(patch.object(RBACResourceService, "get_app_agent_binding", return_value=None))+ stack.enter_context(patch.object(RBACResourceService, "get_app_maintainer", return_value=None))+ stack.enter_context(+ patch(+ "services.enterprise.rbac_service.RBACService.CheckAccess.check",+ return_value=scenario.rbac_allows,+ )+ )+ stack.enter_context(patch.object(AccountService, "get_account_by_email", return_value=_webapp_account()))+ client = app.test_client()+ return contextvars.copy_context().run(+ lambda: client.open(_url(route, world, scenario, bearer), method=route.method, headers=headers)+ )+++ ("route", "case", "expected"),+ ROWS,+ ids=[f"{route.id}-{case.value}" for route, case, _ in ROWS],+)+def test_allow_deny_matrix(+ route: Route,+ case: Case,+ expected: Expect,+ matrix_app: Flask,+ world: World,+ token_rows: dict[str, ResolvedRow],+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ response = _run_case(+ route=route,+ scenario=SCENARIOS[case],+ app=matrix_app,+ world=world,+ token_rows=token_rows,+ monkeypatch=monkeypatch,+ )++ body = response.get_json(silent=True) or {}+ assert response.status_code == expected.status, f"{route.id}/{case.value}: body={body}"+ if expected.message is not None:+ assert body.get("message") == expected.message+++def _rule_path(route: Route) -> str:+ return "/openapi/v1" + route.path.replace("{", "<string:").replace("}", ">")+++def _endpoint_spec(app: Flask, rule: Rule, method: str) -> EndpointSpec | None:+ """The `EndpointSpec` `@endpoint` attached to this rule's handler, or None.++ Carrying a spec *is* being guarded: `@endpoint` is the only thing that sets+ it, and it sets it on the same object it wraps in `subject_router.guard`.+ """+ view = app.view_functions.get(rule.endpoint)+ resource = view.view_class if hasattr(view, "view_class") else None+ if resource is None:+ return None+ handler = getattr(resource, method.lower(), None) # guard-ignore: no-new-getattr -- HTTP verb selects the handler+ return handler.__spec__ if hasattr(handler, "__spec__") else None+++def test_registered_openapi_routes_match_the_matrix(matrix_app: Flask) -> None:+ """Every guarded /openapi/v1 route is in the table, and nothing else is.++ Guarded-ness is derived from `view.__spec__`, not from a hand-kept list of+ exemptions — so a route that gains a guard without gaining a row fails here,+ and so does a guarded route that quietly stops carrying a spec. Neither can+ be silenced by editing this file.+ """+ guarded: set[tuple[str, str]] = set()+ unguarded: set[tuple[str, str]] = set()+ for rule in matrix_app.url_map.iter_rules():+ if not str(rule).startswith("/openapi/v1") or str(rule) == "/openapi/v1/":+ continue+ for method in rule.methods or set():+ if method in {"HEAD", "OPTIONS"}:+ continue+ entry = (method, str(rule))+ target = guarded if _endpoint_spec(matrix_app, rule, method) is not None else unguarded+ target.add(entry)++ expected = {(route.method, _rule_path(route)) for route in ROUTES}+ assert guarded == expected+ # The remainder is the device-flow and documentation surface. Its size is pinned+ # rather than enumerated: a list of exemptions rots silently — the one this+ # replaced still named `swagger.json`, a route that is not registered at all.+ assert len(unguarded) == 13+++@singledispatch+def _config(_requirement: Requirement) -> object:+ return None+++@_config.register+def _(requirement: CheckSubject) -> object:+ return requirement.allowed+++@_config.register+def _(requirement: CheckScope) -> object:+ return requirement.scope+++@_config.register+def _(requirement: CheckRBACPermission) -> object:+ return tuple((check.scene, repr(check.locator)) for check in requirement.checks)+++@_config.register+def _(requirement: CheckWorkspaceRole) -> object:+ return requirement.allowed_roles+++def _canonical(requirement: Requirement) -> tuple[type[Requirement], object]:+ """`Requirement` has no `__eq__`, so compare by type plus the config that sets it apart."""+ return type(requirement), _config(requirement)+++def _spec_for(app: Flask, route: Route) -> EndpointSpec | None:+ for rule in app.url_map.iter_rules():+ if str(rule) == _rule_path(route) and route.method in (rule.methods or set()):+ return _endpoint_spec(app, rule, route.method)+ return None++[email protected]("route", ROUTES, ids=[route.id for route in ROUTES])+def test_route_declares_expected_requirements(route: Route, matrix_app: Flask) -> None:+ """The guard that lets `MATRIX` run one representative per tuple: a route+ that drifts from the tuple its representative was chosen for fails here.+ """+ spec = _spec_for(matrix_app, route)+ assert spec is not None, route.id+ assert [*map(_canonical, spec.requirements)] == [*map(_canonical, DECLARED[route.id])]+++ERROR_DEFAULT_RESPONSE: dict[str, object] = {+ "description": "Error",+ "content": {"application/json": {"schema": {"$ref": "#/components/schemas/ErrorBody"}}},+}+"""Exactly what `@returns` registers as `("default", "Error", ErrorBody)`."""++EXPECTED_RESPONSE_CODES: dict[tuple[str, str], frozenset[str]] = {+ ("get", "/_health"): frozenset({"200", "default"}),+ ("get", "/_version"): frozenset({"200", "default"}),+ ("get", "/account"): frozenset({"200", "default"}),+ ("get", "/account/sessions"): frozenset({"200", "422", "default"}),+ ("delete", "/account/sessions/self"): frozenset({"200", "default"}),+ ("delete", "/account/sessions/{session_id}"): frozenset({"200", "default"}),+ ("get", "/apps"): frozenset({"200", "422", "default"}),+ ("get", "/apps/{app_id}"): frozenset({"200", "422", "default"}),+ ("get", "/apps/{app_id}/dependencies:check"): frozenset({"200", "default"}),+ ("get", "/apps/{app_id}/dsl"): frozenset({"200", "422", "default"}),+ ("post", "/apps/{app_id}/files"): frozenset({"201", "400", "401", "413", "415", "default"}),+ ("get", "/apps/{app_id}/human-input-forms/{form_token}"): frozenset({"200", "default"}),+ ("post", "/apps/{app_id}/human-input-forms/{form_token}:submit"): frozenset({"200", "422", "default"}),+ ("get", "/apps/{app_id}/tasks/{task_id}/events"): frozenset({"200", "default"}),+ ("post", "/apps/{app_id}/tasks/{task_id}:stop"): frozenset({"200", "default"}),+ ("post", "/apps/{app_id}:run"): frozenset({"200", "422", "default"}),+ # The five device-flow rows are the only operations with no `default`: they+ # document their 200 with a raw `openapi_ns.response` rather than `@returns`,+ # so no `ErrorBody` schema is registered for them.+ ("post", "/oauth/device/approve"): frozenset({"200"}),+ ("post", "/oauth/device/code"): frozenset({"200"}),+ ("post", "/oauth/device/deny"): frozenset({"200"}),+ ("get", "/oauth/device/lookup"): frozenset({"200"}),+ ("post", "/oauth/device/token"): frozenset({"200"}),+ ("get", "/permitted-external-apps"): frozenset({"200", "422", "default"}),+ ("get", "/permitted-external-apps/{app_id}"): frozenset({"200", "422", "default"}),+ ("get", "/workspaces"): frozenset({"200", "default"}),+ ("get", "/workspaces/{workspace_id}"): frozenset({"200", "default"}),+ ("post", "/workspaces/{workspace_id}/apps/imports"): frozenset({"200", "202", "400", "422", "default"}),+ ("post", "/workspaces/{workspace_id}/apps/imports/{import_id}:confirm"): frozenset({"200", "400", "default"}),+ ("get", "/workspaces/{workspace_id}/members"): frozenset({"200", "422", "default"}),+ ("post", "/workspaces/{workspace_id}/members"): frozenset({"201", "422", "default"}),+ ("delete", "/workspaces/{workspace_id}/members/{member_id}"): frozenset({"200", "default"}),+ ("patch", "/workspaces/{workspace_id}/members/{member_id}"): frozenset({"200", "422", "default"}),+ ("post", "/workspaces/{workspace_id}:switch"): frozenset({"200", "default"}),+}++_HTTP_METHODS = frozenset({"get", "post", "put", "patch", "delete", "head", "options", "trace"})+++def openapi_document(config_overrides: Callable[..., None]) -> dict[str, object]:+ config_overrides(SWAGGER_UI_ENABLED=True)+ app = Flask(__name__)+ app.config["TESTING"] = True+ app.register_blueprint(openapi_bp)+ response = app.test_client().get("/openapi/v1/openapi.json")+ assert response.status_code == 200+ return response.get_json()+++def _operations(document: dict[str, object]) -> Iterator[tuple[tuple[str, str], dict[str, object]]]:+ paths = document["paths"]+ assert isinstance(paths, dict)+ for path, item in paths.items():+ assert isinstance(item, dict)+ for method, operation in item.items():+ if method in _HTTP_METHODS:+ assert isinstance(operation, dict)+ yield (method, path), operation+++def test_openapi_document_operations_and_response_codes(openapi_document: dict[str, object]) -> None:+ """Every operation's response codes are pinned exactly.++ `@endpoint` routes through `@returns`, which registers `default` -> `ErrorBody`,+ so a route that stops emitting the error schema (or one that starts) moves a row+ here and has to be re-pinned deliberately.+ """+ seen = dict(_operations(openapi_document))+ assert set(seen) == set(EXPECTED_RESPONSE_CODES)+ for key, operation in seen.items():+ responses = operation.get("responses", {})+ assert isinstance(responses, dict)+ assert frozenset(responses) == EXPECTED_RESPONSE_CODES[key], (+ f"{key}: {sorted(responses)} != {sorted(EXPECTED_RESPONSE_CODES[key])}"+ )+++def test_every_default_response_is_the_one_returns_registers(openapi_document: dict[str, object]) -> None:+ """A hand-written `default` pointing at some other schema would still satisfy+ the code sets above, which compare codes and not bodies.+ """+ for key, operation in _operations(openapi_document):+ responses = operation["responses"]+ assert isinstance(responses, dict)+ if "default" in responses:+ assert responses["default"] == ERROR_DEFAULT_RESPONSE, keydiff --git a/api/tests/unit_tests/controllers/openapi/test_contract.py b/api/tests/unit_tests/controllers/openapi/test_contract.pyindex 69263a5d929..bb0fa8a7386 100644--- a/api/tests/unit_tests/controllers/openapi/test_contract.py+++ b/api/tests/unit_tests/controllers/openapi/test_contract.py@@ -45,7 +45,7 @@ def _register_contract_test_models():def _guard_like(view):- """Stand-in for ``@auth_router.guard`` — an outermost @wraps layer."""+ """Stand-in for ``@subject_router.guard`` — an outermost @wraps layer."""@wraps(view)def wrapper(*args, **kwargs):@@ -54,32 +54,20 @@ def _guard_like(view):return wrapper-def test_accepts_injects_validated_query(app):+def test_accepts_injects_validated_query_with_defaults_for_absent_fields(app):@accepts(query=ContractQuery)def view(*, query):return query- with app.test_request_context("/?page=3&limit=5"):+ with app.test_request_context("/?page=3"):result = view()assert isinstance(result, ContractQuery)assert result.page == 3- assert result.limit == 5---def test_accepts_query_uses_defaults_when_absent(app):- @accepts(query=ContractQuery)- def view(*, query):- return query-- with app.test_request_context("/"):- result = view()-- assert result.page == 1assert result.limit == 20[email protected]("query_string", ["page=0", "limit=999", "page=abc", "unknown=1"])[email protected]("query_string", ["page=abc", "unknown=1"])def test_accepts_rejects_invalid_query_with_422(app, query_string):@accepts(query=ContractQuery)def view(*, query):@@ -124,16 +112,6 @@ def test_accepts_injects_validated_body(app):assert result.name == "x"-def test_accepts_rejects_invalid_body_with_422(app):- @accepts(body=ContractBody)- def view(*, body):- return body-- with app.test_request_context("/", method="POST", json={"wrong": 1}):- with pytest.raises(UnprocessableEntity):- view()--def test_returns_serializes_model_with_decorator_status(app):@returns(200, ContractResp)def view():@@ -146,16 +124,17 @@ def test_returns_serializes_model_with_decorator_status(app):assert body == {"value": 7}-def test_returns_serializes_model_in_tuple_and_honors_status(app):[email protected]("trailing", [(201,), (202, {"X-Test": "1"})], ids=["status", "status_and_headers"])+def test_returns_serializes_model_in_tuple_and_keeps_trailing_parts(app, trailing):@returns(200, ContractResp)def view():- return ContractResp(value=9), 201+ return ContractResp(value=9), *trailingwith app.test_request_context("/"):- body, status = view()+ body, *rest = view()- assert status == 201assert body == {"value": 9}+ assert tuple(rest) == trailingdef test_returns_passes_through_non_model(app):@@ -171,79 +150,17 @@ def test_returns_passes_through_non_model(app):assert result is sentinel-def test_returns_serializes_model_in_three_tuple_with_headers(app):- """A (model, status, headers) tuple keeps its trailing status/headers intact."""-- @returns(200, ContractResp)- def view():- return ContractResp(value=3), 202, {"X-Test": "1"}-- with app.test_request_context("/"):- body, status, headers = view()-- assert body == {"value": 3}- assert status == 202- assert headers == {"X-Test": "1"}--# Swagger metadata (read off __apidoc__) must survive @wraps up through the guard layer.def test_accepts_returns_emit_apidoc_through_guard_stack():@_guard_like@returns(200, ContractResp)- @accepts(query=ContractQuery)- def view(*, query):+ @accepts(query=ContractQuery, body=ContractBody)+ def view(*, query, body):return ContractResp(value=1)apidoc = getattr(view, "__apidoc__", {})assert "page" in apidoc.get("params", {}) # from @accepts(query=)+ assert apidoc.get("expect") # from @accepts(body=), via @openapi_ns.expectassert "200" in apidoc.get("responses", {}) # from @returns (flask_restx keys by str code)---def test_accepts_body_emits_expect_through_guard_stack():- @_guard_like- @accepts(body=ContractBody)- def view(*, body):- return body-- apidoc = getattr(view, "__apidoc__", {})- assert apidoc.get("expect") # body schema advertised via @openapi_ns.expect---def _response_model_name(entry) -> str:- """Extract the model name from a flask-restx __apidoc__ response entry.-- flask-restx stores responses as ``(description, model, kwargs)`` tuples- where ``model.name`` is the registered schema name.- """- if isinstance(entry, tuple) and len(entry) >= 2:- model = entry[1]- return getattr(model, "name", "") or ""- return ""---def test_accepts_documents_422_error_response(app):- from controllers.openapi._errors import ErrorBody-- @accepts(query=ContractQuery)- def view(*, query):- return query-- doc = getattr(view, "__apidoc__", {})- responses = doc.get("responses", {})- assert "422" in responses- assert _response_model_name(responses["422"]) == ErrorBody.__name__---def test_returns_documents_default_error_response(app):- from controllers.openapi._errors import ErrorBody-- @returns(200, ContractResp)- def view():- return ContractResp(value=1)-- doc = getattr(view, "__apidoc__", {})- responses = doc.get("responses", {})- assert "default" in responses- assert _response_model_name(responses["default"]) == ErrorBody.__name__diff --git a/api/tests/unit_tests/controllers/openapi/test_error_contract.py b/api/tests/unit_tests/controllers/openapi/test_error_contract.pyindex 6a30637b7ae..8d1cf8ddf04 100644--- a/api/tests/unit_tests/controllers/openapi/test_error_contract.py+++ b/api/tests/unit_tests/controllers/openapi/test_error_contract.py@@ -1,8 +1,11 @@"""Wire-contract tests for the canonical /openapi/v1 error body."""+import uuid+from types import SimpleNamespacefrom unittest.mock import MagicMock, patchimport pytest+from sqlalchemy.orm import Sessionfrom werkzeug.exceptions import (BadGateway,BadRequest,@@ -44,6 +47,8 @@ from controllers.service_api.app.error import (ProviderQuotaExceededError,)from controllers.web.error import InvokeRateLimitError as InvokeRateLimitHttpError+from libs.oauth_bearer import AuthContext, TokenType+from models.account import Account, AccountStatus@pytest.fixture@@ -82,22 +87,6 @@ class TestErrorBodyModel:class TestOpenApiErrorFormatter:- def test_plain_werkzeug_exception_maps_code_from_status(self, fmt):- e = NotFound("app not found")- data = {"code": "not_found", "message": "app not found", "status": 404}-- wire = fmt.finalize(e, data, 404)-- assert wire == {"code": "not_found", "message": "app not found", "status": 404}-- def test_422_maps_to_invalid_param(self, fmt):- e = UnprocessableEntity("workspace_id is required for name-based lookup")- data = {"code": "unprocessable_entity", "message": e.description, "status": 422}-- wire = fmt.finalize(e, data, 422)-- assert wire["code"] == "invalid_param"-def test_flask_restx_abort_data_path_yields_canonical_body(self, fmt):# Simulates _contract.py's abort(422, message=..., errors=...): flask_restx# attaches kwargs to e.data, which handle_error would otherwise put on the@@ -142,24 +131,6 @@ class TestOpenApiErrorFormatter:assert wire == {"code": "invalid_param", "message": "Unprocessable Entity", "status": 422}- def test_base_http_exception_error_code_wins_over_status_map(self, fmt):- e = ProviderQuotaExceededError()- data = dict(e.data)-- wire = fmt.finalize(e, data, 400)-- assert wire["code"] == "provider_quota_exceeded"- assert wire["status"] == 400-- def test_hint_attribute_is_emitted(self, fmt):- e = Conflict("seat limit")- e.hint = "remove a member first"- data = {"code": "conflict", "message": "seat limit", "status": 409}-- wire = fmt.finalize(e, data, 409)-- assert wire["hint"] == "remove a member first"-def test_params_shape_becomes_details(self, fmt):e = ValueError("is required")data = {"code": "invalid_param", "message": "is required", "params": "email", "status": 400}@@ -188,43 +159,25 @@ class TestOpenApiErrorFormatter:assert wire["code"] == "unknown"- def test_openapi_error_subclass_is_throw_and_done(self, fmt):+ @pytest.mark.parametrize("message", [None, "custom reason"], ids=["class_description", "call_site_override"])+ def test_openapi_error_subclass_is_throw_and_done(self, fmt, message):# The dedicated throwable: subclass declares status + code + message once,- # call sites just `raise`; the formatter emits everything verbatim.+ # call sites just `raise`, or pass a message to override the description;+ # the formatter emits everything verbatim.class TeapotError(OpenApiError):code = 418error_code = OpenApiErrorCode.INVALID_PARAMdescription = "kettle says no"- e = TeapotError(details=[ErrorDetail(type="invalid", loc=["kettle"], msg="too hot")])+ e = TeapotError(message, details=[ErrorDetail(type="invalid", loc=["kettle"], msg="too hot")])data = {"code": "im_a_teapot", "message": e.description, "status": 418}wire = fmt.finalize(e, data, 418)assert wire["code"] == OpenApiErrorCode.INVALID_PARAM- assert wire["message"] == TeapotError.description+ assert wire["message"] == (message or TeapotError.description)assert wire["details"] == [{"type": "invalid", "loc": ["kettle"], "msg": "too hot"}]- def test_openapi_error_message_override(self, fmt):- e = OpenApiError("custom reason")- data = {"code": "bad_request", "message": e.description, "status": 400}-- wire = fmt.finalize(e, data, 400)-- assert wire["message"] == "custom reason"- assert wire["code"] == "bad_request"-- def test_every_emitted_code_is_an_enum_member(self, fmt):- # Guard against the formatter inventing codes outside the contract.- cases = [- (NotFound("x"), {"code": "not_found", "message": "x", "status": 404}, 404),- (ProviderQuotaExceededError(), dict(ProviderQuotaExceededError().data), 400),- (ValueError("x"), {"code": "invalid_param", "message": "x", "status": 400}, 400),- ]- for e, data, status in cases:- wire = fmt.finalize(e, data, status)- assert wire["code"] in {c.value for c in OpenApiErrorCode}-class TestQuotaExceptions:@pytest.mark.parametrize("exc_class", [MemberLimitExceeded, MemberLicenseExceeded])@@ -244,12 +197,39 @@ class TestQuotaExceptions:class TestWireContract:"""End-to-end: request in, canonical JSON out, through the real openapi blueprint."""- def test_accepts_422_carries_code_status_details(self, openapi_app, bypass_pipeline):- client = openapi_app.test_client()+ def test_accepts_422_carries_code_status_details(+ self, openapi_app, sqlite_session: Session, monkeypatch: pytest.MonkeyPatch+ ):+ """`@endpoint` runs auth outermost, so reaching `@accepts` means passing+ it: one account row and a stubbed authenticator are the whole world+ `GET /account/sessions` needs.+ """+ account_id = uuid.uuid4()+ account = Account(name="caller", email="[email protected]", status=AccountStatus.ACTIVE)+ account.id = str(account_id)+ sqlite_session.add(account)+ sqlite_session.commit()++ token = AuthContext(+ subject_email="[email protected]",+ subject_issuer="dify:account",+ account_id=account_id,+ client_id="difyctl",+ token_id=uuid.uuid4(),+ token_type=TokenType.OAUTH_ACCOUNT,+ expires_at=None,+ )+ monkeypatch.setattr(+ "controllers.openapi.auth.router.get_authenticator",+ lambda: SimpleNamespace(authenticate=lambda _token: token),+ )+ monkeypatch.setattr("controllers.openapi.auth.pipelines._mount_flask_login", lambda _user: None)- resp = client.get("/openapi/v1/apps?page=0")+ resp = openapi_app.test_client().get(+ "/openapi/v1/account/sessions?page=0", headers={"Authorization": "Bearer dfoa_wire"}+ )- assert resp.status_code == 422+ assert resp.status_code == 422, resp.get_json()wire = resp.get_json()ErrorBody.model_validate(wire)assert wire["code"] == "invalid_param"diff --git a/api/tests/unit_tests/controllers/openapi/test_files.py b/api/tests/unit_tests/controllers/openapi/test_files.pyindex 2ced95bfea4..c950b35f2af 100644--- a/api/tests/unit_tests/controllers/openapi/test_files.py+++ b/api/tests/unit_tests/controllers/openapi/test_files.py@@ -1,4 +1,3 @@-from inspect import unwrapfrom io import BytesIOfrom types import SimpleNamespacefrom unittest.mock import Mock@@ -12,27 +11,14 @@ from controllers.common.errors import (FileTooLargeError,UnsupportedFileTypeError,)-from controllers.openapi.auth.data import AuthData, CallerKindfrom controllers.openapi.files import AppFileUploadApifrom libs.exception import BaseHTTPException-from libs.oauth_bearer import Scope, TokenTypefrom models import Accountfrom services.errors.file import BlockedFileExtensionError as ServiceBlockedFileExtensionErrorfrom services.errors.file import FileTooLargeError as ServiceFileTooLargeErrorfrom services.errors.file import UnsupportedFileTypeError as ServiceUnsupportedFileTypeError-def _auth_data(caller: Account) -> AuthData:- return AuthData.model_construct(- token_type=TokenType.OAUTH_ACCOUNT,- token_hash="test-token",- scopes=frozenset({Scope.APPS_RUN}),- app=object(),- caller=caller,- caller_kind=CallerKind.ACCOUNT,- )--def _caller() -> Account:caller = Account(name="Uploader", email="[email protected]")caller.id = "account-1"@@ -68,11 +54,8 @@ def test_upload_uses_injected_file_service(app: Flask, monkeypatch: pytest.Monkedata={"file": (BytesIO(b"hello"), "note.txt", "text/plain")},content_type="multipart/form-data",):- result = unwrap(AppFileUploadApi.post)(- AppFileUploadApi(),- app_id="app-1",- auth_data=_auth_data(caller),- )+ api = AppFileUploadApi()+ result = api.post.__handler__(api, SimpleNamespace(caller=caller), app_id="app-1")assert result.id == "00000000-0000-0000-0000-000000000001"service.upload_file.assert_called_once_with(@@ -121,12 +104,9 @@ def test_upload_preserves_specific_file_errors(data={"file": (BytesIO(b"hello"), "note.txt", "text/plain")},content_type="multipart/form-data",):+ api = AppFileUploadApi()with pytest.raises(controller_error) as error_info:- unwrap(AppFileUploadApi.post)(- AppFileUploadApi(),- app_id="app-1",- auth_data=_auth_data(_caller()),- )+ api.post.__handler__(api, SimpleNamespace(caller=_caller()), app_id="app-1")assert error_info.value.code == statusassert error_info.value.error_code == error_code@@ -145,12 +125,9 @@ def test_upload_maps_other_value_errors_to_bad_request(app: Flask, monkeypatch:data={"file": (BytesIO(b"hello"), "../note.txt", "text/plain")},content_type="multipart/form-data",):+ api = AppFileUploadApi()with pytest.raises(BadRequest) as error_info:- unwrap(AppFileUploadApi.post)(- AppFileUploadApi(),- app_id="app-1",- auth_data=_auth_data(_caller()),- )+ api.post.__handler__(api, SimpleNamespace(caller=_caller()), app_id="app-1")assert error_info.value.description == str(service_error)assert error_info.value.__cause__ is service_errordiff --git a/api/tests/unit_tests/controllers/openapi/test_flask_admission.py b/api/tests/unit_tests/controllers/openapi/test_flask_admission.pydeleted file mode 100644index fb18eea75ae..00000000000--- a/api/tests/unit_tests/controllers/openapi/test_flask_admission.py+++ /dev/null@@ -1,116 +0,0 @@-from __future__ import annotations--from collections.abc import Callable-from functools import wraps-from uuid import UUID--import pytest-from flask import Flask-from werkzeug.exceptions import Unauthorized--from controllers.openapi import flask_admission-from controllers.openapi.auth.data import AuthData-from enums import DeploymentEdition-from libs.oauth_bearer import Scope, TokenType-from libs.rate_limit import LIMIT_ME_PER_ACCOUNT-from machinery.context import AccountRequestContext-from models.account import Account, AccountStatus---def _auth_data(*, status: AccountStatus = AccountStatus.ACTIVE) -> AuthData:- account = Account(name="Ada", email="[email protected]", status=status)- account.id = "11111111-1111-1111-1111-111111111111"- return AuthData(- token_type=TokenType.OAUTH_ACCOUNT,- account_id=UUID(account.id),- token_hash="hash-1",- token_id=UUID("22222222-2222-2222-2222-222222222222"),- scopes=frozenset({Scope.FULL}),- caller=account,- )---def _install_fake_transport(- monkeypatch: pytest.MonkeyPatch,- auth_data: AuthData,- captured: dict[str, object],-) -> None:- def guard(**requirements: object) -> Callable[[Callable[..., object]], Callable[..., object]]:- captured.update(requirements)-- def decorator(view: Callable[..., object]) -> Callable[..., object]:- @wraps(view)- def admitted(*args: object, **kwargs: object) -> object:- return view(*args, auth_data=auth_data, **kwargs)-- return admitted-- return decorator-- monkeypatch.setattr(flask_admission.auth_router, "guard", guard)---def test_admission_builds_stable_request_context(- monkeypatch: pytest.MonkeyPatch,-) -> None:- captured: dict[str, object] = {}- limited: list[tuple[object, str]] = []- _install_fake_transport(monkeypatch, _auth_data(), captured)- monkeypatch.setattr(flask_admission, "get_request_id", lambda: "request-1")- monkeypatch.setattr(flask_admission, "get_trace_id", lambda: "trace-1")- monkeypatch.setattr(flask_admission, "enforce", lambda spec, *, key: limited.append((spec, key)))-- @flask_admission.openapi_account_admission(- scope=Scope.FULL,- editions=frozenset({DeploymentEdition.ENTERPRISE}),- rate_limit=LIMIT_ME_PER_ACCOUNT,- )- def view(_self: object, context: AccountRequestContext) -> AccountRequestContext:- return context-- with Flask(__name__).test_request_context("/openapi/v1/account"):- context = view(object())-- assert context == AccountRequestContext(- request_id="request-1",- trace_id="trace-1",- account_id="11111111-1111-1111-1111-111111111111",- access_token_id="22222222-2222-2222-2222-222222222222",- )- assert captured == {- "scope": Scope.FULL,- "allowed_token_types": frozenset({TokenType.OAUTH_ACCOUNT}),- "edition": frozenset({DeploymentEdition.ENTERPRISE}),- "require_valid_enterprise_license": True,- }- assert limited == [(LIMIT_ME_PER_ACCOUNT, "account:11111111-1111-1111-1111-111111111111")]---def test_admission_rejects_uninitialized_account(monkeypatch: pytest.MonkeyPatch) -> None:- _install_fake_transport(monkeypatch, _auth_data(status=AccountStatus.UNINITIALIZED), {})-- @flask_admission.openapi_account_admission(scope=Scope.FULL)- def view(_self: object, _context: AccountRequestContext) -> None:- raise AssertionError("view must not run")-- with Flask(__name__).test_request_context("/openapi/v1/account"):- with pytest.raises(Unauthorized, match="account not initialized"):- view(object())---def test_admission_rejects_missing_auth_data(monkeypatch: pytest.MonkeyPatch) -> None:- def guard(**_requirements: object) -> Callable[[Callable[..., object]], Callable[..., object]]:- def decorator(view: Callable[..., object]) -> Callable[..., object]:- return view-- return decorator-- monkeypatch.setattr(flask_admission.auth_router, "guard", guard)-- @flask_admission.openapi_account_admission(scope=Scope.FULL)- def view(_self: object, _context: AccountRequestContext) -> None:- raise AssertionError("view must not run")-- with Flask(__name__).test_request_context("/openapi/v1/account"):- with pytest.raises(RuntimeError, match="did not provide valid AuthData"):- view(object())diff --git a/api/tests/unit_tests/controllers/openapi/test_human_input_form.py b/api/tests/unit_tests/controllers/openapi/test_human_input_form.pyindex 97590ad6dfe..80bfae27870 100644--- a/api/tests/unit_tests/controllers/openapi/test_human_input_form.py+++ b/api/tests/unit_tests/controllers/openapi/test_human_input_form.py@@ -1,4 +1,12 @@-"""Tests for openapi human input form endpoints."""+"""Tests for openapi human input form endpoints.++Auth is not exercised here: `@endpoint` resolves the `Context` before the handler+runs, and the allow/deny answers live in `test_auth_matrix.py`. The recipient-surface+refusal is `CheckFormSurface`'s — a `Requirement` this feature owns rather than the+auth layer, so it is pinned here too. Body tests call `__handler__` — the one seam —+with a `Context` double. The submit route's 422 goes over the wire instead,+in the shared table in `test_workspaces_members.py`.+"""from __future__ import annotations@@ -7,34 +15,39 @@ import sysimport uuidfrom datetime import UTC, datetimefrom types import SimpleNamespace+from typing import castfrom unittest.mock import Mockimport pytestfrom flask import Flask-from werkzeug.exceptions import UnprocessableEntity+from controllers.common.human_input import HumanInputFormSubmitPayloadfrom controllers.openapi._errors import HumanInputFormNotFound, RecipientSurfaceMismatch-from controllers.openapi.auth.data import AuthData-from libs.oauth_bearer import Scope, TokenType+from controllers.openapi._models import FormSubmitResponse+from controllers.openapi.auth.context import Context+from controllers.openapi.auth.requirements import Rank+from controllers.openapi.auth.subjects import Subject+from controllers.openapi.human_input_form import (+ CheckFormSurface,+ OpenApiWorkflowHumanInputFormApi,+ OpenApiWorkflowHumanInputFormSubmitApi,+)from models.account import Account-from models.enums import EndUserType+from models.enums import CreatorUserRole, EndUserTypefrom models.human_input import RecipientTypefrom models.model import App, AppMode, EndUser--def _make_auth_data(app_model, caller, caller_kind):- return AuthData.model_construct(- token_type=TokenType.OAUTH_ACCOUNT,- account_id=uuid.uuid4(),- scopes=frozenset({Scope.FULL}),- app=app_model,- caller=caller,- caller_kind=caller_kind,- )+_MODULE = "controllers.openapi.human_input_form"-def _make_app() -> App:- return App(+def _context(caller: Account | EndUser, caller_role: CreatorUserRole) -> Context:+ """A store already filled the way the route's requirements would have filled it."""+ ctx = Context(+ cast(Subject, SimpleNamespace(caller_role=caller_role)),+ Mock(),+ {"app_id": "app-1", "form_token": "tok-1"},+ )+ ctx._app = App(id="app-1",tenant_id="tenant-1",name="Human input app",@@ -42,6 +55,27 @@ def _make_app() -> App:enable_site=True,enable_api=True,)+ ctx._caller = caller+ return ctx+++def _mock_service(monkeypatch: pytest.MonkeyPatch, form) -> Mock:+ """Bind a mocked `HumanInputService` (and the engine it is built from) into the module."""+ service_mock = Mock()+ service_mock.get_form_by_token.return_value = form+ module = sys.modules[_MODULE]+ monkeypatch.setattr(module, "HumanInputService", lambda _engine: service_mock)+ monkeypatch.setattr(module, "db", SimpleNamespace(engine=object()))+ return service_mock+++def _make_form(app_id: str = "app-1", recipient_type=RecipientType.STANDALONE_WEB_APP) -> SimpleNamespace:+ return SimpleNamespace(+ app_id=app_id,+ tenant_id="tenant-1",+ recipient_type=recipient_type,+ expiration_time=datetime(2099, 1, 1, tzinfo=UTC),+ )def _make_account(account_id: str = "acct-1") -> Account:@@ -61,9 +95,7 @@ def _make_end_user(end_user_id: str = "eu-1") -> EndUser:class TestOpenApiHumanInputFormGet:- def test_get_success(self, app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch):- from controllers.openapi.human_input_form import OpenApiWorkflowHumanInputFormApi-+ def test_get_success(self, app: Flask, monkeypatch: pytest.MonkeyPatch):definition = SimpleNamespace(model_dump=lambda: {"rendered_content": "Fill out the form",@@ -72,31 +104,17 @@ class TestOpenApiHumanInputFormGet:"user_actions": [{"id": "submit", "title": "Submit"}],})- form = SimpleNamespace(- app_id="app-1",- tenant_id="tenant-1",- recipient_type=RecipientType.STANDALONE_WEB_APP,- expiration_time=datetime(2099, 1, 1, tzinfo=UTC),- get_definition=lambda: definition,- )- service_mock = Mock()- service_mock.get_form_by_token.return_value = form- service_mock.ensure_form_active = Mock()-- module = sys.modules["controllers.openapi.human_input_form"]- monkeypatch.setattr(module, "HumanInputService", lambda _engine: service_mock)- monkeypatch.setattr(module, "db", SimpleNamespace(engine=object()))+ form = _make_form()+ form.get_definition = lambda: definition+ service_mock = _mock_service(monkeypatch, form)api = OpenApiWorkflowHumanInputFormApi()- app_model = _make_app()- caller = _make_account()-with app.test_request_context("/openapi/v1/apps/app-1/human-input-forms/tok-1"):- resp = api.get.__wrapped__(+ resp = api.get.__handler__(api,+ _context(_make_account(), CreatorUserRole.ACCOUNT),app_id="app-1",form_token="tok-1",- auth_data=_make_auth_data(app_model, caller, "account"),)payload = json.loads(resp.get_data(as_text=True))@@ -105,119 +123,49 @@ class TestOpenApiHumanInputFormGet:assert payload["user_actions"] == [{"id": "submit", "title": "Submit"}]service_mock.ensure_form_active.assert_called_once_with(form)- def test_get_form_not_found(self, app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch):- from controllers.openapi.human_input_form import OpenApiWorkflowHumanInputFormApi-- service_mock = Mock()- service_mock.get_form_by_token.return_value = None- module = sys.modules["controllers.openapi.human_input_form"]- monkeypatch.setattr(module, "HumanInputService", lambda _engine: service_mock)- monkeypatch.setattr(module, "db", SimpleNamespace(engine=object()))+ def test_get_form_not_found(self, app: Flask, monkeypatch: pytest.MonkeyPatch):+ _mock_service(monkeypatch, None)api = OpenApiWorkflowHumanInputFormApi()- app_model = _make_app()- caller = _make_account()-with app.test_request_context("/openapi/v1/apps/app-1/human-input-forms/bad"):with pytest.raises(HumanInputFormNotFound):- api.get.__wrapped__(+ api.get.__handler__(api,+ _context(_make_account(), CreatorUserRole.ACCOUNT),app_id="app-1",form_token="bad",- auth_data=_make_auth_data(app_model, caller, "account"),)- def test_get_form_wrong_app(self, app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch):- from controllers.openapi.human_input_form import OpenApiWorkflowHumanInputFormApi-- form = SimpleNamespace(- app_id="other-app",- tenant_id="tenant-1",- recipient_type=RecipientType.STANDALONE_WEB_APP,- expiration_time=datetime(2099, 1, 1, tzinfo=UTC),- )- service_mock = Mock()- service_mock.get_form_by_token.return_value = form- module = sys.modules["controllers.openapi.human_input_form"]- monkeypatch.setattr(module, "HumanInputService", lambda _engine: service_mock)- monkeypatch.setattr(module, "db", SimpleNamespace(engine=object()))+ def test_get_form_wrong_app(self, app: Flask, monkeypatch: pytest.MonkeyPatch):+ _mock_service(monkeypatch, _make_form(app_id="other-app"))api = OpenApiWorkflowHumanInputFormApi()- app_model = _make_app()- caller = _make_account()-with app.test_request_context("/openapi/v1/apps/app-1/human-input-forms/tok-1"):with pytest.raises(HumanInputFormNotFound):- api.get.__wrapped__(+ api.get.__handler__(api,+ _context(_make_account(), CreatorUserRole.ACCOUNT),app_id="app-1",form_token="tok-1",- auth_data=_make_auth_data(app_model, caller, "account"),- )-- def test_get_form_wrong_surface(self, app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch):- from controllers.openapi.human_input_form import OpenApiWorkflowHumanInputFormApi-- form = SimpleNamespace(- app_id="app-1",- tenant_id="tenant-1",- recipient_type=RecipientType.CONSOLE,- expiration_time=datetime(2099, 1, 1, tzinfo=UTC),- )- service_mock = Mock()- service_mock.get_form_by_token.return_value = form- module = sys.modules["controllers.openapi.human_input_form"]- monkeypatch.setattr(module, "HumanInputService", lambda _engine: service_mock)- monkeypatch.setattr(module, "db", SimpleNamespace(engine=object()))-- api = OpenApiWorkflowHumanInputFormApi()- app_model = _make_app()- caller = _make_account()-- with app.test_request_context("/openapi/v1/apps/app-1/human-input-forms/tok-1"):- with pytest.raises(RecipientSurfaceMismatch):- api.get.__wrapped__(- api,- app_id="app-1",- form_token="tok-1",- auth_data=_make_auth_data(app_model, caller, "account"),)class TestOpenApiHumanInputFormPost:- def _make_form(self, app_id="app-1", recipient_type=RecipientType.STANDALONE_WEB_APP):- return SimpleNamespace(- app_id=app_id,- tenant_id="tenant-1",- recipient_type=recipient_type,- expiration_time=datetime(2099, 1, 1, tzinfo=UTC),- )-- def test_post_account_caller_uses_user_id(self, app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch):- from controllers.openapi.human_input_form import OpenApiWorkflowHumanInputFormSubmitApi-- form = self._make_form()- service_mock = Mock()- service_mock.get_form_by_token.return_value = form-- module = sys.modules["controllers.openapi.human_input_form"]- monkeypatch.setattr(module, "HumanInputService", lambda _engine: service_mock)- monkeypatch.setattr(module, "db", SimpleNamespace(engine=object()))+ def test_post_account_caller_uses_user_id(self, app: Flask, monkeypatch: pytest.MonkeyPatch):+ service_mock = _mock_service(monkeypatch, _make_form())api = OpenApiWorkflowHumanInputFormSubmitApi()- app_model = _make_app()- caller = _make_account("acct-42")-with app.test_request_context("/openapi/v1/apps/app-1/human-input-forms/tok-1:submit",method="POST",json={"action": "approve", "inputs": {"field1": "val"}},):- result = api.post.__wrapped__(+ result = api.post.__handler__(api,+ _context(_make_account("acct-42"), CreatorUserRole.ACCOUNT),app_id="app-1",form_token="tok-1",- auth_data=_make_auth_data(app_model, caller, "account"),+ body=HumanInputFormSubmitPayload(action="approve", inputs={"field1": "val"}),)service_mock.submit_form_by_token.assert_called_once_with(@@ -228,33 +176,23 @@ class TestOpenApiHumanInputFormPost:submission_user_id="acct-42",submission_end_user_id=None,)- assert result == ({}, 200)-- def test_post_end_user_caller_uses_end_user_id(self, app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch):- from controllers.openapi.human_input_form import OpenApiWorkflowHumanInputFormSubmitApi-- form = self._make_form()- service_mock = Mock()- service_mock.get_form_by_token.return_value = form+ assert result == FormSubmitResponse()- module = sys.modules["controllers.openapi.human_input_form"]- monkeypatch.setattr(module, "HumanInputService", lambda _engine: service_mock)- monkeypatch.setattr(module, "db", SimpleNamespace(engine=object()))+ def test_post_end_user_caller_uses_end_user_id(self, app: Flask, monkeypatch: pytest.MonkeyPatch):+ service_mock = _mock_service(monkeypatch, _make_form())api = OpenApiWorkflowHumanInputFormSubmitApi()- app_model = _make_app()- caller = _make_end_user("eu-7")-with app.test_request_context("/openapi/v1/apps/app-1/human-input-forms/tok-1:submit",method="POST",json={"action": "approve", "inputs": {}},):- result = api.post.__wrapped__(+ result = api.post.__handler__(api,+ _context(_make_end_user("eu-7"), CreatorUserRole.END_USER),app_id="app-1",form_token="tok-1",- auth_data=_make_auth_data(app_model, caller, "end_user"),+ body=HumanInputFormSubmitPayload(action="approve", inputs={}),)service_mock.submit_form_by_token.assert_called_once_with(@@ -265,57 +203,48 @@ class TestOpenApiHumanInputFormPost:submission_user_id=None,submission_end_user_id="eu-7",)- assert result == ({}, 200)-- def test_post_standalone_web_app_recipient_submits(- self, app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch+ assert result == FormSubmitResponse()+++ "view",+ [OpenApiWorkflowHumanInputFormApi.get, OpenApiWorkflowHumanInputFormSubmitApi.post],+ ids=["get", "submit"],+)+def test_both_routes_declare_the_surface_check_last_at_the_default_rank(view):+ """The wiring, not the requirement's own logic: `CheckFormSurface` only runs+ on a route that declares it, and the allow/deny matrix has no console-recipient+ case, so removing either declaration changes no row there. It carries no rank+ of its own, so declaration order is what keeps it last.+ """+ assert isinstance(view.__spec__.requirements[-1], CheckFormSurface)+ assert CheckFormSurface.rank is Rank.NORMAL+++class TestCheckFormSurface:+ """The refusal itself. Declared last at both routes, so it answers before+ the handler body runs.+ """++ def _run(self, monkeypatch: pytest.MonkeyPatch, form) -> None:+ _mock_service(monkeypatch, form)+ ctx = _context(_make_account(), CreatorUserRole.ACCOUNT)+ CheckFormSurface().run(ctx.subject, ctx, Mock())++ def test_admits_a_web_app_recipient(self, monkeypatch: pytest.MonkeyPatch):+ self._run(monkeypatch, _make_form(recipient_type=RecipientType.STANDALONE_WEB_APP))++ @pytest.mark.parametrize("recipient_type", [RecipientType.CONSOLE, RecipientType.BACKSTAGE, None])+ def test_refuses_a_recipient_this_surface_may_not_act_on(self, monkeypatch: pytest.MonkeyPatch, recipient_type):+ with pytest.raises(RecipientSurfaceMismatch):+ self._run(monkeypatch, _make_form(recipient_type=recipient_type))++ @pytest.mark.parametrize("form", [None, "foreign"])+ def test_leaves_a_form_the_caller_could_not_have_found_to_the_handlers_404(+ self, monkeypatch: pytest.MonkeyPatch, form):- from controllers.openapi.human_input_form import OpenApiWorkflowHumanInputFormSubmitApi-- form = self._make_form(recipient_type=RecipientType.STANDALONE_WEB_APP)- service_mock = Mock()- service_mock.get_form_by_token.return_value = form-- module = sys.modules["controllers.openapi.human_input_form"]- monkeypatch.setattr(module, "HumanInputService", lambda _engine: service_mock)- monkeypatch.setattr(module, "db", SimpleNamespace(engine=object()))-- api = OpenApiWorkflowHumanInputFormSubmitApi()- app_model = _make_app()- caller = _make_end_user("anyone")-- with app.test_request_context(- "/openapi/v1/apps/app-1/human-input-forms/tok-1:submit",- method="POST",- json={"action": "approve", "inputs": {}},- ):- result = api.post.__wrapped__(- api,- app_id="app-1",- form_token="tok-1",- auth_data=_make_auth_data(app_model, caller, "end_user"),- )-- service_mock.submit_form_by_token.assert_called_once()- assert result == ({}, 200)-- def test_post_rejects_invalid_body_with_422(self, app: Flask, bypass_pipeline):- """Malformed body → 422 via @accepts (was an unmapped pydantic error → 500)."""- from controllers.openapi.human_input_form import OpenApiWorkflowHumanInputFormSubmitApi-- api = OpenApiWorkflowHumanInputFormSubmitApi()- app_model = _make_app()- caller = _make_account("acct-42")-- with app.test_request_context(- "/openapi/v1/apps/app-1/human-input-forms/tok-1:submit",- method="POST",- json={"inputs": {"field1": "val"}}, # missing required "action"- ):- with pytest.raises(UnprocessableEntity):- api.post.__wrapped__(- api,- app_id="app-1",- form_token="tok-1",- auth_data=_make_auth_data(app_model, caller, "account"),- )+ """Answering 403 on a console-bound form in another app would confirm the+ token exists; the handler's own 404 owns both cases.+ """+ foreign = _make_form(app_id=str(uuid.uuid4()), recipient_type=RecipientType.CONSOLE)+ self._run(monkeypatch, foreign if form == "foreign" else None)diff --git a/api/tests/unit_tests/controllers/openapi/test_models.py b/api/tests/unit_tests/controllers/openapi/test_models.pyindex d29b592f6ab..9dd7e5b69fc 100644--- a/api/tests/unit_tests/controllers/openapi/test_models.py+++ b/api/tests/unit_tests/controllers/openapi/test_models.py@@ -1,31 +1,6 @@-from controllers.openapi._models import MessageMetadata, UsageInfo---def test_usage_info_defaults_zero():- u = UsageInfo()- assert u.prompt_tokens == 0- assert u.completion_tokens == 0- assert u.total_tokens == 0---def test_message_metadata_accepts_partial():- m = MessageMetadata(usage=UsageInfo(total_tokens=10))- assert m.usage.total_tokens == 10- assert m.retriever_resources == []+from controllers.openapi._models import AppDescribeResponsedef test_describe_response_all_blocks_optional() -> None:- from controllers.openapi._models import AppDescribeResponse-payload = AppDescribeResponse().model_dump(mode="json", exclude_none=False)assert payload == {"info": None, "parameters": None, "input_schema": None}---def test_describe_response_input_schema_field() -> None:- from controllers.openapi._models import AppDescribeResponse-- schema = {"$schema": "https://json-schema.org/draft/2020-12/schema", "type": "object"}- payload = AppDescribeResponse(input_schema=schema).model_dump(mode="json", exclude_none=False)- assert payload["input_schema"] == schema- assert payload["info"] is None- assert payload["parameters"] is Nonediff --git a/api/tests/unit_tests/controllers/openapi/test_workflow_events_openapi.py b/api/tests/unit_tests/controllers/openapi/test_workflow_events_openapi.pyindex 7f906826403..28039508b9d 100644--- a/api/tests/unit_tests/controllers/openapi/test_workflow_events_openapi.py+++ b/api/tests/unit_tests/controllers/openapi/test_workflow_events_openapi.py@@ -2,39 +2,56 @@The controller constructs a repository session factory, so every case bindsthat real SQLAlchemy factory to an isolated SQLite engine. Repository behavior-remains mocked because these tests focus on authorization and SSE responses.+remains mocked because these tests focus on run ownership and SSE responses.++Auth is not exercised here: `@endpoint` resolves the `Context` before the handler+runs, and the allow/deny answers live in `test_auth_matrix.py`."""from __future__ import annotationsimport sys-import uuidfrom types import SimpleNamespacefrom unittest.mock import Mockimport pytestfrom flask import Flask-from sqlalchemy.engine import Engine-from sqlalchemy.orm import sessionmakerfrom werkzeug.exceptions import NotFound-from controllers.openapi.auth.data import AuthData+from controllers.openapi.workflow_events import OpenApiWorkflowEventsApi+from core.db.session_factory import session_factoryfrom graphon.enums import WorkflowExecutionStatus-from libs.oauth_bearer import Scope, TokenTypefrom models.account import Accountfrom models.enums import CreatorUserRole, EndUserType, WorkflowRunTriggeredFromfrom models.model import App, AppMode, EndUserfrom models.workflow import WorkflowRun, WorkflowType-def _make_auth_data(app_model, caller, caller_kind):- return AuthData.model_construct(- token_type=TokenType.OAUTH_ACCOUNT,- account_id=uuid.uuid4(),- scopes=frozenset({Scope.FULL}),- app=app_model,+class _SealableContext:+ """A `Context` stand-in that refuses reads once `seal()` is called.++ The router's session closes when the handler returns, so anything the SSE+ body still needs off `ctx` would be read through a closed session.+ """++ def __init__(self, **values: object) -> None:+ self._values = values+ self._sealed = False++ def seal(self) -> None:+ self._sealed = True++ def __getattr__(self, name: str) -> object:+ if self._sealed:+ raise AssertionError(f"ctx.{name} was read after the handler returned")+ return self._values[name]+++def _context(caller: Account | EndUser, caller_role: CreatorUserRole) -> _SealableContext:+ return _SealableContext(+ app=_make_app(),caller=caller,- caller_kind=caller_kind,+ subject=SimpleNamespace(caller_role=caller_role),)@@ -91,177 +108,95 @@ def _make_end_user() -> EndUser:class TestOpenApiWorkflowEventsApi:- @pytest.fixture(autouse=True)- def _bind_sqlite_engine(self, monkeypatch: pytest.MonkeyPatch, sqlite_engine: Engine) -> None:- module = sys.modules["controllers.openapi.workflow_events"]- monkeypatch.setattr(module, "db", SimpleNamespace(engine=sqlite_engine))-- def _get_api(self):- from controllers.openapi.workflow_events import OpenApiWorkflowEventsApi-- return OpenApiWorkflowEventsApi()-- def test_not_found_when_run_missing(self, app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch):+ def _bind_repo(self, monkeypatch: pytest.MonkeyPatch, workflow_run: WorkflowRun | None) -> Mock:module = sys.modules["controllers.openapi.workflow_events"]repo_mock = Mock()- repo_mock.get_workflow_run_by_id_and_tenant_id.return_value = None+ repo_mock.get_workflow_run_by_id_and_tenant_id.return_value = workflow_runfactory_mock = Mock()factory_mock.create_api_workflow_run_repository.return_value = repo_mockmonkeypatch.setattr(module, "DifyAPIRepositoryFactory", factory_mock)+ return factory_mock- api = self._get_api()+ def _bind_generators(self, monkeypatch: pytest.MonkeyPatch) -> None:+ module = sys.modules["controllers.openapi.workflow_events"]+ generator_mock = Mock()+ generator_mock.convert_to_event_stream.return_value = iter([])+ monkeypatch.setattr(module, "WorkflowAppGenerator", lambda: generator_mock)+ msg_gen_mock = Mock()+ msg_gen_mock.retrieve_events.return_value = iter([])+ monkeypatch.setattr(module, "MessageGenerator", lambda: msg_gen_mock)- app_model = _make_app()- caller = _make_account()+ def test_not_found_when_run_missing(self, app: Flask, monkeypatch: pytest.MonkeyPatch):+ factory_mock = self._bind_repo(monkeypatch, None)+ api = OpenApiWorkflowEventsApi()with app.test_request_context("/openapi/v1/apps/app-1/tasks/wf-run-1/events"):with pytest.raises(NotFound):- api.get.__wrapped__(+ api.get.__handler__(api,+ _context(_make_account(), CreatorUserRole.ACCOUNT),app_id="app-1",task_id="wf-run-1",- auth_data=_make_auth_data(app_model, caller, "account"),)+ # The stream outlives the guard's session, so the repository gets the guard's+ # own maker rather than a fresh one bound straight to the engine.session_maker = factory_mock.create_api_workflow_run_repository.call_args.args[0]- assert isinstance(session_maker, sessionmaker)- assert session_maker.kw["bind"] is module.db.engine-- def test_not_found_when_run_belongs_to_different_app(- self, app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch- ):- module = sys.modules["controllers.openapi.workflow_events"]- run = _make_workflow_run(app_id="other-app")- repo_mock = Mock()- repo_mock.get_workflow_run_by_id_and_tenant_id.return_value = run- factory_mock = Mock()- factory_mock.create_api_workflow_run_repository.return_value = repo_mock- monkeypatch.setattr(module, "DifyAPIRepositoryFactory", factory_mock)-- api = self._get_api()+ assert session_maker is session_factory.get_session_maker()- app_model = _make_app()- caller = _make_account()+ def test_not_found_when_run_belongs_to_different_app(self, app: Flask, monkeypatch: pytest.MonkeyPatch):+ self._bind_repo(monkeypatch, _make_workflow_run(app_id="other-app"))+ api = OpenApiWorkflowEventsApi()with app.test_request_context("/openapi/v1/apps/app-1/tasks/wf-run-1/events"):with pytest.raises(NotFound):- api.get.__wrapped__(+ api.get.__handler__(api,+ _context(_make_account(), CreatorUserRole.ACCOUNT),app_id="app-1",task_id="wf-run-1",- auth_data=_make_auth_data(app_model, caller, "account"),)- def test_account_caller_checks_created_by_account(- self, app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch- ):- """Account caller must match created_by == caller.id and role == ACCOUNT."""- module = sys.modules["controllers.openapi.workflow_events"]- run = _make_workflow_run(created_by_role=CreatorUserRole.ACCOUNT, created_by="acct-1")- repo_mock = Mock()- repo_mock.get_workflow_run_by_id_and_tenant_id.return_value = run- factory_mock = Mock()- factory_mock.create_api_workflow_run_repository.return_value = repo_mock- monkeypatch.setattr(module, "DifyAPIRepositoryFactory", factory_mock)-- snapshot_builder = Mock(return_value=iter([]))- monkeypatch.setattr(module, "build_workflow_event_stream", snapshot_builder)-- generator_mock = Mock()- generator_mock.convert_to_event_stream.return_value = iter([])- monkeypatch.setattr(module, "WorkflowAppGenerator", lambda: generator_mock)-- msg_gen_mock = Mock()- msg_gen_mock.retrieve_events.return_value = iter([])- monkeypatch.setattr(module, "MessageGenerator", lambda: msg_gen_mock)-- app_model = _make_app()- caller = _make_account()-- api = self._get_api()- with app.test_request_context("/openapi/v1/apps/app-1/tasks/wf-run-1/events"):- # Should not raise NotFound for matching caller- resp = api.get.__wrapped__(- api,- app_id="app-1",- task_id="wf-run-1",- auth_data=_make_auth_data(app_model, caller, "account"),- )- assert resp.mimetype == "text/event-stream"-- def test_account_caller_rejected_for_end_user_run(- self, app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch- ):- module = sys.modules["controllers.openapi.workflow_events"]- run = _make_workflow_run(created_by_role=CreatorUserRole.END_USER, created_by="eu-1")- repo_mock = Mock()- repo_mock.get_workflow_run_by_id_and_tenant_id.return_value = run- factory_mock = Mock()- factory_mock.create_api_workflow_run_repository.return_value = repo_mock- monkeypatch.setattr(module, "DifyAPIRepositoryFactory", factory_mock)-- app_model = _make_app()- caller = _make_account()+ def test_account_caller_rejected_for_end_user_run(self, app: Flask, monkeypatch: pytest.MonkeyPatch):+ self._bind_repo(monkeypatch, _make_workflow_run(created_by_role=CreatorUserRole.END_USER, created_by="eu-1"))- api = self._get_api()+ api = OpenApiWorkflowEventsApi()with app.test_request_context("/openapi/v1/apps/app-1/tasks/wf-run-1/events"):with pytest.raises(NotFound):- api.get.__wrapped__(+ api.get.__handler__(api,+ _context(_make_account(), CreatorUserRole.ACCOUNT),app_id="app-1",task_id="wf-run-1",- auth_data=_make_auth_data(app_model, caller, "account"),)- def test_end_user_caller_checks_created_by_end_user(- self, app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch- ):+ def test_end_user_caller_checks_created_by_end_user(self, app: Flask, monkeypatch: pytest.MonkeyPatch):"""End-user caller must match created_by == caller.id and role == END_USER."""- module = sys.modules["controllers.openapi.workflow_events"]- run = _make_workflow_run(created_by_role=CreatorUserRole.END_USER, created_by="eu-1")- repo_mock = Mock()- repo_mock.get_workflow_run_by_id_and_tenant_id.return_value = run- factory_mock = Mock()- factory_mock.create_api_workflow_run_repository.return_value = repo_mock- monkeypatch.setattr(module, "DifyAPIRepositoryFactory", factory_mock)-- msg_gen_mock = Mock()- msg_gen_mock.retrieve_events.return_value = iter([])- monkeypatch.setattr(module, "MessageGenerator", lambda: msg_gen_mock)-- generator_mock = Mock()- generator_mock.convert_to_event_stream.return_value = iter([])- monkeypatch.setattr(module, "WorkflowAppGenerator", lambda: generator_mock)-- app_model = _make_app()- caller = _make_end_user()+ self._bind_repo(monkeypatch, _make_workflow_run(created_by_role=CreatorUserRole.END_USER, created_by="eu-1"))+ self._bind_generators(monkeypatch)- api = self._get_api()+ api = OpenApiWorkflowEventsApi()with app.test_request_context("/openapi/v1/apps/app-1/tasks/wf-run-1/events"):- resp = api.get.__wrapped__(+ resp = api.get.__handler__(api,+ _context(_make_end_user(), CreatorUserRole.END_USER),app_id="app-1",task_id="wf-run-1",- auth_data=_make_auth_data(app_model, caller, "end_user"),)assert resp.mimetype == "text/event-stream"- def test_finished_run_returns_single_sse_event(self, app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch):- """A finished run returns a single done-event SSE response without streaming."""+ def _bind_finished_run(self, monkeypatch: pytest.MonkeyPatch) -> None:from datetime import UTC, datetimemodule = sys.modules["controllers.openapi.workflow_events"]- finished_at = datetime(2024, 1, 1, tzinfo=UTC)- run = _make_workflow_run(- created_by_role=CreatorUserRole.ACCOUNT,- created_by="acct-1",- finished_at=finished_at,+ self._bind_repo(+ monkeypatch,+ _make_workflow_run(+ created_by_role=CreatorUserRole.ACCOUNT,+ created_by="acct-1",+ finished_at=datetime(2024, 1, 1, tzinfo=UTC),+ ),)- repo_mock = Mock()- repo_mock.get_workflow_run_by_id_and_tenant_id.return_value = run- factory_mock = Mock()- factory_mock.create_api_workflow_run_repository.return_value = repo_mock- monkeypatch.setattr(module, "DifyAPIRepositoryFactory", factory_mock)finish_response = SimpleNamespace(event=SimpleNamespace(value="workflow_finished"),@@ -271,18 +206,54 @@ class TestOpenApiWorkflowEventsApi:converter_mock.workflow_run_result_to_finish_response.return_value = finish_responsemonkeypatch.setattr(module, "WorkflowResponseConverter", converter_mock)- app_model = _make_app()- caller = _make_account()-- api = self._get_api()+ def test_finished_run_reads_everything_off_the_context_before_streaming(+ self, app: Flask, monkeypatch: pytest.MonkeyPatch+ ):+ """A finished run answers a single done event without streaming. Its body+ is a real generator, so it runs entirely after the handler has returned+ and the router's session is gone.+ """+ self._bind_finished_run(monkeypatch)++ ctx = _context(_make_account(), CreatorUserRole.ACCOUNT)+ api = OpenApiWorkflowEventsApi()with app.test_request_context("/openapi/v1/apps/app-1/tasks/wf-run-1/events"):- resp = api.get.__wrapped__(- api,- app_id="app-1",- task_id="wf-run-1",- auth_data=_make_auth_data(app_model, caller, "account"),- )+ resp = api.get.__handler__(api, ctx, app_id="app-1", task_id="wf-run-1")+ ctx.seal()+ body = "".join(resp.response)++ assert resp.mimetype == "text/event-stream"+ assert "workflow_finished" in body++ @pytest.mark.parametrize("include_state_snapshot", [False, True], ids=["events", "snapshot"])+ def test_stream_reads_everything_off_the_context_before_streaming(+ self, app: Flask, monkeypatch: pytest.MonkeyPatch, include_state_snapshot: bool+ ):+ """Both stream shapes must be fully resolved before the handler returns,+ and an account caller whose id and role match `created_by` is admitted.++ The snapshot branch is the one that used to read `app_model.tenant_id` and+ `app_model.id` from inside the generator, which the router's closed session+ can no longer answer.+ """+ module = sys.modules["controllers.openapi.workflow_events"]+ self._bind_repo(monkeypatch, _make_workflow_run(created_by_role=CreatorUserRole.ACCOUNT, created_by="acct-1"))++ generator_mock = Mock()+ generator_mock.convert_to_event_stream.return_value = iter(["event: a\n\n", "event: b\n\n"])+ monkeypatch.setattr(module, "WorkflowAppGenerator", lambda: generator_mock)+ msg_gen_mock = Mock()+ msg_gen_mock.retrieve_events.return_value = iter([])+ monkeypatch.setattr(module, "MessageGenerator", lambda: msg_gen_mock)+ monkeypatch.setattr(module, "build_workflow_event_stream", Mock(return_value=iter([])))++ ctx = _context(_make_account(), CreatorUserRole.ACCOUNT)+ api = OpenApiWorkflowEventsApi()+ query = "?include_state_snapshot=true" if include_state_snapshot else ""+ with app.test_request_context(f"/openapi/v1/apps/app-1/tasks/wf-run-1/events{query}"):+ resp = api.get.__handler__(api, ctx, app_id="app-1", task_id="wf-run-1")+ ctx.seal()+ body = "".join(resp.response)+assert resp.mimetype == "text/event-stream"- chunks = list(resp.response)- data = b"".join(c if isinstance(c, bytes) else c.encode() for c in chunks).decode()- assert "workflow_finished" in data+ assert body == "event: a\n\nevent: b\n\n"diff --git a/api/tests/unit_tests/controllers/openapi/test_workspaces.py b/api/tests/unit_tests/controllers/openapi/test_workspaces.pydeleted file mode 100644index 9cdc13a395a..00000000000--- a/api/tests/unit_tests/controllers/openapi/test_workspaces.py+++ /dev/null@@ -1,58 +0,0 @@-"""Phase E step 17: workspace reads at /openapi/v1/workspaces. Bearer-authed-list + member-gated detail. No legacy /v1/ equivalent — the cookie-authed-/console/api/workspaces is a separate consumer that stays in console.-"""--import builtins--import pytest-from flask import Flask-from flask.views import MethodView--from controllers.openapi import bp as openapi_bp-from controllers.openapi.workspaces import WorkspaceByIdApi, WorkspacesApi--if not hasattr(builtins, "MethodView"):- builtins.MethodView = MethodView # type: ignore[attr-defined]---def openapi_app() -> Flask:- app = Flask(__name__)- app.config["TESTING"] = True- app.register_blueprint(openapi_bp)- return app---def _rule(app: Flask, path: str):- return next(r for r in app.url_map.iter_rules() if r.rule == path)---def test_workspaces_list_route_registered(openapi_app: Flask):- rules = {r.rule for r in openapi_app.url_map.iter_rules()}- assert "/openapi/v1/workspaces" in rules---def test_workspaces_list_dispatches_to_workspaces_api(openapi_app: Flask):- rule = _rule(openapi_app, "/openapi/v1/workspaces")- assert openapi_app.view_functions[rule.endpoint].view_class is WorkspacesApi- assert "GET" in rule.methods---def test_workspace_by_id_route_registered(openapi_app: Flask):- rules = {r.rule for r in openapi_app.url_map.iter_rules()}- assert "/openapi/v1/workspaces/<string:workspace_id>" in rules---def test_workspace_by_id_dispatches_to_correct_class(openapi_app: Flask):- rule = _rule(openapi_app, "/openapi/v1/workspaces/<string:workspace_id>")- assert openapi_app.view_functions[rule.endpoint].view_class is WorkspaceByIdApi- assert "GET" in rule.methods---def test_console_legacy_workspaces_route_not_remounted_on_openapi(openapi_app: Flask):- """Phase E only adds the bearer-authed mounts on /openapi/v1/.- The cookie-authed /console/api/workspaces stays where it is.- """- rules = {r.rule for r in openapi_app.url_map.iter_rules()}- assert "/console/api/workspaces" not in rulesdiff --git a/api/tests/unit_tests/controllers/openapi/test_workspaces_members.py b/api/tests/unit_tests/controllers/openapi/test_workspaces_members.pyindex 9b998edff57..c13b7b2e0aa 100644--- a/api/tests/unit_tests/controllers/openapi/test_workspaces_members.py+++ b/api/tests/unit_tests/controllers/openapi/test_workspaces_members.py@@ -1,51 +1,57 @@"""Member endpoints under /openapi/v1/workspaces/<id>/...Coverage:-- Route registration (5 endpoints across 3 URL patterns)-- Body validation lands at 400 (per spec — not Pydantic's default 422)+- Payload validation lands at 422 on the wire (unified via @accepts) — one+ table for every `@accepts` route with a body or query model, the human-input+ submit route included, since all of them share `admitted_bearer`- Domain exception → HTTP code mapping is preserved with the service'soriginal message (so CLI users see what the console user sees)- Response shape matches the Pydantic models--Auth-pipeline plumbing is bypassed via the `bypass_pipeline` fixture from-conftest.py; the bearer identity is seeded into the openapi auth ContextVar-via `_seed`. Tests that exercise-endpoint *bodies* skip the single `guard_workspace` decorator via-``__wrapped__`` — membership and role enforcement live in the auth pipeline-and are covered in `auth/test_prepare.py` and `auth/test_verify.py`.+- The invite route actually commits its unit of work++Auth is not exercised here: `@endpoint` resolves the `Context` before the+handler runs, and the allow/deny answers live in `test_auth_matrix.py`. Body+tests call `__handler__` — the one seam — with a real `Context` over the test+database. The 422 tests cannot use it, because `@accepts` sits inside the guard+and `__handler__` is below it; they go over the wire through `admitted_bearer`+instead, and assert the canonical `ErrorBody` a client actually receives."""from __future__ import annotationsimport builtins-import jsonimport uuidfrom datetime import UTC, datetime+from http import HTTPMethodfrom types import SimpleNamespacefrom unittest.mock import Mockimport pytestfrom flask import Flaskfrom flask.views import MethodView-from pydantic import ValidationError+from pydantic import BaseModel, ValidationErrorfrom sqlalchemy import select-from sqlalchemy.orm import Session-from werkzeug.exceptions import BadRequest, NotFound, UnprocessableEntity+from sqlalchemy.orm import Session, sessionmaker+from werkzeug.exceptions import BadRequest, NotFound+from werkzeug.test import TestResponsefrom controllers.openapi import bp as openapi_bpfrom controllers.openapi import workspaces as workspaces_module-from controllers.openapi._errors import MemberLicenseExceeded, MemberLimitExceeded-from controllers.openapi._models import MemberInvitePayload, MemberRoleUpdatePayload-from controllers.openapi.auth.data import AuthData-from controllers.openapi.workspaces import (- WorkspaceMemberApi,- WorkspaceMembersApi,- WorkspaceSwitchApi,+from controllers.openapi._errors import (+ ErrorBody,+ MemberLicenseExceeded,+ MemberLimitExceeded,+ OpenApiErrorCode,)+from controllers.openapi._models import MemberInvitePayload, MemberListQuery, MemberRoleUpdatePayload+from controllers.openapi.auth.context import Context+from controllers.openapi.auth.loaders import load_caller, load_workspace+from controllers.openapi.auth.subjects import AccountSubject+from controllers.openapi.workspaces import WorkspaceMemberApi, WorkspaceMembersApi, WorkspaceSwitchApifrom enums import DeploymentEdition-from libs.oauth_bearer import AuthContext, Scope, SubjectType, TokenType, reset_auth_ctx, set_auth_ctx+from libs.oauth_bearer import AuthContext, TokenTypefrom models import Account, Tenant, TenantAccountJoin-from models.account import TenantAccountRole, TenantStatus+from models.account import TenantAccountRolefrom services.account_service import TenantService as RealTenantServicefrom services.errors.account import (AccountAlreadyInTenantError,@@ -57,6 +63,7 @@ from services.errors.account import (RoleAlreadyAssignedError,)from tests.unit_tests.config_override import config_overrides_context+from tests.unit_tests.controllers.openapi.conftest import AdmittedWorldfrom tests.unit_tests.model_factories import make_account, make_tenantif not hasattr(builtins, "MethodView"):@@ -67,23 +74,6 @@ if not hasattr(builtins, "MethodView"):# Fixtures# ----------------------------------------------------------------------------# Tokens from `_seed`'s `set_auth_ctx` calls, drained after each test so a-# published identity can't leak into the next (the ContextVar is module-global-# and worker threads are reused). Seed via `_seed(...)`, never `flask.g` —-# production fills the ContextVar, nothing fills `g.auth_ctx`.-_seed_tokens: list = []---def _seed(ctx: AuthContext) -> None:- _seed_tokens.append(set_auth_ctx(ctx))--[email protected](autouse=True)-def _reset_auth_ctx():- yield- while _seed_tokens:- reset_auth_ctx(_seed_tokens.pop())-@pytest.fixturedef openapi_app() -> Flask:@@ -98,41 +88,35 @@ def database_session(sqlite_session: Session):return sqlite_session-def _rule(app: Flask, path: str):- return next(r for r in app.url_map.iter_rules() if r.rule == path)--def _auth_ctx(account_id: uuid.UUID | None = None) -> AuthContext:return AuthContext(- subject_type=SubjectType.ACCOUNT,subject_email="[email protected]",subject_issuer="dify:account",account_id=account_id or uuid.uuid4(),client_id="difyctl",- scopes=frozenset({Scope.FULL}),token_id=uuid.uuid4(),token_type=TokenType.OAUTH_ACCOUNT,expires_at=datetime.now(UTC),)-def _auth_data(account_id: uuid.UUID) -> AuthData:- from controllers.openapi.auth.data import AuthData- from libs.oauth_bearer import Scope, TokenType-- return AuthData(- token_type=TokenType.OAUTH_ACCOUNT,- account_id=account_id,- scopes=frozenset({Scope.FULL}),- )+def _context(session: Session, account_id: uuid.UUID, workspace_id: str) -> Context:+ """The context a handler is given *after* the pipeline ran: the caller's+ subject, the request's session and its path params, plus the workspace and+ caller these routes' requirements load off the same rows.+ """+ ctx = Context(AccountSubject(_auth_ctx(account_id)), session, {"workspace_id": workspace_id})+ load_workspace(ctx)+ load_caller(ctx)+ return ctxdef _account(account_id: str = "acct-1", email: str = "[email protected]") -> Account:return make_account(account_id=account_id, name="User", email=email)-def _tenant(tenant_id: str = "ws-1", *, status: TenantStatus = TenantStatus.NORMAL) -> Tenant:- tenant = make_tenant(tenant_id=tenant_id, name="WS", status=status)+def _tenant(tenant_id: str = "ws-1") -> Tenant:+ tenant = make_tenant(tenant_id=tenant_id, name="WS")tenant.created_at = datetime(2026, 5, 18)return tenant@@ -141,10 +125,8 @@ def _persist_workspace(session: Session,workspace_id: str,memberships: list[tuple[str, str, TenantAccountRole, bool]],- *,- status: TenantStatus = TenantStatus.NORMAL,) -> tuple[Tenant, list[Account]]:- tenant = _tenant(workspace_id, status=status)+ tenant = _tenant(workspace_id)accounts: list[Account] = []session.add(tenant)for account_id, email, role, current in memberships:@@ -161,6 +143,15 @@ def _persist_workspace(return tenant, accounts+def _persist_caller(session: Session, account_id: uuid.UUID) -> None:+ """These routes all declare `CheckWorkspaceMember`, which resolves the+ caller, so a handler reached through `__handler__` needs the caller's row+ even when its own body only reads the workspace.+ """+ session.add(_account(account_id=str(account_id), email="[email protected]"))+ session.commit()++def _tenant_service(**overrides) -> SimpleNamespace:"""Retain domain mutator doubles while delegating reads to the real service."""methods: dict = {@@ -176,92 +167,73 @@ def _tenant_service(**overrides) -> SimpleNamespace:# ----------------------------------------------------------------------------# Route registration+# Payload validation lands at 422 on the wire (unified via @accepts)# ----------------------------------------------------------------------------def test_switch_route_registered(openapi_app: Flask):- rule = _rule(openapi_app, "/openapi/v1/workspaces/<string:workspace_id>:switch")- assert openapi_app.view_functions[rule.endpoint].view_class is WorkspaceSwitchApi- assert "POST" in rule.methods-+def _assert_validation_422(resp: TestResponse) -> None:+ """The wire contract for a rejected payload: 422 carrying the canonical body."""+ assert resp.status_code == 422, resp.get_json()+ wire = resp.get_json()+ ErrorBody.model_validate(wire)+ assert wire["code"] == OpenApiErrorCode.INVALID_PARAM+ assert wire["details"]-def test_members_route_registered(openapi_app: Flask):- rule = _rule(openapi_app, "/openapi/v1/workspaces/<string:workspace_id>/members")- assert openapi_app.view_functions[rule.endpoint].view_class is WorkspaceMembersApi- assert "GET" in rule.methods- assert "POST" in rule.methods--def test_member_by_id_route_registered(openapi_app: Flask):- rule = _rule(openapi_app, "/openapi/v1/workspaces/<string:workspace_id>/members/<string:member_id>")- assert openapi_app.view_functions[rule.endpoint].view_class is WorkspaceMemberApi- assert "DELETE" in rule.methods- assert "PATCH" in rule.methods---# ----------------------------------------------------------------------------# Payload validation lands at 422 (unified via @accepts)-# ------------------------------------------------------------------------------def test_invite_payload_rejects_unknown_role():- with pytest.raises(ValidationError):- MemberInvitePayload.model_validate({"email": "[email protected]", "role": "owner"})---def test_invite_payload_rejects_bad_email():- with pytest.raises(ValidationError):- MemberInvitePayload.model_validate({"email": "not-an-email", "role": "normal"})---def test_invite_payload_rejects_extra_field():- with pytest.raises(ValidationError):- MemberInvitePayload.model_validate({"email": "[email protected]", "role": "normal", "extra": "x"})---def test_role_payload_rejects_owner():- with pytest.raises(ValidationError):- MemberRoleUpdatePayload.model_validate({"role": "owner"})---def test_role_payload_rejects_extra_field():+ ("model", "payload"),+ [+ (MemberInvitePayload, {"email": "not-an-email", "role": TenantAccountRole.NORMAL}),+ (MemberInvitePayload, {"email": "[email protected]", "role": TenantAccountRole.NORMAL, "extra": "x"}),+ (MemberRoleUpdatePayload, {"role": TenantAccountRole.NORMAL, "extra": "x"}),+ ],+ ids=["invite.bad_email", "invite.extra_field", "role.extra_field"],+)+def test_payload_models_reject(model: type[BaseModel], payload: dict[str, object]):with pytest.raises(ValidationError):- MemberRoleUpdatePayload.model_validate({"role": "normal", "extra": "x"})---def test_invite_rejects_invalid_body_with_422(app: Flask, bypass_pipeline):- """Invalid invite body → 422 via @accepts (was 400 through _validate_body)."""- ws_id = str(uuid.uuid4())- acct_id = uuid.uuid4()- api = WorkspaceMembersApi()-- with app.test_request_context(- f"/openapi/v1/workspaces/{ws_id}/members",- method="POST",- data=json.dumps({"email": "[email protected]", "role": "owner"}), # owner is not invite-assignable- content_type="application/json",- ):- _seed(_auth_ctx(account_id=acct_id))- with pytest.raises(UnprocessableEntity):- api.post.__wrapped__(api, workspace_id=ws_id, auth_data=_auth_data(acct_id))+ model.model_validate(payload)-def test_update_role_rejects_invalid_body_with_422(app: Flask, bypass_pipeline):- """Invalid role-update body surfaces as 422 through @accepts (was 400)."""- ws_id, member_id = str(uuid.uuid4()), str(uuid.uuid4())- acct_id = uuid.uuid4()- api = WorkspaceMemberApi()+ ("method", "path", "body"),+ [+ (+ HTTPMethod.POST,+ "/openapi/v1/workspaces/{workspace_id}/members",+ {"email": "[email protected]", "role": TenantAccountRole.OWNER},+ ),+ (+ HTTPMethod.PATCH,+ "/openapi/v1/workspaces/{workspace_id}/members/{member_id}",+ {"role": TenantAccountRole.OWNER},+ ),+ (HTTPMethod.GET, "/openapi/v1/workspaces/{workspace_id}/members?pg=2", None),+ (+ HTTPMethod.POST,+ "/openapi/v1/apps/{app_id}/human-input-forms/tok-1:submit",+ {"inputs": {"field1": "val"}},+ ),+ ],+ ids=["invite.owner", "update_role.owner", "members_list.unknown_query", "human_input_form.missing_action"],+)+def test_invalid_request_is_422_on_the_wire(+ admitted_bearer: AdmittedWorld, method: HTTPMethod, path: str, body: dict[str, object] | None+):+ """Owner is not assignable, query models are `extra='forbid'`, and the form+ submit needs an action: each surfaces as 422 from `@accepts` inside the guard.+ """+ resp = admitted_bearer.client.open(+ path.format(+ workspace_id=admitted_bearer.workspace_id,+ member_id=admitted_bearer.member_id,+ app_id=admitted_bearer.app_id,+ ),+ method=method,+ json=body,+ headers=admitted_bearer.headers,+ )- with app.test_request_context(- f"/openapi/v1/workspaces/{ws_id}/members/{member_id}",- method="PATCH",- data=json.dumps({"role": "owner"}), # closed enum rejects owner- content_type="application/json",- ):- _seed(_auth_ctx(account_id=acct_id))- with pytest.raises(UnprocessableEntity):- api.patch.__wrapped__(api, workspace_id=ws_id, member_id=member_id, auth_data=_auth_data(acct_id))+ _assert_validation_422(resp)# ---------------------------------------------------------------------------@@ -269,7 +241,7 @@ def test_update_role_rejects_invalid_body_with_422(app: Flask, bypass_pipeline):# ----------------------------------------------------------------------------def test_switch_returns_workspace_detail_with_current_true(app: Flask, bypass_pipeline, database_session: Session):+def test_switch_returns_workspace_detail_with_current_true(database_session: Session):"""Happy path: switch service is called, then the workspace+membershiprow is re-queried so the returned `current` reflects post-commit state."""@@ -283,13 +255,10 @@ def test_switch_returns_workspace_detail_with_current_true(app: Flask, bypass_pi[(str(acct_id), "[email protected]", TenantAccountRole.OWNER, False)],)- with app.test_request_context(f"/openapi/v1/workspaces/{ws_id}:switch", method="POST"):- _seed(_auth_ctx(account_id=acct_id))- body, status = api.post.__wrapped__(api, workspace_id=ws_id, auth_data=_auth_data(acct_id))+ result = api.post.__handler__(api, _context(database_session, acct_id, ws_id), workspace_id=ws_id)- assert status == 200- assert body["id"] == ws_id- assert body["current"] is True+ assert result.id == ws_id+ assert result.current is Truemembership = database_session.scalar(select(TenantAccountJoin).where(TenantAccountJoin.tenant_id == ws_id,@@ -301,7 +270,7 @@ def test_switch_returns_workspace_detail_with_current_true(app: Flask, bypass_pidef test_switch_404s_when_service_raises_account_not_link_tenant(- app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch, database_session: Session+ monkeypatch: pytest.MonkeyPatch, database_session: Session):"""If switch_tenant raises (e.g. Tenant.status != NORMAL), the bodysurfaces as NotFound, not 500."""@@ -321,10 +290,8 @@ def test_switch_404s_when_service_raises_account_not_link_tenant(_tenant_service(switch_tenant=Mock(side_effect=AccountNotLinkTenantError("…"))),)- with app.test_request_context(f"/openapi/v1/workspaces/{ws_id}:switch", method="POST"):- _seed(_auth_ctx(account_id=acct_id))- with pytest.raises(NotFound):- api.post.__wrapped__(api, workspace_id=ws_id, auth_data=_auth_data(acct_id))+ with pytest.raises(NotFound):+ api.post.__handler__(api, _context(database_session, acct_id, ws_id), workspace_id=ws_id)# ---------------------------------------------------------------------------@@ -332,7 +299,7 @@ def test_switch_404s_when_service_raises_account_not_link_tenant(# ----------------------------------------------------------------------------def test_members_list_returns_normalized_rows(app: Flask, bypass_pipeline, database_session: Session):+def test_members_list_returns_normalized_rows(database_session: Session):ws_id = str(uuid.uuid4())acct_id = uuid.uuid4()member_id = str(uuid.uuid4())@@ -344,23 +311,26 @@ def test_members_list_returns_normalized_rows(app: Flask, bypass_pipeline, datab[(member_id, "[email protected]", TenantAccountRole.ADMIN, False)],)members[0].name = "Mia"+ _persist_caller(database_session, acct_id)- with app.test_request_context(f"/openapi/v1/workspaces/{ws_id}/members"):- _seed(_auth_ctx(account_id=acct_id))- body, status = api.get.__wrapped__(api, workspace_id=ws_id, auth_data=_auth_data(acct_id))+ result = api.get.__handler__(+ api,+ _context(database_session, acct_id, ws_id),+ workspace_id=ws_id,+ query=MemberListQuery(),+ )- assert status == 200- assert body["page"] == 1- assert body["limit"] == 20- assert body["total"] == 1- assert body["has_more"] is False- assert body["data"][0]["email"] == "[email protected]"- assert body["data"][0]["role"] == "admin"- assert body["data"][0]["status"] == "active"+ assert result.page == 1+ assert result.limit == 20+ assert result.total == 1+ assert result.has_more is False+ assert result.data[0].email == "[email protected]"+ assert result.data[0].role == "admin"+ assert result.data[0].status == "active"-def test_members_list_paginates_with_query_params(app: Flask, bypass_pipeline, database_session: Session):- """`?page=2&limit=2` slices service output and reports total/has_more."""+def test_members_list_paginates_with_query_params(database_session: Session):+ """`page=2&limit=2` slices service output and reports total/has_more."""ws_id = str(uuid.uuid4())acct_id = uuid.uuid4()api = WorkspaceMembersApi()@@ -368,29 +338,20 @@ def test_members_list_paginates_with_query_params(app: Flask, bypass_pipeline, dmember_ids = [str(uuid.uuid4()) for _ in range(5)]memberships = [(member_ids[i], f"u{i}@example.com", TenantAccountRole.NORMAL, False) for i in range(5)]_persist_workspace(database_session, ws_id, memberships)+ _persist_caller(database_session, acct_id)- with app.test_request_context(f"/openapi/v1/workspaces/{ws_id}/members?page=2&limit=2"):- _seed(_auth_ctx(account_id=acct_id))- body, status = api.get.__wrapped__(api, workspace_id=ws_id, auth_data=_auth_data(acct_id))-- assert status == 200- assert body["page"] == 2- assert body["limit"] == 2- assert body["total"] == 5- assert body["has_more"] is True- assert [d["id"] for d in body["data"]] == member_ids[2:4]---def test_members_list_rejects_unknown_query_param(app: Flask, bypass_pipeline):- """Strict (`extra='forbid'`) — typos like `?pg=2` surface as 422 (unified via @accepts)."""- ws_id = str(uuid.uuid4())- acct_id = uuid.uuid4()- api = WorkspaceMembersApi()+ result = api.get.__handler__(+ api,+ _context(database_session, acct_id, ws_id),+ workspace_id=ws_id,+ query=MemberListQuery(page=2, limit=2),+ )- with app.test_request_context(f"/openapi/v1/workspaces/{ws_id}/members?pg=2"):- _seed(_auth_ctx(account_id=acct_id))- with pytest.raises(UnprocessableEntity):- api.get.__wrapped__(api, workspace_id=ws_id, auth_data=_auth_data(acct_id))+ assert result.page == 2+ assert result.limit == 2+ assert result.total == 5+ assert result.has_more is True+ assert [d.id for d in result.data] == member_ids[2:4]# ---------------------------------------------------------------------------@@ -398,9 +359,11 @@ def test_members_list_rejects_unknown_query_param(app: Flask, bypass_pipeline):# ----------------------------------------------------------------------------def test_invite_happy_path_returns_invite_url_and_member_id(- app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch, database_session: Session-):+def _invite_body(email: str = "[email protected]") -> MemberInvitePayload:+ return MemberInvitePayload(email=email, role="normal")+++def test_invite_happy_path_returns_invite_url_and_member_id(monkeypatch: pytest.MonkeyPatch, database_session: Session):ws_id = str(uuid.uuid4())acct_id = uuid.uuid4()api = WorkspaceMembersApi()@@ -420,23 +383,71 @@ def test_invite_happy_path_returns_invite_url_and_member_id(SimpleNamespace(invite_new_member=Mock(return_value="tok-123")),)- with app.test_request_context(+ result = api.post.__handler__(+ api,+ _context(database_session, acct_id, ws_id),+ workspace_id=ws_id,+ body=_invite_body("[email protected]"),+ )++ assert result.result == "success"+ assert result.email == "[email protected]"+ assert result.role == "normal"+ assert result.member_id == invited_id+ assert "token=tok-123" in result.invite_url+ assert "email=new%40example.com" in result.invite_url+ assert result.tenant_id == ws_id+++def test_invite_commits_the_invitation(+ openapi_app: Flask,+ sqlite_session_factory: sessionmaker[Session],+ monkeypatch: pytest.MonkeyPatch,+):+ """`RegisterService.invite_new_member` carries no commit of its own, so the+ invitation persists only because the router commits the request's session.+ The double stands in for that contract — it writes through the session it+ is handed and returns a token — so this fails if the router stops committing.+ """+ ws_id = str(uuid.uuid4())+ acct_id = uuid.uuid4()+ invited_id = str(uuid.uuid4())++ with sqlite_session_factory() as setup:+ _persist_workspace(+ setup,+ ws_id,+ [(str(acct_id), "[email protected]", TenantAccountRole.OWNER, True)],+ )+ setup.add(_account(account_id=invited_id, email="[email protected]"))+ setup.commit()++ def _invite(*, tenant, email, language, role, inviter, session) -> str:+ session.add(TenantAccountJoin(tenant_id=tenant.id, account_id=invited_id, role=TenantAccountRole.NORMAL))+ return "tok-persist"++ monkeypatch.setattr(workspaces_module, "RegisterService", SimpleNamespace(invite_new_member=_invite))+ monkeypatch.setattr(+ "controllers.openapi.auth.router.get_authenticator",+ lambda: SimpleNamespace(authenticate=lambda _token: _auth_ctx(acct_id)),+ )+ monkeypatch.setattr("controllers.openapi.auth.pipelines._mount_flask_login", lambda _user: None)++ response = openapi_app.test_client().post(f"/openapi/v1/workspaces/{ws_id}/members",- method="POST",- data=json.dumps({"email": "[email protected]", "role": "normal"}),- content_type="application/json",- ):- _seed(_auth_ctx(account_id=acct_id))- body, status = api.post.__wrapped__(api, workspace_id=ws_id, auth_data=_auth_data(acct_id))-- assert status == 201- assert body["result"] == "success"- assert body["email"] == "[email protected]"- assert body["role"] == "normal"- assert body["member_id"] == invited_id- assert "token=tok-123" in body["invite_url"]- assert "email=new%40example.com" in body["invite_url"]- assert body["tenant_id"] == ws_id+ json={"email": "[email protected]", "role": "normal"},+ headers={"Authorization": "Bearer dfoa_matrix"},+ )++ assert response.status_code == 201, response.get_json()+ with sqlite_session_factory() as verify:+ persisted = verify.scalar(+ select(TenantAccountJoin).where(+ TenantAccountJoin.tenant_id == ws_id,+ TenantAccountJoin.account_id == invited_id,+ )+ )+ assert persisted is not Nonedef _features(@@ -468,19 +479,8 @@ def _features()-def _invite_request(app, ws_id: str, acct_id: uuid.UUID):- return app.test_request_context(- f"/openapi/v1/workspaces/{ws_id}/members",- method="POST",- data=json.dumps({"email": "[email protected]", "role": "normal"}),- content_type="application/json",- )--@config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)-def test_invite_blocked_by_saas_members_cap(- app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch, database_session: Session-):+def test_invite_blocked_by_saas_members_cap(monkeypatch: pytest.MonkeyPatch, database_session: Session):"""SaaS billing plan member cap → MemberLimitExceeded (403)."""ws_id = str(uuid.uuid4())acct_id = uuid.uuid4()@@ -508,18 +508,14 @@ def test_invite_blocked_by_saas_members_cap(),)- with _invite_request(app, ws_id, acct_id):- _seed(_auth_ctx(account_id=acct_id))- with pytest.raises(MemberLimitExceeded):- api.post.__wrapped__(api, workspace_id=ws_id, auth_data=_auth_data(acct_id))+ with pytest.raises(MemberLimitExceeded):+ api.post.__handler__(api, _context(database_session, acct_id, ws_id), workspace_id=ws_id, body=_invite_body())invite_mock.assert_not_called()@config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.ENTERPRISE)-def test_invite_blocked_by_ee_workspace_members_license(- app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch, database_session: Session-):+def test_invite_blocked_by_ee_workspace_members_license(monkeypatch: pytest.MonkeyPatch, database_session: Session):"""EE License workspace_members cap → MemberLicenseExceeded (403).Enterprise member limits come from the license.@@ -554,54 +550,21 @@ def test_invite_blocked_by_ee_workspace_members_license(),)- with _invite_request(app, ws_id, acct_id):- _seed(_auth_ctx(account_id=acct_id))- with pytest.raises(MemberLicenseExceeded):- api.post.__wrapped__(api, workspace_id=ws_id, auth_data=_auth_data(acct_id))+ with pytest.raises(MemberLicenseExceeded):+ api.post.__handler__(api, _context(database_session, acct_id, ws_id), workspace_id=ws_id, body=_invite_body())invite_mock.assert_not_called()-def test_invite_ce_passes_when_both_caps_disabled(- app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch, database_session: Session-):- """CE deployment (no billing, no license) → quota gate is a no-op,- invite proceeds normally."""- ws_id = str(uuid.uuid4())- acct_id = uuid.uuid4()- api = WorkspaceMembersApi()-- invited_id = str(uuid.uuid4())- _persist_workspace(- database_session,- ws_id,- [(str(acct_id), "[email protected]", TenantAccountRole.OWNER, True)],- )- database_session.add(_account(account_id=invited_id, email="[email protected]"))- database_session.commit()-- monkeypatch.setattr(- workspaces_module,- "RegisterService",- SimpleNamespace(invite_new_member=Mock(return_value="tok-ce")),- )- monkeypatch.setattr(- workspaces_module,- "FeatureService",- SimpleNamespace(get_features=Mock(return_value=_features())), # all defaults- )-- with _invite_request(app, ws_id, acct_id):- _seed(_auth_ctx(account_id=acct_id))- body, status = api.post.__wrapped__(api, workspace_id=ws_id, auth_data=_auth_data(acct_id))-- assert status == 201- assert body["email"] == "[email protected]"---def test_invite_400_when_already_in_tenant(- app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch, database_session: Session-):+ "exc",+ [+ AccountAlreadyInTenantError("already in tenant"),+ AccountRegisterError("Workspace is not allowed to create."),+ ],+ ids=["already_in_tenant", "register_error"],+)+def test_invite_400_on_registration_refusal(monkeypatch: pytest.MonkeyPatch, database_session: Session, exc: Exception):ws_id = str(uuid.uuid4())acct_id = uuid.uuid4()api = WorkspaceMembersApi()@@ -615,18 +578,16 @@ def test_invite_400_when_already_in_tenant(monkeypatch.setattr(workspaces_module,"RegisterService",- SimpleNamespace(invite_new_member=Mock(side_effect=AccountAlreadyInTenantError("already in tenant"))),+ SimpleNamespace(invite_new_member=Mock(side_effect=exc)),)- with app.test_request_context(- f"/openapi/v1/workspaces/{ws_id}/members",- method="POST",- data=json.dumps({"email": "[email protected]", "role": "normal"}),- content_type="application/json",- ):- _seed(_auth_ctx(account_id=acct_id))- with pytest.raises(BadRequest):- api.post.__wrapped__(api, workspace_id=ws_id, auth_data=_auth_data(acct_id))+ with pytest.raises(BadRequest):+ api.post.__handler__(+ api,+ _context(database_session, acct_id, ws_id),+ workspace_id=ws_id,+ body=_invite_body(),+ )# ---------------------------------------------------------------------------@@ -634,9 +595,7 @@ def test_invite_400_when_already_in_tenant(# ----------------------------------------------------------------------------def test_delete_member_happy_path(- app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch, database_session: Session-):+def test_delete_member_happy_path(monkeypatch: pytest.MonkeyPatch, database_session: Session):ws_id, member_id = str(uuid.uuid4()), str(uuid.uuid4())acct_id = uuid.uuid4()api = WorkspaceMemberApi()@@ -657,17 +616,11 @@ def test_delete_member_happy_path(_tenant_service(remove_member_from_tenant=remove_mock),)- with app.test_request_context(- f"/openapi/v1/workspaces/{ws_id}/members/{member_id}",- method="DELETE",- ):- _seed(_auth_ctx(account_id=acct_id))- body, status = api.delete.__wrapped__(- api, workspace_id=ws_id, member_id=member_id, auth_data=_auth_data(acct_id)- )+ result = api.delete.__handler__(+ api, _context(database_session, acct_id, ws_id), workspace_id=ws_id, member_id=member_id+ )- assert status == 200- assert body == {"result": "success"}+ assert result.result == "success"assert remove_mock.called@@ -679,9 +632,7 @@ def test_delete_member_happy_path((MemberNotInTenantError("not in tenant"), NotFound),],)-def test_delete_member_exception_mapping(- app: Flask, bypass_pipeline, monkeypatch, exc, expected, database_session: Session-):+def test_delete_member_exception_mapping(monkeypatch, exc, expected, database_session: Session):ws_id, member_id = str(uuid.uuid4()), str(uuid.uuid4())acct_id = uuid.uuid4()api = WorkspaceMemberApi()@@ -701,21 +652,11 @@ def test_delete_member_exception_mapping(_tenant_service(remove_member_from_tenant=Mock(side_effect=exc)),)- with app.test_request_context(- f"/openapi/v1/workspaces/{ws_id}/members/{member_id}",- method="DELETE",- ):- _seed(_auth_ctx(account_id=acct_id))- with pytest.raises(expected):- api.delete.__wrapped__(- api,- workspace_id=ws_id,- member_id=member_id,- auth_data=_auth_data(acct_id),- )+ with pytest.raises(expected):+ api.delete.__handler__(api, _context(database_session, acct_id, ws_id), workspace_id=ws_id, member_id=member_id)-def test_delete_member_404_when_member_missing(app: Flask, bypass_pipeline, database_session: Session):+def test_delete_member_404_when_member_missing(database_session: Session):ws_id, member_id = str(uuid.uuid4()), str(uuid.uuid4())acct_id = uuid.uuid4()api = WorkspaceMemberApi()@@ -726,18 +667,8 @@ def test_delete_member_404_when_member_missing(app: Flask, bypass_pipeline, data[(str(acct_id), "[email protected]", TenantAccountRole.OWNER, True)],)- with app.test_request_context(- f"/openapi/v1/workspaces/{ws_id}/members/{member_id}",- method="DELETE",- ):- _seed(_auth_ctx(account_id=acct_id))- with pytest.raises(NotFound):- api.delete.__wrapped__(- api,- workspace_id=ws_id,- member_id=member_id,- auth_data=_auth_data(acct_id),- )+ with pytest.raises(NotFound):+ api.delete.__handler__(api, _context(database_session, acct_id, ws_id), workspace_id=ws_id, member_id=member_id)# ---------------------------------------------------------------------------@@ -745,9 +676,7 @@ def test_delete_member_404_when_member_missing(app: Flask, bypass_pipeline, data# ----------------------------------------------------------------------------def test_update_role_happy_path(- app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch, database_session: Session-):+def test_update_role_happy_path(monkeypatch: pytest.MonkeyPatch, database_session: Session):ws_id, member_id = str(uuid.uuid4()), str(uuid.uuid4())acct_id = uuid.uuid4()api = WorkspaceMemberApi()@@ -768,19 +697,15 @@ def test_update_role_happy_path(_tenant_service(update_member_role=update_mock),)- with app.test_request_context(- f"/openapi/v1/workspaces/{ws_id}/members/{member_id}",- method="PATCH",- data=json.dumps({"role": "admin"}),- content_type="application/json",- ):- _seed(_auth_ctx(account_id=acct_id))- body, status = api.patch.__wrapped__(- api, workspace_id=ws_id, member_id=member_id, auth_data=_auth_data(acct_id)- )+ result = api.patch.__handler__(+ api,+ _context(database_session, acct_id, ws_id),+ workspace_id=ws_id,+ member_id=member_id,+ body=MemberRoleUpdatePayload(role="admin"),+ )- assert status == 200- assert body == {"result": "success"}+ assert result.result == "success"args = update_mock.call_args.argsassert args[2] == "admin"@@ -794,9 +719,7 @@ def test_update_role_happy_path((MemberNotInTenantError("not in tenant"), NotFound),],)-def test_update_role_exception_mapping(- app: Flask, bypass_pipeline, monkeypatch, exc, expected, database_session: Session-):+def test_update_role_exception_mapping(monkeypatch, exc, expected, database_session: Session):ws_id, member_id = str(uuid.uuid4()), str(uuid.uuid4())acct_id = uuid.uuid4()api = WorkspaceMemberApi()@@ -816,74 +739,11 @@ def test_update_role_exception_mapping(_tenant_service(update_member_role=Mock(side_effect=exc)),)- with app.test_request_context(- f"/openapi/v1/workspaces/{ws_id}/members/{member_id}",- method="PATCH",- data=json.dumps({"role": "admin"}),- content_type="application/json",- ):- _seed(_auth_ctx(account_id=acct_id))- with pytest.raises(expected):- api.patch.__wrapped__(- api,- workspace_id=ws_id,- member_id=member_id,- auth_data=_auth_data(acct_id),- )---# ----------------------------------------------------------------------------# _load_tenant rejects archived tenant-# ------------------------------------------------------------------------------def test_load_tenant_rejects_archived_workspace(app: Flask, bypass_pipeline, database_session: Session):- """Member management against an archived workspace → 404."""- ws_id = str(uuid.uuid4())- acct_id = uuid.uuid4()- api = WorkspaceMembersApi()-- _persist_workspace(database_session, ws_id, [], status=TenantStatus.ARCHIVE)-- with app.test_request_context(f"/openapi/v1/workspaces/{ws_id}/members"):- _seed(_auth_ctx(account_id=acct_id))- with pytest.raises(NotFound):- api.get.__wrapped__(api, workspace_id=ws_id, auth_data=_auth_data(acct_id))---# ----------------------------------------------------------------------------# Invite catches AccountRegisterError-# ------------------------------------------------------------------------------def test_invite_400_when_register_error(- app: Flask, bypass_pipeline, monkeypatch: pytest.MonkeyPatch, database_session: Session-):- """AccountRegisterError (frozen email, workspace creation blocked) → 400."""- ws_id = str(uuid.uuid4())- acct_id = uuid.uuid4()- api = WorkspaceMembersApi()-- _persist_workspace(- database_session,- ws_id,- [(str(acct_id), "[email protected]", TenantAccountRole.OWNER, True)],- )-- monkeypatch.setattr(- workspaces_module,- "RegisterService",- SimpleNamespace(- invite_new_member=Mock(side_effect=AccountRegisterError("Workspace is not allowed to create.")),- ),- )-- with app.test_request_context(- f"/openapi/v1/workspaces/{ws_id}/members",- method="POST",- data=json.dumps({"email": "[email protected]", "role": "normal"}),- content_type="application/json",- ):- _seed(_auth_ctx(account_id=acct_id))- with pytest.raises(BadRequest):- api.post.__wrapped__(api, workspace_id=ws_id, auth_data=_auth_data(acct_id))+ with pytest.raises(expected):+ api.patch.__handler__(+ api,+ _context(database_session, acct_id, ws_id),+ workspace_id=ws_id,+ member_id=member_id,+ body=MemberRoleUpdatePayload(role="admin"),+ )diff --git a/api/tests/unit_tests/libs/test_oauth_bearer.py b/api/tests/unit_tests/libs/test_oauth_bearer.pyindex 1ce25a48f73..e6566adcb9a 100644--- a/api/tests/unit_tests/libs/test_oauth_bearer.py+++ b/api/tests/unit_tests/libs/test_oauth_bearer.py@@ -1,29 +1,50 @@-"""Unit tests for the openapi bearer-scope catalog and TokenKind registry."""+"""The bearer catalog: which subject each token type serves and what it may do."""from __future__ import annotations+import uuid+from datetime import UTC, datetimefrom unittest.mock import MagicMock+import pytest-def test_apps_read_permitted_external_scope_present():- from libs.oauth_bearer import Scope+from libs.oauth_bearer import ResolvedRow, Scope, SubjectType, TokenType, _TokenTypeResolver- assert Scope.APPS_READ_PERMITTED_EXTERNAL.value == "apps:read:permitted-external"+def _row(account_id: uuid.UUID | None) -> ResolvedRow:+ return ResolvedRow(+ subject_email="[email protected]",+ subject_issuer="issuer",+ account_id=account_id,+ client_id="client",+ token_id=uuid.uuid4(),+ expires_at=datetime.now(UTC),+ )-def test_dfoe_token_kind_carries_apps_read_permitted_external():- from libs.oauth_bearer import Scope, build_registry- registry = build_registry(MagicMock(), MagicMock())- dfoe = next(k for k in registry.kinds() if k.prefix == "dfoe_")- assert Scope.APPS_READ_PERMITTED_EXTERNAL in dfoe.scopes[email protected]("token_type", list(TokenType), ids=lambda t: t.value)+def test_a_row_matches_its_subject_only_when_its_account_binding_agrees(token_type: TokenType) -> None:+ """Every token type, present or future, is held to the binding its subject declares."""+ resolver = _TokenTypeResolver(MagicMock(), token_type)+ bound = token_type.subject.bound_to_account+ assert resolver._matches_subject(_row(uuid.uuid4())) is bound+ assert resolver._matches_subject(_row(None)) is not bound-def test_dfoa_token_kind_does_not_carry_apps_read_permitted_external():- """dfoa_ relies on Scope.FULL umbrella; the explicit permitted scope- is reserved for dfoe_."""- from libs.oauth_bearer import Scope, build_registry+def test_scope_sets_are_pinned_exactly() -> None:+ """`dfoa_` relies on the `Scope.FULL` umbrella; the explicit scopes are reserved for `dfoe_`."""+ assert SubjectType.ACCOUNT.scopes == frozenset({Scope.FULL})+ assert SubjectType.EXTERNAL_SSO.scopes == frozenset({Scope.APPS_RUN, Scope.APPS_READ_PERMITTED_EXTERNAL})- registry = build_registry(MagicMock(), MagicMock())- dfoa = next(k for k in registry.kinds() if k.prefix == "dfoa_")- assert Scope.APPS_READ_PERMITTED_EXTERNAL not in dfoa.scopes++ ("token", "expected"),+ [+ ("dfoa_abc", TokenType.OAUTH_ACCOUNT),+ ("dfoe_abc", TokenType.OAUTH_EXTERNAL_SSO),+ ("dfp_abc", None),+ ("", None),+ ],+)+def test_for_token_classifies_by_prefix_and_refuses_the_rest(token: str, expected: TokenType | None) -> None:+ assert TokenType.for_token(token) is expecteddiff --git a/api/tests/unit_tests/libs/test_oauth_bearer_rate_limit_ordering.py b/api/tests/unit_tests/libs/test_oauth_bearer_rate_limit_ordering.pyindex d3d2d583f25..845e520d946 100644--- a/api/tests/unit_tests/libs/test_oauth_bearer_rate_limit_ordering.py+++ b/api/tests/unit_tests/libs/test_oauth_bearer_rate_limit_ordering.py@@ -4,42 +4,11 @@ from unittest.mock import MagicMock, patchimport pytest-from libs.oauth_bearer import (- BearerAuthenticator,- InvalidBearerError,- Scope,- SubjectType,- TokenKind,- TokenKindRegistry,- TokenType,-)+from libs.oauth_bearer import BearerAuthenticator, InvalidBearerError, TokenType-def _registry_with_resolver(resolver) -> TokenKindRegistry:- return TokenKindRegistry(- [- TokenKind(- prefix="dfoa_",- subject_type=SubjectType.ACCOUNT,- scopes=frozenset({Scope.FULL}),- token_type=TokenType.OAUTH_ACCOUNT,- resolver=resolver,- )- ]- )---@patch("libs.oauth_bearer.enforce_bearer_rate_limit")-def test_rate_limit_called_on_unknown_revoked_token(rl):- resolver = MagicMock()- resolver.resolve.return_value = None- auth = BearerAuthenticator(_registry_with_resolver(resolver))-- with pytest.raises(InvalidBearerError):- auth.authenticate("dfoa_revokedtoken123")-- rl.assert_called_once()- resolver.resolve.assert_called_once()+def _authenticator_with(resolver) -> BearerAuthenticator:+ return BearerAuthenticator({TokenType.OAUTH_ACCOUNT: resolver})@patch("libs.oauth_bearer.enforce_bearer_rate_limit")@@ -48,7 +17,7 @@ def test_rate_limit_called_before_resolve(rl):rl.side_effect = lambda _h: call_order.append("rl")resolver = MagicMock()resolver.resolve.side_effect = lambda _h: call_order.append("resolve") or None- auth = BearerAuthenticator(_registry_with_resolver(resolver))+ auth = _authenticator_with(resolver)with pytest.raises(InvalidBearerError):auth.authenticate("dfoa_xyz")@@ -56,30 +25,12 @@ def test_rate_limit_called_before_resolve(rl):assert call_order == ["rl", "resolve"], f"expected rl before resolve, got {call_order}"-def test_unknown_prefix_raises_generic_invalid_bearer():- auth = BearerAuthenticator(- TokenKindRegistry(- [- TokenKind(- prefix="dfoa_",- subject_type=SubjectType.ACCOUNT,- scopes=frozenset({Scope.FULL}),- token_type=TokenType.OAUTH_ACCOUNT,- resolver=MagicMock(),- )- ]- )- )- with pytest.raises(InvalidBearerError) as exc:- auth.authenticate("zzz_xyz")- assert str(exc.value) == "invalid_bearer"--[email protected]("token", ["zzz_xyz", "dfoa_revoked"], ids=["unknown prefix", "revoked"])@patch("libs.oauth_bearer.enforce_bearer_rate_limit")-def test_revoked_token_raises_generic_invalid_bearer(rl):+def test_every_refusal_raises_the_generic_invalid_bearer(rl, token: str):resolver = MagicMock()resolver.resolve.return_value = None- auth = BearerAuthenticator(_registry_with_resolver(resolver))+ auth = _authenticator_with(resolver)with pytest.raises(InvalidBearerError) as exc:- auth.authenticate("dfoa_revoked")+ auth.authenticate(token)assert str(exc.value) == "invalid_bearer"diff --git a/api/tests/unit_tests/pyrefly.toml b/api/tests/unit_tests/pyrefly.tomlindex 651f39a79f3..18d3252ef04 100644--- a/api/tests/unit_tests/pyrefly.toml+++ b/api/tests/unit_tests/pyrefly.toml@@ -148,13 +148,6 @@ project-excludes = ["controllers/inner_api/test_runtime_credentials.py","controllers/inner_api/workspace/test_workspace.py","controllers/mcp/test_mcp.py",- "controllers/openapi/auth/test_composition.py",- "controllers/openapi/auth/test_conditions.py",- "controllers/openapi/auth/test_data.py",- "controllers/openapi/auth/test_flow.py",- "controllers/openapi/auth/test_pipeline.py",- "controllers/openapi/auth/test_prepare.py",- "controllers/openapi/auth/test_verify.py","controllers/openapi/conftest.py","controllers/openapi/test_account.py","controllers/openapi/test_app_describe_builder.py",@@ -181,7 +174,6 @@ project-excludes = ["controllers/openapi/test_oauth_sso_claims.py","controllers/openapi/test_oauth_sso_csrf.py","controllers/openapi/test_oauth_sso_host_header.py",- "controllers/openapi/test_pagination_envelope.py","controllers/openapi/test_supported_app_type.py","controllers/openapi/test_version_gate.py","controllers/openapi/test_workflow_events_openapi.py",@@ -694,9 +686,7 @@ project-excludes = ["libs/test_login.py","libs/test_oauth_base.py","libs/test_oauth_bearer.py",- "libs/test_oauth_bearer_layer0_cache.py","libs/test_oauth_bearer_rate_limit_ordering.py",- "libs/test_oauth_bearer_require_scope.py","libs/test_oauth_clients.py","libs/test_orjson.py","libs/test_pagination.py",@@ -713,7 +703,6 @@ project-excludes = ["libs/test_token.py","libs/test_token_manager.py","libs/test_uuid_utils.py",- "libs/test_workspace_member_helper.py","libs/test_workspace_permission.py","libs/test_yarl.py","migrations/test_uuidv7_pg18_migration.py",@@ -780,7 +769,6 @@ project-excludes = ["services/enterprise/test_rbac_service.py","services/enterprise/test_traceparent_propagation.py","services/hit_service.py",- "services/openapi/test_mint_policy.py","services/plugin/conftest.py","services/plugin/test_dependencies_analysis.py","services/plugin/test_endpoint_service.py",diff --git a/api/tests/unit_tests/services/openapi/__init__.py b/api/tests/unit_tests/services/openapi/__init__.pydeleted file mode 100644index e69de29bb2d..00000000000diff --git a/api/tests/unit_tests/services/openapi/test_mint_policy.py b/api/tests/unit_tests/services/openapi/test_mint_policy.pydeleted file mode 100644index c3df657ed4c..00000000000--- a/api/tests/unit_tests/services/openapi/test_mint_policy.py+++ /dev/null@@ -1,74 +0,0 @@-"""Tests for the mint-policy validator.--Cross-checks the (subject_type, prefix, scopes) triple a caller intends-to mint against ``MINTABLE_PROFILES``. The validator's defense-in-depth-value kicks in when a caller wires scopes or prefix from a non-canonical-source — the well-formed canonical path is the no-violation case.-"""--from __future__ import annotations--import pytest--from libs.oauth_bearer import MINTABLE_PROFILES, Scope, SubjectType-from services.openapi.mint_policy import MintPolicyViolation, validate_mint_policy---def test_canonical_account_profile_passes():- profile = MINTABLE_PROFILES[SubjectType.ACCOUNT]- validate_mint_policy(- subject_type=profile.subject_type,- prefix=profile.prefix,- scopes=profile.scopes,- )---def test_canonical_external_sso_profile_passes():- profile = MINTABLE_PROFILES[SubjectType.EXTERNAL_SSO]- validate_mint_policy(- subject_type=profile.subject_type,- prefix=profile.prefix,- scopes=profile.scopes,- )---def test_wrong_prefix_rejected():- with pytest.raises(MintPolicyViolation) as exc:- validate_mint_policy(- subject_type=SubjectType.ACCOUNT,- prefix="dfoe_", # SSO prefix on an account subject- scopes=frozenset({Scope.FULL}),- )- assert "prefix" in str(exc.value)---def test_wrong_scopes_rejected():- with pytest.raises(MintPolicyViolation) as exc:- validate_mint_policy(- subject_type=SubjectType.ACCOUNT,- prefix="dfoa_",- scopes=frozenset({Scope.APPS_RUN}), # account should be {FULL}- )- assert "scopes" in str(exc.value)---def test_external_sso_with_full_scope_rejected():- with pytest.raises(MintPolicyViolation):- validate_mint_policy(- subject_type=SubjectType.EXTERNAL_SSO,- prefix="dfoe_",- scopes=frozenset({Scope.FULL}), # FULL never applies to dfoe_- )---def test_message_carries_both_drift_reasons():- """Mismatched prefix AND mismatched scopes both surface in one error."""- with pytest.raises(MintPolicyViolation) as exc:- validate_mint_policy(- subject_type=SubjectType.ACCOUNT,- prefix="dfoe_",- scopes=frozenset({Scope.APPS_RUN}),- )- msg = str(exc.value)- assert "prefix" in msg- assert "scopes" in msgdiff --git a/api/tests/unit_tests/services/test_app_service.py b/api/tests/unit_tests/services/test_app_service.pyindex d568fb6742c..7ab02093684 100644--- a/api/tests/unit_tests/services/test_app_service.py+++ b/api/tests/unit_tests/services/test_app_service.py@@ -373,31 +373,6 @@ class TestOpenapiVisibilityHelpers:with patch("services.app_service.is_openapi_visible", return_value=False):assert AppService.get_visible_app_by_id(app.id, sqlite_session) is None- def test_find_visible_apps_by_name_returns_scalars_through_visibility_gate(self, sqlite_session: Session):- """Tenant-scoped name lookup. The helper passes the SELECT through- ``apply_openapi_gate`` and materialises ``.scalars()`` into a list- so the controller can branch on length (404 / single / 409).- """- tenant_id = str(uuid4())- rows = [- _persist_app(sqlite_session, tenant_id=tenant_id, name="my-app"),- _persist_app(sqlite_session, tenant_id=tenant_id, name="my-app"),- ]- _persist_app(sqlite_session, tenant_id=str(uuid4()), name="my-app")-- with patch("services.app_service.apply_openapi_gate", side_effect=lambda q: q) as gate:- out = AppService.find_visible_apps_by_name(name="my-app", tenant_id=tenant_id, session=sqlite_session)-- assert {app.id for app in out} == {app.id for app in rows}- # Visibility gate must wrap the SELECT exactly once.- gate.assert_called_once()-- def test_find_visible_apps_by_name_returns_empty_list_on_no_match(self, sqlite_session: Session):- with patch("services.app_service.apply_openapi_gate", side_effect=lambda q: q):- out = AppService.find_visible_apps_by_name(name="nope", tenant_id=str(uuid4()), session=sqlite_session)-- assert out == []-def test_find_visible_apps_by_ids_short_circuits_on_empty_input(self, unbound_session: Session):"""Empty id list must not emit ``WHERE id IN ()`` — Postgresrejects empty IN lists and the call is a guaranteed no-opdiff --git a/api/tests/unit_tests/services/test_oauth_device_flow_mint.py b/api/tests/unit_tests/services/test_oauth_device_flow_mint.pynew file mode 100644index 00000000000..f16493b7774--- /dev/null+++ b/api/tests/unit_tests/services/test_oauth_device_flow_mint.py@@ -0,0 +1,44 @@+"""Minting normalises the issuer by the subject's declared account binding."""++from __future__ import annotations++import uuid+from unittest.mock import MagicMock, patch++import pytest++from libs.oauth_bearer import TokenType+from services.oauth_device_flow import ACCOUNT_ISSUER_SENTINEL, UpsertOutcome, mint_oauth_token++UPSERT = "services.oauth_device_flow._upsert"+++def _mint(token_type: TokenType, subject_issuer: str | None) -> MagicMock:+ outcome = UpsertOutcome(token_id=uuid.uuid4(), rotated=False, old_hash=None)+ with patch(UPSERT, return_value=outcome) as upsert:+ mint_oauth_token(+ MagicMock(),+ subject_email="[email protected]",+ subject_issuer=subject_issuer,+ account_id=str(uuid.uuid4()) if token_type.subject.bound_to_account else None,+ client_id="client",+ device_label="device",+ token_type=token_type,+ ttl_days=1,+ session=MagicMock(),+ )+ return upsert++[email protected]("token_type", list(TokenType), ids=lambda t: t.value)+def test_the_issuer_follows_the_subject_binding(token_type: TokenType) -> None:+ if token_type.subject.bound_to_account:+ upsert = _mint(token_type, None)+ assert upsert.call_args.kwargs["subject_issuer"] == ACCOUNT_ISSUER_SENTINEL+ with pytest.raises(ValueError, match="ACCOUNT_ISSUER_SENTINEL"):+ _mint(token_type, "https://idp.example.com")+ else:+ upsert = _mint(token_type, "https://idp.example.com")+ assert upsert.call_args.kwargs["subject_issuer"] == "https://idp.example.com"+ with pytest.raises(ValueError, match="subject_issuer"):+ _mint(token_type, " ")diff --git a/packages/contracts/generated/api/openapi/types.gen.ts b/packages/contracts/generated/api/openapi/types.gen.tsindex ac9af4af710..7aa67a61c26 100644--- a/packages/contracts/generated/api/openapi/types.gen.ts+++ b/packages/contracts/generated/api/openapi/types.gen.ts@@ -15,7 +15,7 @@ export type AccountResponse = {default_workspace_id?: string | nullsubject_email?: string | nullsubject_issuer?: string | null- subject_type: string+ subject_type: SubjectTypeworkspaces?: Array<WorkspacePayload>}@@ -169,7 +169,7 @@ export type DeviceTokenResponse = {expires_at: stringsubject_email?: string | nullsubject_issuer?: string | null- subject_type: 'account' | 'external_sso'+ subject_type: SubjectTypetoken: stringtoken_id: stringworkspaces?: Array<WorkspacePayload>@@ -426,6 +426,8 @@ export type SimpleResultResponse = {result: string}+export type SubjectType = 'account' | 'external_sso'+export type SupportedAppType = 'advanced-chat' | 'agent-chat' | 'chat' | 'completion' | 'workflow'export type TaskStopResponse = {@@ -739,6 +741,13 @@ export type GetAppsByAppIdHumanInputFormsByFormTokenData = {url: '/apps/{app_id}/human-input-forms/{form_token}'}+export type GetAppsByAppIdHumanInputFormsByFormTokenErrors = {+ default: ErrorBody+}++export type GetAppsByAppIdHumanInputFormsByFormTokenError =+ GetAppsByAppIdHumanInputFormsByFormTokenErrors[keyof GetAppsByAppIdHumanInputFormsByFormTokenErrors]+export type GetAppsByAppIdHumanInputFormsByFormTokenResponses = {200: HumanInputFormDefinitionResponse}@@ -784,6 +793,13 @@ export type GetAppsByAppIdTasksByTaskIdEventsData = {url: '/apps/{app_id}/tasks/{task_id}/events'}+export type GetAppsByAppIdTasksByTaskIdEventsErrors = {+ default: ErrorBody+}++export type GetAppsByAppIdTasksByTaskIdEventsError =+ GetAppsByAppIdTasksByTaskIdEventsErrors[keyof GetAppsByAppIdTasksByTaskIdEventsErrors]+export type GetAppsByAppIdTasksByTaskIdEventsResponses = {200: EventStreamResponse}@@ -826,6 +842,7 @@ export type PostAppsByAppIdRunData = {export type PostAppsByAppIdRunErrors = {422: ErrorBody+ default: ErrorBody}export type PostAppsByAppIdRunError = PostAppsByAppIdRunErrors[keyof PostAppsByAppIdRunErrors]diff --git a/packages/contracts/generated/api/openapi/zod.gen.ts b/packages/contracts/generated/api/openapi/zod.gen.tsindex 55ddcc32f6e..722ff155c30 100644--- a/packages/contracts/generated/api/openapi/zod.gen.ts+++ b/packages/contracts/generated/api/openapi/zod.gen.ts@@ -552,6 +552,11 @@ export const zSimpleResultResponse = z.object({result: z.string(),})+/**+ * SubjectType+ */+export const zSubjectType = z.enum(['account', 'external_sso'])+/*** SupportedAppType*@@ -673,7 +678,7 @@ export const zAccountResponse = z.object({default_workspace_id: z.string().nullish(),subject_email: z.string().nullish(),subject_issuer: z.string().nullish(),- subject_type: z.string(),+ subject_type: zSubjectType,workspaces: z.array(zWorkspacePayload).optional().default([]),})@@ -686,7 +691,7 @@ export const zDeviceTokenResponse = z.object({expires_at: z.string(),subject_email: z.string().nullish(),subject_issuer: z.string().nullish(),- subject_type: z.enum(['account', 'external_sso']),+ subject_type: zSubjectType,token: z.string(),token_id: z.string(),workspaces: z.array(zWorkspacePayload).optional().default([]),