Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
refactor(api): extract web app access queries (#40482)
非法操作532489babd06
diff --git a/api/.importlinter b/api/.importlinterindex 1cbafd9b8ec..d7492912e7f 100644--- a/api/.importlinter+++ b/api/.importlinter@@ -107,6 +107,23 @@ forbidden_modules =sqlalchemywerkzeug+[importlinter:contract:webapp-access-query-service-boundary]+name = Web app access query application service is framework and persistence neutral+type = forbidden+source_modules =+ services.webapp_access_query_service+forbidden_modules =+ configs+ controllers+ extensions+ flask+ models+ repositories+ services.enterprise+ services.feature_service+ sqlalchemy+ werkzeug+[importlinter:contract:feature-query-service-boundary]name = Feature query application service is framework and persistence neutraltype = forbiddendiff --git a/api/controllers/web/app.py b/api/controllers/web/app.pyindex a6d8dc47109..135765a902c 100644--- a/api/controllers/web/app.py+++ b/api/controllers/web/app.py@@ -8,8 +8,17 @@ from werkzeug.exceptions import Unauthorizedfrom constants import HEADER_NAME_APP_CODEfrom controllers.common import fields-from controllers.common.fields import Parameters+from controllers.common.errors import InvalidArgumentError+from controllers.common.fields import AccessModeResponse, Parametersfrom controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_models+from controllers.web import web_ns+from controllers.web.error import (+ AgentNotPublishedError,+ AppUnavailableError,+ WebAppAccessServiceUnavailableError,+ WebAppNotFoundError,+)+from controllers.web.wraps import WebApiResourcefrom extensions.ext_application_services import application_servicesfrom extensions.ext_database import dbfrom libs.helper import dump_response@@ -17,15 +26,15 @@ from libs.passport import PassportServicefrom libs.token import extract_webapp_passportfrom models.model import App, EndUserfrom services.app_definition_query_service import AppDefinitionNotPublishedError, AppDefinitionUnavailableError-from services.app_service import AppServicefrom services.enterprise.enterprise_service import EnterpriseServicefrom services.feature_service import FeatureService+from services.webapp_access_query_service import (+ WebAppAccessAppNotFoundError,+ WebAppAccessReferenceRequiredError,+ WebAppAccessUnavailableError,+)from services.webapp_auth_service import WebAppAuthService-from . import web_ns-from .error import AgentNotPublishedError, AppUnavailableError-from .wraps import WebApiResource-logger = logging.getLogger(__name__)@@ -54,7 +63,7 @@ register_response_schema_models(web_ns,Parameters,AppMetaResponse,- fields.AccessModeResponse,+ AccessModeResponse,fields.BooleanResultResponse,)@@ -122,28 +131,27 @@ class AppAccessMode(Resource):responses={200: "Success",400: "Bad Request",+ 404: "App Not Found",500: "Internal Server Error",+ 503: "Web App Access Service Unavailable",})- @web_ns.response(200, "Success", web_ns.models[fields.AccessModeResponse.__name__])+ @web_ns.response(200, "Success", web_ns.models[AccessModeResponse.__name__])def get(self):raw_args = request.args.to_dict()args = AppAccessModeQuery.model_validate(raw_args)-- features = FeatureService.get_system_features()- if not features.webapp_auth.enabled:- return {"accessMode": "public"}-- app_id = args.app_id- if args.app_code:- app_id = AppService.get_app_id_by_code(args.app_code, session=db.session())-- if not app_id:- raise ValueError("appId or appCode must be provided")-- res = EnterpriseService.WebAppAuth.get_app_access_mode_by_id(app_id)-- return {"accessMode": res.access_mode}+ try:+ access_mode = application_services().webapp_access.get_access_mode(+ app_id=args.app_id,+ app_code=args.app_code,+ )+ except WebAppAccessReferenceRequiredError as e:+ raise InvalidArgumentError(description=str(e)) from None+ except WebAppAccessAppNotFoundError:+ raise WebAppNotFoundError() from None+ except WebAppAccessUnavailableError:+ raise WebAppAccessServiceUnavailableError() from None+ return dump_response(AccessModeResponse, {"access_mode": access_mode})@web_ns.route("/webapp/permission")diff --git a/api/controllers/web/error.py b/api/controllers/web/error.pyindex c6ea2aea192..b0ab2f0334c 100644--- a/api/controllers/web/error.py+++ b/api/controllers/web/error.py@@ -121,6 +121,18 @@ class WebAppAuthAccessDeniedError(BaseHTTPException):code = 401+class WebAppNotFoundError(BaseHTTPException):+ error_code = "app_not_found"+ description = "App not found."+ code = 404+++class WebAppAccessServiceUnavailableError(BaseHTTPException):+ error_code = "web_app_access_unavailable"+ description = "Web app access service is unavailable."+ code = 503++class InvokeRateLimitError(BaseHTTPException):"""Raised when the Invoke returns rate limit error."""diff --git a/api/enums/__init__.py b/api/enums/__init__.pyindex dd5d029f56f..a56af59be25 100644--- a/api/enums/__init__.py+++ b/api/enums/__init__.py@@ -23,6 +23,13 @@ class DeploymentEdition(StrEnum):CLOUD = "CLOUD"+class WebAppAccessMode(StrEnum):+ PUBLIC = "public"+ PRIVATE = "private"+ PRIVATE_ALL = "private_all"+ SSO_VERIFIED = "sso_verified"++class HostedTrialProvider(StrEnum):"""Enum representing hosted model provider names for trial access."""diff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.pyindex 9d9b37c88c0..af732a18044 100644--- a/api/extensions/ext_application_services.py+++ b/api/extensions/ext_application_services.py@@ -1,22 +1,26 @@"""Composition root for application services used by transport adapters."""+import jsonfrom dataclasses import dataclassfrom typing import cast+import httpxfrom flask import Flask, current_app+from pydantic import ValidationErrorfrom sqlalchemy.orm import Session, sessionmakerfrom configs import dify_configfrom constants.dsl_version import CURRENT_APP_DSL_VERSIONfrom core.db.session_factory import get_session_makerfrom core.schemas.schema_manager import SchemaManager-from enums import DeploymentEdition+from enums import DeploymentEdition, WebAppAccessModefrom extensions.ext_redis import RedisClientWrapper, redis_clientfrom repositories.account_activation_repository import SQLAlchemyAccountActivationRepositoryfrom repositories.app_definition_query_repository import AppDefinitionQueryRepositoryfrom repositories.data_source_api_key_auth_repository import SQLAlchemyDataSourceApiKeyAuthBindingRepositoryfrom repositories.explore_banner_query_repository import ExploreBannerQueryRepositoryfrom repositories.installation_state_repository import InstallationStateRepository+from repositories.webapp_access_query_repository import WebAppAccessQueryRepositoryfrom repositories.workspace_member_query_repository import WorkspaceMemberQueryRepositoryfrom repositories.workspace_query_repository import WorkspaceQueryRepositoryfrom services.account_activation_adapters import (@@ -32,6 +36,8 @@ from services.auth.data_source_api_key_auth_gateways import (TenantApiKeyAuthCredentialEncryptor,)from services.auth.data_source_api_key_auth_service import DataSourceApiKeyAuthService+from services.enterprise.enterprise_service import EnterpriseService+from services.errors.enterprise import EnterpriseServiceErrorfrom services.explore_banner_query_service import ExploreBannerQueryServicefrom services.feature_query_service import FeatureQueryServicefrom services.feature_service import FeatureService@@ -40,6 +46,10 @@ from services.init_validation_service import InitValidationServicefrom services.schema_definition_service import SchemaDefinitionServicefrom services.setup_adapters import RedisSetupLock, RegisterServiceAccountProvisionerfrom services.setup_service import SetupService+from services.webapp_access_query_service import (+ WebAppAccessQueryService,+ WebAppAccessUnavailableError,+)from services.workspace_member_query_service import WorkspaceMemberQueryServicefrom services.workspace_member_role_resolver import DeploymentWorkspaceMemberRoleResolverfrom services.workspace_plan_gateway import DeploymentWorkspacePlanGateway@@ -48,11 +58,23 @@ from services.workspace_query_service import WorkspaceQueryService_EXTENSION_KEY = "application_services"+def _get_enterprise_webapp_access_mode(app_id: str) -> WebAppAccessMode:+ try:+ settings = EnterpriseService.WebAppAuth.get_app_access_mode_by_id(app_id)+ except (EnterpriseServiceError, httpx.RequestError, json.JSONDecodeError, UnicodeDecodeError, ValidationError) as e:+ raise WebAppAccessUnavailableError from e+ try:+ return WebAppAccessMode(settings.access_mode)+ except ValueError as e:+ raise WebAppAccessUnavailableError from e++@dataclass(frozen=True, slots=True)class ApplicationServices:account_activation: AccountActivationServiceapp_definitions: AppDefinitionQueryServicedata_source_api_key_auth: DataSourceApiKeyAuthService+ webapp_access: WebAppAccessQueryServiceexplore_banner_queries: ExploreBannerQueryServiceschema_definitions: SchemaDefinitionServicesetup: SetupService@@ -94,6 +116,11 @@ def build_application_services(validator=ProviderApiKeyAuthCredentialValidator(),encryptor=TenantApiKeyAuthCredentialEncryptor(),),+ webapp_access=WebAppAccessQueryService(+ access=WebAppAccessQueryRepository(session_factory=database_client),+ webapp_auth_enabled=FeatureService.is_webapp_auth_enabled(),+ access_mode_for_app=_get_enterprise_webapp_access_mode,+ ),explore_banner_queries=ExploreBannerQueryService(banners=ExploreBannerQueryRepository(client=database_client),is_enabled=FeatureService.is_explore_banner_enabled,diff --git a/api/openapi/markdown/web-openapi.md b/api/openapi/markdown/web-openapi.mdindex 36f2f7a084a..0fa5dfe91ca 100644--- a/api/openapi/markdown/web-openapi.md+++ b/api/openapi/markdown/web-openapi.md@@ -826,7 +826,9 @@ Retrieve the access mode for a web application (public or restricted).| ---- | ----------- | ------ || 200 | Success | **application/json**: [AccessModeResponse](#accessmoderesponse)<br> || 400 | Bad Request | |+| 404 | App Not Found | || 500 | Internal Server Error | |+| 503 | Web App Access Service Unavailable | |### [GET] /webapp/permissionCheck if user has permission to access a web application.diff --git a/api/repositories/webapp_access_query_repository.py b/api/repositories/webapp_access_query_repository.pynew file mode 100644index 00000000000..94e2a31b6a9--- /dev/null+++ b/api/repositories/webapp_access_query_repository.py@@ -0,0 +1,24 @@+"""Database repository for web-app access queries."""++from typing import override++from sqlalchemy import select+from sqlalchemy.exc import DBAPIError, TimeoutError+from sqlalchemy.orm import Session, sessionmaker++from models.model import Site+from services.webapp_access_query_service import WebAppAccessQuery, WebAppAccessUnavailableError+++class WebAppAccessQueryRepository(WebAppAccessQuery):+ def __init__(self, *, session_factory: sessionmaker[Session]) -> None:+ self._session_factory = session_factory++ @override+ def find_app_id_by_code(self, app_code: str) -> str | None:+ try:+ with self._session_factory() as session:+ app_id = session.scalar(select(Site.app_id).where(Site.code == app_code).limit(1))+ return str(app_id) if app_id is not None else None+ except (DBAPIError, TimeoutError) as e:+ raise WebAppAccessUnavailableError from ediff --git a/api/services/enterprise/enterprise_service.py b/api/services/enterprise/enterprise_service.pyindex e8c768f20be..b64bfc914e2 100644--- a/api/services/enterprise/enterprise_service.py+++ b/api/services/enterprise/enterprise_service.py@@ -1,6 +1,5 @@from __future__ import annotations-import enumimport loggingimport uuidfrom datetime import datetime@@ -9,7 +8,7 @@ from cachetools.func import ttl_cachefrom pydantic import BaseModel, ConfigDict, Field, model_validatorfrom configs import dify_config-from enums import DeploymentEdition+from enums import DeploymentEdition, WebAppAccessModefrom extensions.ext_redis import redis_clientfrom services.enterprise.base import (EnterpriseRequest,@@ -31,13 +30,6 @@ VALID_LICENSE_CACHE_TTL = 600 # 10 minutes — valid licenses are stableINVALID_LICENSE_CACHE_TTL = 30 # 30 seconds — short so admin fixes are picked up quickly-class WebAppAccessMode(enum.StrEnum):- PUBLIC = "public"- PRIVATE = "private"- PRIVATE_ALL = "private_all"- SSO_VERIFIED = "sso_verified"--PERMISSION_CHECK_MODES: frozenset[WebAppAccessMode] = frozenset({WebAppAccessMode.PRIVATE, WebAppAccessMode.PRIVATE_ALL})@@ -293,7 +285,7 @@ class EnterpriseService:params = {"appId": app_id}data = EnterpriseRequest.send_request("GET", "/webapp/access-mode/id", params=params)if not data:- raise ValueError("No data found.")+ raise EnterpriseServiceError("No data found.")return WebAppSettings.model_validate(data)@classmethoddiff --git a/api/services/feature_service.py b/api/services/feature_service.pyindex b32387ffea0..d1e80a65fd4 100644--- a/api/services/feature_service.py+++ b/api/services/feature_service.py@@ -104,10 +104,10 @@ class FeatureService:system_features.rbac_enabled = dify_config.RBAC_ENABLEDcls._fulfill_system_params_from_env(system_features)+ system_features.webapp_auth.enabled = cls.is_webapp_auth_enabled()if dify_config.DEPLOYMENT_EDITION == DeploymentEdition.ENTERPRISE:system_features.branding.enabled = True- system_features.webapp_auth.enabled = Truesystem_features.enable_change_email = Falsecls._fulfill_params_from_enterprise(system_features)@@ -159,6 +159,10 @@ class FeatureService:def is_explore_banner_enabled() -> bool:return dify_config.DEPLOYMENT_EDITION == DeploymentEdition.CLOUD and dify_config.ENABLE_EXPLORE_BANNER+ @staticmethod+ def is_webapp_auth_enabled() -> bool:+ return dify_config.DEPLOYMENT_EDITION == DeploymentEdition.ENTERPRISE+@classmethoddef _fulfill_system_params_from_env(cls, system_features: feature_entities.SystemFeatureModel):system_features.enable_email_code_login = dify_config.ENABLE_EMAIL_CODE_LOGINdiff --git a/api/services/webapp_access_query_service.py b/api/services/webapp_access_query_service.pynew file mode 100644index 00000000000..10524041f9c--- /dev/null+++ b/api/services/webapp_access_query_service.py@@ -0,0 +1,49 @@+"""Application service for resolving web-app access."""++from collections.abc import Callable+from typing import Protocol++from enums import WebAppAccessMode+++class WebAppAccessQuery(Protocol):+ def find_app_id_by_code(self, app_code: str) -> str | None: ...+++class WebAppAccessReferenceRequiredError(ValueError):+ """Raised when neither an app ID nor an app code was provided."""+++class WebAppAccessAppNotFoundError(LookupError):+ """Raised when an app code does not resolve to an app."""+++class WebAppAccessUnavailableError(RuntimeError):+ """Raised when an access dependency cannot answer the query."""+++class WebAppAccessQueryService:+ def __init__(+ self,+ *,+ access: WebAppAccessQuery,+ webapp_auth_enabled: bool,+ access_mode_for_app: Callable[[str], WebAppAccessMode],+ ) -> None:+ self._access = access+ self._webapp_auth_enabled = webapp_auth_enabled+ self._access_mode_for_app = access_mode_for_app++ def get_access_mode(self, *, app_id: str | None, app_code: str | None) -> WebAppAccessMode:+ if not self._webapp_auth_enabled:+ return WebAppAccessMode.PUBLIC++ if app_code:+ app_id = self._access.find_app_id_by_code(app_code)+ if app_id is None:+ raise WebAppAccessAppNotFoundError++ if not app_id:+ raise WebAppAccessReferenceRequiredError("appId or appCode must be provided")++ return self._access_mode_for_app(app_id)diff --git a/api/tests/unit_tests/controllers/web/test_app.py b/api/tests/unit_tests/controllers/web/test_app.pyindex b6245da2f01..3c5daf9224c 100644--- a/api/tests/unit_tests/controllers/web/test_app.py+++ b/api/tests/unit_tests/controllers/web/test_app.py@@ -3,17 +3,29 @@from __future__ import annotationsfrom types import SimpleNamespace-from unittest.mock import ANY, MagicMock, patch+from unittest.mock import MagicMock, patchimport pytestfrom flask import Flask+from controllers.common.errors import InvalidArgumentErrorfrom controllers.web.app import AppAccessMode, AppMeta, AppParameterApi, AppWebAuthPermission-from controllers.web.error import AgentNotPublishedError, AppUnavailableError+from controllers.web.error import (+ AgentNotPublishedError,+ AppUnavailableError,+ WebAppAccessServiceUnavailableError,+ WebAppNotFoundError,+)from core.app.app_config.common.parameters_mapping import get_parameters_from_feature_dict+from enums import WebAppAccessModefrom models.enums import EndUserTypefrom models.model import App, AppMode, EndUserfrom services.app_definition_query_service import AppDefinitionNotPublishedError, AppDefinitionUnavailableError+from services.webapp_access_query_service import (+ WebAppAccessAppNotFoundError,+ WebAppAccessReferenceRequiredError,+ WebAppAccessUnavailableError,+)def _make_app() -> App:@@ -119,53 +131,64 @@ class TestAppMeta:# AppAccessMode# ---------------------------------------------------------------------------class TestAppAccessMode:- @patch("controllers.web.app.FeatureService.get_system_features")- def test_returns_public_when_webapp_auth_disabled(self, mock_features: MagicMock, app: Flask) -> None:- mock_features.return_value = SimpleNamespace(webapp_auth=SimpleNamespace(enabled=False))-- with app.test_request_context("/webapp/access-mode?appId=app-1"):- result = AppAccessMode().get()-- assert result == {"accessMode": "public"}-- @patch("controllers.web.app.EnterpriseService.WebAppAuth.get_app_access_mode_by_id")- @patch("controllers.web.app.FeatureService.get_system_features")- def test_returns_access_mode_with_app_id(- self, mock_features: MagicMock, mock_access: MagicMock, app: Flask- ) -> None:- mock_features.return_value = SimpleNamespace(webapp_auth=SimpleNamespace(enabled=True))- mock_access.return_value = SimpleNamespace(access_mode="internal")+ @patch("controllers.web.app.application_services")+ def test_delegates_validated_app_references(self, application_services: MagicMock, app: Flask) -> None:+ webapp_access = MagicMock()+ webapp_access.get_access_mode.return_value = WebAppAccessMode.SSO_VERIFIED+ application_services.return_value = SimpleNamespace(webapp_access=webapp_access)- with app.test_request_context("/webapp/access-mode?appId=app-1"):+ with app.test_request_context("/webapp/access-mode?appId=app-1&appCode=code-1"):result = AppAccessMode().get()- assert result == {"accessMode": "internal"}- mock_access.assert_called_once_with("app-1")+ assert result == {"accessMode": "sso_verified"}+ webapp_access.get_access_mode.assert_called_once_with(app_id="app-1", app_code="code-1")- @patch("controllers.web.app.AppService.get_app_id_by_code", return_value="resolved-id")- @patch("controllers.web.app.EnterpriseService.WebAppAuth.get_app_access_mode_by_id")- @patch("controllers.web.app.FeatureService.get_system_features")- def test_resolves_app_code_to_id(- self, mock_features: MagicMock, mock_access: MagicMock, mock_resolve: MagicMock, app: Flask+ @pytest.mark.parametrize(+ ("service_error", "http_error", "expected_data"),+ [+ pytest.param(+ WebAppAccessReferenceRequiredError("appId or appCode must be provided"),+ InvalidArgumentError,+ {"code": "invalid_param", "message": "appId or appCode must be provided", "status": 400},+ id="missing-reference",+ ),+ pytest.param(+ WebAppAccessAppNotFoundError(),+ WebAppNotFoundError,+ {"code": "app_not_found", "message": "App not found.", "status": 404},+ id="app-not-found",+ ),+ pytest.param(+ WebAppAccessUnavailableError(),+ WebAppAccessServiceUnavailableError,+ {+ "code": "web_app_access_unavailable",+ "message": "Web app access service is unavailable.",+ "status": 503,+ },+ id="access-unavailable",+ ),+ ],+ )+ @patch("controllers.web.app.application_services")+ def test_maps_query_errors(+ self,+ application_services: MagicMock,+ service_error: Exception,+ http_error: type[Exception],+ expected_data: dict[str, object],+ app: Flask,) -> None:- mock_features.return_value = SimpleNamespace(webapp_auth=SimpleNamespace(enabled=True))- mock_access.return_value = SimpleNamespace(access_mode="external")+ webapp_access = MagicMock()+ webapp_access.get_access_mode.side_effect = service_error+ application_services.return_value = SimpleNamespace(webapp_access=webapp_access)- with app.test_request_context("/webapp/access-mode?appCode=code1"):- result = AppAccessMode().get()-- mock_resolve.assert_called_once_with("code1", session=ANY)- mock_access.assert_called_once_with("resolved-id")- assert result == {"accessMode": "external"}-- @patch("controllers.web.app.FeatureService.get_system_features")- def test_raises_when_no_app_id_or_code(self, mock_features: MagicMock, app: Flask) -> None:- mock_features.return_value = SimpleNamespace(webapp_auth=SimpleNamespace(enabled=True))-- with app.test_request_context("/webapp/access-mode"):- with pytest.raises(ValueError, match="appId or appCode"):+ with app.test_request_context("/webapp/access-mode?appCode=code-1"):+ with pytest.raises(http_error) as raised:AppAccessMode().get()+ assert raised.value.data == expected_data+# ---------------------------------------------------------------------------# AppWebAuthPermissiondiff --git a/api/tests/unit_tests/controllers/web/test_error.py b/api/tests/unit_tests/controllers/web/test_error.pyindex 78a72fc624f..578f2807225 100644--- a/api/tests/unit_tests/controllers/web/test_error.py+++ b/api/tests/unit_tests/controllers/web/test_error.py@@ -24,8 +24,10 @@ from controllers.web.error import (ProviderQuotaExceededError,SpeechToTextDisabledError,UnsupportedAudioTypeError,+ WebAppAccessServiceUnavailableError,WebAppAuthAccessDeniedError,WebAppAuthRequiredError,+ WebAppNotFoundError,WebFormRateLimitExceededError,)@@ -49,6 +51,8 @@ _ERROR_SPECS: list[tuple[type, str, int]] = [(SpeechToTextDisabledError, "speech_to_text_disabled", 400),(WebAppAuthRequiredError, "web_sso_auth_required", 401),(WebAppAuthAccessDeniedError, "web_app_access_denied", 401),+ (WebAppNotFoundError, "app_not_found", 404),+ (WebAppAccessServiceUnavailableError, "web_app_access_unavailable", 503),(InvokeRateLimitError, "rate_limit_error", 429),(WebFormRateLimitExceededError, "web_form_rate_limit_exceeded", 429),(NotFoundError, "not_found", 404),diff --git a/api/tests/unit_tests/extensions/test_ext_application_services.py b/api/tests/unit_tests/extensions/test_ext_application_services.pyindex 5701827304c..5ddaeb99412 100644--- a/api/tests/unit_tests/extensions/test_ext_application_services.py+++ b/api/tests/unit_tests/extensions/test_ext_application_services.py@@ -1,12 +1,16 @@"""Tests for application-service dependency wiring."""+import json+from types import SimpleNamespacefrom unittest.mock import MagicMock, patch+import httpximport pytestfrom flask import Flask+from pydantic import ValidationErrorfrom sqlalchemy.orm import Session, sessionmaker-from enums import DeploymentEdition+from enums import DeploymentEdition, WebAppAccessModefrom extensions import ext_application_servicesfrom extensions.ext_redis import RedisClientWrapperfrom models.model import DifySetup@@ -18,7 +22,10 @@ from services.account_activation_adapters import (RegisterServiceInvitationTokenStore,)from services.auth.data_source_api_key_auth_service import DataSourceApiKeyAuthService+from services.enterprise.enterprise_service import WebAppSettings+from services.errors.enterprise import EnterpriseAPIError, EnterpriseAPINotFoundErrorfrom services.init_validation_service import InvalidInitializationPasswordError+from services.webapp_access_query_service import WebAppAccessUnavailableError@pytest.mark.parametrize(@@ -186,3 +193,110 @@ def test_build_application_services_wires_data_source_api_key_auth()assert isinstance(services.data_source_api_key_auth, DataSourceApiKeyAuthService)+++def test_build_application_services_adapts_enterprise_webapp_access_mode(+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ with (+ patch("extensions.ext_application_services.FeatureService.is_webapp_auth_enabled", return_value=True),+ patch(+ "extensions.ext_application_services.EnterpriseService.WebAppAuth.get_app_access_mode_by_id",+ return_value=SimpleNamespace(access_mode="private_all"),+ ) as get_access_mode,+ ):+ services = ext_application_services.build_application_services(+ database_client=sqlite_session_factory,+ deployment_edition=DeploymentEdition.COMMUNITY,+ initialization_password="",+ redis=MagicMock(spec=RedisClientWrapper),+ )+ result = services.webapp_access.get_access_mode(app_id="app-1", app_code=None)++ assert result is WebAppAccessMode.PRIVATE_ALL+ get_access_mode.assert_called_once_with("app-1")+++ "enterprise_error",+ [+ pytest.param(EnterpriseAPINotFoundError(), id="not-found"),+ pytest.param(EnterpriseAPIError(), id="api-error"),+ pytest.param(httpx.ConnectError("connection failed"), id="transport"),+ pytest.param(json.JSONDecodeError("invalid", "", 0), id="invalid-json"),+ pytest.param(UnicodeDecodeError("utf-8", b"\xff", 0, 1, "invalid"), id="invalid-encoding"),+ pytest.param(+ ValidationError.from_exception_data(WebAppSettings.__name__, []),+ id="invalid-response",+ ),+ ],+)+def test_build_application_services_maps_known_enterprise_errors(+ sqlite_session_factory: sessionmaker[Session],+ enterprise_error: Exception,+) -> None:+ with (+ patch("extensions.ext_application_services.FeatureService.is_webapp_auth_enabled", return_value=True),+ patch(+ "extensions.ext_application_services.EnterpriseService.WebAppAuth.get_app_access_mode_by_id",+ side_effect=enterprise_error,+ ),+ ):+ services = ext_application_services.build_application_services(+ database_client=sqlite_session_factory,+ deployment_edition=DeploymentEdition.COMMUNITY,+ initialization_password="",+ redis=MagicMock(spec=RedisClientWrapper),+ )++ with pytest.raises(WebAppAccessUnavailableError) as raised:+ services.webapp_access.get_access_mode(app_id="app-1", app_code=None)++ assert raised.value.__cause__ is enterprise_error+++def test_build_application_services_maps_invalid_access_mode_to_unavailable(+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ with (+ patch("extensions.ext_application_services.FeatureService.is_webapp_auth_enabled", return_value=True),+ patch(+ "extensions.ext_application_services.EnterpriseService.WebAppAuth.get_app_access_mode_by_id",+ return_value=SimpleNamespace(access_mode="invalid"),+ ),+ ):+ services = ext_application_services.build_application_services(+ database_client=sqlite_session_factory,+ deployment_edition=DeploymentEdition.COMMUNITY,+ initialization_password="",+ redis=MagicMock(spec=RedisClientWrapper),+ )++ with pytest.raises(WebAppAccessUnavailableError) as raised:+ services.webapp_access.get_access_mode(app_id="app-1", app_code=None)++ assert isinstance(raised.value.__cause__, ValueError)+++def test_build_application_services_does_not_hide_unknown_enterprise_errors(+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ failure = TypeError("adapter bug")+ with (+ patch("extensions.ext_application_services.FeatureService.is_webapp_auth_enabled", return_value=True),+ patch(+ "extensions.ext_application_services.EnterpriseService.WebAppAuth.get_app_access_mode_by_id",+ side_effect=failure,+ ),+ ):+ services = ext_application_services.build_application_services(+ database_client=sqlite_session_factory,+ deployment_edition=DeploymentEdition.COMMUNITY,+ initialization_password="",+ redis=MagicMock(spec=RedisClientWrapper),+ )++ with pytest.raises(TypeError) as raised:+ services.webapp_access.get_access_mode(app_id="app-1", app_code=None)++ assert raised.value is failurediff --git a/api/tests/unit_tests/repositories/test_webapp_access_query_repository.py b/api/tests/unit_tests/repositories/test_webapp_access_query_repository.pynew file mode 100644index 00000000000..478898cdc5e--- /dev/null+++ b/api/tests/unit_tests/repositories/test_webapp_access_query_repository.py@@ -0,0 +1,60 @@+from unittest.mock import MagicMock++import pytest+from sqlalchemy.exc import OperationalError+from sqlalchemy.orm import Session, sessionmaker++from models.model import Site+from repositories.webapp_access_query_repository import WebAppAccessQueryRepository+from services.webapp_access_query_service import WebAppAccessUnavailableError++_APP_ID = "11111111-1111-1111-1111-111111111111"+++def test_find_app_id_by_code_returns_matching_site_app(sqlite_session_factory: sessionmaker[Session]) -> None:+ with sqlite_session_factory.begin() as session:+ session.add(+ Site(+ app_id=_APP_ID,+ code="site-code",+ title="Test Site",+ default_language="en-US",+ customize_token_strategy="uuid",+ )+ )++ repository = WebAppAccessQueryRepository(session_factory=sqlite_session_factory)++ assert repository.find_app_id_by_code("site-code") == _APP_ID+++def test_find_app_id_by_code_returns_none_for_missing_code(+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ repository = WebAppAccessQueryRepository(session_factory=sqlite_session_factory)++ assert repository.find_app_id_by_code("missing-code") is None+++def test_find_app_id_by_code_maps_database_failures_to_unavailable() -> None:+ database_error = OperationalError("select", {}, RuntimeError("connection failed"))+ session = MagicMock()+ session.__enter__.return_value.scalar.side_effect = database_error+ repository = WebAppAccessQueryRepository(session_factory=MagicMock(return_value=session))++ with pytest.raises(WebAppAccessUnavailableError) as raised:+ repository.find_app_id_by_code("site-code")++ assert raised.value.__cause__ is database_error+++def test_find_app_id_by_code_does_not_hide_unknown_errors() -> None:+ failure = TypeError("repository bug")+ session = MagicMock()+ session.__enter__.return_value.scalar.side_effect = failure+ repository = WebAppAccessQueryRepository(session_factory=MagicMock(return_value=session))++ with pytest.raises(TypeError) as raised:+ repository.find_app_id_by_code("site-code")++ assert raised.value is failurediff --git a/api/tests/unit_tests/services/enterprise/test_enterprise_service.py b/api/tests/unit_tests/services/enterprise/test_enterprise_service.pyindex d50f276bc75..e37ffc8d425 100644--- a/api/tests/unit_tests/services/enterprise/test_enterprise_service.py+++ b/api/tests/unit_tests/services/enterprise/test_enterprise_service.py@@ -23,7 +23,12 @@ from services.enterprise.enterprise_service import (try_join_default_workspace,)from services.entities.feature_entities import LicenseStatus-from services.errors.enterprise import EnterpriseAPIError, EnterpriseAPIForbiddenError, EnterpriseAPIUnauthorizedError+from services.errors.enterprise import (+ EnterpriseAPIError,+ EnterpriseAPIForbiddenError,+ EnterpriseAPIUnauthorizedError,+ EnterpriseServiceError,+)MODULE = "services.enterprise.enterprise_service"@@ -147,6 +152,12 @@ class TestWebAppAuth:assert isinstance(result, WebAppSettings)assert result.access_mode == "public"+ def test_get_app_access_mode_raises_service_error_on_empty_response(self):+ with patch(f"{MODULE}.EnterpriseRequest") as req:+ req.send_request.return_value = None+ with pytest.raises(EnterpriseServiceError, match="No data found"):+ EnterpriseService.WebAppAuth.get_app_access_mode_by_id("a1")+def test_batch_get_returns_empty_for_no_apps(self):assert EnterpriseService.WebAppAuth.batch_get_app_access_mode_by_id([]) == {}diff --git a/api/tests/unit_tests/services/test_feature_service_deployment_edition.py b/api/tests/unit_tests/services/test_feature_service_deployment_edition.pyindex 8336b923ffb..63ebb75c4ba 100644--- a/api/tests/unit_tests/services/test_feature_service_deployment_edition.py+++ b/api/tests/unit_tests/services/test_feature_service_deployment_edition.py@@ -36,6 +36,9 @@ def test_get_system_features_uses_configured_deployment_edition(assert result.deployment_edition is editionassert result.model_dump(mode="json")["deployment_edition"] == edition.value+ webapp_auth_enabled = edition is DeploymentEdition.ENTERPRISE+ assert FeatureService.is_webapp_auth_enabled() is webapp_auth_enabled+ assert result.webapp_auth.enabled is webapp_auth_enabledif edition is DeploymentEdition.ENTERPRISE:fulfill_from_enterprise.assert_called_once_with(result)else:diff --git a/api/tests/unit_tests/services/test_webapp_access_query_service.py b/api/tests/unit_tests/services/test_webapp_access_query_service.pynew file mode 100644index 00000000000..8c0702a9018--- /dev/null+++ b/api/tests/unit_tests/services/test_webapp_access_query_service.py@@ -0,0 +1,101 @@+from unittest.mock import MagicMock, create_autospec++import pytest++from enums import WebAppAccessMode+from services.webapp_access_query_service import (+ WebAppAccessAppNotFoundError,+ WebAppAccessQuery,+ WebAppAccessQueryService,+ WebAppAccessReferenceRequiredError,+)+++def _service(+ *,+ access: MagicMock,+ enabled: bool = True,+ access_mode: WebAppAccessMode = WebAppAccessMode.PRIVATE,+) -> tuple[WebAppAccessQueryService, MagicMock]:+ access_mode_for_app = MagicMock(return_value=access_mode)+ return (+ WebAppAccessQueryService(+ access=access,+ webapp_auth_enabled=enabled,+ access_mode_for_app=access_mode_for_app,+ ),+ access_mode_for_app,+ )+++def test_disabled_auth_returns_public_before_resolving_app() -> None:+ access: MagicMock = create_autospec(WebAppAccessQuery, instance=True, spec_set=True)+ service, access_mode_for_app = _service(access=access, enabled=False)++ assert service.get_access_mode(app_id=None, app_code=None) is WebAppAccessMode.PUBLIC+ access.find_app_id_by_code.assert_not_called()+ access_mode_for_app.assert_not_called()+++def test_enabled_auth_reads_access_mode_by_app_id() -> None:+ access: MagicMock = create_autospec(WebAppAccessQuery, instance=True, spec_set=True)+ service, access_mode_for_app = _service(access=access)++ assert service.get_access_mode(app_id="app-1", app_code=None) is WebAppAccessMode.PRIVATE+ access.find_app_id_by_code.assert_not_called()+ access_mode_for_app.assert_called_once_with("app-1")+++def test_app_code_takes_precedence_over_app_id() -> None:+ access: MagicMock = create_autospec(WebAppAccessQuery, instance=True, spec_set=True)+ access.find_app_id_by_code.return_value = "resolved-id"+ service, access_mode_for_app = _service(access=access, access_mode=WebAppAccessMode.SSO_VERIFIED)++ assert service.get_access_mode(app_id="ignored-id", app_code="code-1") is WebAppAccessMode.SSO_VERIFIED+ access.find_app_id_by_code.assert_called_once_with("code-1")+ access_mode_for_app.assert_called_once_with("resolved-id")+++def test_missing_app_code_raises_not_found() -> None:+ access: MagicMock = create_autospec(WebAppAccessQuery, instance=True, spec_set=True)+ access.find_app_id_by_code.return_value = None+ service, access_mode_for_app = _service(access=access)++ with pytest.raises(WebAppAccessAppNotFoundError):+ service.get_access_mode(app_id="must-not-fallback", app_code="missing-code")++ access_mode_for_app.assert_not_called()+++def test_enabled_auth_requires_app_id_or_code() -> None:+ access: MagicMock = create_autospec(WebAppAccessQuery, instance=True, spec_set=True)+ service, access_mode_for_app = _service(access=access)++ with pytest.raises(WebAppAccessReferenceRequiredError, match="^appId or appCode must be provided$"):+ service.get_access_mode(app_id=None, app_code=None)++ access_mode_for_app.assert_not_called()+++def test_repository_failure_is_not_hidden() -> None:+ access: MagicMock = create_autospec(WebAppAccessQuery, instance=True, spec_set=True)+ failure = TypeError("repository bug")+ access.find_app_id_by_code.side_effect = failure+ service, _ = _service(access=access)++ with pytest.raises(TypeError) as raised:+ service.get_access_mode(app_id=None, app_code="code-1")++ assert raised.value is failure+++def test_access_mode_failure_is_not_hidden() -> None:+ access: MagicMock = create_autospec(WebAppAccessQuery, instance=True, spec_set=True)+ service, access_mode_for_app = _service(access=access)+ failure = TypeError("adapter bug")+ access_mode_for_app.side_effect = failure++ with pytest.raises(TypeError) as raised:+ service.get_access_mode(app_id="app-1", app_code=None)++ assert raised.value is failurediff --git a/packages/contracts/generated/api/web/types.gen.ts b/packages/contracts/generated/api/web/types.gen.tsindex f95ed066bb5..5c9b6a578e8 100644--- a/packages/contracts/generated/api/web/types.gen.ts+++ b/packages/contracts/generated/api/web/types.gen.ts@@ -1543,7 +1543,9 @@ export type GetWebappAccessModeData = {export type GetWebappAccessModeErrors = {400: unknown+ 404: unknown500: unknown+ 503: unknown}export type GetWebappAccessModeResponses = {