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 workspace member listing into layered service (#39974)
Escape0707b6b3e747f3d5
diff --git a/api/.importlinter b/api/.importlinterindex 6fa9c7cd873..3d6416f4080 100644--- a/api/.importlinter+++ b/api/.importlinter@@ -41,3 +41,20 @@ forbidden_modules =repositoriessqlalchemywerkzeug++[importlinter:contract:workspace-member-query-service-boundary]+name = Workspace member query application service is framework and persistence neutral+type = forbidden+source_modules =+ services.workspace_member_query_service+forbidden_modules =+ configs+ controllers+ extensions+ flask+ models+ repositories+ services.enterprise+ services.workspace_member_role_resolver+ sqlalchemy+ werkzeugdiff --git a/api/controllers/console/workspace/members.py b/api/controllers/console/workspace/members.pyindex 9d40d32aaa2..ae7eb9d2ac1 100644--- a/api/controllers/console/workspace/members.py+++ b/api/controllers/console/workspace/members.py@@ -24,6 +24,7 @@ from controllers.console.auth.error import (OwnerTransferLimitError,)from controllers.console.error import EmailSendIpLimitError, SeatsLimitExceeded, WorkspaceMembersLimitExceeded+from controllers.console.flask_admission import console_account_admissionfrom controllers.console.workspace.error import InvalidMemberRoleErrorfrom controllers.console.wraps import (account_initialization_required,@@ -31,15 +32,16 @@ from controllers.console.wraps import (setup_required,with_current_user,)+from extensions.ext_application_services import application_servicesfrom extensions.ext_database import dbfrom extensions.ext_redis import redis_clientfrom fields.base import ResponseModelfrom fields.member_fields import AccountWithRoleListResponse, AccountWithRoleResponsefrom libs.helper import dump_response, extract_remote_ip-from libs.login import current_account_with_tenant, login_required+from libs.login import login_required+from machinery.context import RequestContextfrom models.account import Account, TenantAccountJoin, TenantAccountRolefrom services.account_service import AccountService, RegisterService, TenantService-from services.enterprise import rbac_service as enterprise_rbac_servicefrom services.errors.account import AccountAlreadyInTenantErrorfrom services.feature_service import FeatureService@@ -144,22 +146,6 @@ def _is_role_enabled(role: TenantAccountRole | str, tenant_id: str) -> bool:return FeatureService.get_features(tenant_id=tenant_id, exclude_vector_space=True).dataset_operator_enabled-def _serialize_member_roles(- current_role: str | None, member_roles: list[enterprise_rbac_service.RBACRole]-) -> list[dict[str, str]]:- if dify_config.RBAC_ENABLED:- return [{"id": role.id, "name": role.name} for role in member_roles]- else:- if current_role:- return [{"id": current_role, "name": current_role}]- return []---def _normalize_enum_value(value: object) -> str:- normalized = getattr(value, "value", value)- return str(normalized) if normalized is not None else ""--def _count_new_member_invites(tenant_id: str, emails: list[str]) -> tuple[int, int]:new_member_count = 0new_account_count = 0@@ -214,46 +200,25 @@ def _check_member_invite_limits(tenant_id: str, new_member_count: int, new_accouclass MemberListApi(Resource):"""List all members of current tenant."""- @setup_required- @login_required- @account_initialization_required@console_ns.response(HTTPStatus.OK, "Success", console_ns.models[AccountWithRoleListResponse.__name__])- @with_current_user- def get(self, current_user: Account | None = None):- if current_user is None:- current_user, _ = current_account_with_tenant()- if not current_user.current_tenant:- raise ValueError("No current tenant")- members = TenantService.get_tenant_members(current_user.current_tenant, session=db.session())- if dify_config.RBAC_ENABLED:- member_ids = [member.id for member in members]- member_roles = enterprise_rbac_service.RBACService.MemberRoles.batch_get(- str(current_user.current_tenant.id),- current_user.id,- member_ids,- )- roles_map = {item.account_id: item.roles for item in member_roles}- else:- roles_map = {}-- serialized_members = []- for member in members:- current_role = _normalize_enum_value(member.current_role)- serialized_members.append(- {- "id": member.id,- "name": member.name,- "email": member.email,- "avatar": member.avatar,- "last_login_at": member.last_login_at,- "last_active_at": member.last_active_at,- "created_at": member.created_at,- "role": current_role,- "roles": _serialize_member_roles(current_role, roles_map.get(member.id, [])),- "status": _normalize_enum_value(member.status),- }- )-+ @console_account_admission()+ def get(self, request_context: RequestContext):+ members = application_services().workspace_member_queries.list_current(request_context)+ serialized_members = [+ {+ "id": member.id,+ "name": member.name,+ "email": member.email,+ "avatar": member.avatar,+ "last_login_at": member.last_login_at,+ "last_active_at": member.last_active_at,+ "created_at": member.created_at,+ "role": member.role,+ "roles": [{"id": role.id, "name": role.name} for role in member.roles],+ "status": member.status,+ }+ for member in members+ ]return dump_response(AccountWithRoleListResponse, {"accounts": serialized_members}), HTTPStatus.OKdiff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.pyindex 8e8e5b39947..3cdda39de14 100644--- a/api/extensions/ext_application_services.py+++ b/api/extensions/ext_application_services.py@@ -7,7 +7,10 @@ from flask import Flask, current_appfrom sqlalchemy.orm import Session, sessionmakerfrom core.db.session_factory import get_session_maker+from repositories.workspace_member_query_repository import WorkspaceMemberQueryRepositoryfrom repositories.workspace_query_repository import WorkspaceQueryRepository+from services.workspace_member_query_service import WorkspaceMemberQueryService+from services.workspace_member_role_resolver import DeploymentWorkspaceMemberRoleResolverfrom services.workspace_query_compat import LegacyWorkspacePlanGatewayfrom services.workspace_query_service import WorkspaceQueryService@@ -17,6 +20,7 @@ _EXTENSION_KEY = "application_services"@dataclass(frozen=True, slots=True)class ApplicationServices:workspace_queries: WorkspaceQueryService+ workspace_member_queries: WorkspaceMemberQueryServicedef build_application_services(@@ -29,7 +33,13 @@ def build_application_services(client=database_client,),plans=LegacyWorkspacePlanGateway(),- )+ ),+ workspace_member_queries=WorkspaceMemberQueryService(+ members=WorkspaceMemberQueryRepository(+ session_factory=database_client,+ ),+ roles=DeploymentWorkspaceMemberRoleResolver(),+ ),)diff --git a/api/repositories/workspace_member_query_repository.py b/api/repositories/workspace_member_query_repository.pynew file mode 100644index 00000000000..1c67ae13e7f--- /dev/null+++ b/api/repositories/workspace_member_query_repository.py@@ -0,0 +1,62 @@+"""Database repository for the workspace-member read model."""++from typing import override++from sqlalchemy import select+from sqlalchemy.orm import Session, sessionmaker++from models.account import Account, TenantAccountJoin+from services.workspace_member_query_service import WorkspaceMemberQuery, WorkspaceMemberRecord+++class WorkspaceMemberQueryRepository(WorkspaceMemberQuery):+ def __init__(self, session_factory: sessionmaker[Session]) -> None:+ self._session_factory = session_factory++ @override+ def list_for_workspace(self, workspace_id: str) -> tuple[WorkspaceMemberRecord, ...]:+ stmt = (+ select(+ Account.id,+ Account.name,+ Account.email,+ Account.avatar,+ Account.last_login_at,+ Account.last_active_at,+ Account.created_at,+ Account.status,+ TenantAccountJoin.role,+ )+ .select_from(Account)+ .join(TenantAccountJoin, TenantAccountJoin.account_id == Account.id)+ .where(TenantAccountJoin.tenant_id == workspace_id)+ )++ with self._session_factory() as session:+ rows = session.execute(stmt).all()+ records = tuple(+ WorkspaceMemberRecord(+ id=account_id,+ name=name,+ email=email,+ avatar=avatar,+ last_login_at=last_login_at,+ last_active_at=last_active_at,+ created_at=created_at,+ status=status.value,+ legacy_role=legacy_role.value,+ )+ for (+ account_id,+ name,+ email,+ avatar,+ last_login_at,+ last_active_at,+ created_at,+ status,+ legacy_role,+ ) in rows+ )++ return recordsdiff --git a/api/services/workspace_member_query_service.py b/api/services/workspace_member_query_service.pynew file mode 100644index 00000000000..76ccb3d25a7--- /dev/null+++ b/api/services/workspace_member_query_service.py@@ -0,0 +1,96 @@+"""Application service for listing members of the active Console workspace."""++from collections.abc import Mapping, Sequence+from datetime import datetime+from typing import NamedTuple, Protocol++from machinery.context import RequestContext+++class WorkspaceMemberRole(NamedTuple):+ id: str+ name: str+++class WorkspaceMemberRecord(NamedTuple):+ id: str+ name: str+ email: str+ avatar: str | None+ last_login_at: datetime | None+ last_active_at: datetime+ created_at: datetime+ status: str+ legacy_role: str+++class WorkspaceMemberQuery(Protocol):+ def list_for_workspace(self, workspace_id: str) -> Sequence[WorkspaceMemberRecord]: ...+++class WorkspaceMemberRoleSubject(NamedTuple):+ account_id: str+ legacy_role: str+++class WorkspaceMemberRoleResolver(Protocol):+ def resolve_many(+ self,+ workspace_id: str,+ actor_account_id: str,+ subjects: Sequence[WorkspaceMemberRoleSubject],+ ) -> Mapping[str, Sequence[WorkspaceMemberRole]]: ...+++class WorkspaceMemberSummary(NamedTuple):+ id: str+ name: str+ email: str+ avatar: str | None+ last_login_at: datetime | None+ last_active_at: datetime+ created_at: datetime+ role: str+ roles: tuple[WorkspaceMemberRole, ...]+ status: str+++class WorkspaceMemberQueryService:+ def __init__(+ self,+ *,+ members: WorkspaceMemberQuery,+ roles: WorkspaceMemberRoleResolver,+ ) -> None:+ self._members = members+ self._roles = roles++ def list_current(self, context: RequestContext) -> tuple[WorkspaceMemberSummary, ...]:+ workspace_id = context.active_workspace_id+ if workspace_id is None:+ raise RuntimeError("Console account admission did not resolve an active workspace")++ records = tuple(self._members.list_for_workspace(workspace_id))+ role_subjects = tuple(+ WorkspaceMemberRoleSubject(account_id=record.id, legacy_role=record.legacy_role) for record in records+ )++ # The repository closes its read Session before role resolution+ # performs enterprise I/O.+ roles_by_member = self._roles.resolve_many(workspace_id, context.account_id, role_subjects)++ return tuple(+ WorkspaceMemberSummary(+ id=record.id,+ name=record.name,+ email=record.email,+ avatar=record.avatar,+ last_login_at=record.last_login_at,+ last_active_at=record.last_active_at,+ created_at=record.created_at,+ role=record.legacy_role,+ roles=tuple(roles_by_member.get(record.id, ())),+ status=record.status,+ )+ for record in records+ )diff --git a/api/services/workspace_member_role_resolver.py b/api/services/workspace_member_role_resolver.pynew file mode 100644index 00000000000..d2a4ceacec2--- /dev/null+++ b/api/services/workspace_member_role_resolver.py@@ -0,0 +1,43 @@+"""Deployment-compatible role resolution for workspace-member queries."""++from collections.abc import Mapping, Sequence+from typing import override++from configs import dify_config+from services.enterprise import rbac_service as enterprise_rbac_service+from services.workspace_member_query_service import (+ WorkspaceMemberRole,+ WorkspaceMemberRoleResolver,+ WorkspaceMemberRoleSubject,+)+++class DeploymentWorkspaceMemberRoleResolver(WorkspaceMemberRoleResolver):+ """Preserve deployment-specific legacy and enterprise role behavior."""++ @override+ def resolve_many(+ self,+ workspace_id: str,+ actor_account_id: str,+ subjects: Sequence[WorkspaceMemberRoleSubject],+ ) -> Mapping[str, Sequence[WorkspaceMemberRole]]:+ role_subjects = tuple(subjects)+ if not role_subjects:+ return {}++ if not dify_config.RBAC_ENABLED:+ return {+ subject.account_id: (WorkspaceMemberRole(id=subject.legacy_role, name=subject.legacy_role),)+ for subject in role_subjects+ }++ member_roles = enterprise_rbac_service.RBACService.MemberRoles.batch_get(+ workspace_id,+ actor_account_id,+ [subject.account_id for subject in role_subjects],+ )+ return {+ item.account_id: tuple(WorkspaceMemberRole(id=role.id, name=role.name) for role in item.roles)+ for item in member_roles+ }diff --git a/api/tests/unit_tests/controllers/console/test_workspace_members.py b/api/tests/unit_tests/controllers/console/test_workspace_members.pyindex deadff06c94..9b3a272dfcb 100644--- a/api/tests/unit_tests/controllers/console/test_workspace_members.py+++ b/api/tests/unit_tests/controllers/console/test_workspace_members.py@@ -81,14 +81,12 @@ class TestMemberInviteEmailApi:@patch("controllers.console.workspace.members.FeatureService.get_features")@patch("controllers.console.workspace.members.RegisterService.invite_new_member")- @patch("controllers.console.workspace.members.current_account_with_tenant")@patch("controllers.console.wraps.db")@patch("libs.login.check_csrf_token", return_value=None)def test_invite_rbac_enabled_accepts_rbac_role_id(self,mock_csrf,mock_db,- mock_current_account,mock_invite_member,mock_get_features,app,@@ -98,8 +96,6 @@ class TestMemberInviteEmailApi:mock_invite_member.return_value = "rbac-token"tenant = SimpleNamespace(id="tenant-1", name="Test Tenant")- inviter = SimpleNamespace(email="[email protected]", current_tenant=tenant, status="active")- mock_current_account.return_value = (inviter, tenant.id)with patch("controllers.console.workspace.members.dify_config") as mock_config:mock_config.RBAC_ENABLED = True@@ -121,14 +117,12 @@ class TestMemberInviteEmailApi:assert call_args.kwargs["role"] == "rbac-role-id-abc"@patch("controllers.console.workspace.members.FeatureService.get_features")- @patch("controllers.console.workspace.members.current_account_with_tenant")@patch("controllers.console.wraps.db")@patch("libs.login.check_csrf_token", return_value=None)def test_invite_rbac_disabled_rejects_invalid_role(self,mock_csrf,mock_db,- mock_current_account,mock_get_features,app,):@@ -136,8 +130,6 @@ class TestMemberInviteEmailApi:mock_get_features.return_value = _build_feature_flags()tenant = SimpleNamespace(id="tenant-1", name="Test Tenant")- inviter = SimpleNamespace(email="[email protected]", current_tenant=tenant, status="active")- mock_current_account.return_value = (inviter, tenant.id)with patch("controllers.console.workspace.members.dify_config") as mock_config:mock_config.RBAC_ENABLED = False@@ -158,14 +150,12 @@ class TestMemberInviteEmailApi:assert exc_info.value.data == {"code": "invalid_role", "message": "Invalid role.", "status": 400}@patch("controllers.console.workspace.members.FeatureService.get_features")- @patch("controllers.console.workspace.members.current_account_with_tenant")@patch("controllers.console.wraps.db")@patch("libs.login.check_csrf_token", return_value=None)def test_invite_rbac_disabled_rejects_owner_role(self,mock_csrf,mock_db,- mock_current_account,mock_get_features,app,):@@ -173,8 +163,6 @@ class TestMemberInviteEmailApi:mock_get_features.return_value = _build_feature_flags()tenant = SimpleNamespace(id="tenant-1", name="Test Tenant")- inviter = SimpleNamespace(email="[email protected]", current_tenant=tenant, status="active")- mock_current_account.return_value = (inviter, tenant.id)with patch("controllers.console.workspace.members.dify_config") as mock_config:mock_config.RBAC_ENABLED = Falsediff --git a/api/tests/unit_tests/controllers/console/workspace/test_members.py b/api/tests/unit_tests/controllers/console/workspace/test_members.pyindex 58f8468429a..98222e4836b 100644--- a/api/tests/unit_tests/controllers/console/workspace/test_members.py+++ b/api/tests/unit_tests/controllers/console/workspace/test_members.py@@ -1,6 +1,9 @@from contextlib import nullcontext+from datetime import datetime+from http import HTTPStatusfrom inspect import unwrapfrom types import SimpleNamespace+from typing import NamedTuple, overridefrom unittest.mock import MagicMock, patchimport pytest@@ -29,92 +32,93 @@ from controllers.console.workspace.members import (_count_new_member_invites,)from libs.external_api import ExternalApi+from machinery.context import RequestContextfrom services.errors.account import AccountAlreadyInTenantError, SeatsLimitExceededError+from services.workspace_member_query_service import (+ WorkspaceMemberQueryService,+ WorkspaceMemberRole,+ WorkspaceMemberSummary,+)-class TestMemberListApi:- def test_get_success(self, app: Flask):- api = MemberListApi()- method = unwrap(api.get)+class _RecordingWorkspaceMemberQueryService(WorkspaceMemberQueryService):+ def __init__(self, result: tuple[WorkspaceMemberSummary, ...]) -> None:+ self._result = result+ self.contexts: list[RequestContext] = []- tenant = MagicMock()- user = MagicMock(current_tenant=tenant)- member = MagicMock()- member.id = "m1"- member.name = "Member"- member.email = "[email protected]"- member.avatar = "avatar.png"- member.current_role = SimpleNamespace(value="admin")- member.status = SimpleNamespace(value="active")- members = [member]+ @override+ def list_current(self, context: RequestContext) -> tuple[WorkspaceMemberSummary, ...]:+ self.contexts.append(context)+ return self._result- with (- app.test_request_context("/"),- patch("controllers.console.workspace.members.TenantService.get_tenant_members", return_value=members),- ):- result, status = method(api, user)- assert status == 200- assert len(result["accounts"]) == 1- assert result["accounts"][0]["role"] == "admin"- assert result["accounts"][0]["roles"] == [{"id": "admin", "name": "admin"}]+class _ApplicationServicesStub(NamedTuple):+ workspace_member_queries: WorkspaceMemberQueryService- def test_get_with_rbac_enabled_fetches_roles_in_batch(self, app):++class TestMemberListApi:+ def test_get_passes_context_and_serializes_application_result(self, app: Flask) -> None:api = MemberListApi()method = unwrap(api.get)-- tenant = MagicMock(id="tenant-1")- user = MagicMock(id="acct-1", current_tenant=tenant)- member = SimpleNamespace(- id="m1",- name="Member",- email="[email protected]",- avatar=None,- last_login_at=1,- last_active_at=2,- created_at=3,- current_role=SimpleNamespace(value="editor"),- status=SimpleNamespace(value="active"),+ request_context = RequestContext(+ request_id="request-1",+ trace_id="trace-1",+ account_id="actor-1",+ active_workspace_id="workspace-1",)- role_item = SimpleNamespace(- account_id="m1",- roles=[- SimpleNamespace(id="workspace.owner", name="Owner"),- SimpleNamespace(id="workspace.editor", name="Editor"),- ],+ timestamp = datetime(2026, 1, 1)+ workspace_member_queries = _RecordingWorkspaceMemberQueryService(+ (+ WorkspaceMemberSummary(+ id="member-1",+ name="Member",+ email="[email protected]",+ avatar=None,+ last_login_at=None,+ last_active_at=timestamp,+ created_at=timestamp,+ role="owner",+ roles=(+ WorkspaceMemberRole(id="workspace.owner", name="Owner"),+ WorkspaceMemberRole(id="workspace.editor", name="Editor"),+ ),+ status="active",+ ),+ ))+ application_services_stub = _ApplicationServicesStub(workspace_member_queries=workspace_member_queries)with (app.test_request_context("/"),- patch("controllers.console.workspace.members.current_account_with_tenant", return_value=(user, "tenant-1")),- patch("controllers.console.workspace.members.dify_config.RBAC_ENABLED", True),- patch("controllers.console.workspace.members.TenantService.get_tenant_members", return_value=[member]),patch(- "controllers.console.workspace.members.enterprise_rbac_service.RBACService.MemberRoles.batch_get",- return_value=[role_item],- ) as mock_batch_get,- ):- result, status = method(api)-- assert status == 200- assert result["accounts"][0]["role"] == "editor"- assert result["accounts"][0]["roles"] == [- {"id": "workspace.owner", "name": "Owner"},- {"id": "workspace.editor", "name": "Editor"},- ]- mock_batch_get.assert_called_once_with("tenant-1", "acct-1", ["m1"])-- def test_get_no_tenant(self, app: Flask):- api = MemberListApi()- method = unwrap(api.get)-- user = MagicMock(current_tenant=None)-- with (- app.test_request_context("/"),+ "controllers.console.workspace.members.application_services",+ return_value=application_services_stub,+ ),):- with pytest.raises(ValueError):- method(api, user)+ result, status = method(api, request_context=request_context)++ assert status == HTTPStatus.OK+ assert result == {+ "accounts": [+ {+ "id": "member-1",+ "name": "Member",+ "email": "[email protected]",+ "avatar": None,+ "avatar_url": None,+ "last_login_at": None,+ "last_active_at": int(timestamp.timestamp()),+ "created_at": int(timestamp.timestamp()),+ "role": "owner",+ "roles": [+ {"id": "workspace.owner", "name": "Owner"},+ {"id": "workspace.editor", "name": "Editor"},+ ],+ "status": "active",+ }+ ]+ }+ assert workspace_member_queries.contexts == [request_context]class TestMemberInviteEmailApi:diff --git a/api/tests/unit_tests/repositories/test_workspace_member_query_repository.py b/api/tests/unit_tests/repositories/test_workspace_member_query_repository.pynew file mode 100644index 00000000000..852dc543e67--- /dev/null+++ b/api/tests/unit_tests/repositories/test_workspace_member_query_repository.py@@ -0,0 +1,126 @@+from datetime import datetime++from sqlalchemy.orm import Session, sessionmaker++from models.account import Account, AccountStatus, Tenant, TenantAccountJoin, TenantAccountRole+from repositories.workspace_member_query_repository import WorkspaceMemberQueryRepository+from services.workspace_member_query_service import WorkspaceMemberRecord+++def make_account(+ account_id: str,+ *,+ status: AccountStatus,+ created_at: datetime,+) -> Account:+ account = Account(+ name=f"Member {account_id}",+ email=f"{account_id}@example.com",+ avatar=f"{account_id}.png",+ status=status,+ )+ account.id = account_id+ account.last_login_at = created_at+ account.last_active_at = created_at+ account.created_at = created_at+ return account+++def make_tenant(tenant_id: str) -> Tenant:+ tenant = Tenant(name=f"Workspace {tenant_id}")+ tenant.id = tenant_id+ return tenant+++def test_list_for_workspace_uses_join_membership_and_preserves_account_lifecycle(+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ created_at = datetime(2026, 1, 1)+ active = make_account("active", status=AccountStatus.ACTIVE, created_at=created_at)+ uninitialized = make_account("uninitialized", status=AccountStatus.UNINITIALIZED, created_at=created_at)+ pending = make_account("pending", status=AccountStatus.PENDING, created_at=created_at)+ banned = make_account("banned", status=AccountStatus.BANNED, created_at=created_at)+ closed = make_account("closed", status=AccountStatus.CLOSED, created_at=created_at)+ other_workspace_member = make_account("other", status=AccountStatus.ACTIVE, created_at=created_at)+ unjoined = make_account("unjoined", status=AccountStatus.ACTIVE, created_at=created_at)+ workspace = make_tenant("workspace-1")+ other_workspace = make_tenant("workspace-2")++ with sqlite_session_factory() as session:+ session.add_all(+ [+ workspace,+ other_workspace,+ active,+ uninitialized,+ pending,+ banned,+ closed,+ other_workspace_member,+ unjoined,+ TenantAccountJoin(+ tenant_id=workspace.id,+ account_id=active.id,+ role=TenantAccountRole.OWNER,+ ),+ TenantAccountJoin(+ tenant_id=workspace.id,+ account_id=uninitialized.id,+ role=TenantAccountRole.NORMAL,+ ),+ TenantAccountJoin(+ tenant_id=workspace.id,+ account_id=pending.id,+ role=TenantAccountRole.NORMAL,+ ),+ TenantAccountJoin(+ tenant_id=workspace.id,+ account_id=banned.id,+ role=TenantAccountRole.ADMIN,+ ),+ TenantAccountJoin(+ tenant_id=workspace.id,+ account_id=closed.id,+ role=TenantAccountRole.EDITOR,+ ),+ TenantAccountJoin(+ tenant_id=other_workspace.id,+ account_id=other_workspace_member.id,+ role=TenantAccountRole.ADMIN,+ ),+ ]+ )+ session.commit()++ result = WorkspaceMemberQueryRepository(sqlite_session_factory).list_for_workspace(workspace.id)++ by_id = {member.id: member for member in result}+ assert set(by_id) == {"active", "uninitialized", "pending", "banned", "closed"}+ assert by_id["active"] == WorkspaceMemberRecord(+ id=active.id,+ name=active.name,+ email=active.email,+ avatar=active.avatar,+ last_login_at=created_at,+ last_active_at=created_at,+ created_at=created_at,+ status=AccountStatus.ACTIVE.value,+ legacy_role=TenantAccountRole.OWNER.value,+ )+ assert by_id["uninitialized"].status == AccountStatus.UNINITIALIZED.value+ assert by_id["pending"].status == AccountStatus.PENDING.value+ assert by_id["pending"].legacy_role == TenantAccountRole.NORMAL.value+ assert by_id["banned"].status == AccountStatus.BANNED.value+ assert by_id["closed"].status == AccountStatus.CLOSED.value+++def test_list_for_workspace_returns_empty_tuple_without_membership(+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ with sqlite_session_factory() as session:+ session.add(make_tenant("workspace-1"))+ session.commit()++ result = WorkspaceMemberQueryRepository(sqlite_session_factory).list_for_workspace("workspace-1")++ assert result == ()diff --git a/api/tests/unit_tests/services/test_workspace_member_query_service.py b/api/tests/unit_tests/services/test_workspace_member_query_service.pynew file mode 100644index 00000000000..cc2d3fb859d--- /dev/null+++ b/api/tests/unit_tests/services/test_workspace_member_query_service.py@@ -0,0 +1,150 @@+from collections.abc import Mapping, Sequence+from datetime import datetime++import pytest++from machinery.context import RequestContext+from services.workspace_member_query_service import (+ WorkspaceMemberQueryService,+ WorkspaceMemberRecord,+ WorkspaceMemberRole,+ WorkspaceMemberRoleSubject,+ WorkspaceMemberSummary,+)+++def make_context(*, workspace_id: str | None = "workspace-1") -> RequestContext:+ return RequestContext(+ request_id="request-1",+ trace_id="trace-1",+ account_id="actor-1",+ active_workspace_id=workspace_id,+ )+++def make_member(+ member_id: str,+ *,+ status: str = "active",+ legacy_role: str = "normal",+) -> WorkspaceMemberRecord:+ created_at = datetime(2026, 1, 1)+ return WorkspaceMemberRecord(+ id=member_id,+ name=f"Member {member_id}",+ email=f"{member_id}@example.com",+ avatar=None,+ last_login_at=None,+ last_active_at=created_at,+ created_at=created_at,+ status=status,+ legacy_role=legacy_role,+ )+++class RecordingMemberQuery:+ def __init__(self, records: Sequence[WorkspaceMemberRecord]) -> None:+ self.records = tuple(records)+ self.workspace_ids: list[str] = []++ def list_for_workspace(self, workspace_id: str) -> Sequence[WorkspaceMemberRecord]:+ self.workspace_ids.append(workspace_id)+ return self.records+++class RecordingRoleResolver:+ def __init__(self, roles: Mapping[str, Sequence[WorkspaceMemberRole]]) -> None:+ self.roles = roles+ self.calls: list[tuple[str, str, tuple[WorkspaceMemberRoleSubject, ...]]] = []++ def resolve_many(+ self,+ workspace_id: str,+ actor_account_id: str,+ subjects: Sequence[WorkspaceMemberRoleSubject],+ ) -> Mapping[str, Sequence[WorkspaceMemberRole]]:+ self.calls.append((workspace_id, actor_account_id, tuple(subjects)))+ return self.roles+++class FailingRoleResolver:+ def resolve_many(+ self,+ workspace_id: str,+ actor_account_id: str,+ subjects: Sequence[WorkspaceMemberRoleSubject],+ ) -> Mapping[str, Sequence[WorkspaceMemberRole]]:+ del workspace_id, actor_account_id, subjects+ raise RoleResolutionError+++class RoleResolutionError(Exception):+ pass+++def test_list_current_projects_members_and_merges_roles_by_account_id() -> None:+ active = make_member("active", legacy_role="owner")+ pending = make_member("pending", status="pending")+ members = RecordingMemberQuery([active, pending])+ roles = RecordingRoleResolver(+ {+ active.id: [+ WorkspaceMemberRole(id="workspace.owner", name="Owner"),+ WorkspaceMemberRole(id="workspace.editor", name="Editor"),+ ]+ }+ )+ service = WorkspaceMemberQueryService(members=members, roles=roles)++ result = service.list_current(make_context())++ by_id = {member.id: member for member in result}+ assert set(by_id) == {"active", "pending"}+ assert by_id["active"] == WorkspaceMemberSummary(+ id=active.id,+ name=active.name,+ email=active.email,+ avatar=active.avatar,+ last_login_at=active.last_login_at,+ last_active_at=active.last_active_at,+ created_at=active.created_at,+ role=active.legacy_role,+ roles=(+ WorkspaceMemberRole(id="workspace.owner", name="Owner"),+ WorkspaceMemberRole(id="workspace.editor", name="Editor"),+ ),+ status=active.status,+ )+ assert by_id["pending"].status == "pending"+ assert by_id["pending"].roles == ()+ assert members.workspace_ids == ["workspace-1"]+ assert roles.calls == [+ (+ "workspace-1",+ "actor-1",+ (+ WorkspaceMemberRoleSubject(account_id=active.id, legacy_role=active.legacy_role),+ WorkspaceMemberRoleSubject(account_id=pending.id, legacy_role=pending.legacy_role),+ ),+ )+ ]+++def test_list_current_rejects_missing_workspace_before_calling_ports() -> None:+ members = RecordingMemberQuery([])+ roles = RecordingRoleResolver({})+ service = WorkspaceMemberQueryService(members=members, roles=roles)++ with pytest.raises(RuntimeError, match="Console account admission did not resolve an active workspace"):+ service.list_current(make_context(workspace_id=None))++ assert members.workspace_ids == []+ assert roles.calls == []+++def test_list_current_propagates_role_resolution_failure() -> None:+ members = RecordingMemberQuery([make_member("member-1")])+ service = WorkspaceMemberQueryService(members=members, roles=FailingRoleResolver())++ with pytest.raises(RoleResolutionError):+ service.list_current(make_context())diff --git a/api/tests/unit_tests/services/test_workspace_member_role_resolver.py b/api/tests/unit_tests/services/test_workspace_member_role_resolver.pynew file mode 100644index 00000000000..b40f77da45c--- /dev/null+++ b/api/tests/unit_tests/services/test_workspace_member_role_resolver.py@@ -0,0 +1,128 @@+from types import SimpleNamespace+from unittest.mock import MagicMock++import pytest++from services import workspace_member_role_resolver+from services.enterprise.rbac_service import MemberRolesResponse, RBACRole+from services.workspace_member_query_service import WorkspaceMemberRole, WorkspaceMemberRoleSubject+++def make_subject(account_id: str, *, legacy_role: str = "normal") -> WorkspaceMemberRoleSubject:+ return WorkspaceMemberRoleSubject(account_id=account_id, legacy_role=legacy_role)+++def batch_get(monkeypatch: pytest.MonkeyPatch) -> MagicMock:+ batch_get = MagicMock()+ monkeypatch.setattr(+ workspace_member_role_resolver.enterprise_rbac_service.RBACService.MemberRoles,+ "batch_get",+ batch_get,+ )+ return batch_get+++def configure_rbac(monkeypatch: pytest.MonkeyPatch, *, enabled: bool) -> None:+ monkeypatch.setattr(+ workspace_member_role_resolver,+ "dify_config",+ SimpleNamespace(RBAC_ENABLED=enabled),+ )+++def test_legacy_mode_projects_join_roles_without_enterprise_call(+ monkeypatch: pytest.MonkeyPatch,+ batch_get: MagicMock,+) -> None:+ configure_rbac(monkeypatch, enabled=False)+ owner = make_subject("owner", legacy_role="owner")+ member = make_subject("member")++ result = workspace_member_role_resolver.DeploymentWorkspaceMemberRoleResolver().resolve_many(+ "workspace-1",+ "actor-1",+ [owner, member],+ )++ assert result == {+ "owner": (WorkspaceMemberRole(id="owner", name="owner"),),+ "member": (WorkspaceMemberRole(id="normal", name="normal"),),+ }+ batch_get.assert_not_called()+++def test_rbac_mode_maps_batch_response_without_legacy_fallback(+ monkeypatch: pytest.MonkeyPatch,+ batch_get: MagicMock,+) -> None:+ configure_rbac(monkeypatch, enabled=True)+ owner = make_subject("owner", legacy_role="owner")+ omitted = make_subject("omitted", legacy_role="admin")+ batch_get.return_value = [+ MemberRolesResponse(+ account_id=owner.account_id,+ roles=[+ RBACRole(+ id="workspace.owner",+ name="Owner",+ type="builtin",+ ),+ RBACRole(+ id="workspace.editor",+ name="Editor",+ type="builtin",+ ),+ ],+ )+ ]++ result = workspace_member_role_resolver.DeploymentWorkspaceMemberRoleResolver().resolve_many(+ "workspace-1",+ "actor-1",+ [owner, omitted],+ )++ assert result == {+ "owner": (+ WorkspaceMemberRole(id="workspace.owner", name="Owner"),+ WorkspaceMemberRole(id="workspace.editor", name="Editor"),+ )+ }+ assert "omitted" not in result+ batch_get.assert_called_once_with("workspace-1", "actor-1", ["owner", "omitted"])+++def test_rbac_failure_propagates(+ monkeypatch: pytest.MonkeyPatch,+ batch_get: MagicMock,+) -> None:+ configure_rbac(monkeypatch, enabled=True)+ batch_get.side_effect = RoleResolutionError("enterprise unavailable")++ with pytest.raises(RoleResolutionError, match="enterprise unavailable"):+ workspace_member_role_resolver.DeploymentWorkspaceMemberRoleResolver().resolve_many(+ "workspace-1",+ "actor-1",+ [make_subject("member-1")],+ )+++def test_empty_member_list_skips_enterprise_call(+ monkeypatch: pytest.MonkeyPatch,+ batch_get: MagicMock,+) -> None:+ configure_rbac(monkeypatch, enabled=True)++ result = workspace_member_role_resolver.DeploymentWorkspaceMemberRoleResolver().resolve_many(+ "workspace-1",+ "actor-1",+ [],+ )++ assert result == {}+ batch_get.assert_not_called()+++class RoleResolutionError(Exception):+ pass