Fix #27107: soft-deleted users still appear in Experts/Reviewers across all entities

openmetadata-integration-tests/src/test/java/org/openmetadata/it/tests/DataProductResourceIT.java

@@ -33,6 +33,7 @@
 import org.openmetadata.schema.api.domains.CreateDomain.DomainType;
 import org.openmetadata.schema.api.domains.DataProductPortsView;
 import org.openmetadata.schema.api.services.CreateDatabaseService;
+import org.openmetadata.schema.api.teams.CreateUser;
 import org.openmetadata.schema.entity.data.Dashboard;
 import org.openmetadata.schema.entity.data.Table;
 import org.openmetadata.schema.entity.data.Topic;
@@ -41,6 +42,7 @@
 import org.openmetadata.schema.entity.services.DashboardService;
 import org.openmetadata.schema.entity.services.DatabaseService;
 import org.openmetadata.schema.entity.services.MessagingService;
+import org.openmetadata.schema.entity.teams.User;
 import org.openmetadata.schema.entity.type.Style;
 import org.openmetadata.schema.services.connections.database.MysqlConnection;
 import org.openmetadata.schema.services.connections.database.common.basicAuth;
@@ -2873,4 +2875,81 @@ void test_deletingAssetRemovesItFromPorts(TestNamespace ns) throws Exception {
     ResultList<Map<String, Object>> outputPorts = getOutputPorts(dataProduct.getId(), 10, 0);
     assertEquals(0, outputPorts.getPaging().getTotal());
   }
+
+  @Test
+  void softDeletedExpert_notReturnedInSingleGet(TestNamespace ns) {
+    OpenMetadataClient client = SdkClients.adminClient();
+    Domain domain = getOrCreateDomain(ns);
+
+    String userName = ns.shortPrefix("expert_user");
+    User expert =
+        client
+            .users()
+            .create(
+                new CreateUser()
+                    .withName(userName)
+                    .withEmail(userName + "@test.openmetadata.org")
+                    .withDescription("Expert user for soft-delete test"));
+
+    CreateDataProduct create =
+        new CreateDataProduct()
+            .withName(ns.prefix("dp_softdel_expert"))
+            .withDescription("DataProduct for soft-delete expert test")
+            .withDomains(List.of(domain.getFullyQualifiedName()))
+            .withExperts(List.of(expert.getFullyQualifiedName()));
+    DataProduct dp = createEntity(create);
+
+    client.users().delete(expert.getId().toString());
+
+    DataProduct byId = client.dataProducts().get(dp.getId().toString(), "experts");
+    assertTrue(
+        byId.getExperts() == null || byId.getExperts().isEmpty(),
+        "Soft-deleted expert must not appear in single GET by ID");
+
+    DataProduct byName = client.dataProducts().getByName(dp.getFullyQualifiedName(), "experts");
+    assertTrue(
+        byName.getExperts() == null || byName.getExperts().isEmpty(),
+        "Soft-deleted expert must not appear in single GET by name");
+  }
+
+  @Test
+  void softDeletedExpert_notReturnedInListEndpoint(TestNamespace ns) {
+    OpenMetadataClient client = SdkClients.adminClient();
+    Domain domain = getOrCreateDomain(ns);
+
+    String userName = ns.shortPrefix("expert_list_user");
+    User expert =
+        client
+            .users()
+            .create(
+                new CreateUser()
+                    .withName(userName)
+                    .withEmail(userName + "@test.openmetadata.org")
+                    .withDescription("Expert user for bulk soft-delete test"));
+
+    CreateDataProduct create =
+        new CreateDataProduct()
+            .withName(ns.prefix("dp_softdel_expert_list"))
+            .withDescription("DataProduct for soft-delete expert list test")
+            .withDomains(List.of(domain.getFullyQualifiedName()))
+            .withExperts(List.of(expert.getFullyQualifiedName()));
+    DataProduct dp = createEntity(create);
+
+    client.users().delete(expert.getId().toString());
+
+    ListParams params =
+        new ListParams()
+            .setFields("experts")
+            .withDomain(domain.getFullyQualifiedName())
+            .withLimit(100);
+    ListResponse<DataProduct> list = client.dataProducts().list(params);
+    DataProduct listed =
+        list.getData().stream()
+            .filter(p -> p.getId().equals(dp.getId()))
+            .findFirst()
+            .orElseThrow(() -> new AssertionError("DataProduct not found in list"));
+    assertTrue(
+        listed.getExperts() == null || listed.getExperts().isEmpty(),
+        "Soft-deleted expert must not appear in list endpoint");
+  }
 }

