add domain query ES fix (#26037)

* add domain query ES

* test: add coverage for non-bool clause extraction in DomainUtils

Co-authored-by: siddhant1 <siddhant1@users.noreply.github.com>

---------

Co-authored-by: Siddhant <siddhant@MacBook-Pro-2.local>
Co-authored-by: Gitar <noreply@gitar.ai>
Co-authored-by: siddhant1 <siddhant1@users.noreply.github.com>

Author: 3 people

openmetadata-ui/src/main/resources/ui/src/utils/DomainUtils.test.tsx

@@ -612,23 +612,67 @@ describe('withDomainFilter', () => {
       });
     });
 
-    it('should preserve existing params when adding query_filter', () => {
-      mockGetPathName.mockReturnValue('/api/search');
-      mockGetState.mockReturnValue({ activeDomain: 'engineering' });
-
-      const config = createMockConfig('get', '/search/query', {
-        index: SearchIndex.TABLE,
-        limit: 10,
-        offset: 0,
+      it('should preserve existing params when adding query_filter', () => {
+        mockGetPathName.mockReturnValue('/api/search');
+        mockGetState.mockReturnValue({ activeDomain: 'engineering' });
+
+        const config = createMockConfig('get', '/search/query', {
+          index: SearchIndex.TABLE,
+          limit: 10,
+          offset: 0,
+        });
+        const result = withDomainFilter(config);
+
+        expect(result.params).toHaveProperty('index', SearchIndex.TABLE);
+        expect(result.params).toHaveProperty('limit', 10);
+        expect(result.params).toHaveProperty('offset', 0);
+        expect(result.params).toHaveProperty('query_filter');
       });
-      const result = withDomainFilter(config);
 
-      expect(result.params).toHaveProperty('index', SearchIndex.TABLE);
-      expect(result.params).toHaveProperty('limit', 10);
-      expect(result.params).toHaveProperty('offset', 0);
-      expect(result.params).toHaveProperty('query_filter');
+      it('should preserve non-bool top-level clauses when adding domain filter', () => {
+        mockGetPathName.mockReturnValue('/api/search');
+        mockGetState.mockReturnValue({ activeDomain: 'engineering' });
+
+        const existingFilter = JSON.stringify({
+          query: {
+            term: { 'some.field': 'someValue' },
+            bool: { must: [{ term: { 'other.field': 'otherValue' } }] },
+          },
+        });
+
+        const config = createMockConfig('get', '/search/query', {
+          index: SearchIndex.TABLE,
+          query_filter: existingFilter,
+        });
+        const result = withDomainFilter(config);
+
+        const parsed = JSON.parse(result.params?.query_filter as string);
+
+        expect(parsed.query.bool.must).toContainEqual({
+          term: { 'some.field': 'someValue' },
+        });
+        expect(parsed.query.bool.must).toContainEqual({
+          term: { 'other.field': 'otherValue' },
+        });
+        expect(parsed.query.bool.must).toContainEqual({
+          bool: {
+            should: [
+              {
+                term: {
+                  'domains.fullyQualifiedName': 'engineering',
+                },
+              },
+              {
+                prefix: {
+                  'domains.fullyQualifiedName': 'engineering.',
+                },
+              },
+            ],
+          },
+        });
+        expect(parsed.query.bool.must).toHaveLength(3);
+      });
     });
-  });
 
   describe('nested domain paths', () => {
     it('should handle nested domain paths correctly', () => {

openmetadata-ui/src/main/resources/ui/src/utils/DomainUtils.tsx

@@ -101,33 +101,42 @@ export const withDomainFilter = (
         }
       }
 
-      const mustArray = Array.isArray(filter.query?.bool?.must)
-        ? filter.query.bool.must
-        : filter.query?.bool?.must
-        ? [filter.query.bool.must]
-        : [];
-
-      filter.query.bool = {
-        ...filter.query?.bool,
-        must: [
-          ...mustArray,
-          {
-            bool: {
-              should: [
-                {
-                  term: {
-                    'domains.fullyQualifiedName': activeDomain,
+      let mustArray: QueryFieldInterface[] = [];
+      const existingMust = filter.query?.bool?.must;
+      if (Array.isArray(existingMust)) {
+        mustArray = [...existingMust];
+      } else if (existingMust) {
+        mustArray = [existingMust];
+      }
+
+      const { bool: existingBool, ...nonBoolClauses } = filter.query ?? {};
+      for (const [key, value] of Object.entries(nonBoolClauses)) {
+        mustArray.push({ [key]: value } as QueryFieldInterface);
+      }
+
+      filter.query = {
+        bool: {
+          ...existingBool,
+          must: [
+            ...mustArray,
+            {
+              bool: {
+                should: [
+                  {
+                    term: {
+                      'domains.fullyQualifiedName': activeDomain,
+                    },
                   },
-                },
-                {
-                  prefix: {
-                    'domains.fullyQualifiedName': `${activeDomain}.`,
+                  {
+                    prefix: {
+                      'domains.fullyQualifiedName': `${activeDomain}.`,
+                    },
                   },
-                },
-              ],
-            },
-          } as QueryFieldInterface,
-        ],
+                ],
+              },
+            } as QueryFieldInterface,
+          ],
+        },
       };
 
       config.params = {