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-3853 [FIX] Attribute platform-key-created resources to the API key's creator (#2274)
Kirtiman Mishra11bde0ebacde
diff --git a/backend/adapter_processor_v2/views.py b/backend/adapter_processor_v2/views.pyindex f2aef82b0..79092acad 100644--- a/backend/adapter_processor_v2/views.py+++ b/backend/adapter_processor_v2/views.py@@ -15,7 +15,6 @@ from permissions.permission import (IsOwnerOrSharedUserOrSharedToOrg,)from permissions.resource_share_views import ResourceShareManagementMixin-from permissions.roles import ResourceRolefrom plugins import get_pluginfrom rest_framework import statusfrom rest_framework.decorators import action@@ -271,9 +270,7 @@ class AdapterInstanceViewSet(instance = serializer.save(organization=UserContext.get_organization())# ``created_by`` is audit-only; the creator's access flows through# an OWNER membership row (UN-2202 co-owners).- instance.memberships.get_or_create(- user_id=request.user.id, defaults={"role": ResourceRole.OWNER}- )+ instance.grant_owner(request.user)organization_member = OrganizationMemberService.get_user_by_id(request.user.id)diff --git a/backend/api_v2/api_deployment_views.py b/backend/api_v2/api_deployment_views.pyindex 46ddc6795..33d7844b9 100644--- a/backend/api_v2/api_deployment_views.py+++ b/backend/api_v2/api_deployment_views.py@@ -9,7 +9,6 @@ from django.http import HttpResponsefrom permissions.membership_views import OwnerManagementMixinfrom permissions.permission import IsOwner, IsOwnerOrSharedUserOrSharedToOrgfrom permissions.resource_share_views import ResourceShareManagementMixin-from permissions.roles import ResourceRolefrom platform_api.openapi_schema import PlatformKeyAutoSchemafrom plugins import get_pluginfrom prompt_studio.prompt_studio_registry_v2.models import PromptStudioRegistry@@ -360,9 +359,7 @@ class APIDeploymentViewSet(self.perform_create(serializer)# ``created_by`` is audit-only; the creator's access flows through an# OWNER membership row (UN-2202 co-owners).- serializer.instance.memberships.get_or_create(- user_id=request.user.id, defaults={"role": ResourceRole.OWNER}- )+ serializer.instance.grant_owner(request.user)api_key = DeploymentHelper.create_api_key(serializer=serializer, request=request)response_serializer = DeploymentResponseSerializer({"api_key": api_key.api_key, **serializer.data}@@ -406,8 +403,11 @@ class APIDeploymentViewSet(# Get API deployments for these workflows the user can access —# ``created_by`` is audit-only; access flows through memberships,# sharing, and the admin/SA bypasses (UN-2202).- deployments = APIDeployment.objects.for_user(request.user).filter(- workflow_id__in=workflow_ids+ deployments = (+ APIDeployment.objects.for_user(request.user)+ .select_related("created_by")+ .prefetch_related("memberships__user")+ .filter(workflow_id__in=workflow_ids))serializer = APIDeploymentListSerializer(deployments, many=True)diff --git a/backend/api_v2/serializers.py b/backend/api_v2/serializers.pyindex 31c609eba..d9d8c9638 100644--- a/backend/api_v2/serializers.py+++ b/backend/api_v2/serializers.py@@ -510,6 +510,7 @@ class APIDeploymentListSerializer(ModelSerializer):last_run_time = SerializerMethodField()is_owner = SerializerMethodField()co_owners_count = SerializerMethodField()+ owner_emails = SerializerMethodField()class Meta:model = APIDeployment@@ -529,6 +530,7 @@ class APIDeploymentListSerializer(ModelSerializer):"last_run_time","is_owner","co_owners_count",+ "owner_emails",]def get_created_by_email(self, obj) -> str | None:@@ -542,6 +544,12 @@ class APIDeploymentListSerializer(ModelSerializer):def get_co_owners_count(self, obj) -> int:return obj.co_owners_count()+ def get_owner_emails(self, obj) -> list[str]:+ """Email of each owner, earliest first. Empty if none is a person."""+ # Published field: APIDeploymentSummary inherits it, so it also+ # reaches platform-key callers.+ return obj.owner_emails()+# Both read the list view's annotations when they are there, and fall back# to a query for the callers that serialize a plain queryset. A deployment# that has never run annotates to `None`, so absence is what decides, notdiff --git a/backend/connector_v2/views.py b/backend/connector_v2/views.pyindex fd75b749d..28f803821 100644--- a/backend/connector_v2/views.py+++ b/backend/connector_v2/views.py@@ -11,7 +11,6 @@ from django.db.models import ProtectedError, QuerySetfrom permissions.membership_views import OwnerManagementMixinfrom permissions.permission import IsOwner, IsOwnerOrSharedUserOrSharedToOrgfrom permissions.resource_share_views import ResourceShareManagementMixin-from permissions.roles import ResourceRolefrom plugins import get_pluginfrom rest_framework import status, viewsetsfrom rest_framework.decorators import action@@ -258,9 +257,7 @@ class ConnectorInstanceViewSet()# ``created_by`` is audit-only; the creator's access flows through an# OWNER membership row (UN-2202 co-owners).- serializer.instance.memberships.get_or_create(- user_id=request.user.id, defaults={"role": ResourceRole.OWNER}- )+ serializer.instance.grant_owner(request.user)headers = self.get_success_headers(serializer.data)return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)diff --git a/backend/permissions/models.py b/backend/permissions/models.pyindex 7f5ad1208..80b2d5030 100644--- a/backend/permissions/models.py+++ b/backend/permissions/models.py@@ -76,3 +76,12 @@ class HasMembersMixin:m.user_id == user.id and m.role == ResourceRole.OWNERfor m in self.memberships.all() # type: ignore[attr-defined])++ def grant_owner(self, user: Any) -> None:+ """Grant OWNER on create, resolving a platform key to its creator."""+ # Lazy: platform_api.services imports models at import time.+ from platform_api.services import owner_user_for++ self.memberships.get_or_create( # type: ignore[attr-defined]+ user=owner_user_for(user), defaults={"role": ResourceRole.OWNER}+ )diff --git a/backend/permissions/permission.py b/backend/permissions/permission.pyindex 33d4dd507..18db6827a 100644--- a/backend/permissions/permission.py+++ b/backend/permissions/permission.py@@ -282,6 +282,8 @@ class IsFrictionLessAdapterDelete(permissions.BasePermission):) -> bool:if obj.is_friction_less:return True+ if _is_service_account(request):+ return Trueif _is_resource_owner(request.user, obj):return Truereturn _is_organization_admin(request)diff --git a/backend/pipeline_v2/serializers/crud.py b/backend/pipeline_v2/serializers/crud.pyindex 956d9d3bf..acc45a333 100644--- a/backend/pipeline_v2/serializers/crud.py+++ b/backend/pipeline_v2/serializers/crud.py@@ -32,6 +32,7 @@ class PipelineSerializer(IntegrityErrorMixin, AuditSerializer):next_run_time = SerializerMethodField()is_owner = SerializerMethodField()co_owners_count = SerializerMethodField()+ owner_emails = SerializerMethodField()# ``shared_groups`` is no longer an M2M on Pipeline — declare it# explicitly so ``fields = "__all__"`` continues to expose it. Share# mutations go through ``POST /pipeline/{id}/share/`` (UN-2977 plan §B).@@ -224,6 +225,11 @@ class PipelineSerializer(IntegrityErrorMixin, AuditSerializer):def get_co_owners_count(self, obj) -> int:return obj.co_owners_count()+ def get_owner_emails(self, obj) -> list[str]:+ # Names the actual owner in "Owned By"; ``created_by`` is audit-only+ # (UN-2202) and stays the service account on platform-key creates.+ return obj.owner_emails()+def get_last_5_run_statuses(self, instance: Pipeline) -> list[dict]:"""Fetch the last 5 execution statuses with timestamps for this pipeline."""return WorkflowExecution.get_last_run_statuses(instance.id, limit=5)diff --git a/backend/pipeline_v2/views.py b/backend/pipeline_v2/views.pyindex ec7e7720f..2bf502c90 100644--- a/backend/pipeline_v2/views.py+++ b/backend/pipeline_v2/views.py@@ -12,7 +12,6 @@ from django.http import HttpResponsefrom permissions.membership_views import OwnerManagementMixinfrom permissions.permission import IsOwner, IsOwnerOrSharedUserOrSharedToOrgfrom permissions.resource_share_views import ResourceShareManagementMixin-from permissions.roles import ResourceRolefrom plugins import get_pluginfrom rest_framework import serializers, status, viewsetsfrom rest_framework.decorators import action@@ -158,9 +157,7 @@ class PipelineViewSet(pipeline_instance = serializer.save()# Grant before the API key so the creator's access is committed# with the row itself, matching api_deployment_views.create().- pipeline_instance.memberships.get_or_create(- user_id=request.user.id, defaults={"role": ResourceRole.OWNER}- )+ pipeline_instance.grant_owner(request.user)# Create API key using the created instanceKeyHelper.create_api_key(pipeline_instance, request)except IntegrityError:diff --git a/backend/platform_api/services.py b/backend/platform_api/services.pyindex 408774122..0fce45cb3 100644--- a/backend/platform_api/services.py+++ b/backend/platform_api/services.py@@ -1,5 +1,6 @@from __future__ import annotations+import loggingimport reimport uuid as _uuidfrom typing import TYPE_CHECKING@@ -15,6 +16,15 @@ if TYPE_CHECKING:from platform_api.models import PlatformApiKey+logger = logging.getLogger(__name__)++# Distinguishes "caller said nothing" from an explicit None in transfer_ownership.+_SAME_AS_TO_USER: object = object()++# Reserved domain for service-account addresses. The frontend matches on it to+# label an ownerless resource "Platform key" instead of naming a machine.+SERVICE_ACCOUNT_EMAIL_DOMAIN = "platform.internal"+# Business app labels whose models may carry created_by / membership rows.# Restricts transfer_ownership to avoid scanning Django built-in and third-party models._BUSINESS_APP_LABELS = {@@ -45,7 +55,7 @@ def create_api_user_for_key(name_slug = _slugify_for_email(platform_api_key.name)user = User(username=f"svc-{name_slug}-{uid[:8]}",- email=f"{name_slug}-{uid[:8]}@platform.internal",+ email=f"{name_slug}-{uid[:8]}@{SERVICE_ACCOUNT_EMAIL_DOMAIN}",user_id=uid,is_service_account=True,)@@ -63,6 +73,63 @@ def create_api_user_for_key(return user+def live_key_creator(platform_api_key: PlatformApiKey) -> User | None:+ """The key's creator if they still belong to the key's organization.++ ``_is_resource_owner`` grants on any surviving OWNER row without checking+ live membership, which is why ``cleanup_user_org_access`` purges those rows+ when a user leaves. Handing an ex-member a fresh row -- at create, on key+ deletion, or in a backfill -- reopens that rejoin backdoor, so every path+ that names a successor asks this one question.+ """+ creator = platform_api_key.created_by+ if creator is None:+ return None+ # ``_base_manager`` because the default manager is org-scoped by+ # ``UserContext``, which is None outside a request — an empty result would+ # silently strip every resource of its owner. The org is filtered here.+ if not OrganizationMember._base_manager.filter(+ user=creator, organization=platform_api_key.organization+ ).exists():+ return None+ return creator+++def owner_user_for(user: User) -> User:+ """Resolve the human who should own a resource created by ``user``.++ Service accounts are filtered out of every owner surface, so granting to+ one leaves no human owner; attribute it to the key's live creator instead.+ Returns ``user`` unchanged for a normal session, or when no live creator+ can be named -- the UI then labels the resource "Platform key".+ """+ if not getattr(user, "is_service_account", False):+ return user++ # Imported here so the module keeps its models import behind TYPE_CHECKING.+ from platform_api.models import PlatformApiKey++ key = (+ PlatformApiKey.objects.filter(api_user=user)+ .select_related("created_by", "organization")+ .first()+ )+ if key is None:+ logger.warning(+ "Service account %s backs no platform key; resource gets no human owner",+ user.id,+ )+ return user+ creator = live_key_creator(key)+ if creator is None:+ logger.warning(+ "Platform key %s has no live creator; resource gets no human owner",+ key.id,+ )+ return user+ return creator++def _get_user_fk_fields(model: type) -> list[str]:"""Return names of all ForeignKey fields pointing to User."""return [@@ -150,7 +217,9 @@ def _transfer_membership_rows(from_user: User, to_user: User) -> None:row.delete()-def transfer_ownership(from_user: User, to_user: User | None) -> None:+def transfer_ownership(+ from_user: User, to_user: User | None, membership_to: User | None = _SAME_AS_TO_USER+) -> None:"""Transfer all resource ownership from one user to another.Replaces from_user with to_user across business models:@@ -159,25 +228,41 @@ def transfer_ownership(from_user: User, to_user: User | None) -> None:- OWNER/VIEWER membership rows (custom-through, UN-2202) — re-pointed,reconciling by role precedence when to_user already holds a row so theresource keeps an owner.++ ``membership_to`` splits the two halves. Audit fields may follow a user who+ has left the org -- nulling them has no security value and breaks deletes+ that dereference ``created_by`` -- while an OWNER row may not."""- if not to_user:- return+ if membership_to is _SAME_AS_TO_USER:+ membership_to = to_userwith transaction.atomic():- for model in apps.get_models():- if model._meta.app_label not in _BUSINESS_APP_LABELS:- continue- _transfer_model_ownership(model, from_user, to_user)+ if to_user:+ for model in apps.get_models():+ if model._meta.app_label not in _BUSINESS_APP_LABELS:+ continue+ _transfer_model_ownership(model, from_user, to_user)# Memberships live in one polymorphic table — transfer once, not per model.- _transfer_membership_rows(from_user, to_user)+ if membership_to:+ _transfer_membership_rows(from_user, membership_to)def delete_api_user_for_key(platform_api_key: PlatformApiKey) -> None:- """Transfer ownership to key creator, then delete the service account."""+ """Transfer ownership to the key's creator, then delete the service account.++ Audit fields follow ``created_by`` even if they have left the org: deleting+ the account is ``SET_NULL`` on those FKs, and a null ``created_by`` breaks+ callers that dereference it. An OWNER row is a live-membership question, so+ it goes only to a creator ``live_key_creator`` still admits.+ """api_user = platform_api_key.api_userif not api_user:returnwith transaction.atomic():- transfer_ownership(from_user=api_user, to_user=platform_api_key.created_by)+ transfer_ownership(+ from_user=api_user,+ to_user=platform_api_key.created_by,+ membership_to=live_key_creator(platform_api_key),+ )api_user.delete()diff --git a/backend/platform_api/tests/test_owner_user_for.py b/backend/platform_api/tests/test_owner_user_for.pynew file mode 100644index 000000000..3408de4f9--- /dev/null+++ b/backend/platform_api/tests/test_owner_user_for.py@@ -0,0 +1,244 @@+"""The ownership resolvers in isolation.++End-to-end coverage of the create sites that call them lives in+`test_platform_key_resource_ownership.py`.+"""++import secrets+import uuid+from types import SimpleNamespace++from account_v2.enums import UserRole+from account_v2.models import Organization, User+from django.db import connection+from django.test.utils import CaptureQueriesContext+from permissions.roles import ResourceRole+from platform_api.models import ApiKeyPermission, PlatformApiKey+from platform_api.services import create_api_user_for_key, owner_user_for+from rest_framework.test import APIRequestFactory, APITestCase+from tenant_account_v2.models import OrganizationMember+from utils.user_context import UserContext++ORG = "org-owner-test"+++def _make_user() -> User:+ email = f"user-{uuid.uuid4().hex[:8]}@example.com"+ return User.objects.create_user(+ username=email, email=email, password=secrets.token_urlsafe()+ )+++class _KeyFixture:+ """Org, a member who mints keys, and the minting path itself."""++ def setUp(self) -> None:+ self.org = Organization.objects.create(+ name=ORG, display_name="Owner Test", organization_id=ORG+ )++ def _make_member(self) -> User:+ """A key creator as production guarantees one.++ ``IsOrganizationAdmin`` resolves the caller's ``OrganizationMember``+ before allowing key creation, so a key's ``created_by`` is always a+ member of that org at mint time.+ """+ user = _make_user()+ OrganizationMember.objects.create(+ user=user, organization=self.org, role=UserRole.ADMIN.value+ )+ return user++ def _make_key(self, created_by: User | None) -> PlatformApiKey:+ key = PlatformApiKey.objects.create(+ name=f"key-{uuid.uuid4().hex[:8]}",+ description="test key",+ organization=self.org,+ permission=ApiKeyPermission.FULL_ACCESS,+ created_by=created_by,+ )+ # The minting path, for the `is_service_account` flag it sets.+ create_api_user_for_key(key, self.org)+ key.refresh_from_db()+ return key+++class OwnerUserForTest(_KeyFixture, APITestCase):+ """The resolver in isolation."""++ def test_a_normal_user_is_returned_unchanged(self) -> None:+ user = _make_user()+ self.assertEqual(owner_user_for(user), user)++ def test_a_normal_user_costs_no_query(self) -> None:+ """The early return is the hot path — every create site calls this."""+ user = _make_user()+ with CaptureQueriesContext(connection) as queries:+ owner_user_for(user)+ self.assertEqual(len(queries), 0)++ def test_a_service_account_resolves_to_the_keys_creator(self) -> None:+ creator = self._make_member()+ key = self._make_key(created_by=creator)+ self.assertEqual(owner_user_for(key.api_user), creator)++ def test_a_deleted_creator_leaves_the_resource_ownerless(self) -> None:+ """`created_by` is SET_NULL, so the key can outlive its creator."""+ key = self._make_key(created_by=self._make_member())+ PlatformApiKey.objects.filter(pk=key.pk).update(created_by=None)+ self.assertEqual(owner_user_for(key.api_user), key.api_user)++ def test_a_service_account_with_no_key_stays_itself(self) -> None:+ key = self._make_key(created_by=self._make_member())+ service_account = key.api_user+ PlatformApiKey.objects.filter(pk=key.pk).delete()+ self.assertEqual(owner_user_for(service_account), service_account)++ def test_a_creator_who_left_the_org_leaves_the_resource_ownerless(self) -> None:+ """An ex-member must not be granted OWNER; it would survive re-invite."""+ creator = self._make_member()+ key = self._make_key(created_by=creator)+ # _base_manager: the default one is org-scoped and UserContext is unset.+ OrganizationMember._base_manager.filter(+ user=creator, organization=self.org+ ).delete()+ self.assertEqual(owner_user_for(key.api_user), key.api_user)++ def test_a_creator_in_a_different_org_is_not_granted(self) -> None:+ """Membership is checked against the key's org, not any org."""+ creator = _make_user()+ other_org = Organization.objects.create(+ name="other", display_name="Other", organization_id="org-other"+ )+ OrganizationMember.objects.create(+ user=creator, organization=other_org, role=UserRole.ADMIN.value+ )+ key = self._make_key(created_by=creator)+ self.assertEqual(owner_user_for(key.api_user), key.api_user)+++class KeyDeletionSuccessorTest(_KeyFixture, APITestCase):+ """Deleting a key must not hand its rows to a departed creator."""++ def _owner_row_users(self, resource):+ return {m.user_id for m in resource.memberships.filter(role=ResourceRole.OWNER)}++ def _key_owned_workflow(self, creator):+ from workflow_manager.workflow_v2.models.workflow import Workflow++ key = self._make_key(created_by=creator)+ workflow = Workflow.objects.create(+ workflow_name=f"wf-{uuid.uuid4().hex[:8]}", organization=self.org+ )+ workflow.memberships.create(+ user=key.api_user, role=ResourceRole.OWNER, organization=self.org+ )+ return key, workflow++ def test_a_live_creator_inherits_the_rows(self) -> None:+ creator = self._make_member()+ key, workflow = self._key_owned_workflow(creator)+ key.delete()+ self.assertEqual(self._owner_row_users(workflow), {creator.id})++ def test_a_departed_creator_inherits_nothing(self) -> None:+ creator = self._make_member()+ key, workflow = self._key_owned_workflow(creator)+ OrganizationMember._base_manager.filter(+ user=creator, organization=self.org+ ).delete()+ key.delete()+ self.assertNotIn(creator.id, self._owner_row_users(workflow))++ def test_a_departed_creator_still_keeps_the_audit_trail(self) -> None:+ """Deleting the account is SET_NULL on created_by; a null breaks deletes."""+ creator = self._make_member()+ key, workflow = self._key_owned_workflow(creator)+ workflow.created_by = key.api_user+ workflow.save(update_fields=["created_by"])+ OrganizationMember._base_manager.filter(+ user=creator, organization=self.org+ ).delete()++ key.delete()++ workflow.refresh_from_db()+ self.assertEqual(workflow.created_by_id, creator.id)+++class ServiceAccountStaysAuthorizedTest(_KeyFixture, APITestCase):+ """Ownership no longer names the service account, so the gates that read+ ownership need their own bypass -- otherwise a key cannot use what it made.+ """++ def test_adapter_access_admits_a_service_account(self) -> None:+ from adapter_processor_v2.models import AdapterInstance+ from tool_instance_v2.tool_instance_helper import ToolInstanceHelper++ creator = self._make_member()+ key = self._make_key(created_by=creator)+ adapter = AdapterInstance.objects.create(+ adapter_name=f"a-{uuid.uuid4().hex[:8]}",+ adapter_id=f"llm|{uuid.uuid4()}",+ adapter_type="LLM",+ adapter_metadata={},+ organization=self.org,+ created_by=creator,+ )+ adapter.grant_owner(creator)+ # AdapterInstance.objects is org-scoped; without this the gate sees an+ # empty queryset and the assertion proves nothing.+ UserContext.set_organization_identifier(ORG)+ self.addCleanup(UserContext.set_organization_identifier, None)++ # Raises PermissionDenied without the bypass.+ ToolInstanceHelper.validate_adapter_access(+ user=key.api_user, adapter_ids={str(adapter.id)}+ )++ def test_adapter_delete_admits_a_service_account(self) -> None:+ """A key must be able to delete the adapter it created."""+ from adapter_processor_v2.models import AdapterInstance+ from permissions.permission import IsFrictionLessAdapterDelete++ creator = self._make_member()+ key = self._make_key(created_by=creator)+ adapter = AdapterInstance.objects.create(+ adapter_name=f"a-{uuid.uuid4().hex[:8]}",+ adapter_id=f"llm|{uuid.uuid4()}",+ adapter_type="LLM",+ adapter_metadata={},+ organization=self.org,+ created_by=creator,+ )+ adapter.grant_owner(creator)++ request = APIRequestFactory().delete("/")+ request.user = key.api_user++ self.assertTrue(+ IsFrictionLessAdapterDelete().has_object_permission(+ request, view=None, obj=adapter+ )+ )++ def test_workflow_permission_admits_a_service_account(self) -> None:+ from workflow_manager.workflow_v2.models.workflow import Workflow+ from workflow_manager.workflow_v2.permissions import IsWorkflowOwnerOrShared++ creator = self._make_member()+ key = self._make_key(created_by=creator)+ workflow = Workflow.objects.create(+ workflow_name=f"wf-{uuid.uuid4().hex[:8]}", organization=self.org+ )+ workflow.grant_owner(creator)++ request = APIRequestFactory().get("/")+ request.user = key.api_user+ view = SimpleNamespace(kwargs={"workflow_id": str(workflow.id)})+ # The permission resolves the workflow through the org-scoped manager.+ UserContext.set_organization_identifier(ORG)+ self.addCleanup(UserContext.set_organization_identifier, None)++ self.assertTrue(IsWorkflowOwnerOrShared().has_permission(request, view))diff --git a/backend/platform_api/tests/test_platform_key_resource_ownership.py b/backend/platform_api/tests/test_platform_key_resource_ownership.pynew file mode 100644index 000000000..1b03dac20--- /dev/null+++ b/backend/platform_api/tests/test_platform_key_resource_ownership.py@@ -0,0 +1,254 @@+"""A resource created through a platform key is owned by the key's creator.++One case per resource that grants an OWNER row on create, kept together since+they all exercise one resolver. Each drives the real URLconf and middleware+with a key minted here; side effects unrelated to the grant are patched out.+"""++import secrets+import uuid+from unittest.mock import patch++from account_v2.enums import UserRole+from account_v2.models import Organization, User+from django.conf import settings+from django.test import override_settings+from permissions.roles import ResourceRole+from platform_api.models import ApiKeyPermission, PlatformApiKey+from platform_api.services import create_api_user_for_key+from rest_framework.test import APITestCase+from tenant_account_v2.models import OrganizationMember+from utils.user_context import UserContext+from workflow_manager.workflow_v2.models.workflow import Workflow++ORG = "org-ownership"++# Trimmed from the production chain, preserving its relative order. Pinning it+# keeps the suite behaving the same under the OSS and cloud test settings.+_MIDDLEWARE = [+ "middleware.request_id.CustomRequestIDMiddleware",+ settings.TENANT_MIDDLEWARE,+ "django.contrib.sessions.middleware.SessionMiddleware",+ "django.middleware.csrf.CsrfViewMiddleware",+ "django.contrib.auth.middleware.AuthenticationMiddleware",+ settings.CUSTOM_AUTH_MIDDLEWARE,+]+++@override_settings(MIDDLEWARE=_MIDDLEWARE)+class PlatformKeyResourceOwnershipTest(APITestCase):+ def setUp(self) -> None:+ self.org = Organization.objects.create(+ name=ORG, display_name="Ownership", organization_id=ORG+ )+ email = f"creator-{uuid.uuid4().hex[:8]}@example.com"+ self.creator = User.objects.create_user(+ username=email, email=email, password=secrets.token_urlsafe()+ )+ # ``IsOrganizationAdmin`` resolves the caller's membership before+ # allowing key creation, so a key's creator is always a member of its+ # org -- and ``owner_user_for`` re-checks that before granting.+ OrganizationMember.objects.create(+ user=self.creator, organization=self.org, role=UserRole.ADMIN.value+ )+ self.key = PlatformApiKey.objects.create(+ name=f"key-{uuid.uuid4().hex[:8]}",+ description="test key",+ organization=self.org,+ permission=ApiKeyPermission.FULL_ACCESS,+ created_by=self.creator,+ )+ # The minting path, for the `is_service_account` flag it sets.+ create_api_user_for_key(self.key, self.org)++ def tearDown(self) -> None:+ # Left set, this thread-local scopes the managers in whatever runs next.+ UserContext.set_organization_identifier(None)++ # -- helpers ---------------------------------------------------------++ def _post(self, path: str, payload: dict):+ return self.client.post(+ f"/{settings.PATH_PREFIX}/unstract/{ORG}/{path}",+ payload,+ format="json",+ HTTP_AUTHORIZATION=f"Bearer {self.key.key}",+ )++ def _assert_owned_by_creator(self, instance) -> None:+ """The OWNER row names the human who made the key, not the machine."""+ membership = instance.memberships.get(role=ResourceRole.OWNER)+ self.assertEqual(membership.user, self.creator)+ self.assertFalse(+ membership.user.is_service_account,+ "the OWNER row went to the key's service account",+ )++ def _make_workflow(self, *, api_endpoints: bool = False) -> Workflow:+ UserContext.set_organization_identifier(ORG)+ workflow = Workflow.objects.create(+ workflow_name=f"wf-{uuid.uuid4().hex[:8]}",+ organization=self.org,+ created_by=self.creator,+ )+ if api_endpoints:+ # An API deployment is refused unless both endpoints exist and+ # carry a connection type; API ones need no connector instance.+ from workflow_manager.endpoint_v2.models import WorkflowEndpoint++ for endpoint_type in (+ WorkflowEndpoint.EndpointType.SOURCE,+ WorkflowEndpoint.EndpointType.DESTINATION,+ ):+ WorkflowEndpoint.objects.update_or_create(+ workflow=workflow,+ endpoint_type=endpoint_type,+ defaults={+ "connection_type": WorkflowEndpoint.ConnectionType.API+ },+ )+ return workflow++ def _fetch(self, model, pk):+ # Managers are org-scoped off a thread-local the request cleared.+ UserContext.set_organization_identifier(ORG)+ return model.objects.get(pk=pk)++ # -- resources -------------------------------------------------------++ def test_workflow(self) -> None:+ response = self._post(+ "workflow/", {"workflow_name": f"wf-{uuid.uuid4().hex[:8]}"}+ )+ self.assertEqual(response.status_code, 201, response.content)+ self._assert_owned_by_creator(self._fetch(Workflow, response.json()["id"]))++ def test_prompt_studio_project(self) -> None:+ from prompt_studio.prompt_studio_core_v2.models import CustomTool++ with patch(+ "prompt_studio.prompt_studio_core_v2.views.PromptStudioHelper."+ "create_default_profile_manager"+ ):+ response = self._post(+ "prompt-studio/",+ {+ "tool_name": f"ps-{uuid.uuid4().hex[:8]}",+ "description": "owned by the key's creator",+ "author": "tester",+ },+ )+ self.assertEqual(response.status_code, 201, response.content)+ self._assert_owned_by_creator(+ self._fetch(CustomTool, response.json()["tool_id"])+ )++ def test_etl_pipeline(self) -> None:+ from pipeline_v2.models import Pipeline++ workflow = self._make_workflow()+ with patch("pipeline_v2.views.KeyHelper.create_api_key"):+ response = self._post(+ "pipeline/",+ {+ "pipeline_name": f"etl-{uuid.uuid4().hex[:8]}",+ "workflow": str(workflow.id),+ "pipeline_type": "ETL",+ },+ )+ self.assertEqual(response.status_code, 201, response.content)+ self._assert_owned_by_creator(self._fetch(Pipeline, response.json()["id"]))++ def test_api_deployment(self) -> None:+ from api_v2.models import APIDeployment++ workflow = self._make_workflow(api_endpoints=True)+ with (+ patch("api_v2.api_deployment_views.DeploymentHelper.create_api_key"),+ patch("api_v2.api_deployment_views.notify_hubspot_event"),+ ):+ response = self._post(+ "api/deployment/",+ {+ "display_name": f"api-{uuid.uuid4().hex[:8]}",+ "api_name": f"api-{uuid.uuid4().hex[:8]}",+ "description": "owned by the key's creator",+ "workflow": str(workflow.id),+ },+ )+ self.assertEqual(response.status_code, 201, response.content)+ self._assert_owned_by_creator(+ self._fetch(APIDeployment, response.json()["id"])+ )++ def test_connector(self) -> None:+ from connector_v2.models import ConnectorInstance++ workflow = self._make_workflow()+ response = self._post(+ "connector/",+ {+ "connector_name": f"conn-{uuid.uuid4().hex[:8]}",+ # Must resolve in the connector registry, which is keyed by+ # this exact string -- see ConnectorProcessor.+ "connector_id": "minio|c799f6e3-2b57-434e-aaac-b5daa415da19",+ "workflow": str(workflow.id),+ "connector_mode": "FILESYSTEM",+ "connector_metadata": {+ "key": "test",+ "secret": "test",+ "endpoint_url": "http://localhost:9000",+ "bucket": "test",+ },+ },+ )+ self.assertEqual(response.status_code, 201, response.content)+ self._assert_owned_by_creator(+ self._fetch(ConnectorInstance, response.json()["id"])+ )++ def test_prompt_studio_project_import(self) -> None:+ """The import path grants its own OWNER row, separately from create.++ ``create_tool_from_import_data`` is reached by ``project-transfer/``+ and by ``sync-prompts/`` with ``create_copy``, and takes ``request.user``+ directly. Called here rather than over HTTP because the endpoint's other+ work -- profile managers, prompt import, adapter validation -- is not+ what is under test, and stubbing it would pin the stubs.+ """+ from prompt_studio.prompt_studio_core_v2.models import CustomTool+ from prompt_studio.prompt_studio_core_v2.prompt_studio_helper import (+ PromptStudioHelper,+ )++ tool = PromptStudioHelper.create_tool_from_import_data(+ {+ "tool_metadata": {+ "tool_name": f"imported-{uuid.uuid4().hex[:8]}",+ "author": "test",+ "description": "imported through a platform key",+ },+ "tool_settings": {},+ },+ f"imported-{uuid.uuid4().hex[:8]}",+ self.org,+ self.key.api_user,+ )+ self._assert_owned_by_creator(self._fetch(CustomTool, tool.pk))++ def test_adapter(self) -> None:+ from adapter_processor_v2.models import AdapterInstance++ response = self._post(+ "adapter/",+ {+ "adapter_name": f"adapter-{uuid.uuid4().hex[:8]}",+ "adapter_id": "openai|502ecf49-e47c-445c-9907-6d4b90c5cd17",+ "adapter_type": "LLM",+ "adapter_metadata": {"adapter_name": "test", "api_key": "sk-test"},+ },+ )+ self.assertEqual(response.status_code, 201, response.content)+ self._assert_owned_by_creator(+ self._fetch(AdapterInstance, response.json()["id"])+ )diff --git a/backend/prompt_studio/prompt_studio_core_v2/prompt_studio_helper.py b/backend/prompt_studio/prompt_studio_core_v2/prompt_studio_helper.pyindex 774d6e19e..a1d1cfb54 100644--- a/backend/prompt_studio/prompt_studio_core_v2/prompt_studio_helper.py+++ b/backend/prompt_studio/prompt_studio_core_v2/prompt_studio_helper.py@@ -17,7 +17,6 @@ from permissions.permission import (_is_resource_viewer,has_group_access,)-from permissions.roles import ResourceRolefrom plugins import get_pluginfrom rest_framework.exceptions import APIExceptionfrom rest_framework.request import Request@@ -2923,7 +2922,7 @@ class PromptStudioHelper:# created_by is audit-only; grant the creator an OWNER membership row so# access/ownership flows through it (UN-2202), as the viewset create does.- tool.memberships.get_or_create(user=user, defaults={"role": ResourceRole.OWNER})+ tool.grant_owner(user)return tooldiff --git a/backend/prompt_studio/prompt_studio_core_v2/views.py b/backend/prompt_studio/prompt_studio_core_v2/views.pyindex 68c17adcd..86a739efc 100644--- a/backend/prompt_studio/prompt_studio_core_v2/views.py+++ b/backend/prompt_studio/prompt_studio_core_v2/views.py@@ -19,7 +19,6 @@ from file_management.exceptions import FileNotFoundfrom permissions.membership_views import OwnerManagementMixinfrom permissions.permission import IsOwner, IsOwnerOrSharedUserOrSharedToOrgfrom permissions.resource_share_views import ResourceShareManagementMixin-from permissions.roles import ResourceRolefrom plugins import get_pluginfrom rest_framework import status, viewsetsfrom rest_framework.decorators import action@@ -211,9 +210,7 @@ class PromptStudioCoreView()# ``created_by`` is audit-only; the creator's access flows through an# OWNER membership row (UN-2202 co-owners).- serializer.instance.memberships.get_or_create(- user_id=request.user.id, defaults={"role": ResourceRole.OWNER}- )+ serializer.instance.grant_owner(request.user)PromptStudioHelper.create_default_profile_manager(request.user, serializer.data["tool_id"])diff --git a/backend/tenant_account_v2/migrations/0006_backfill_platform_key_ownership.py b/backend/tenant_account_v2/migrations/0006_backfill_platform_key_ownership.pynew file mode 100644index 000000000..11cfa3b74--- /dev/null+++ b/backend/tenant_account_v2/migrations/0006_backfill_platform_key_ownership.py@@ -0,0 +1,43 @@+"""Re-point service-account OWNER rows to the key's live creator.++Rows written before ``owner_user_for`` existed name the service account, which+every owner surface filters out. Skips a creator who has left the org, matching+the resolver. Idempotent.++The repair itself lives in ``_membership_backfill.repair_platform_key_ownership``+so a cloud-only app -- which this migration can't declare a dependency on --+can import and re-run it after its own absorb-shared-users migration.+"""++from django.db import migrations++from tenant_account_v2.migrations._membership_backfill import (+ repair_platform_key_ownership,+)+++def _forward(apps, schema_editor):+ repair_platform_key_ownership(apps)+++class Migration(migrations.Migration):+ dependencies = [+ ("tenant_account_v2", "0005_resource_membership"),+ ("platform_api", "0004_alter_platformapikey_organization"),+ # UN-2202's backfills write an OWNER row from ``created_by``, which is+ # the service account on a key-created resource. They must land before+ # this one or their rows are written after the repair and stay+ # ownerless -- ordering that was otherwise alphabetical accident, and+ # already wrong for workflow_v2.+ ("adapter_processor_v2", "0005_absorb_shared_users"),+ ("api_v2", "0005_absorb_shared_users"),+ ("connector_v2", "0007_absorb_shared_users"),+ ("pipeline_v2", "0005_absorb_shared_users"),+ ("prompt_studio_core_v2", "0009_absorb_shared_users"),+ ("workflow_v2", "0022_absorb_shared_users"),+ ]++ # Irreversible in substance: which rows were the service account's is not+ # recoverable afterwards. Reversing is a no-op so the migration can still+ # be unapplied without blocking a rollback.+ operations = [migrations.RunPython(_forward, migrations.RunPython.noop)]diff --git a/backend/tenant_account_v2/migrations/_membership_backfill.py b/backend/tenant_account_v2/migrations/_membership_backfill.pyindex 00235b60f..b9368db90 100644--- a/backend/tenant_account_v2/migrations/_membership_backfill.py+++ b/backend/tenant_account_v2/migrations/_membership_backfill.py@@ -1,9 +1,9 @@-"""Shared backfill for the UN-2202 single-table membership migration.+"""Shared backfills for the UN-2202 single-table membership migration.Lives inside the migrations package with a ``_`` prefix so Django's migrationloader skips it (it only treats non-``_``/``~`` modules as migrations), while-the per-app membership migrations can still import it and stay thin instead of-each carrying its own copy.+the per-app membership migrations -- OSS and cloud alike -- can still import+it and stay thin instead of each carrying its own copy.Idempotent: ``get_or_create`` is keyed on the unique ``(user, content_type,object_id)`` triple, so re-runs and the creator-is-also-a-shared-user overlap@@ -12,6 +12,8 @@ are both safe (the existing OWNER row wins over a would-be VIEWER row).import logging+from django.utils import timezone+logger = logging.getLogger(__name__)OWNER = "owner"@@ -68,3 +70,59 @@ def backfill_memberships(apps, app_label: str, model_name: str) -> None:skipped,skipped_org,)+++def repair_platform_key_ownership(apps) -> None:+ """Re-point service-account OWNER rows to the key's live creator.++ Rows written before ``owner_user_for`` existed name the service account,+ which every owner surface filters out. Skips a creator who has left the+ org, matching the resolver. Safe to re-run: a resource type whose OWNER+ rows are written by a migration that lands after this one (cloud-only+ apps this module's app can't declare a dependency on) needs this called+ again from a migration that depends on both.+ """+ resource_membership_model = apps.get_model(+ "tenant_account_v2", "ResourceMembership"+ ) # NOSONAR+ organization_member_model = apps.get_model(+ "tenant_account_v2", "OrganizationMember"+ ) # NOSONAR+ platform_api_key_model = apps.get_model("platform_api", "PlatformApiKey") # NOSONAR++ # Keyed off key rows so only accounts actually backing a key move.+ successor: dict[int, int] = {}+ for key in platform_api_key_model.objects.exclude(api_user_id=None).exclude(+ created_by_id=None+ ):+ if organization_member_model.objects.filter(+ user_id=key.created_by_id, organization_id=key.organization_id+ ).exists():+ successor[key.api_user_id] = key.created_by_id++ if not successor:+ return++ rows = resource_membership_model.objects.filter(+ role=OWNER, user_id__in=successor.keys()+ )+ for row in rows.iterator():+ new_user_id = successor[row.user_id]+ clash = resource_membership_model.objects.filter(+ user_id=new_user_id,+ content_type_id=row.content_type_id,+ object_id=row.object_id,+ ).first()+ if clash is None:+ row.user_id = new_user_id+ # Historical models skip BaseModel.save's modified_at injection.+ row.modified_at = timezone.now()+ row.save(update_fields=["user", "modified_at"])+ continue+ # Creator already holds a row here: keep the stronger role, drop the+ # service account's, so the uniqueness constraint holds.+ if clash.role != OWNER:+ clash.role = OWNER+ clash.modified_at = timezone.now()+ clash.save(update_fields=["role", "modified_at"])+ row.delete()diff --git a/backend/tool_instance_v2/tool_instance_helper.py b/backend/tool_instance_v2/tool_instance_helper.pyindex 138e48b5b..0669048a3 100644--- a/backend/tool_instance_v2/tool_instance_helper.py+++ b/backend/tool_instance_v2/tool_instance_helper.py@@ -523,6 +523,11 @@ class ToolInstanceHelper:) -> None:adapter_instances = AdapterInstance.objects.filter(id__in=adapter_ids).all()is_admin = OrganizationMemberService.is_user_organization_admin(user)+ # A platform key's service account is trusted across its own org, the+ # same bypass every other access surface applies. Ownership no longer+ # names it (UN-3853), so without this a key-provisioned workflow would+ # fail its own execution.+ is_service_account = getattr(user, "is_service_account", False)for adapter_instance in adapter_instances:if not adapter_instance.is_usable:@@ -536,6 +541,7 @@ class ToolInstanceHelper:if not (is_admin+ or is_service_accountor adapter_instance.shared_to_orgor _is_resource_owner(user, adapter_instance)or _is_resource_viewer(user, adapter_instance)diff --git a/backend/workflow_manager/workflow_v2/permissions.py b/backend/workflow_manager/workflow_v2/permissions.pyindex 01e0cb0ca..d133ed441 100644--- a/backend/workflow_manager/workflow_v2/permissions.py+++ b/backend/workflow_manager/workflow_v2/permissions.py@@ -38,7 +38,9 @@ class IsWorkflowOwnerOrShared(BasePermission):user = request.userhas_access = (- _is_resource_owner(user, workflow)+ # Trusted across its own org; ownership no longer names it (UN-3853).+ getattr(user, "is_service_account", False)+ or _is_resource_owner(user, workflow)or _is_resource_viewer(user, workflow)or (workflow.shared_to_org and workflow.organization == user.organization)or OrganizationMemberService.is_user_organization_admin(user)diff --git a/backend/workflow_manager/workflow_v2/views.py b/backend/workflow_manager/workflow_v2/views.pyindex c999b7f9f..e8f6d2272 100644--- a/backend/workflow_manager/workflow_v2/views.py+++ b/backend/workflow_manager/workflow_v2/views.py@@ -10,7 +10,6 @@ from django.views.decorators.csrf import csrf_exemptfrom permissions.membership_views import OwnerManagementMixinfrom permissions.permission import IsOwner, IsOwnerOrSharedUserOrSharedToOrgfrom permissions.resource_share_views import ResourceShareManagementMixin-from permissions.roles import ResourceRolefrom pipeline_v2.models import Pipelinefrom pipeline_v2.pipeline_processor import PipelineProcessorfrom plugins import get_plugin@@ -161,9 +160,7 @@ class WorkflowViewSet()# ``created_by`` is audit-only; the creator's access flows through an# OWNER membership row (UN-2202 co-owners).- workflow.memberships.get_or_create(- user_id=self.request.user.id, defaults={"role": ResourceRole.OWNER}- )+ workflow.grant_owner(self.request.user)try:# Create empty WorkflowEndpoints for UI compatibility# ConnectorInstances will be created when users actually configure connectorsdiff --git a/frontend/src/components/deployments/api-deployment/ApiDeployment.jsx b/frontend/src/components/deployments/api-deployment/ApiDeployment.jsxindex b1e5bd070..62867bacb 100644--- a/frontend/src/components/deployments/api-deployment/ApiDeployment.jsx+++ b/frontend/src/components/deployments/api-deployment/ApiDeployment.jsx@@ -85,6 +85,7 @@ function ApiDeployment() {fetchRef,handlePaginationChange,handleSearch,+ handleListRefresh,} = usePaginatedList();const { scrollRestoreId, activateScrollRestore, clearPendingScroll } =@@ -360,6 +361,7 @@ function ApiDeployment() {openCodeModal={setOpenCodeModal}setSelectedRow={setSelectedRow}workflowEndpointList={workflowEndpointList}+ refreshList={handleListRefresh}/>)}<ManageKeysdiff --git a/frontend/src/components/deployments/create-api-deployment-modal/CreateApiDeploymentModal.jsx b/frontend/src/components/deployments/create-api-deployment-modal/CreateApiDeploymentModal.jsxindex 6669c7339..cd781569c 100644--- a/frontend/src/components/deployments/create-api-deployment-modal/CreateApiDeploymentModal.jsx+++ b/frontend/src/components/deployments/create-api-deployment-modal/CreateApiDeploymentModal.jsx@@ -30,6 +30,7 @@ const CreateApiDeploymentModal = ({workflowEndpointList = [],setDeploymentName,onDeploymentCreated,+ refreshList,}) => {const workflowStore = useWorkflowStore();const { updateWorkflow } = workflowStore;@@ -109,8 +110,9 @@ const CreateApiDeploymentModal = ({onDeploymentCreated();}} else {- // Add new deployment to list- setTableData((prev) => [res?.data, ...prev]);+ // Refetch: the create response is a summary without the owner+ // fields the list renders.+ refreshList?.();setSelectedRow(res?.data);openCodeModal(true);}@@ -294,6 +296,7 @@ CreateApiDeploymentModal.propTypes = {workflowEndpointList: PropTypes.object,setDeploymentName: PropTypes.func,onDeploymentCreated: PropTypes.func,+ refreshList: PropTypes.func,};export { CreateApiDeploymentModal };diff --git a/frontend/src/components/widgets/card-grid-view/CardFieldComponents.jsx b/frontend/src/components/widgets/card-grid-view/CardFieldComponents.jsxindex 646d2fbce..4ea6ae090 100644--- a/frontend/src/components/widgets/card-grid-view/CardFieldComponents.jsx+++ b/frontend/src/components/widgets/card-grid-view/CardFieldComponents.jsx@@ -27,6 +27,7 @@ import {formattedDateTime,shortenApiEndpoint,} from "../../../helpers/GetStaticData";+import { resolveOwnerDisplay } from "../owner-display";/*** Reusable action box with Edit, Share, Delete icons and kebab menu@@ -139,11 +140,7 @@ CardActionBox.propTypes = {* @return {JSX.Element} Rendered owner field row*/function OwnerFieldRow({ item, sessionDetails, onManageCoOwners }) {- const isOwner = item?.is_owner ?? item.created_by === sessionDetails?.userId;- const email = item.created_by_email;- const name = isOwner ? "Me" : email?.split("@")[0] || "Unknown";- const extra =- item?.co_owners_count > 1 ? ` +${item.co_owners_count - 1}` : "";+ const { email, name, extra } = resolveOwnerDisplay(item, sessionDetails);const ownerDisplay = `${name}${extra}`;const ownerContent = (diff --git a/frontend/src/components/widgets/owner-display.js b/frontend/src/components/widgets/owner-display.jsnew file mode 100644index 000000000..a8cdb93f7--- /dev/null+++ b/frontend/src/components/widgets/owner-display.js@@ -0,0 +1,34 @@+// Service accounts live in this domain; label them rather than name them.+const PLATFORM_KEY_EMAIL_DOMAIN = "@platform.internal";++/**+ * Resolve the "Owned By" label for a resource row. Shared by the table and+ * card views so the two cannot drift.+ *+ * @param {object} item Resource row from a list endpoint.+ * @param {object} sessionDetails Current session, for the "Me" comparison.+ * @param {string} ownerEmailsProp Field holding the owner emails.+ * @return {{email: string|undefined, name: string, extra: string}}+ */+function resolveOwnerDisplay(item, sessionDetails, ownerEmailsProp) {+ // Earliest owner first; created_by_email covers rows with no OWNER row.+ const ownerEmails = item?.[ownerEmailsProp ?? "owner_emails"];+ const rawEmail =+ (Array.isArray(ownerEmails) ? ownerEmails[0] : undefined) ??+ item?.created_by_email;+ const isPlatformKey = Boolean(rawEmail?.endsWith(PLATFORM_KEY_EMAIL_DOMAIN));+ const email = isPlatformKey ? undefined : rawEmail;+ // Tracks the displayed owner, not the viewer's own membership.+ const isMe = Boolean(email) && email === sessionDetails?.email;+ let name = email?.split("@")[0] || "Unknown";+ if (isPlatformKey) {+ name = "Platform key";+ } else if (isMe) {+ name = "Me";+ }+ const extra =+ item?.co_owners_count > 1 ? ` +${item.co_owners_count - 1}` : "";+ return { email, name, extra };+}++export { resolveOwnerDisplay };diff --git a/frontend/src/components/widgets/owner-display.test.js b/frontend/src/components/widgets/owner-display.test.jsnew file mode 100644index 000000000..41bb4b83c--- /dev/null+++ b/frontend/src/components/widgets/owner-display.test.js@@ -0,0 +1,64 @@+import { describe, expect, it } from "vitest";++import { resolveOwnerDisplay } from "./owner-display";++const SESSION = { email: "[email protected]" };++describe("resolveOwnerDisplay", () => {+ it("prefers the first owner email over created_by_email", () => {+ const { email, name } = resolveOwnerDisplay(+ {+ owner_emails: ["[email protected]"],+ created_by_email: "[email protected]",+ },+ SESSION,+ );+ expect(email).toBe("[email protected]");+ expect(name).toBe("owner");+ });++ it("falls back to created_by_email when owner_emails is absent or empty", () => {+ for (const item of [+ { created_by_email: "[email protected]" },+ { owner_emails: [], created_by_email: "[email protected]" },+ ]) {+ expect(resolveOwnerDisplay(item, SESSION).email).toBe(+ "[email protected]",+ );+ }+ });++ it("labels a service-account address 'Platform key' and shows no email", () => {+ const { email, name } = resolveOwnerDisplay(+ { created_by_email: "[email protected]" },+ SESSION,+ );+ expect(name).toBe("Platform key");+ expect(email).toBeUndefined();+ });++ it("reads 'Me' only when the DISPLAYED owner is the viewer", () => {+ expect(+ resolveOwnerDisplay({ owner_emails: ["[email protected]"] }, SESSION).name,+ ).toBe("Me");+ // A co-owner viewing a resource someone else owns must not read "Me".+ expect(+ resolveOwnerDisplay({ owner_emails: ["[email protected]"] }, SESSION)+ .name,+ ).toBe("other");+ });++ it("suffixes the extra co-owners, and nothing when there is one owner", () => {+ const item = { owner_emails: ["[email protected]"] };+ expect(+ resolveOwnerDisplay({ ...item, co_owners_count: 3 }, SESSION).extra,+ ).toBe(" +2");+ expect(+ resolveOwnerDisplay({ ...item, co_owners_count: 1 }, SESSION).extra,+ ).toBe("");+ });++ it("renders 'Unknown' when the row carries no owner field at all", () => {+ expect(resolveOwnerDisplay({}, SESSION).name).toBe("Unknown");+ });+});diff --git a/frontend/src/components/widgets/resource-table/ResourceTable.jsx b/frontend/src/components/widgets/resource-table/ResourceTable.jsxindex c2a99ecb3..d218b5107 100644--- a/frontend/src/components/widgets/resource-table/ResourceTable.jsx+++ b/frontend/src/components/widgets/resource-table/ResourceTable.jsx@@ -22,6 +22,7 @@ import { Table } from "@/components/ui/shims/antd-structure";import { Typography } from "@/components/ui/shims/antd-typography";import { formattedDateTime, timeAgo } from "../../../helpers/GetStaticData";+import { resolveOwnerDisplay } from "../owner-display";import "./ResourceTable.css";// Stable, distinct avatar swatch per owner (seeded on email/name) like the@@ -217,20 +218,11 @@ function ResourceTable({};const renderOwner = (item) => {- // owner_emails is earliest-first; [0] is the primary shown owner.- // Fall back to created_by_email so rows with no live OWNER membership- // (platform API-key sessions, pre-backfill rows) don't render "Unknown".- const ownerEmails = item?.[ownerEmailsProp];- const email =- (Array.isArray(ownerEmails) ? ownerEmails[0] : undefined) ??- item?.created_by_email;- // "Me" must track the DISPLAYED owner, not the viewer's own membership —- // else a co-owner sees "Me" over the primary owner's avatar/email. Match on- // the shown email so the creator viewing their own resource still reads "Me".- const isMe = Boolean(email) && email === sessionDetails?.email;- const name = isMe ? "Me" : email?.split("@")[0] || "Unknown";- const extra =- item?.co_owners_count > 1 ? ` +${item.co_owners_count - 1}` : "";+ const { email, name, extra } = resolveOwnerDisplay(+ item,+ sessionDetails,+ ownerEmailsProp,+ );const initials = (email || name).slice(0, 2).toUpperCase();const swatch = colorForSeed(email || name);diff --git a/specs/docstudio-oss.json b/specs/docstudio-oss.jsonindex 7bd536cda..36a7ffe20 100644--- a/specs/docstudio-oss.json+++ b/specs/docstudio-oss.json@@ -65,6 +65,14 @@"readOnly": true,"type": "string"},+ "owner_emails": {+ "description": "Email of each owner, earliest first. Empty if none is a person.",+ "items": {+ "type": "string"+ },+ "readOnly": true,+ "type": "array"+ },"run_count": {"readOnly": true,"type": "integer"@@ -91,6 +99,7 @@"is_owner","last_5_run_statuses","last_run_time",+ "owner_emails","run_count","workflow","workflow_name"