openmetadata-integration-tests/src/test/java/org/openmetadata/it/tests/DomainResourceIT.java

@@ -31,7 +31,9 @@
 import org.openmetadata.it.util.TestNamespace;
 import org.openmetadata.schema.api.domains.CreateDomain;
 import org.openmetadata.schema.api.domains.CreateDomain.DomainType;
+import org.openmetadata.schema.api.teams.CreateUser;
 import org.openmetadata.schema.entity.domains.Domain;
+import org.openmetadata.schema.entity.teams.User;
 import org.openmetadata.schema.type.EntityHistory;
 import org.openmetadata.schema.type.EntityReference;
 import org.openmetadata.sdk.client.OpenMetadataClient;
@@ -1153,4 +1155,82 @@ void test_renameDomainDoesNotAffectSimilarPrefixDomains(TestNamespace ns) throws
     // Verify old child FQN no longer works
     assertThrows(Exception.class, () -> getEntityByName(oldChildFqn));
   }
+
+  @Test
+  void softDeletedExpert_notReturnedInSingleGet(TestNamespace ns) {
+    OpenMetadataClient client = SdkClients.adminClient();
+
+    String userName = ns.shortPrefix("domain_expert");
+    User expert =
+        client
+            .users()
+            .create(
+                new CreateUser()
+                    .withName(userName)
+                    .withEmail(userName + "@test.openmetadata.org")
+                    .withDescription("Expert user for domain soft-delete test"));
+
+    CreateDomain create =
+        new CreateDomain()
+            .withName(ns.prefix("domain_softdel"))
+            .withDomainType(DomainType.AGGREGATE)
+            .withExperts(List.of(expert.getFullyQualifiedName()))
+            .withDescription("Domain for soft-delete expert test");
+    Domain domain = createEntity(create);
+
+    client.users().delete(expert.getId().toString());
+
+    Domain byId = client.domains().get(domain.getId().toString(), "experts");
+    assertTrue(
+        byId.getExperts() == null || byId.getExperts().isEmpty(),
+        "Soft-deleted expert must not appear in single GET by ID");
+
+    Domain byName = client.domains().getByName(domain.getFullyQualifiedName(), "experts");
+    assertTrue(
+        byName.getExperts() == null || byName.getExperts().isEmpty(),
+        "Soft-deleted expert must not appear in single GET by name");
+  }
+
+  @Test
+  void softDeletedExpert_notReturnedInListEndpoint(TestNamespace ns) {
+    OpenMetadataClient client = SdkClients.adminClient();
+
+    String userName = ns.shortPrefix("domain_expert_list");
+    User expert =
+        client
+            .users()
+            .create(
+                new CreateUser()
+                    .withName(userName)
+                    .withEmail(userName + "@test.openmetadata.org")
+                    .withDescription("Expert user for domain list soft-delete test"));
+
+    CreateDomain create =
+        new CreateDomain()
+            .withName(ns.prefix("domain_softdel_list"))
+            .withDomainType(DomainType.AGGREGATE)
+            .withExperts(List.of(expert.getFullyQualifiedName()))
+            .withDescription("Domain for soft-delete expert list test");
+    Domain domain = createEntity(create);
+
+    client.users().delete(expert.getId().toString());
+
+    Domain listed = null;
+    ListParams params = new ListParams().setFields("experts").withLimit(100);
+    while (listed == null) {
+      ListResponse<Domain> page = listEntities(params);
+      listed =
+          page.getData().stream()
+              .filter(d -> d.getId().equals(domain.getId()))
+              .findFirst()
+              .orElse(null);
+      String after = page.getPaging() != null ? page.getPaging().getAfter() : null;
+      if (listed != null || after == null) break;
+      params = new ListParams().setFields("experts").withLimit(100).setAfter(after);
+    }
+    assertNotNull(listed, "Domain not found in list");
+    assertTrue(
+        listed.getExperts() == null || listed.getExperts().isEmpty(),
+        "Soft-deleted expert must not appear in list endpoint");
+  }
 }

