fix(search): resolve entity-specific aliases to canonical index names (#27813)

Closes #27761.

Background. When the UI started passing the alias `index=table` (instead
of the legacy `index=table_search_index`), every search for tables also
returned column docs. Root cause: ES alias expansion is bidirectional
through the parent/child graph in indexMapping.json. column_search_index
is created with `table` as one of its aliases (because tableColumn lists
"table" in parentAliases), so when ES sees alias `table` it expands it
to both `table_search_index` and `column_search_index`. The same shape
exists for every alias whose entities also act as a parent for some
other entity (testCase, testSuite, database, …).

Fix. Resolve entity-specific aliases at the API boundary into their
canonical `*_search_index` names so we send literal index names to ES,
bypassing alias expansion entirely. Compound aliases (`all`,
`dataAsset`) have no canonical index — they pass through unchanged so
ES expands them natively, preserving the "everything under the
data-asset umbrella" use case the UI's MyData / CuratedAssets / search-
bar widgets rely on.

The change is one method, `SearchRepository.getIndexOrAliasName(String)`:

  * entity-specific alias (`"table"`)         → `"<cluster>_table_search_index"`
  * compound alias (`"dataAsset"`, `"all"`)   → `"<cluster>_dataAsset"` (passes through)
  * canonical name (`"table_search_index"`)   → `"<cluster>_table_search_index"` (legacy callers)
  * already cluster-prefixed                  → returned unchanged (idempotent)
  * empty token from `"table,"` / `","`       → dropped, with all-empty input preserved

All four search/export/preview/NLQ resource paths already call this
method; `searchByField`, `aggregate`, and `getEntityTypeCounts` already
call it inside the ES/OS managers. So the fix takes effect across every
endpoint that accepts an `index` parameter without changing the public
API surface — no new query params, no schema changes, no signature
churn.

No caller passes an entity-specific alias and expects child entity types
back: UI sites with `SearchIndex.TABLE`/`TOPIC`/etc. all want only that
type (asset-type filter chips, advanced-search builders, lineage
selection, alert rule scoping). UI sites that DO want mixed entity
types use `SearchIndex.ALL` or `SearchIndex.DATA_ASSET`, which are
compound aliases that this change leaves unchanged. Internal Java
callers (RBAC, propagation, DataInsightSystemChartRepository) pass
entity-specific aliases for entity-specific operations — no leakage
expected there either.

Tests pin: entity-alias → canonical resolution; compound-alias passes
through; idempotent prefix; comma-separated input; empty-token
handling; existing canonical-name behavior unchanged.

Author: mohityadav766

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

@@ -641,13 +641,59 @@ private boolean isKnownCanonicalIndex(String name) {
     return false;
   }
 
+  /**
+   * Resolve the supplied index alias into the actual Elasticsearch / OpenSearch index name to
+   * query. Handles four shapes:
+   *
+   * <ul>
+   *   <li><b>Entity-specific alias</b> (e.g. {@code "table"}): looked up in
+   *       {@code entityIndexMap} and resolved to the canonical {@code *_search_index} name.
+   *       This is the bug fix — without resolving, ES would treat {@code "table"} as an alias
+   *       and expand it to every index that has that alias attached, including
+   *       {@code column_search_index} (because {@code tableColumn} declares {@code "table"} as
+   *       a {@code parentAlias}). Resolving here bypasses ES's alias expansion entirely so a
+   *       query for tables only hits the table index.
+   *   <li><b>Compound alias</b> (e.g. {@code "all"}, {@code "dataAsset"}): no entry in
+   *       {@code entityIndexMap}, no canonical index, so the alias passes through and ES
+   *       resolves it natively across the entities that have registered the alias. This is the
+   *       intended behavior — searching {@code dataAsset} should surface every data-asset
+   *       entity.
+   *   <li><b>Canonical / legacy index name</b> (e.g. {@code "table_search_index"}): not a key
+   *       in {@code entityIndexMap}, falls through to the prefix-and-pass branch, identical to
+   *       the legacy behavior.
+   *   <li><b>Already cluster-prefixed token</b>: idempotent — returned unchanged so that
+   *       internal code paths that hand back a resolved value don't double-prefix.
+   * </ul>
+   *
+   * Comma-separated tokens are resolved independently. Empty tokens (from {@code "table,"} or
+   * {@code ","}) are dropped instead of materializing as a bare cluster prefix; if every token
+   * is empty the original input is returned unchanged so downstream ES surfaces a normal
+   * "unknown index" error instead of an empty-target failure.
+   */
   public String getIndexOrAliasName(String name) {
-    if (clusterAlias == null || clusterAlias.isEmpty()) {
+    if (nullOrEmpty(name)) {
       return name;
     }
-    return Arrays.stream(name.split(","))
-        .map(index -> clusterAlias + INDEX_NAME_SEPARATOR + index.trim())
-        .collect(Collectors.joining(","));
+    String prefix =
+        clusterAlias == null || clusterAlias.isEmpty() ? null : clusterAlias + INDEX_NAME_SEPARATOR;
+    String resolved =
+        Arrays.stream(name.split(","))
+            .map(String::trim)
+            .filter(t -> !t.isEmpty())
+            .map(t -> resolveSingleAliasToken(t, prefix))
+            .collect(Collectors.joining(","));
+    return resolved.isEmpty() ? name : resolved;
+  }
+
+  private String resolveSingleAliasToken(String token, String clusterPrefix) {
+    if (clusterPrefix != null && token.startsWith(clusterPrefix)) {
+      return token;
+    }
+    IndexMapping mapping = entityIndexMap == null ? null : entityIndexMap.get(token);
+    if (mapping != null) {
+      return mapping.getIndexName(clusterAlias);
+    }
+    return clusterPrefix == null ? token : clusterPrefix + token;
   }
 
   private static final Map<String, Set<String>> RBAC_CHILD_TYPES =

openmetadata-service/src/test/java/org/openmetadata/service/search/SearchRepositoryBehaviorTest.java

@@ -275,6 +275,68 @@ void indexNameHelpersRespectClusterAlias() {
         "table_search_index", repository.getIndexNameWithoutAlias("cluster_table_search_index"));
   }
 
+  /**
+   * Bug regression for issue #27761: passing the entity-specific alias {@code "table"} used to
+   * leak into ES alias expansion and surface tableColumn docs (because column_search_index is
+   * registered with {@code "table"} as one of its aliases). Resolving the alias to its canonical
+   * index name here bypasses ES's alias resolution, so the search hits exactly the table index.
+   */
+  @Test
+  void getIndexOrAliasNameResolvesEntitySpecificAliasToCanonicalIndex() {
+    assertEquals("cluster_table_search_index", repository.getIndexOrAliasName("table"));
+    assertEquals("cluster_domain_search_index", repository.getIndexOrAliasName("domain"));
+  }
+
+  /**
+   * Compound aliases like {@code "all"} and {@code "dataAsset"} have no entry in
+   * {@code entityIndexMap} (they're meta-aliases registered against many entities at index
+   * creation time). The resolver passes them through with the cluster prefix so ES expands them
+   * natively — searching {@code dataAsset} should still surface every data-asset entity.
+   */
+  @Test
+  void getIndexOrAliasNamePassesCompoundAliasesThroughForNativeESExpansion() {
+    assertEquals("cluster_dataAsset", repository.getIndexOrAliasName("dataAsset"));
+    assertEquals("cluster_all", repository.getIndexOrAliasName("all"));
+  }
+
+  /**
+   * Defense-in-depth: a token that already carries the cluster prefix must not get prefixed
+   * again. Otherwise multi-tenant deployments would 404 on
+   * {@code cluster_cluster_table_search_index} if any internal code accidentally hands a
+   * resolved value back to this method.
+   */
+  @Test
+  void getIndexOrAliasNameIsIdempotentForAlreadyPrefixedTokens() {
+    assertEquals(
+        "cluster_table_search_index", repository.getIndexOrAliasName("cluster_table_search_index"));
+  }
+
+  /**
+   * Mixed input: each comma-separated token is resolved independently. Entity-specific aliases
+   * resolve to canonical names; compound aliases pass through.
+   */
+  @Test
+  void getIndexOrAliasNameResolvesEachCommaSeparatedTokenIndependently() {
+    assertEquals(
+        "cluster_table_search_index,cluster_dataAsset",
+        repository.getIndexOrAliasName("table,dataAsset"));
+  }
+
+  /**
+   * Stray-comma / empty-token input must not produce bare cluster prefixes such as
+   * {@code "cluster_"}. Empty tokens are dropped; if every token is empty the original string
+   * is returned unchanged so downstream ES surfaces a normal "unknown index" error instead of
+   * a confusing empty-target failure.
+   */
+  @Test
+  void getIndexOrAliasNameDropsEmptyTokensAndPreservesAllEmptyInput() {
+    assertEquals("cluster_table_search_index", repository.getIndexOrAliasName("table,"));
+    assertEquals(
+        "cluster_table_search_index,cluster_domain_search_index",
+        repository.getIndexOrAliasName("table, ,domain"));
+    assertEquals(", ,", repository.getIndexOrAliasName(", ,"));
+  }
+
   @Test
   void indexExistsFallsBackToAliasLookup() {
     when(searchClient.indexExists("cluster_table_search_index")).thenReturn(false);