LLM-Driven Extraction of Unstructured Data — Built for API Deployments & ETL Pipeline Workflows
Python ai-agentsdata-engineeringdocument-aigenerative-aiidpjson-extractionllmmcp-serverocrpdf-extractionprompt-engineeringstructured-output
UN-4399 [FEAT] Capability permissions part 2: members, API keys and platform defaults (#2357)
Ritwik Gbb848518b5f2
diff --git a/backend/account_v2/authentication_controller.py b/backend/account_v2/authentication_controller.pyindex 0e7062e3b..51bee8557 100644--- a/backend/account_v2/authentication_controller.py+++ b/backend/account_v2/authentication_controller.py@@ -360,8 +360,7 @@ class AuthenticationController:user invitation."""admin_user = OrganizationMemberService.get_user_by_id(id=admin.id)- if not self.auth_service.is_organization_admin(admin_user):- raise Forbidden()+ self.authorize_invite(admin_user, [item.get("role") for item in user_list])response = []for user_item in user_list:email = user_item.get("email")@@ -440,6 +439,67 @@ class AuthenticationController:if admin_count <= 1:raise Forbidden("Cannot demote the only admin of the organization")+ def _member_management_open(self, actor: OrganizationMember) -> bool:+ """Whether ``actor`` (not an admin) may manage members at all."""+ from tenant_account_v2.capabilities import Capability, opened_to_members++ return opened_to_members(+ actor.user, UserContext.get_organization(), Capability.MANAGE_MEMBERS+ )++ def _refuse_members(self) -> None:+ from tenant_account_v2.capabilities import SPECS_BY_KEY, Capability++ raise Forbidden(SPECS_BY_KEY[Capability.MANAGE_MEMBERS].message())++ def authorize_invite(self, actor: OrganizationMember | None, roles: list) -> None:+ """Admins invite with any role. A member may, when the org lets members+ manage members, invite with the member role only.+ """+ if actor is None: # not a member of this org+ raise Forbidden()+ if self.auth_service.is_organization_admin(actor):+ return+ if not self._member_management_open(actor):+ self._refuse_members()+ is_member_role = getattr(self.auth_service, "is_member_invite_role", None)+ # A plugin that does not say which roles members may use refuses them+ # (plugins need not inherit AuthenticationService).+ if is_member_role is None or not all(is_member_role(role) for role in roles):+ raise Forbidden("Members can invite with the user role only.")++ def authorize_role_change(+ self,+ actor: OrganizationMember | None,+ target: OrganizationMember,+ role: str,+ removing: bool = False,+ ) -> None:+ """Admins change any role. A member may, when the org lets members+ manage members, grant a member-assignable role to another member who+ is not an admin. Removing roles, granting admin, and changing one's own+ role stay admin-only.++ The check reads the target's role before the write without a lock, so+ an admin promotion landing in between can be overwritten. Accepted: it+ needs an admin and a member acting on the same person at once.+ """+ if actor is None: # not a member of this org+ raise Forbidden()+ if self.auth_service.is_organization_admin(actor):+ return+ if not self._member_management_open(actor):+ self._refuse_members()+ if removing:+ raise Forbidden("Only admins can remove a member's role.")+ if target.user_id == actor.user_id:+ raise Forbidden("You cannot change your own role.")+ if self.is_admin_by_role(target.role):+ raise Forbidden("Only admins can change an admin's role.")+ is_assignable = getattr(self.auth_service, "is_member_assignable_role", None)+ if is_assignable is None or not is_assignable(role):+ raise Forbidden("Only admins can grant this role.")+def add_user_role(self, request: Request, org_id: str, email: str, role: str) -> str | None:@@ -448,6 +508,7 @@ class AuthenticationController:admin_user = OrganizationMemberService.get_user_by_id(id=admin.id)user = OrganizationMemberService.get_user_by_email(email=email)if user:+ self.authorize_role_change(admin_user, user, role)current_roles = self.auth_service.add_organization_user_role(admin_user, org_id, user.user.user_id, [role], request)@@ -470,6 +531,9 @@ class AuthenticationController:admin_user = OrganizationMemberService.get_user_by_id(id=admin.id)organization_member = OrganizationMemberService.get_user_by_email(email=email)if organization_member:+ self.authorize_role_change(+ admin_user, organization_member, role, removing=True+ )current_roles = self.auth_service.remove_organization_user_role(admin_user, org_id, organization_member.user.user_id, [role], request)diff --git a/backend/account_v2/authentication_service.py b/backend/account_v2/authentication_service.pyindex 053a1e67a..3fc70e1e3 100644--- a/backend/account_v2/authentication_service.py+++ b/backend/account_v2/authentication_service.py@@ -15,7 +15,7 @@ from utils.user_context import UserContextfrom account_v2.authentication_helper import AuthenticationHelperfrom account_v2.constants import DefaultOrg, ErrorMessage, UserLoginTemplate-from account_v2.custom_exceptions import Forbidden, MethodNotImplemented+from account_v2.custom_exceptions import MethodNotImplementedfrom account_v2.dto import (CallbackData,MemberData,@@ -282,9 +282,8 @@ class AuthenticationService:role_ids: list[str],request: Request,) -> list[str]:- if admin.role == UserRole.ADMIN.value:- return role_ids- raise Forbidden+ # Authorised by AuthenticationController.authorize_role_change.+ return role_idsdef remove_organization_user_role(self,@@ -294,9 +293,20 @@ class AuthenticationService:role_ids: list[str],request: Request,) -> list[str]:- if admin.role == UserRole.ADMIN.value:- return role_ids- raise Forbidden+ # Authorised by AuthenticationController.authorize_role_change.+ return role_ids++ def is_member_invite_role(self, role: str | None) -> bool:+ """Whether a non-admin may invite with ``role`` (when the org lets+ members manage members). Plugins with their own role names override.+ """+ return role is None or role == UserRole.USER.value++ def is_member_assignable_role(self, role: str | None) -> bool:+ """Whether a non-admin may grant ``role`` to someone else.+ Never an admin role; plugins with more roles override.+ """+ return role == UserRole.USER.valuedef get_organization_by_org_id(self, id: str) -> OrganizationData:organizationData: OrganizationData = OrganizationData(diff --git a/backend/api_v2/api_deployment_views.py b/backend/api_v2/api_deployment_views.pyindex 73c90ff78..32562f07c 100644--- a/backend/api_v2/api_deployment_views.py+++ b/backend/api_v2/api_deployment_views.py@@ -105,7 +105,7 @@ class DeploymentExecution(views.APIView):context={"api": api,"api_key": api_key,- "is_global_key": deployment_execution_dto.is_global_key,+ "global_key": deployment_execution_dto.global_key,},)serializer.is_valid(raise_exception=True)diff --git a/backend/api_v2/deployment_helper.py b/backend/api_v2/deployment_helper.pyindex 38b1a8795..df8650813 100644--- a/backend/api_v2/deployment_helper.py+++ b/backend/api_v2/deployment_helper.py@@ -91,7 +91,8 @@ class DeploymentHelper(BaseAPIKeyValidator):Returns:The authorizing ``GlobalApiDeploymentKey`` when the request wasauthenticated via a global key, else ``None`` (deployment-specific- key). Returning the key (not a bool) preserves audit identity.+ key). Returning the key (not a bool) preserves audit identity and+ lets the request serializer check a member-created key's profiles.Raises:APINotFound: If deployment not founddiff --git a/backend/api_v2/dto.py b/backend/api_v2/dto.pyindex e7fb9203c..539dfce52 100644--- a/backend/api_v2/dto.py+++ b/backend/api_v2/dto.py@@ -22,9 +22,7 @@ class DeploymentExecutionDTO:api_key: str = field(repr=False)# The global API deployment key that authorized this execution, if any.# Carrying the resolved key (not just a bool) preserves audit identity —- # "which named key authorized this?" — for downstream logging/incidents.+ # "which named key authorized this?" — for downstream logging/incidents,+ # and lets ExecutionRequestSerializer hold a member-created key to its+ # creator's LLM profiles (UN-4399).global_key: "GlobalApiDeploymentKey | None" = None-- @property- def is_global_key(self) -> bool:- return self.global_key is not Nonediff --git a/backend/api_v2/key_helper.py b/backend/api_v2/key_helper.pyindex cacf40faf..3f2ffa153 100644--- a/backend/api_v2/key_helper.py+++ b/backend/api_v2/key_helper.py@@ -105,7 +105,7 @@ class KeyHelper:if not global_key.has_access_to_deployment(api_deployment):logger.warning("Global API key '%s' (%s) rejected: no access to deployment %s "- "(out of scope or different organization).",+ "(out of scope, different organization, or its creator may no longer key it).",global_key.name,global_key.id,api_deployment.id,diff --git a/backend/api_v2/serializers.py b/backend/api_v2/serializers.pyindex 52dec96ab..d0c05d8ec 100644--- a/backend/api_v2/serializers.py+++ b/backend/api_v2/serializers.py@@ -482,7 +482,11 @@ class ExecutionRequestSerializer(TagParamsSerializer):# Get context from serializerapi = self.context.get("api")api_key = self.context.get("api_key")- is_global_key = self.context.get("is_global_key", False)+ # One source of truth: the authorising global key itself, so the+ # member-key check below cannot be skipped by a caller that marks the+ # request global without passing the key.+ global_key = self.context.get("global_key")+ is_global_key = global_key is not Noneif not api or not api_key:raise ValidationError("Unable to validate LLM profile ownership")@@ -493,8 +497,10 @@ class ExecutionRequestSerializer(TagParamsSerializer):except ProfileManager.DoesNotExist:raise ValidationError("Profile not found")- # Global API Keys are org-level (not tied to a single user), so the- # per-user ownership check below does not apply. We must still confirm+ # A Global API Key an admin created is org-level, so the per-user+ # ownership check below does not apply to it; one a member created+ # (UN-4399) may only use profiles its creator owns, as a deployment's+ # own key does, checked after the org check. We must still confirm# the profile belongs to the same organization as the deployment,# otherwise a caller could reference another org's profile by UUID.# ``ProfileManager.objects`` is not org-scoped by default, so this@@ -514,6 +520,11 @@ class ExecutionRequestSerializer(TagParamsSerializer):if profile_org_id != api.organization_id:# Generic error avoids confirming another org's profile exists.raise ValidationError("Profile not found")+ if (+ global_key.created_by_member+ and profile.created_by_id != global_key.created_by_id+ ):+ raise ValidationError("You can only use profiles that you own")return value# Get the specific API key being useddiff --git a/backend/global_api_deployment_key/migrations/0002_global_key_created_by_member.py b/backend/global_api_deployment_key/migrations/0002_global_key_created_by_member.pynew file mode 100644index 000000000..be5eabd9d--- /dev/null+++ b/backend/global_api_deployment_key/migrations/0002_global_key_created_by_member.py@@ -0,0 +1,30 @@+# Generated by Django 4.2.30 on 2026-10-20 05:27++from django.db import migrations, models+++class Migration(migrations.Migration):+ dependencies = [+ ("global_api_deployment_key", "0001_initial"),+ ]++ # Reversing this migration drops the column, and rolling back only the code+ # leaves the column unread. Either way member keys stop being bound to their+ # creator, so deactivate keys with created_by_member set first.+ operations = [+ migrations.AddField(+ model_name="globalapideploymentkey",+ name="created_by_member",+ field=models.BooleanField(+ db_comment="True if a non-admin created this key (UN-4399): it then works only within the deployments its creator may key (deployments_keyable_by)",+ default=False,+ ),+ ),+ # AddField drops the default it used for the backfill. Keep one in the+ # database so pods still on the old code can create keys mid-deploy.+ migrations.RunSQL(+ "ALTER TABLE global_api_deployment_key "+ "ALTER COLUMN created_by_member SET DEFAULT false",+ reverse_sql=migrations.RunSQL.noop,+ ),+ ]diff --git a/backend/global_api_deployment_key/models.py b/backend/global_api_deployment_key/models.pyindex f77330ecd..8d2c7b66c 100644--- a/backend/global_api_deployment_key/models.py+++ b/backend/global_api_deployment_key/models.py@@ -1,3 +1,4 @@+import loggingimport uuidfrom account_v2.models import User@@ -6,6 +7,34 @@ from django.db import modelsfrom utils.models.base_model import BaseModelfrom utils.models.organization_mixin import DefaultOrganizationMixin+logger = logging.getLogger(__name__)+++def deployments_keyable_by(user):+ """API deployments a global key ``user`` creates may cover (UN-4399):+ every one for an org admin, otherwise the ones they own (creator or+ co-owner) -- the rule for minting a deployment's own key+ (``IsParentDeploymentOwner``). An empty queryset for anyone outside the+ organisation.+ """+ # Lazy: tenant_account_v2 imports account_v2, which imports this app.+ from permissions.roles import ResourceRole+ from tenant_account_v2.models import OrganizationMember+ from tenant_account_v2.organization_member_service import (+ OrganizationMemberService,+ )+ from tenant_account_v2.sharing_helpers import resources_visible_via_memberships++ if user is None or not OrganizationMember.objects.filter(user=user).exists():+ return APIDeployment.objects.none()+ if OrganizationMemberService.is_user_organization_admin(user):+ return APIDeployment.objects.all()+ return APIDeployment.objects.filter(+ pk__in=resources_visible_via_memberships(+ APIDeployment, user, role=ResourceRole.OWNER+ )+ )+class GlobalApiDeploymentKey(DefaultOrganizationMixin, BaseModel):id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)@@ -30,6 +59,13 @@ class GlobalApiDeploymentKey(DefaultOrganizationMixin, BaseModel):null=True,related_name="global_api_deployment_keys_created",)+ created_by_member = models.BooleanField(+ default=False,+ db_comment=(+ "True if a non-admin created this key (UN-4399): it then works only "+ "within the deployments its creator may key (deployments_keyable_by)"+ ),+ )modified_by = models.ForeignKey(User,on_delete=models.SET_NULL,@@ -65,6 +101,36 @@ class GlobalApiDeploymentKey(DefaultOrganizationMixin, BaseModel):# ``clean()`` runs before M2M rows exist), so the serializers own the# invariant — see ``_GlobalApiDeploymentKeyWriteSerializer`` subclasses,# which reject/clear a list whenever allow-all is set.+ if self.created_by_member and not self._creator_can_access(api_deployment):+ return Falseif self.allow_all_deployments:return Truereturn self.api_deployments.filter(id=api_deployment.id).exists()++ def _creator_can_access(self, api_deployment: APIDeployment) -> bool:+ """A member's key works only within ``deployments_keyable_by`` its+ creator (UN-4399), so its deployments' other owners never have to find+ and revoke it.+ """+ # Lazy: tenant_account_v2 imports account_v2, which imports this app.+ from tenant_account_v2.models import OrganizationMember++ creator = self.created_by+ if creator is None:+ reason = "its creator was deleted"+ # Both lookups use the organisation the request resolved, which+ # has_access_to_deployment has already matched to this key's.+ elif not OrganizationMember.objects.filter(user=creator).exists():+ reason = "its creator left the organization"+ elif not deployments_keyable_by(creator).filter(pk=api_deployment.pk).exists():+ reason = "its creator does not own the deployment"+ else:+ return True+ logger.warning(+ "Global API key %s refused for deployment %s: %s (creator %s).",+ self.id,+ api_deployment.id,+ reason,+ self.created_by_id,+ )+ return Falsediff --git a/backend/global_api_deployment_key/permissions.py b/backend/global_api_deployment_key/permissions.pyindex 5af1675ba..63dd8de8d 100644--- a/backend/global_api_deployment_key/permissions.py+++ b/backend/global_api_deployment_key/permissions.py@@ -1,3 +1,4 @@+from platform_api.permissions import CanManageApiKeysfrom platform_api.permissions import IsOrganizationAdmin as PlatformIsOrganizationAdmin@@ -5,4 +6,4 @@ class IsOrganizationAdmin(PlatformIsOrganizationAdmin):message = "Only organization admins can manage global API deployment keys."-__all__ = ["IsOrganizationAdmin"]+__all__ = ["CanManageApiKeys", "IsOrganizationAdmin"]diff --git a/backend/global_api_deployment_key/serializers.py b/backend/global_api_deployment_key/serializers.pyindex 0f22f83f7..a28529bf6 100644--- a/backend/global_api_deployment_key/serializers.py+++ b/backend/global_api_deployment_key/serializers.py@@ -38,11 +38,13 @@ class GlobalApiDeploymentKeyListSerializer(serializers.ModelSerializer):"key","is_active","allow_all_deployments",+ "created_by_member","api_deployments","created_at","modified_at","created_by_email",]+ read_only_fields = ["created_by_member"]def get_key(self, obj):key_str = str(obj.key)@@ -56,7 +58,9 @@ class GlobalApiDeploymentKeyDetailSerializer(serializers.ModelSerializer):"""Exposes the full plaintext key.Used by the create/rotate responses and by ``retrieve`` (GET keys/<pk>/),- so the full key stays retrievable by an org admin for the key's lifetime —+ so the full key stays retrievable for the key's lifetime by an org admin+ (and by the member who created it, as a member, while members may manage+ keys and they still own its deployments) —consistent with the platform_api key flow (not a one-time reveal)."""@@ -189,7 +193,14 @@ class GlobalApiDeploymentKeyUpdateSerializer(_GlobalApiDeploymentKeyWriteSerialidef update(self, instance, validated_data):api_deployments = validated_data.pop("api_deployments", None)- instance = super().update(instance, validated_data)+ request = self.context.get("request")+ if request:+ validated_data["modified_by"] = request.user+ for field, value in validated_data.items():+ setattr(instance, field, value)+ # Only the fields this edit sets: a whole-row save would write back a+ # key value rotated while the edit was in flight.+ instance.save(update_fields=list(validated_data))if api_deployments is not None:instance.api_deployments.set(api_deployments)return instancediff --git a/backend/global_api_deployment_key/tests/test_global_key_auth.py b/backend/global_api_deployment_key/tests/test_global_key_auth.pyindex cf17a5cab..e61aecc56 100644--- a/backend/global_api_deployment_key/tests/test_global_key_auth.py+++ b/backend/global_api_deployment_key/tests/test_global_key_auth.py@@ -232,8 +232,9 @@ class TestValidateApiFallbackOrdering:class TestGlobalKeyLlmProfileScoping:"""``llm_profile_id`` must stay org-scoped when a global key is used.- The per-user ownership check that guards deployment-specific keys cannot- apply to an org-level key, so the organization comparison in+ The per-user ownership check that guards deployment-specific keys does+ not apply to an admin-created (org-level) key, so the organization+ comparison in``ExecutionRequestSerializer.validate_llm_profile_id`` is what stops acaller referencing another org's profile by UUID."""@@ -245,7 +246,7 @@ class TestGlobalKeyLlmProfileScoping:context={"api": _deployment(organization_id),"api_key": WELL_FORMED_UUID,- "is_global_key": True,+ "global_key": mock.MagicMock(created_by_member=False),})@@ -288,6 +289,59 @@ class TestGlobalKeyLlmProfileScoping:serializer.validate_llm_profile_id(self.PROFILE_ID)+class TestMemberGlobalKeyLlmProfileOwnership:+ """A global key a member created carries only that member's rights+ (UN-4399): like a deployment's own key, it may only use profiles its+ creator owns. An admin-created key stays org-level.+ """++ PROFILE_ID = "b7c2f1de-0000-4000-8000-000000000003"+ CREATOR, OTHER = 11, 12++ def _validate(self, created_by_member: bool, profile_owner: int):+ key = mock.MagicMock(created_by_member=created_by_member, created_by_id=self.CREATOR)+ serializer = ExecutionRequestSerializer(+ context={+ "api": _deployment(ORG_A),+ "api_key": WELL_FORMED_UUID,+ "global_key": key,+ }+ )+ profile = mock.MagicMock(prompt_studio_tool_id="tool-id", created_by_id=profile_owner)+ profile.prompt_studio_tool.organization_id = ORG_A+ with mock.patch.object(ProfileManager, "objects") as objects:+ objects.get.return_value = profile+ return serializer.validate_llm_profile_id(self.PROFILE_ID)++ def test_a_member_key_uses_its_creators_profile(self) -> None:+ assert self._validate(True, self.CREATOR) == self.PROFILE_ID++ def test_a_member_key_cannot_use_another_users_profile(self) -> None:+ with pytest.raises(DRFValidationError, match="profiles that you own"):+ self._validate(True, self.OTHER)++ def test_an_admin_key_stays_org_level(self) -> None:+ assert self._validate(False, self.OTHER) == self.PROFILE_ID++ def test_marking_a_request_global_without_the_key_grants_nothing(self) -> None:+ # The org-level branch is chosen from the key itself, so a bare flag+ # falls through to the deployment-key lookup.+ api = mock.MagicMock(organization_id=ORG_A)+ # No deployment key matches: the bare flag earns no org-level access.+ api_key_model = APIDeployment.api_keys.rel.related_model+ api.api_keys.model = api_key_model+ api.api_keys.get.side_effect = api_key_model.DoesNotExist+ serializer = ExecutionRequestSerializer(+ context={"api": api, "api_key": WELL_FORMED_UUID, "is_global_key": True}+ )+ profile = mock.MagicMock(prompt_studio_tool_id="tool-id", created_by_id=self.OTHER)+ profile.prompt_studio_tool.organization_id = ORG_A+ with mock.patch.object(ProfileManager, "objects") as objects:+ objects.get.return_value = profile+ with pytest.raises(DRFValidationError, match="API key not found"):+ serializer.validate_llm_profile_id(self.PROFILE_ID)++class TestUpdateSerializerScopeValidation:"""PATCH must not trap callers into an unrepresentable scope.diff --git a/backend/global_api_deployment_key/views.py b/backend/global_api_deployment_key/views.pyindex d164cd382..f5bd9b8ff 100644--- a/backend/global_api_deployment_key/views.py+++ b/backend/global_api_deployment_key/views.py@@ -1,6 +1,8 @@import uuidfrom api_v2.models import APIDeployment+from django.db.models import Prefetch+from platform_api.permissions import is_org_admin_sessionfrom platform_audit.actions import Action, TargetTypefrom platform_audit.recorder import (best_effort,@@ -9,12 +11,16 @@ from platform_audit.recorder import ()from rest_framework import status, viewsetsfrom rest_framework.decorators import action+from rest_framework.exceptions import PermissionDenied, ValidationErrorfrom rest_framework.permissions import IsAuthenticatedfrom rest_framework.response import Responsefrom utils.user_context import UserContext-from global_api_deployment_key.models import GlobalApiDeploymentKey-from global_api_deployment_key.permissions import IsOrganizationAdmin+from global_api_deployment_key.models import (+ GlobalApiDeploymentKey,+ deployments_keyable_by,+)+from global_api_deployment_key.permissions import CanManageApiKeys, IsOrganizationAdminfrom global_api_deployment_key.serializers import (ApiDeploymentMinimalSerializer,GlobalApiDeploymentKeyCreateSerializer,@@ -27,17 +33,70 @@ from global_api_deployment_key.serializers import (class GlobalApiDeploymentKeyViewSet(viewsets.ModelViewSet):permission_classes = [IsAuthenticated, IsOrganizationAdmin]+ def get_permissions(self):+ # Members the org lets manage keys may list, create, view and rotate,+ # and pick deployments (UN-4399); editing and deleting stay admin-only.+ if self.action in ("list", "create", "retrieve", "rotate", "deployments"):+ return [IsAuthenticated(), CanManageApiKeys()]+ return super().get_permissions()++ def _is_admin(self) -> bool:+ return is_org_admin_session(self.request, self)++ def _limit_member(self, allow_all: bool, deployment_ids) -> None:+ """A member only keys deployments they own (``deployments_keyable_by``),+ never every deployment. Viewing or rotating+ a key (both reveal the secret) is held to the same rule.+ """+ if self._is_admin():+ return+ if allow_all:+ raise PermissionDenied(+ "Only organisation admins can use keys for all deployments."+ )+ accessible = set(+ deployments_keyable_by(self.request.user).values_list("pk", flat=True)+ )+ if not set(deployment_ids) <= accessible:+ raise PermissionDenied("Members can only use keys for deployments they own.")++ def _limit_member_to_key(self, instance: GlobalApiDeploymentKey) -> None:+ # Only keys they created as a member: another user's key would hand+ # them its secret (retrieve) or break their integration (rotate), and a+ # key they created while an admin is org-level, not bound to them.+ if not self._is_admin() and (+ instance.created_by_id != self.request.user.id+ or not instance.created_by_member+ ):+ raise PermissionDenied(+ "Members can only view or rotate keys they created as a member."+ )+ self._limit_member(+ instance.allow_all_deployments,+ instance.api_deployments.values_list("pk", flat=True),+ )+def get_queryset(self):# ``created_by`` is select_related because the list serializer reads# ``created_by.email`` per row; without it the unpaginated list costs# one extra query per key.- return (- GlobalApiDeploymentKey.objects.filter(- organization=UserContext.get_organization(),+ keys = GlobalApiDeploymentKey.objects.filter(+ organization=UserContext.get_organization(),+ ).select_related("created_by")+ if self.action == "list" and not self._is_admin():+ # A member's list shows their own keys only: other keys name+ # deployments the member may not be able to see. Within those, only+ # the deployments they still own, so one they lost stops showing+ # its live name and status.+ return keys.filter(+ created_by=self.request.user, created_by_member=True+ ).prefetch_related(+ Prefetch(+ "api_deployments",+ queryset=deployments_keyable_by(self.request.user),+ ))- .select_related("created_by")- .prefetch_related("api_deployments")- )+ return keys.prefetch_related("api_deployments")def get_serializer_class(self):# create/retrieve/partial_update/rotate are overridden and instantiate@@ -50,7 +109,11 @@ class GlobalApiDeploymentKeyViewSet(viewsets.ModelViewSet):data=request.data, context={"request": request})serializer.is_valid(raise_exception=True)- instance = serializer.save()+ self._limit_member(+ serializer.validated_data.get("allow_all_deployments", False),+ [d.pk for d in serializer.validated_data.get("api_deployments") or []],+ )+ instance = serializer.save(created_by_member=not self._is_admin())_record_key_event(request,Action.KEY_CREATED,@@ -63,6 +126,7 @@ class GlobalApiDeploymentKeyViewSet(viewsets.ModelViewSet):def retrieve(self, request, *args, **kwargs):instance = self.get_object()+ self._limit_member_to_key(instance)serializer = GlobalApiDeploymentKeyDetailSerializer(instance)return Response(serializer.data)@@ -73,6 +137,8 @@ class GlobalApiDeploymentKeyViewSet(viewsets.ModelViewSet):instance, data=request.data, partial=True, context={"request": request})serializer.is_valid(raise_exception=True)+ if instance.created_by_member:+ _limit_to_creator(instance, serializer.validated_data)updated_instance = serializer.save()_record_key_update(request, updated_instance, before)response_serializer = GlobalApiDeploymentKeyListSerializer(updated_instance)@@ -80,6 +146,7 @@ class GlobalApiDeploymentKeyViewSet(viewsets.ModelViewSet):def rotate(self, request, *args, **kwargs):instance = self.get_object()+ self._limit_member_to_key(instance)instance.key = uuid.uuid4()instance.modified_by = request.userinstance.save(update_fields=["key", "modified_by", "modified_at"])@@ -96,9 +163,13 @@ class GlobalApiDeploymentKeyViewSet(viewsets.ModelViewSet):@action(detail=False, methods=["get"])def deployments(self, request):- """List all API deployments in the org for admins to assign to keys."""+ """API deployments the caller may assign to keys: all of the org's for+ admins, the ones they own for members.+ """organization = UserContext.get_organization()deployments = APIDeployment.objects.filter(organization=organization)+ if not self._is_admin():+ deployments = deployments_keyable_by(request.user)serializer = ApiDeploymentMinimalSerializer(deployments, many=True)return Response(serializer.data)@@ -116,6 +187,31 @@ def _key_fields(key: GlobalApiDeploymentKey) -> dict:}+def _limit_to_creator(key: GlobalApiDeploymentKey, validated: dict) -> None:+ """An edit may never open a member-created key to all deployments (a new+ key does that), nor add a deployment its creator may not key+ (``deployments_keyable_by``), outside which the key never works.+ """+ message = (+ "This key was created by a member and only works for deployments they "+ "own. Create a new key instead."+ )+ if validated.get("allow_all_deployments"):+ raise ValidationError({"allow_all_deployments": message})+ if "api_deployments" not in validated:+ return+ # Only additions: the edit form resends the current list, which may name+ # deployments the creator has since lost (the key just stops working there).+ added = {d.pk for d in validated["api_deployments"]} - set(+ key.api_deployments.values_list("pk", flat=True)+ )+ if not added:+ return+ accessible = set(deployments_keyable_by(key.created_by).values_list("pk", flat=True))+ if not added <= accessible:+ raise ValidationError({"api_deployments": message})++def _record_key_event(request, action: Action, key_id, key_name: str, **kwargs) -> None:record_platform_event(action=action,diff --git a/backend/notification_v2/views.py b/backend/notification_v2/views.pyindex 42f60b4d4..ac5806158 100644--- a/backend/notification_v2/views.py+++ b/backend/notification_v2/views.py@@ -15,7 +15,7 @@ from platform_audit.recorder import (record_platform_event,)from rest_framework import status, viewsets-from rest_framework.permissions import IsAuthenticated+from rest_framework.permissions import BasePermission, IsAuthenticatedfrom rest_framework.request import Requestfrom rest_framework.response import Responsefrom rest_framework.views import APIView@@ -59,6 +59,19 @@ class NotificationViewSet(viewsets.ModelViewSet):return queryset+class CanChangePlatformDefaults(BasePermission):+ message = "Change platform defaults is restricted to organisation admins."++ def has_permission(self, request, view):+ from tenant_account_v2.capabilities import Capability, opened_to_members++ return IsOrganizationAdmin().has_permission(request, view) or opened_to_members(+ request.user,+ UserContext.get_organization(),+ Capability.CHANGE_PLATFORM_DEFAULTS,+ )++class NotificationSettingsView(APIView):"""Org-scoped notification batching settings — currently just the club interval.@@ -70,7 +83,10 @@ class NotificationSettingsView(APIView):flush_after."""- permission_classes = [IsAuthenticated, IsOrganizationAdmin]+ # Admins, or members when the org lets members change platform defaults+ # (UN-4399). Platform defaults are otherwise per-user; this is the only+ # organisation-level setting the capability governs.+ permission_classes = [IsAuthenticated, CanChangePlatformDefaults]def get(self, request: Request) -> Response:organization = UserContext.get_organization()diff --git a/backend/platform_api/permissions.py b/backend/platform_api/permissions.pyindex 32d6de2f3..c9dc320fc 100644--- a/backend/platform_api/permissions.py+++ b/backend/platform_api/permissions.py@@ -25,6 +25,42 @@ class IsOrganizationAdmin(BasePermission):return False+def is_org_admin_session(request, view=None) -> bool:+ return IsOrganizationAdmin().has_permission(request, view)+++def member_may_manage_keys(request) -> bool:+ """A non-admin the org's ``manage_api_keys`` setting admits (UN-4399).++ Only global deployment keys use this. Platform API keys stay admin-only+ whatever the setting: each acts as a service account that bypasses+ per-resource sharing and ownership, so a member holding one would reach+ every resource in the organisation.+ """+ from tenant_account_v2.capabilities import Capability, opened_to_members+ from utils.user_context import UserContext++ return opened_to_members(+ request.user, UserContext.get_organization(), Capability.MANAGE_API_KEYS+ )+++class CanManageApiKeys(BasePermission):+ """Admins, or members when the org lets members manage API keys.++ For the global deployment key actions members may use (list, create,+ retrieve, rotate, deployments); the view narrows what a member may do to a given key.+ Editing and deleting keys stay ``IsOrganizationAdmin``.+ """++ message = "Manage API keys is restricted to organisation admins."++ def has_permission(self, request, view):+ if not request.user or not request.user.is_authenticated:+ return False+ return is_org_admin_session(request, view) or member_may_manage_keys(request)++class CanRotatePlatformApiKey(BasePermission):"""Permission for the ``rotate`` action (UN-3586).diff --git a/backend/tenant_account_v2/CAPABILITIES.md b/backend/tenant_account_v2/CAPABILITIES.mdindex ddc464a7b..e47d6c3f8 100644--- a/backend/tenant_account_v2/CAPABILITIES.md+++ b/backend/tenant_account_v2/CAPABILITIES.md@@ -38,24 +38,24 @@ Always all seven, in this order:| `create_llm_adapters` | `any_member` | creating an LLM adapter || `create_connectors` | `any_member` | creating a connector || `create_other_adapters` | `any_member` | creating any non-LLM adapter (embedding, vector DB, text extractor, OCR) |-| `manage_api_keys` | `admins_only` | creating and rotating platform keys and global deployment keys (not per-deployment keys, which their owners manage) — **not yet enforced, see below** |-| `manage_members` | `admins_only` | inviting members and changing roles — **not yet enforced** |-| `change_platform_defaults` | `admins_only` | organisation-wide platform settings — **not yet enforced** |+| `manage_api_keys` | `admins_only` | creating, viewing and rotating global deployment keys (platform API keys stay admin-only; per-deployment keys are their owners'); see below |+| `manage_members` | `admins_only` | inviting members with the user role; see below |+| `change_platform_defaults` | `admins_only` | the organisation's notification settings (`notifications/settings/`); other defaults are per-user || `delete_workflows_and_deployments` | `any_member` | deleting a workflow, API deployment or pipeline |`allowed_for_me` means *the setting does not block you* — nothing more. It isalways true for admins and for service accounts (platform API keys), which nocapability setting governs. The endpoint's own rules still apply on top andcan refuse a caller this reports as allowed: deleting needs the caller to own-(or co-own) the resource; the key, member and settings endpoints keep their-existing admin and key-permission checks (for example, a `full_access`-platform key can rotate keys, a lower-tier key cannot). With `admins_only`,-owners who are not admins are refused.+(or co-own) the resource. For the key, member and settings endpoints, see+*What `any_member` allows* below. With `admins_only`, owners who are not+admins are refused.-`configurable` says whether PATCH accepts `any_member` for that capability. It-is false for the three marked *not yet enforced* above: setting them to-`any_member` answers 400 "Not configurable yet". A settings UI can lock those-rows from it instead of hard-coding the keys.+`configurable` says whether PATCH accepts `any_member` for that capability.+Every capability is configurable now; a capability added later before its+endpoints are ready reports false, and setting it to `any_member` answers 400+"Not configurable yet". A settings UI can lock those rows from it instead of+hard-coding the keys.Only creation is governed for adapters. Changing an existing adapter's typecounts as creating one of the new type, and that check runs before the request@@ -78,15 +78,56 @@ standard envelope (`{type, errors[{code, detail, attr}]}`):| Status | When ||---|---|-| 400 | unknown key (`attr` = the key), bad value, empty body, or `any_member` for a capability that is not enforced yet |+| 400 | unknown key (`attr` = the key), bad value or empty body || 403 | not an organisation admin, or a service account || 404 | no organisation in the request context (GET too) |-`manage_api_keys`, `manage_members` and `change_platform_defaults` accept only-`admins_only` until their enforcement lands (PR-2 of UN-4399, which waits on-the product decision about what "any member" may do there). Their endpoints-are admin-only today, so storing `any_member` would promise members something-nothing grants.+### What `any_member` allows for the three admin-only areas++Their endpoints were admin-only. `any_member` lets members in with limits+that keep a member from gaining more than they have; service accounts stay+refused, as before.++- **`manage_members`**: a member may invite with the user role. They may also+ grant another non-admin member a role the auth plugin lets members hand+ out; with the built-in roles that is only the user role, which every+ non-admin already has, so in practice members change no one's role.+ Removing roles, granting or revoking admin, changing an admin's role,+ changing their own role, and removing members stay admin-only. A plugin+ without `is_member_invite_role` refuses every member invite, and one+ without `is_member_assignable_role` every member role grant, so+ `allowed_for_me` can be true while those requests are refused.+- **`manage_api_keys`**: a member may list the global deployment keys they+ created as a member (masked) and create one only for deployments they own (as creator+ or co-owner, the rule for a deployment's own keys), never one for all+ deployments. They may view or rotate only keys they created, under the+ same rule, since both return the secret, and never a key they created+ while an admin (that key is org-level, not bound to them). A key a member+ created may only use LLM profiles its creator owns, like a deployment's own+ key, even after the creator becomes an admin. A key a member created+ (`created_by_member` in the list) stops working once they leave the+ organisation, and for each deployment it names once they stop owning it+ (unless they have since become an org admin). They then cannot rotate it+ either; an admin can deactivate it.+ Setting `manage_api_keys` back to `admins_only` does not disable such keys;+ an admin can deactivate them. An admin cannot add a deployment its creator+ does not own to such a key, or open it to all deployments (400); a new key+ does that. Editing and deleting keys stay admin-only.+ **Platform API keys stay admin-only whatever the setting**:+ each acts as a service account that bypasses per-resource sharing and+ ownership, so a member holding one would reach every resource in the+ organisation. The legacy Settings > Platform keys stay admin-only too.+- **`change_platform_defaults`**: read and change the organisation's+ notification settings. Adapter defaults are per-user and not governed.++`organization/settings` stays admin-only, and so does changing+`organization/capabilities`: changing a capability is never itself a+capability.++This repo's bundled frontend still shows the members, invite and global key+pages to admins only; with `any_member`, members reach member management and+global keys through the API until a frontend reads `allowed_for_me`. The+notification settings already show to members.## Refusals@@ -135,5 +176,7 @@ type CapabilitiesPatchRequest = Partial<Record<CapabilityKey, CapabilitySetting>`tenant_account_v2.capabilities.enforce_capability(request, Capability.X)`raises the refusal; `RequiresCapability(Capability.X)` is the DRF permission-form. Neither applies to service accounts. Set the spec's `enforced=True` in the same+form. Neither applies to service accounts. An endpoint that was admin-only+opens to members instead through `opened_to_members`, checked alongside its+admin check; unlike the two above, it refuses service accounts. Set the spec's `enforced=True` in the samechange that adds the enforcement.diff --git a/backend/tenant_account_v2/capabilities.py b/backend/tenant_account_v2/capabilities.pyindex a86d7f086..2b19b9ddf 100644--- a/backend/tenant_account_v2/capabilities.py+++ b/backend/tenant_account_v2/capabilities.py@@ -7,8 +7,11 @@ the first two capabilities, so ``organization/settings`` and``organization/capabilities/`` stay in step by construction.Service accounts (platform API keys) are never subject to a capability-setting. That is all a capability decides: each endpoint's own rules (admin-checks, key permission levels, ownership) still apply on top, unchanged.+setting. For the three creation capabilities and resource deletion, the+setting only narrows: each endpoint's own rules (ownership, key permission levels)+still apply on top. The three formerly admin-only areas (members, API keys,+platform defaults) are the exception: ``opened_to_members`` admits members to+them, with the limits each endpoint sets; see CAPABILITIES.md."""from dataclasses import dataclass@@ -98,24 +101,25 @@ SPECS: tuple[CapabilitySpec, ...] = (CapabilitySpec(Capability.MANAGE_API_KEYS,"Manage API keys",- "Create and rotate platform keys and global deployment keys "- "(not per-deployment keys, which their owners manage).",+ "Create global deployment keys for deployments they own, and "+ "view or rotate the keys they created. Platform API keys stay "+ "admin-only.","restrict_api_key_management",- enforced=False,+ enforced=True,),CapabilitySpec(Capability.MANAGE_MEMBERS,"Manage members",- "Invite members and change their roles.",+ "Invite members with the user role.","restrict_member_management",- enforced=False,+ enforced=True,),CapabilitySpec(Capability.CHANGE_PLATFORM_DEFAULTS,"Change platform defaults",- "Change organisation-wide platform settings.",+ "Change the organisation's notification settings.","restrict_platform_defaults",- enforced=False,+ enforced=True,),CapabilitySpec(Capability.DELETE_WORKFLOWS_AND_DEPLOYMENTS,@@ -149,6 +153,21 @@ def is_allowed(user: Any, organization: Organization | None, key: Capability) ->return OrganizationMemberService.is_user_organization_admin(user)+def opened_to_members(+ user: Any, organization: Organization | None, key: Capability+) -> bool:+ """Whether ``key`` admits ``user`` though they are not an admin.++ For the capabilities whose endpoints were admin-only (API keys, members,+ platform defaults): the caller's admin check stays, and this is the only+ way past it. Service accounts never qualify; those endpoints refused them+ before and still do.+ """+ if getattr(user, "is_service_account", False) or organization is None:+ return False+ return setting_of(organization, SPECS_BY_KEY[key]) == CapabilitySetting.ANY_MEMBER++def enforce_capability(request: Any, key: Capability) -> None:"""Raise ``PermissionDenied`` when the org restricts ``key`` to admins andthe caller is not one.diff --git a/backend/tenant_account_v2/test_capabilities.py b/backend/tenant_account_v2/test_capabilities.pyindex 16fc9d86f..40e906aa4 100644--- a/backend/tenant_account_v2/test_capabilities.py+++ b/backend/tenant_account_v2/test_capabilities.py@@ -9,17 +9,30 @@ import refrom types import SimpleNamespacefrom unittest.mock import patch+from account_v2.authentication_controller import AuthenticationController+from account_v2.custom_exceptions import Forbiddenfrom account_v2.models import Organizationfrom adapter_processor_v2.models import AdapterInstancefrom adapter_processor_v2.views import AdapterInstanceViewSetfrom api_v2.api_deployment_views import APIDeploymentViewSet+from api_v2.exceptions import UnauthorizedKey+from api_v2.key_helper import KeyHelper+from api_v2.models import APIDeploymentfrom connector_v2.models import ConnectorInstancefrom connector_v2.views import ConnectorInstanceViewSetfrom django.test import SimpleTestCasefrom drf_spectacular.generators import SchemaGenerator+from global_api_deployment_key.models import GlobalApiDeploymentKey+from global_api_deployment_key.serializers import (+ GlobalApiDeploymentKeyUpdateSerializer,+)+from global_api_deployment_key.views import GlobalApiDeploymentKeyViewSet+from notification_v2.views import NotificationSettingsViewfrom permissions.permission import IsOwnerfrom permissions.roles import ResourceRolefrom pipeline_v2.views import PipelineViewSet+from platform_api.models import ApiKeyPermission, PlatformApiKey+from platform_api.views import PlatformApiKeyViewSetfrom platform_audit.tests.base import AuditTestBase, make_userfrom rest_framework.exceptions import PermissionDeniedfrom workflow_manager.workflow_v2.models.workflow import Workflow@@ -31,9 +44,18 @@ from tenant_account_v2.capabilities import (Capability,CapabilitySetting,)+from tenant_account_v2.models import OrganizationMember+from tenant_account_v2.users_view import OrganizationUserViewSetfrom tenant_account_v2.views import organization_capabilities, organization_settings-ENFORCED = [spec for spec in SPECS if spec.enforced]+# Endpoints open to members before UN-4399; service accounts pass them.+MEMBER_OPEN = (+ Capability.CREATE_LLM_ADAPTERS,+ Capability.CREATE_CONNECTORS,+ Capability.CREATE_OTHER_ADAPTERS,+ Capability.DELETE_WORKFLOWS_AND_DEPLOYMENTS,+)+ENFORCED = [spec for spec in SPECS if spec.key in MEMBER_OPEN]class CapabilityRegistryTests(SimpleTestCase):@@ -105,6 +127,10 @@ class CapabilityTestBase(AuditTestBase):def setUp(self) -> None:super().setUp()self.service_account = make_user("[email protected]", is_service_account=True)+ # As platform_api.services gives every platform key's service account.+ OrganizationMember.objects.create(+ organization=self.org, user=self.service_account, role="user"+ )def restrict(self, key: Capability, restricted: bool) -> None:spec = next(s for s in SPECS if s.key == key)@@ -137,7 +163,7 @@ class CapabilitiesApiTests(CapabilityTestBase):self.assertEqual(rows["create_connectors"]["label"], "Create connectors")self.assertEqual({k for k, r in rows.items() if not r["configurable"]},- {"manage_api_keys", "manage_members", "change_platform_defaults"},+ set(),)def test_admins_are_always_allowed(self) -> None:@@ -206,7 +232,6 @@ class CapabilitiesApiTests(CapabilityTestBase):for body, attr in (({"create_connectors": "admins_only", "nope": "admins_only"}, "nope"),({"create_connectors": "admins_only", "create_llm_adapters": "x"}, None),- ({"manage_members": "any_member", "create_connectors": "admins_only"}, None),({}, None),):with self.subTest(body=str(body)):@@ -215,23 +240,14 @@ class CapabilitiesApiTests(CapabilityTestBase):self.org.refresh_from_db()self.assertFalse(self.org.restrict_connector_creation)- def test_unenforced_capabilities_accept_only_admins_only(self) -> None:+ def test_every_capability_accepts_both_settings(self) -> None:for spec in SPECS:- if spec.enforced:- continue- with self.subTest(key=spec.key.value):- ok = self.call(- organization_capabilities,- "patch",- data={spec.key.value: "admins_only"},- )- self.assertEqual(ok.status_code, 200)- refused = self.call(- organization_capabilities,- "patch",- data={spec.key.value: "any_member"},- )- self.assertEqual(refused.status_code, 400)+ for setting in ("any_member", "admins_only"):+ with self.subTest(key=spec.key.value, setting=setting):+ response = self.call(+ organization_capabilities, "patch", data={spec.key.value: setting}+ )+ self.assertEqual(response.status_code, 200, response.data)def test_legacy_settings_and_capabilities_stay_in_step(self) -> None:self.call(@@ -526,3 +542,703 @@ class EnforcementMatrixTests(CapabilityTestBase):):for permission in view.get_permissions():permission.has_permission(request, view)+++class AdminOnlyEndpointsMatrixTests(CapabilityTestBase):+ """API keys, members and platform defaults: endpoints that were admin-only.+ 'Any member' opens them to members; service accounts stay refused.+ """++ def setUp(self) -> None:+ super().setUp()+ self.colleague = make_user("[email protected]")+ OrganizationMember.objects.create(+ organization=self.org, user=self.colleague, role="user"+ )+ workflow = Workflow.objects.create(+ workflow_name="wf", organization=self.org, created_by=self.member+ )+ self.deployment = APIDeployment.objects.create(+ api_name="api",+ workflow=workflow,+ organization=self.org,+ created_by=self.member,+ )+ self.deployment.grant_owner(self.member)++ def _allowed(self, key: Capability, user) -> bool:+ if key == Capability.MANAGE_API_KEYS:+ view = GlobalApiDeploymentKeyViewSet.as_view({"post": "create"})+ data = {+ "name": f"k-{user.pk}-{GlobalApiDeploymentKey.objects.count()}",+ "description": "ci",+ "allow_all_deployments": False,+ "api_deployments": [str(self.deployment.pk)],+ }+ response = self.call(view, "post", user=user, data=data)+ ok_status = 201+ elif key == Capability.MANAGE_MEMBERS:+ view = OrganizationUserViewSet.as_view(+ {"post": "assign_organization_role_to_user"}+ )+ response = self.call(+ view,+ "post",+ user=user,+ data={"email": "[email protected]", "role": "user"},+ )+ ok_status = 200+ else:+ view = NotificationSettingsView.as_view()+ response = self.call(+ view, "patch", user=user, data={"club_interval_seconds": 600}+ )+ ok_status = 200+ if response.status_code == 403:+ return False+ self.assertEqual(response.status_code, ok_status, getattr(response, "data", None))+ return True++ def test_matrix(self) -> None:+ for key in (+ Capability.MANAGE_API_KEYS,+ Capability.MANAGE_MEMBERS,+ Capability.CHANGE_PLATFORM_DEFAULTS,+ ):+ for restricted in (True, False):+ self.restrict(key, restricted)+ for name, user, expected in (+ ("admin", self.admin, True),+ ("member", self.member, not restricted),+ ("service account", self.service_account, False),+ ):+ with self.subTest(key=key.value, restricted=restricted, user=name):+ self.assertEqual(self._allowed(key, user), expected)+++class MemberManagementGuardrailTests(CapabilityTestBase):+ """With 'Any member', a member manages non-admin members only."""++ def setUp(self) -> None:+ super().setUp()+ self.restrict(Capability.MANAGE_MEMBERS, False)+ self.colleague = make_user("[email protected]")+ OrganizationMember.objects.create(+ organization=self.org, user=self.colleague, role="user"+ )+ self.assign = OrganizationUserViewSet.as_view(+ {"post": "assign_organization_role_to_user"}+ )++ def _assign(self, email: str, role: str):+ return self.call(+ self.assign, "post", user=self.member, data={"email": email, "role": role}+ )++ def test_a_member_cannot_grant_admin(self) -> None:+ response = self._assign("[email protected]", "admin")+ self.assertEqual(response.status_code, 403)+ self.assertEqual(OrganizationMember.objects.get(user=self.colleague).role, "user")++ def test_a_member_cannot_change_their_own_role(self) -> None:+ self.assertEqual(self._assign("[email protected]", "user").status_code, 403)++ def test_a_member_cannot_change_an_admins_role(self) -> None:+ # A second admin, so the last-admin guard is not what refuses it.+ second = make_user("[email protected]")+ OrganizationMember.objects.create(+ organization=self.org, user=second, role="admin"+ )+ self.assertEqual(self._assign(second.email, "user").status_code, 403)+ self.assertEqual(OrganizationMember.objects.get(user=second).role, "admin")++ def test_a_member_cannot_revoke_admin(self) -> None:+ # A second admin, so the last-admin guard is not what refuses it.+ second = make_user("[email protected]")+ OrganizationMember.objects.create(+ organization=self.org, user=second, role="admin"+ )+ view = OrganizationUserViewSet.as_view(+ {"delete": "remove_organization_role_from_user"}+ )+ response = self.call(+ view,+ "delete",+ user=self.member,+ data={"email": second.email, "role": "admin"},+ )+ self.assertEqual(response.status_code, 403)+ self.assertEqual(OrganizationMember.objects.get(user=second).role, "admin")++ def test_a_member_cannot_remove_a_role(self) -> None:+ # Removing someone's only role removes them, which stays admin-only.+ view = OrganizationUserViewSet.as_view(+ {"delete": "remove_organization_role_from_user"}+ )+ response = self.call(+ view,+ "delete",+ user=self.member,+ data={"email": "[email protected]", "role": "user"},+ )+ self.assertEqual(response.status_code, 403)+ self.assertEqual(+ str(response.data["errors"][0]["detail"]),+ "Only admins can remove a member's role.",+ )++ def test_admins_invite_and_change_any_role_under_both_settings(self) -> None:+ controller = AuthenticationController()+ admin = OrganizationMember.objects.get(user=self.admin)+ target = OrganizationMember.objects.get(user=self.colleague)+ for restricted in (True, False):+ self.restrict(Capability.MANAGE_MEMBERS, restricted)+ with self.subTest(restricted=restricted):+ controller.authorize_invite(admin, ["admin", "user", None])+ controller.authorize_role_change(admin, target, "admin")+ controller.authorize_role_change(admin, target, "user", removing=True)++ def test_admins_only_refuses_members_removing_roles(self) -> None:+ self.restrict(Capability.MANAGE_MEMBERS, True)+ view = OrganizationUserViewSet.as_view(+ {"delete": "remove_organization_role_from_user"}+ )+ response = self.call(+ view,+ "delete",+ user=self.member,+ data={"email": "[email protected]", "role": "user"},+ )+ self.assertEqual(response.status_code, 403)++ def test_the_invite_endpoint_checks_before_inviting(self) -> None:+ controller = AuthenticationController()+ with patch.object(controller.auth_service, "invite_user") as invite:+ with self.assertRaises(Forbidden):+ controller.invite_user(+ admin=self.member,+ org_id=self.org.organization_id,+ user_list=[{"email": "[email protected]", "role": "admin"}],+ request=None,+ )+ invite.assert_not_called()++ def test_a_member_invites_with_the_user_role_only(self) -> None:+ controller = AuthenticationController()+ actor = OrganizationMember.objects.get(user=self.member)+ controller.authorize_invite(actor, ["user", None])+ with self.assertRaises(Forbidden):+ controller.authorize_invite(actor, ["user", "admin"])++ def test_a_plugin_that_names_no_member_roles_refuses_members(self) -> None:+ # A plugin that does not define the member-role hooks refuses+ # members: plugins need not inherit AuthenticationService.+ controller = AuthenticationController()+ controller.auth_service = SimpleNamespace(+ is_organization_admin=lambda member: False,+ is_admin_by_role=lambda role: role == "admin",+ )+ actor = OrganizationMember.objects.get(user=self.member)+ target = OrganizationMember.objects.get(user=self.colleague)+ with self.assertRaises(Forbidden):+ controller.authorize_invite(actor, ["user"])+ with self.assertRaises(Forbidden):+ controller.authorize_role_change(actor, target, "user")++ def test_admins_only_refuses_members_everything(self) -> None:+ self.restrict(Capability.MANAGE_MEMBERS, True)+ actor = OrganizationMember.objects.get(user=self.member)+ with self.assertRaises(Forbidden):+ AuthenticationController().authorize_invite(actor, ["user"])+ self.assertEqual(self._assign("[email protected]", "user").status_code, 403)+++class PlatformApiKeyGuardrailTests(CapabilityTestBase):+ """Platform API keys stay admin-only even with 'Any member': each acts as+ a service account that bypasses per-resource sharing and ownership.+ """++ def setUp(self) -> None:+ super().setUp()+ self.restrict(Capability.MANAGE_API_KEYS, False)+ self.read = PlatformApiKey.objects.create(+ name="ci-read",+ permission=ApiKeyPermission.READ,+ organization=self.org,+ created_by=self.member,+ )++ def test_members_cannot_use_platform_api_keys(self) -> None:+ pk = {"pk": str(self.read.pk)}+ create = {"data": {"name": "m", "description": "d", "permission": "read"}}+ for action, method, kwargs in (+ ({"get": "list"}, "get", {}),+ ({"post": "create"}, "post", create),+ ({"get": "retrieve"}, "get", pk),+ ({"post": "rotate"}, "post", pk),+ ({"patch": "partial_update"}, "patch", {**pk, "data": {"is_active": False}}),+ ({"delete": "destroy"}, "delete", pk),+ ):+ with self.subTest(action=next(iter(action.values()))):+ view = PlatformApiKeyViewSet.as_view(action)+ response = self.call(view, method, user=self.member, **kwargs)+ self.assertEqual(response.status_code, 403)+ self.assertEqual(PlatformApiKey.objects.count(), 1)+++class GlobalDeploymentKeyGuardrailTests(CapabilityTestBase):+ """With 'Any member', a member only keys deployments they own."""++ def setUp(self) -> None:+ super().setUp()+ self.restrict(Capability.MANAGE_API_KEYS, False)+ workflow = Workflow.objects.create(+ workflow_name="wf", organization=self.org, created_by=self.admin+ )+ self.mine = APIDeployment.objects.create(+ api_name="mine",+ workflow=workflow,+ organization=self.org,+ created_by=self.member,+ )+ self.mine.grant_owner(self.member)+ self.theirs = APIDeployment.objects.create(+ api_name="theirs",+ workflow=workflow,+ organization=self.org,+ created_by=self.admin,+ )+ self.theirs.grant_owner(self.admin)+ self.all_key = GlobalApiDeploymentKey.objects.create(+ name="admin-all",+ allow_all_deployments=True,+ organization=self.org,+ created_by=self.admin,+ )++ def _create(self, data: dict):+ view = GlobalApiDeploymentKeyViewSet.as_view({"post": "create"})+ return self.call(+ view,+ "post",+ user=self.member,+ data={"name": "k", "description": "ci", **data},+ )++ def test_a_member_cannot_create_an_allow_all_key(self) -> None:+ response = self._create({"allow_all_deployments": True, "api_deployments": []})+ self.assertEqual(response.status_code, 403)++ def test_a_member_cannot_key_a_deployment_they_do_not_own(self) -> None:+ response = self._create(+ {"allow_all_deployments": False, "api_deployments": [str(self.theirs.pk)]}+ )+ self.assertEqual(response.status_code, 403)++ def test_a_member_may_grant_their_own_deployment(self) -> None:+ response = self._create(+ {"allow_all_deployments": False, "api_deployments": [str(self.mine.pk)]}+ )+ self.assertEqual(response.status_code, 201, response.data)++ def test_a_member_rotates_only_keys_they_created(self) -> None:+ own = GlobalApiDeploymentKey.objects.create(+ name="own",+ organization=self.org,+ created_by=self.member,+ created_by_member=True,+ )+ own.api_deployments.add(self.mine)+ admins = GlobalApiDeploymentKey.objects.create(+ name="admins", organization=self.org, created_by=self.admin+ )+ admins.api_deployments.add(self.mine)+ rotate = GlobalApiDeploymentKeyViewSet.as_view({"post": "rotate"})+ response = self.call(rotate, "post", user=self.member, pk=str(own.pk))+ self.assertEqual(response.status_code, 200, response.data)+ key_before = admins.key+ response = self.call(rotate, "post", user=self.member, pk=str(admins.pk))+ self.assertEqual(response.status_code, 403)+ admins.refresh_from_db()+ self.assertEqual(admins.key, key_before)++ def test_a_member_cannot_edit_or_delete_their_own_key(self) -> None:+ own = GlobalApiDeploymentKey.objects.create(+ name="own",+ organization=self.org,+ created_by=self.member,+ created_by_member=True,+ )+ own.api_deployments.add(self.mine)+ update = GlobalApiDeploymentKeyViewSet.as_view({"patch": "partial_update"})+ response = self.call(+ update,+ "patch",+ user=self.member,+ pk=str(own.pk),+ data={"allow_all_deployments": True},+ )+ self.assertEqual(response.status_code, 403)+ destroy = GlobalApiDeploymentKeyViewSet.as_view({"delete": "destroy"})+ response = self.call(destroy, "delete", user=self.member, pk=str(own.pk))+ self.assertEqual(response.status_code, 403)+ own.refresh_from_db()+ self.assertFalse(own.allow_all_deployments)++ def test_a_member_cannot_view_or_rotate_their_own_key_once_it_reaches_further(+ self,+ ) -> None:+ # Their own key, later widened by an admin: same rule as creating it.+ own = GlobalApiDeploymentKey.objects.create(+ name="own",+ organization=self.org,+ created_by=self.member,+ created_by_member=True,+ )+ own.api_deployments.add(self.mine, self.theirs)+ rotate = GlobalApiDeploymentKeyViewSet.as_view({"post": "rotate"})+ response = self.call(rotate, "post", user=self.member, pk=str(own.pk))+ self.assertEqual(response.status_code, 403)++ def test_a_member_cannot_view_or_rotate_an_allow_all_key(self) -> None:+ # Their own key, so only the allow-all rule can refuse it.+ own_all = GlobalApiDeploymentKey.objects.create(+ name="own-all",+ allow_all_deployments=True,+ organization=self.org,+ created_by=self.member,+ created_by_member=True,+ )+ for action, method in (+ ({"get": "retrieve"}, "get"),+ ({"post": "rotate"}, "post"),+ ):+ with self.subTest(action=method):+ view = GlobalApiDeploymentKeyViewSet.as_view(action)+ response = self.call(view, method, user=self.member, pk=str(own_all.pk))+ self.assertEqual(response.status_code, 403)++ def test_a_member_lists_and_views_only_their_own_keys(self) -> None:+ own = GlobalApiDeploymentKey.objects.create(+ name="own",+ organization=self.org,+ created_by=self.member,+ created_by_member=True,+ )+ own.api_deployments.add(self.mine)+ listing = GlobalApiDeploymentKeyViewSet.as_view({"get": "list"})+ response = self.call(listing, "get", user=self.member)+ self.assertEqual(response.status_code, 200, response.data)+ self.assertEqual([row["name"] for row in response.data], ["own"])+ response = self.call(listing, "get", user=self.admin)+ self.assertEqual(+ sorted(row["name"] for row in response.data), ["admin-all", "own"]+ )+ retrieve = GlobalApiDeploymentKeyViewSet.as_view({"get": "retrieve"})+ response = self.call(retrieve, "get", user=self.member, pk=str(own.pk))+ self.assertEqual(response.status_code, 200, response.data)+ self.assertEqual(response.data["key"], str(own.key))++ def test_a_members_list_hides_deployments_they_no_longer_own(self) -> None:+ own = GlobalApiDeploymentKey.objects.create(+ name="own",+ organization=self.org,+ created_by=self.member,+ created_by_member=True,+ )+ own.api_deployments.add(self.mine)+ listing = GlobalApiDeploymentKeyViewSet.as_view({"get": "list"})++ def listed(user) -> list[str]:+ response = self.call(listing, "get", user=user)+ self.assertEqual(response.status_code, 200, response.data)+ row = next(r for r in response.data if r["name"] == "own")+ return [d["id"] for d in row["api_deployments"]]++ self.assertEqual(listed(self.member), [str(self.mine.pk)])+ # Still a viewer: viewing is not owning.+ self.mine.memberships.filter(user=self.member).update(role=ResourceRole.VIEWER)+ self.assertEqual(listed(self.member), [])+ # The link itself stays, and an admin still sees it.+ self.assertEqual(listed(self.admin), [str(self.mine.pk)])++ def _member_key(self) -> GlobalApiDeploymentKey:+ response = self._create(+ {"allow_all_deployments": False, "api_deployments": [str(self.mine.pk)]}+ )+ self.assertEqual(response.status_code, 201, response.data)+ return GlobalApiDeploymentKey.objects.get(pk=response.data["id"])++ def _authenticates(self, key: GlobalApiDeploymentKey, deployment=None) -> bool:+ try:+ KeyHelper.validate_global_api_deployment_key(+ api_key=str(key.key), api_deployment=deployment or self.mine+ )+ except UnauthorizedKey:+ return False+ return True++ def test_a_members_key_stops_working_when_they_stop_owning_it(self) -> None:+ key = self._member_key()+ self.assertTrue(key.created_by_member)+ self.assertTrue(self._authenticates(key))+ # Still a viewer: viewing is not owning.+ self.mine.memberships.filter(user=self.member).update(role=ResourceRole.VIEWER)+ self.assertFalse(self._authenticates(key))++ def test_a_members_key_stops_working_when_they_leave(self) -> None:+ key = self._member_key()+ OrganizationMember.objects.filter(user=self.member).delete()+ self.assertFalse(self._authenticates(key))++ def test_an_admins_key_does_not_depend_on_its_creator(self) -> None:+ view = GlobalApiDeploymentKeyViewSet.as_view({"post": "create"})+ response = self.call(+ view,+ "post",+ user=self.admin,+ data={+ "name": "admins",+ "description": "ci",+ "allow_all_deployments": False,+ "api_deployments": [str(self.mine.pk)],+ },+ )+ self.assertEqual(response.status_code, 201, response.data)+ key = GlobalApiDeploymentKey.objects.get(pk=response.data["id"])+ self.assertFalse(key.created_by_member)+ OrganizationMember.objects.filter(user=self.admin).delete()+ self.assertTrue(self._authenticates(key))++ def _admin_patch(self, key: GlobalApiDeploymentKey, data: dict):+ view = GlobalApiDeploymentKeyViewSet.as_view({"patch": "partial_update"})+ response = self.call(view, "patch", user=self.admin, pk=str(key.pk), data=data)+ key.refresh_from_db()+ return response++ def test_an_admin_cannot_widen_a_members_key(self) -> None:+ key = self._member_key()+ for data in (+ {"allow_all_deployments": True},+ {"api_deployments": [str(self.mine.pk), str(self.theirs.pk)]},+ ):+ with self.subTest(data=data):+ response = self._admin_patch(key, data)+ self.assertEqual(response.status_code, 400)+ self.assertIn(next(iter(data)), str(response.data))+ self.assertFalse(key.allow_all_deployments)+ self.assertEqual(list(key.api_deployments.all()), [self.mine])+ # What the edit form sends for a description-only edit.+ response = self._admin_patch(+ key,+ {+ "description": "renamed",+ "allow_all_deployments": False,+ "api_deployments": [str(self.mine.pk)],+ },+ )+ self.assertEqual(response.status_code, 200, response.data)+ self.assertEqual(key.description, "renamed")+ self.assertTrue(key.created_by_member)+ self.assertTrue(response.data["created_by_member"])++ def test_an_admin_can_still_edit_a_stranded_members_key(self) -> None:+ form = {+ "description": "renamed",+ "allow_all_deployments": False,+ "api_deployments": [str(self.mine.pk)],+ }+ key = self._member_key()+ self.mine.memberships.filter(user=self.member).delete()+ self.assertEqual(self._admin_patch(key, form).status_code, 200)+ key.created_by = None+ key.save(update_fields=["created_by"])+ self.assertEqual(+ self._admin_patch(key, {**form, "description": "again"}).status_code, 200+ )+ # Still nothing may be added.+ response = self._admin_patch(+ key, {"api_deployments": [str(self.mine.pk), str(self.theirs.pk)]}+ )+ self.assertEqual(response.status_code, 400)+ self.assertIn("api_deployments", str(response.data))+ self.assertEqual(list(key.api_deployments.all()), [self.mine])++ def _second_deployment(self) -> APIDeployment:+ workflow = Workflow.objects.create(+ workflow_name="wf2", organization=self.org, created_by=self.member+ )+ return APIDeployment.objects.create(+ api_name="mine2",+ workflow=workflow,+ organization=self.org,+ created_by=self.member,+ )++ def test_an_admin_may_add_a_deployment_the_creator_owns(self) -> None:+ mine2 = self._second_deployment()+ mine2.grant_owner(self.member)+ key = self._member_key()+ response = self._admin_patch(+ key, {"api_deployments": [str(self.mine.pk), str(mine2.pk)]}+ )+ self.assertEqual(response.status_code, 200, response.data)+ self.assertEqual(+ {d.pk for d in key.api_deployments.all()}, {self.mine.pk, mine2.pk}+ )+ self.assertTrue(self._authenticates(key, mine2))++ def test_a_creator_who_left_cannot_have_deployments_added(self) -> None:+ mine2 = self._second_deployment()+ mine2.grant_owner(self.member)+ key = self._member_key()+ OrganizationMember.objects.filter(user=self.member).delete()+ response = self._admin_patch(+ key, {"api_deployments": [str(self.mine.pk), str(mine2.pk)]}+ )+ self.assertEqual(response.status_code, 400)+ self.assertIn("api_deployments", str(response.data))++ def test_a_member_cannot_open_another_members_key(self) -> None:+ # Both own the deployment, and the other key is a member's key: only+ # the creator check can refuse it.+ colleague = make_user("[email protected]")+ OrganizationMember.objects.create(+ organization=self.org, user=colleague, role="user"+ )+ self.mine.grant_owner(colleague)+ theirs = GlobalApiDeploymentKey.objects.create(+ name="colleague",+ organization=self.org,+ created_by=colleague,+ created_by_member=True,+ )+ theirs.api_deployments.add(self.mine)+ key_before = theirs.key+ for action, method in (+ ({"get": "retrieve"}, "get"),+ ({"post": "rotate"}, "post"),+ ):+ with self.subTest(action=method):+ response = self.call(+ GlobalApiDeploymentKeyViewSet.as_view(action),+ method,+ user=self.member,+ pk=str(theirs.pk),+ )+ self.assertEqual(response.status_code, 403)+ theirs.refresh_from_db()+ self.assertEqual(theirs.key, key_before)++ def test_a_demoted_admin_cannot_view_or_rotate_their_admin_era_key(self) -> None:+ view = GlobalApiDeploymentKeyViewSet.as_view({"post": "create"})+ response = self.call(+ view,+ "post",+ user=self.admin,+ data={+ "name": "admin-era",+ "description": "ci",+ "allow_all_deployments": False,+ "api_deployments": [str(self.theirs.pk)],+ },+ )+ self.assertEqual(response.status_code, 201, response.data)+ key = GlobalApiDeploymentKey.objects.get(pk=response.data["id"])+ self.assertFalse(key.created_by_member)+ # Demoted, still owning the key's deployment.+ OrganizationMember.objects.filter(user=self.admin).update(role="user")+ demoted = type(self.admin).objects.get(pk=self.admin.pk)+ for action, method in (+ ({"get": "retrieve"}, "get"),+ ({"post": "rotate"}, "post"),+ ):+ with self.subTest(action=method):+ response = self.call(+ GlobalApiDeploymentKeyViewSet.as_view(action),+ method,+ user=demoted,+ pk=str(key.pk),+ )+ self.assertEqual(response.status_code, 403)+ listing = self.call(+ GlobalApiDeploymentKeyViewSet.as_view({"get": "list"}), "get", user=demoted+ )+ self.assertEqual(listing.status_code, 200, listing.data)+ self.assertNotIn("admin-era", [row["name"] for row in listing.data])++ def test_execution_checks_a_members_key_with_its_creators_rights(self) -> None:+ # The execute view hands the authorising global key to the request+ # serializer, which holds a member's key to its creator's profiles.+ from api_v2.api_deployment_views import DeploymentExecution++ key = self._member_key()+ seen = {}++ class Stop(Exception):+ pass++ def capture(*args, **kwargs):+ seen.update(kwargs["context"])+ raise Stop++ request = self.factory.post(+ "/", {}, format="json", HTTP_AUTHORIZATION=f"Bearer {key.key}"+ )+ with patch("api_v2.api_deployment_views.ExecutionRequestSerializer", capture):+ # The view's error handler turns Stop into a 500; only the+ # captured serializer context matters here.+ DeploymentExecution.as_view()(+ request, org_name=self.org.organization_id, api_name="mine"+ )+ self.assertEqual(seen["global_key"].pk, key.pk)+ self.assertTrue(seen["global_key"].created_by_member)++ def test_a_creator_promoted_to_admin_keeps_their_keys_working(self) -> None:+ key = self._member_key()+ self.mine.memberships.filter(user=self.member).delete()+ OrganizationMember.objects.filter(user=self.member).update(role="admin")+ key = GlobalApiDeploymentKey.objects.get(pk=key.pk)+ self.assertTrue(self._authenticates(key))++ def test_a_member_cannot_key_a_deployment_they_only_view(self) -> None:+ self.theirs.memberships.create(user=self.member, role=ResourceRole.VIEWER)+ response = self._create(+ {"allow_all_deployments": False, "api_deployments": [str(self.theirs.pk)]}+ )+ self.assertEqual(response.status_code, 403)+ picker = GlobalApiDeploymentKeyViewSet.as_view({"get": "deployments"})+ names = [+ row["api_name"] for row in self.call(picker, "get", user=self.member).data+ ]+ self.assertEqual(names, ["mine"])+ # A key that covered it (an admin's grant before) stops working for it.+ key = self._member_key()+ key.api_deployments.add(self.theirs)+ self.assertFalse(self._authenticates(key, self.theirs))++ def test_an_edit_does_not_undo_a_rotate_made_meanwhile(self) -> None:+ key = self._member_key()+ stale = GlobalApiDeploymentKey.objects.get(pk=key.pk)+ rotate = GlobalApiDeploymentKeyViewSet.as_view({"post": "rotate"})+ response = self.call(rotate, "post", user=self.member, pk=str(key.pk))+ self.assertEqual(response.status_code, 200, response.data)+ rotated = response.data["key"]+ request = SimpleNamespace(user=self.admin)+ serializer = GlobalApiDeploymentKeyUpdateSerializer(+ stale,+ data={"description": "edited"},+ partial=True,+ context={"request": request},+ )+ serializer.is_valid(raise_exception=True)+ serializer.save()+ key.refresh_from_db()+ self.assertEqual(str(key.key), str(rotated))+ self.assertEqual(key.description, "edited")++ def test_a_member_picks_from_their_own_deployments(self) -> None:+ view = GlobalApiDeploymentKeyViewSet.as_view({"get": "deployments"})+ response = self.call(view, "get", user=self.member)+ self.assertEqual(response.status_code, 200, response.data)+ self.assertEqual([row["api_name"] for row in response.data], ["mine"])