openmetadata-integration-tests/src/test/java/org/openmetadata/it/tests/GlossaryTermResourceIT.java

@@ -28,6 +28,7 @@
 import org.openmetadata.schema.api.data.CreateTable;
 import org.openmetadata.schema.api.data.TermReference;
 import org.openmetadata.schema.api.feed.CreateThread;
+import org.openmetadata.schema.api.teams.CreateUser;
 import org.openmetadata.schema.entity.data.DatabaseSchema;
 import org.openmetadata.schema.entity.data.Glossary;
 import org.openmetadata.schema.entity.data.GlossaryTerm;
@@ -3147,4 +3148,45 @@ private String getTermAssetsByName(OpenMetadataClient client, String fqn) {
             null,
             optionsBuilder.build());
   }
+
+  @Test
+  void softDeletedReviewer_notReturnedInListEndpoint(TestNamespace ns) {
+    OpenMetadataClient client = SdkClients.adminClient();
+    Glossary glossary = getOrCreateGlossary(ns);
+
+    String userName = ns.shortPrefix("reviewer_list");
+    User reviewer =
+        client
+            .users()
+            .create(
+                new CreateUser()
+                    .withName(userName)
+                    .withEmail(userName + "@test.openmetadata.org")
+                    .withDescription("Reviewer user for glossary soft-delete list test"));
+
+    CreateGlossaryTerm create =
+        new CreateGlossaryTerm()
+            .withName(ns.prefix("term_softdel_reviewer"))
+            .withGlossary(glossary.getFullyQualifiedName())
+            .withDescription("Term for soft-delete reviewer list test")
+            .withReviewers(List.of(reviewer.getEntityReference()));
+    GlossaryTerm term = createEntity(create);
+
+    client.users().delete(reviewer.getId().toString());
+
+    ListParams params =
+        new ListParams()
+            .setFields("reviewers")
+            .withLimit(100)
+            .addFilter("glossary", glossary.getId().toString());
+    ListResponse<GlossaryTerm> list = listEntities(params);
+    GlossaryTerm listed =
+        list.getData().stream()
+            .filter(t -> t.getId().equals(term.getId()))
+            .findFirst()
+            .orElseThrow(() -> new AssertionError("GlossaryTerm not found in list"));
+    assertTrue(
+        listed.getReviewers() == null || listed.getReviewers().isEmpty(),
+        "Soft-deleted reviewer must not appear in list endpoint");
+  }
 }

openmetadata-service/src/main/java/org/openmetadata/service/jdbi3/DataProductRepository.java

@@ -38,6 +38,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import lombok.extern.slf4j.Slf4j;
 import org.jdbi.v3.sqlobject.transaction.Transaction;
