fix(search): skip soft-delete script propagation to time-series child aliases

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

@@ -0,0 +1,209 @@
+/*
+ *  Copyright 2026 Collate
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package org.openmetadata.it.tests;
+
+import static org.awaitility.Awaitility.await;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.parallel.Execution;
+import org.junit.jupiter.api.parallel.ExecutionMode;
+import org.openmetadata.it.bootstrap.SharedEntities;
+import org.openmetadata.it.util.SdkClients;
+import org.openmetadata.schema.api.data.CreateDatabase;
+import org.openmetadata.schema.api.data.CreateDatabaseSchema;
+import org.openmetadata.schema.api.data.CreateTable;
+import org.openmetadata.schema.api.tests.CreateTestCase;
+import org.openmetadata.schema.api.tests.CreateTestCaseResolutionStatus;
+import org.openmetadata.schema.entity.data.Database;
+import org.openmetadata.schema.entity.data.DatabaseSchema;
+import org.openmetadata.schema.entity.data.Table;
+import org.openmetadata.schema.tests.TestCase;
+import org.openmetadata.schema.tests.type.Severity;
+import org.openmetadata.schema.tests.type.TestCaseResolutionStatus;
+import org.openmetadata.schema.tests.type.TestCaseResolutionStatusTypes;
+import org.openmetadata.schema.type.Column;
+import org.openmetadata.schema.type.ColumnDataType;
+import org.openmetadata.sdk.client.OpenMetadataClient;
+import org.openmetadata.sdk.models.ListParams;
+import org.openmetadata.sdk.models.ListResponse;
+
+/**
+ * Regression for the live-indexing soft-delete propagation bug. {@code SOFT_DELETE_RESTORE_SCRIPT}
+ * was stamping a top-level {@code deleted} field onto child docs of every alias listed in the
+ * parent's {@code indexMapping}. For {@code testCase}, two of those children
+ * ({@code testCaseResolutionStatus}, {@code testCaseResult}) are time-series indexes whose
+ * Java schemas declare no {@code deleted} field. The poisoned doc broke Jackson on read and
+ * the Incident Manager UI surfaced an "Unrecognized field 'deleted'" toast.
+ *
+ * <p>This test exercises the end-to-end path: create a TC + result + incident, soft-delete the
+ * TC, and confirm that (a) the resolution-status listing API still parses cleanly and (b) the
+ * underlying ES doc carries no top-level {@code deleted} field.
+ */
+@Execution(ExecutionMode.CONCURRENT)
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+public class TestCaseSoftDeleteSearchIT {
+
+  private static final ObjectMapper MAPPER = new ObjectMapper();
+
+  @Test
+  void softDeletingTestCaseDoesNotPollutePropagatedTimeSeriesDocs() throws Exception {
+    OpenMetadataClient client = SdkClients.adminClient();
+
+    long ts = System.currentTimeMillis();
+    Database database =
+        client
+            .databases()
+            .create(
+                new CreateDatabase()
+                    .withName("soft_delete_db_" + ts)
+                    .withService(SharedEntities.get().MYSQL_SERVICE.getFullyQualifiedName()));
+    DatabaseSchema schema =
+        client
+            .databaseSchemas()
+            .create(
+                new CreateDatabaseSchema()
+                    .withName("soft_delete_schema_" + ts)
+                    .withDatabase(database.getFullyQualifiedName()));
+    Table table =
+        client
+            .tables()
+            .create(
+                new CreateTable()
+                    .withName("soft_delete_table_" + ts)
+                    .withDatabaseSchema(schema.getFullyQualifiedName())
+                    .withColumns(
+                        List.of(new Column().withName("id").withDataType(ColumnDataType.BIGINT))));
+
+    String testDefFqn =
+        client
+            .testDefinitions()
+            .list(new ListParams().withLimit(1))
+            .getData()
+            .get(0)
+            .getFullyQualifiedName();
+
+    TestCase testCase =
+        client
+            .testCases()
+            .create(
+                new CreateTestCase()
+                    .withName("soft_delete_tc_" + ts)
+                    .withEntityLink(
+                        "<#E::table::" + table.getFullyQualifiedName() + "::columns::id>")
+                    .withTestDefinition(testDefFqn));
+
+    client
+        .testCaseResolutionStatuses()
+        .create(
+            new CreateTestCaseResolutionStatus()
+                .withTestCaseResolutionStatusType(TestCaseResolutionStatusTypes.New)
+                .withTestCaseReference(testCase.getFullyQualifiedName())
+                .withSeverity(Severity.Severity2));
+
+    awaitIncidentIndexed(client, testCase.getFullyQualifiedName());
+
+    client
+        .testCases()
+        .delete(testCase.getId().toString(), Map.of("hardDelete", "false", "recursive", "true"));
+
+    assertListingApiReturnsCleanlyAfterSoftDelete(client, testCase.getFullyQualifiedName());
+    assertNoTopLevelDeletedFieldOnIncidentDoc(client, testCase.getFullyQualifiedName());
+  }
+
+  private void awaitIncidentIndexed(OpenMetadataClient client, String testCaseFqn) {
+    await("Wait for resolution status to be searchable")
+        .atMost(Duration.ofMinutes(2))
+        .pollInterval(Duration.ofSeconds(2))
+        .ignoreExceptions()
+        .untilAsserted(
+            () -> {
+              ListResponse<TestCaseResolutionStatus> resp =
+                  client
+                      .testCaseResolutionStatuses()
+                      .searchList(
+                          new ListParams()
+                              .withLimit(1)
+                              .withLatest(true)
+                              .addFilter("testCaseFQN", testCaseFqn));
+              assertNotNull(resp);
+              assertEquals(
+                  1,
+                  resp.getData().size(),
+                  "Incident for the test case should be indexed before we soft-delete");
+            });
+  }
+
+  private void assertListingApiReturnsCleanlyAfterSoftDelete(
+      OpenMetadataClient client, String testCaseFqn) {
+    await("API returns parseable body after soft-delete propagation")
+        .atMost(Duration.ofMinutes(1))
+        .pollInterval(Duration.ofSeconds(2))
+        .ignoreExceptions()
+        .untilAsserted(
+            () -> {
+              ListResponse<TestCaseResolutionStatus> resp =
+                  client
+                      .testCaseResolutionStatuses()
+                      .searchList(
+                          new ListParams()
+                              .withLimit(10)
+                              .withLatest(true)
+                              .addFilter("testCaseFQN", testCaseFqn));
+              assertNotNull(
+                  resp, "list endpoint must return a body; null implies a deserialization failure");
+            });
+  }
+
+  /**
+   * The fix in {@link org.openmetadata.service.search.SearchRepository#softDeleteOrRestoredChildren}
+   * filters out time-series child aliases before invoking the soft-delete script. Confirm by
+   * querying ES directly for any TCRS doc that has a top-level {@code deleted} field — there
+   * must be none for our test case.
+   */
+  private void assertNoTopLevelDeletedFieldOnIncidentDoc(
+      OpenMetadataClient client, String testCaseFqn) throws Exception {
+    String rawJson =
+        client
+            .search()
+            .query(
+                "testCaseReference.fullyQualifiedName.keyword:\""
+                    + testCaseFqn
+                    + "\" AND _exists_:deleted")
+            .index("test_case_resolution_status_search_index")
+            .size(5)
+            .execute();
+    JsonNode root = MAPPER.readTree(rawJson);
+    JsonNode hits = root.path("hits").path("hits");
+    assertTrue(
+        hits.isArray(),
+        () -> "ES response missing hits.hits array; raw response was: " + rawJson);
+    assertFalse(
+        hits.elements().hasNext(),
+        () ->
+            "No `deleted` field should exist on testCaseResolutionStatus docs after a parent"
+                + " soft-delete; found "
+                + hits.size()
+                + " polluted docs. Raw response: "
+                + rawJson);
+  }
+}

openmetadata-service/src/main/java/org/openmetadata/service/Entity.java

@@ -720,6 +720,16 @@ public static boolean hasEntityRepository(@NonNull String entityType) {
         || ENTITY_TS_REPOSITORY_MAP.containsKey(entityType);
   }
 
+  /**
+   * Returns true when {@code entityTypeOrAlias} maps to an {@link EntityTimeSeriesInterface}
+   * (append-only, no top-level {@code deleted} field). Used by the search layer to skip
+   * propagation scripts that assume a regular-entity shape — e.g. the soft-delete script that
+   * stamps {@code deleted} onto child docs.
+   */
+  public static boolean isTimeSeriesEntity(@NonNull String entityTypeOrAlias) {
+    return ENTITY_TS_REPOSITORY_MAP.containsKey(entityTypeOrAlias);
+  }
+
   public static EntityTimeSeriesRepository<? extends EntityTimeSeriesInterface>
       getEntityTimeSeriesRepository(@NonNull String entityType) {
     EntityTimeSeriesRepository<? extends EntityTimeSeriesInterface> entityTimeSeriesRepository =

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

@@ -463,7 +463,7 @@ public ResultList<T> listFromSearchWithOffset(
               searchListFilter, limit, offset, entityType, searchSortFilter, q, queryString);
       total = results.getTotal();
       for (Map<String, Object> json : results.getResults()) {
-        T entity = setFieldsInternal(JsonUtils.readOrConvertValue(json, entityClass), fields);
+        T entity = setFieldsInternal(readTimeSeriesSource(json), fields);
         try {
           setInheritedFields(entity);
         } catch (RuntimeException e) {
@@ -524,9 +524,7 @@ public ResultList<T> listLatestFromSearch(
                 hitList -> {
                   for (Map<String, Object> hit : (List<Map<String, Object>>) hitList) {
                     Map<String, Object> source = extractAndFilterSource(hit);
-                    T entity =
-                        setFieldsInternal(
-                            JsonUtils.readOrConvertValue(source, entityClass), fields);
+                    T entity = setFieldsInternal(readTimeSeriesSource(source), fields);
                     if (entity != null) {
                       try {
                         setInheritedFields(entity);
@@ -684,7 +682,7 @@ public T latestFromSearch(EntityUtil.Fields fields, SearchListFilter searchListF
     SearchResultListMapper results =
         searchRepository.listWithOffset(searchListFilter, 1, 0, entityType, searchSortFilter, q);
     for (Map<String, Object> json : results.getResults()) {
-      T entity = setFieldsInternal(JsonUtils.readOrConvertValue(json, entityClass), fields);
+      T entity = setFieldsInternal(readTimeSeriesSource(json), fields);
       setInheritedFields(entity);
       clearFieldsInternal(entity, fields);
       return entity;
@@ -696,6 +694,16 @@ protected void setIncludeSearchFields(SearchListFilter searchListFilter) {
     // Nothing to do in the default implementation
   }
 
+  /**
+   * Lenient-deserializes a search hit source into the time-series entity type. Tolerates legacy
+   * {@code deleted} fields that the live-indexing soft-delete script may have stamped onto
+   * append-only docs whose schema declares no such field. Once a recreate-style reindex has
+   * cleaned the index, the lenient mode is a no-op.
+   */
+  private T readTimeSeriesSource(Object source) {
+    return JsonUtils.readOrConvertValueLenient(source, entityClass);
+  }
+
   protected void setExcludeSearchFields(SearchListFilter searchListFilter) {
     // Nothing to do in the default implementation
   }

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

@@ -109,8 +109,9 @@
 
 @Slf4j
 public class TestCaseRepository extends EntityRepository<TestCase> {
-  private static final String TEST_SUITE_FIELD = "testSuite";
-  private static final String INCIDENTS_FIELD = "incidentId";
+  public static final String TEST_SUITE_FIELD = "testSuite";
+  public static final String TEST_DEFINITION_FIELD = "testDefinition";
+  public static final String INCIDENTS_FIELD = "incidentId";
   private static final String UPDATE_FIELDS =
       "owners,entityLink,testSuite,testSuites,testDefinition,dimensionColumns,topDimensions";
   private static final String PATCH_FIELDS =

openmetadata-service/src/main/java/org/openmetadata/service/search/SearchRepository.java

@@ -2511,33 +2511,37 @@ public void deleteOrUpdateChildren(EntityInterface entity, IndexMapping indexMap
   public void softDeleteOrRestoredChildren(
       EntityReference entityReference, IndexMapping indexMapping, boolean delete)
       throws IOException {
-    String docId = entityReference.getId().toString();
+    // childAliases values are entity-type names (per indexMapping.json). Drop time-series
+    // children — their docs have no top-level `deleted` field and the script would pollute them.
+    List<String> targets =
+        indexMapping.getChildAliases().stream()
+            .filter(a -> !Entity.isTimeSeriesEntity(a))
+            .map(a -> clusterAlias == null || clusterAlias.isEmpty() ? a : clusterAlias + "_" + a)
+            .toList();
+    if (targets.isEmpty()) {
+      return;
+    }
     String entityType = entityReference.getType();
+    String parentIdField =
+        SERVICE_ENTITY_TYPES.contains(entityType) ? "service.id" : entityType + ".id";
     String scriptTxt = String.format(SOFT_DELETE_RESTORE_SCRIPT, delete);
-    switch (entityType) {
-      case Entity.DASHBOARD_SERVICE,
+    searchClient.softDeleteOrRestoreChildren(
+        targets,
+        scriptTxt,
+        List.of(new ImmutablePair<>(parentIdField, entityReference.getId().toString())));
+  }
+
+  private static final Set<String> SERVICE_ENTITY_TYPES =
+      Set.of(
+          Entity.DASHBOARD_SERVICE,
           Entity.DATABASE_SERVICE,
           Entity.MESSAGING_SERVICE,
           Entity.PIPELINE_SERVICE,
           Entity.MLMODEL_SERVICE,
           Entity.STORAGE_SERVICE,
           Entity.SEARCH_SERVICE,
           Entity.SECURITY_SERVICE,
-          Entity.DRIVE_SERVICE -> searchClient.softDeleteOrRestoreChildren(
-          indexMapping.getChildAliases(clusterAlias),
-          scriptTxt,
-          List.of(new ImmutablePair<>("service.id", docId)));
-      default -> {
-        List<String> indexNames = indexMapping.getChildAliases(clusterAlias);
-        if (!indexNames.isEmpty()) {
-          searchClient.softDeleteOrRestoreChildren(
-              indexMapping.getChildAliases(clusterAlias),
-              scriptTxt,
-              List.of(new ImmutablePair<>(entityType + ".id", docId)));
-        }
-      }
-    }
-  }
+          Entity.DRIVE_SERVICE);
 
   public String getScriptWithParams(
       EntityInterface entity,

openmetadata-service/src/main/java/org/openmetadata/service/search/indexes/TestCaseIndex.java

@@ -14,6 +14,7 @@
 import org.openmetadata.schema.type.Include;
 import org.openmetadata.service.Entity;
 import org.openmetadata.service.exception.EntityNotFoundException;
+import org.openmetadata.service.jdbi3.TestCaseRepository;
 import org.openmetadata.service.resources.feeds.MessageParser;
 import org.openmetadata.service.search.SearchIndexUtils;
 
@@ -34,16 +35,19 @@ public String getEntityTypeName() {
   @Override
   public Set<String> getRequiredReindexFields() {
     Set<String> fields = new java.util.HashSet<>(TaggableIndex.super.getRequiredReindexFields());
-    fields.add("testSuite");
-    fields.add("testSuites");
-    fields.add("testDefinition");
+    fields.add(TestCaseRepository.TEST_SUITE_FIELD);
+    fields.add(Entity.FIELD_TEST_SUITES);
+    fields.add(TestCaseRepository.TEST_DEFINITION_FIELD);
+    fields.add(Entity.TEST_CASE_RESULT);
+    fields.add(TestCaseRepository.INCIDENTS_FIELD);
     return java.util.Collections.unmodifiableSet(fields);
   }
 
   @Override
   public void removeNonIndexableFields(Map<String, Object> esDoc) {
     TaggableIndex.super.removeNonIndexableFields(esDoc);
-    List<Map<String, Object>> testSuites = (List<Map<String, Object>>) esDoc.get("testSuites");
+    List<Map<String, Object>> testSuites =
+        (List<Map<String, Object>>) esDoc.get(Entity.FIELD_TEST_SUITES);
     if (testSuites != null) {
       for (Map<String, Object> testSuite : testSuites) {
         SearchIndexUtils.removeNonIndexableFields(testSuite, excludeFields);

openmetadata-service/src/main/java/org/openmetadata/service/search/indexes/TestSuiteIndex.java

@@ -1,5 +1,7 @@
 package org.openmetadata.service.search.indexes;
 
+import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -29,6 +31,13 @@ public Set<String> getExcludedFields() {
     return excludeFields;
   }
 
+  @Override
+  public Set<String> getRequiredReindexFields() {
+    Set<String> fields = new HashSet<>(TaggableIndex.super.getRequiredReindexFields());
+    fields.add("summary");
+    return Collections.unmodifiableSet(fields);
+  }
+
   public Map<String, Object> buildSearchIndexDocInternal(Map<String, Object> doc) {
     setParentRelationships(doc, testSuite);