@@ -208,9 +209,17 @@ public void setInheritedFields(DataProduct dataProduct, Fields fields) {
       List<EntityReference> experts = new ArrayList<>();
 
       for (EntityReference domainRef : domains) {
-        Domain domain = Entity.getEntity(DOMAIN, domainRef.getId(), "owners,experts", ALL);
-        owners = mergedInheritedEntityRefs(owners, domain.getOwners());
-        experts = mergedInheritedEntityRefs(experts, domain.getExperts());
+        try {
+          Domain domain =
+              Entity.getEntity(DOMAIN, domainRef.getId(), "owners,experts", NON_DELETED);
+          owners = mergedInheritedEntityRefs(owners, domain.getOwners());
+          experts = mergedInheritedEntityRefs(experts, domain.getExperts());
+        } catch (EntityNotFoundException ex) {
+          LOG.debug(
+              "Skipping inherited fields from soft-deleted or missing domain {} for data product {}",
+              domainRef.getId(),
+              dataProduct.getId());
+        }
       }
       // inherit only if applicable and empty
       if (inheritOwners) {
@@ -967,24 +976,30 @@ private Map<UUID, List<EntityReference>> batchFetchExperts(List<DataProduct> dat
       return expertsMap;
     }
 
-    // Initialize empty lists for all data products
     for (DataProduct dataProduct : dataProducts) {
       expertsMap.put(dataProduct.getId(), new ArrayList<>());
     }
 
-    // Single batch query to get all expert relationships
     List<CollectionDAO.EntityRelationshipObject> records =
         daoCollection
             .relationshipDAO()
             .findToBatch(
                 entityListToStrings(dataProducts), Relationship.EXPERT.ordinal(), Entity.USER);
 
-    // Group experts by data product ID
+    List<UUID> expertIds =
+        records.stream().map(r -> UUID.fromString(r.getToId())).distinct().toList();
+    Map<UUID, EntityReference> expertRefsById =
+        Entity.getEntityReferencesByIdsRespectingInclude(
+                Entity.USER, expertIds, Include.NON_DELETED)
+            .stream()
+            .collect(Collectors.toMap(EntityReference::getId, Function.identity(), (a, b) -> a));
+
     for (CollectionDAO.EntityRelationshipObject record : records) {
       UUID dataProductId = UUID.fromString(record.getFromId());
-      EntityReference expertRef =
-          Entity.getEntityReferenceById(
-              Entity.USER, UUID.fromString(record.getToId()), NON_DELETED);
+      EntityReference expertRef = expertRefsById.get(UUID.fromString(record.getToId()));
+      if (expertRef == null) {
+        continue;
+      }
       expertsMap.get(dataProductId).add(expertRef);
     }
 

openmetadata-service/src/main/java/org/openmetadata/service/jdbi3/DomainRepository.java

@@ -27,6 +27,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import lombok.extern.slf4j.Slf4j;
 import org.jdbi.v3.sqlobject.transaction.Transaction;
@@ -47,6 +48,7 @@
 import org.openmetadata.schema.utils.JsonUtils;
 import org.openmetadata.schema.utils.ResultList;
 import org.openmetadata.service.Entity;
+import org.openmetadata.service.exception.EntityNotFoundException;
 import org.openmetadata.service.resources.domains.DomainResource;
 import org.openmetadata.service.resources.feeds.MessageParser.EntityLink;
 import org.openmetadata.service.search.DefaultInheritedFieldEntitySearch;
@@ -185,9 +187,16 @@ public void setInheritedFields(Domain domain, Fields fields) {
     // domain
     EntityReference parentRef = domain.getParent() != null ? domain.getParent() : getParent(domain);
     if (parentRef != null) {
-      Domain parent = Entity.getEntity(DOMAIN, parentRef.getId(), "owners,experts", ALL);
-      inheritOwners(domain, fields, parent);
-      inheritExperts(domain, fields, parent);
+      try {
+        Domain parent = Entity.getEntity(DOMAIN, parentRef.getId(), "owners,experts", NON_DELETED);
+        inheritOwners(domain, fields, parent);
+        inheritExperts(domain, fields, parent);
+      } catch (EntityNotFoundException ex) {
+        LOG.debug(
+            "Skipping inherited fields from soft-deleted or missing parent domain {} for domain {}",
+            parentRef.getId(),
+            domain.getId());
+      }
     }
   }
 
@@ -580,22 +589,28 @@ private Map<UUID, List<EntityReference>> batchFetchExperts(List<Domain> domains)
       return expertsMap;
     }
 
-    // Initialize empty lists for all domains
     domains.forEach(domain -> expertsMap.put(domain.getId(), new ArrayList<>()));
 
-    // Single batch query to get all expert relationships
     var records =
         daoCollection
             .relationshipDAO()
             .findToBatch(entityListToStrings(domains), Relationship.EXPERT.ordinal(), Entity.USER);
 
-    // Group experts by domain ID
+    List<UUID> expertIds =
+        records.stream().map(r -> UUID.fromString(r.getToId())).distinct().toList();
+    Map<UUID, EntityReference> expertRefsById =
+        Entity.getEntityReferencesByIdsRespectingInclude(
+                Entity.USER, expertIds, Include.NON_DELETED)
+            .stream()
+            .collect(Collectors.toMap(EntityReference::getId, Function.identity(), (a, b) -> a));
+
     records.forEach(
         record -> {
           var domainId = UUID.fromString(record.getFromId());
-          var expertRef =
-              getEntityReferenceById(Entity.USER, UUID.fromString(record.getToId()), NON_DELETED);
-          expertsMap.get(domainId).add(expertRef);
+          var expertRef = expertRefsById.get(UUID.fromString(record.getToId()));
+          if (expertRef != null) {
+            expertsMap.get(domainId).add(expertRef);
+          }
         });
 
     return expertsMap;