fix(ui): pass fields when fetching KnowledgePage in Explore summary panel

openmetadata-ui/src/main/resources/ui/playwright/e2e/Features/ContextCenterArticles.spec.ts

@@ -76,6 +76,7 @@
 import { waitForSearchIndexed } from '../../utils/polling';
 import { sidebarClick } from '../../utils/sidebar';
 import { test } from '../fixtures/pages';
+import { navigateToKCEntity } from '../Utils/ExplorePageRightPanelUtils';
 import {
   runAdvancedBlocksTest,
   runContentPersistenceTest,
@@ -395,6 +396,57 @@
     });
   });
 
+  test('Article tags added on the article page are visible in the Explore right-panel summary', async ({
+    page,
+    browser,
+  }) => {
+    const { apiContext: setupContext, afterAction: setupAfterAction } =
+      await createNewPage(browser);
+    const article = await createArticleViaApi(setupContext, {
+      displayName: `CC Tag Panel Article ${uuid()}`,
+      name: `cc_tag_panel_article_${uuid()}`,
+    });
+    await setupAfterAction();
+
+    const tagDisplayName = 'Article';
+    const tagFqn = 'KnowledgeCenter.Article';
+
+    try {
+      await test.step('Add tag to article via the article page', async () => {
+        await navigateToArticle(page, article.fullyQualifiedName);
+        await updateTags(page, { tag: tagDisplayName, tagFqn });
+      });
+
+      await test.step('Wait for search index to reflect the update', async () => {
+        const { apiContext, afterAction } = await getApiContext(page);
+        await waitForSearchIndexed(
+          apiContext,
+          article.fullyQualifiedName,
+          'page'
+        );
+        await afterAction();
+      });
+
+      await test.step('Verify tag is visible in Explore right-panel summary', async () => {
+        await navigateToKCEntity(page, article.displayName);
+
+        const summaryPanel = page.locator(
+          '[data-testid="entity-summary-panel-container"]'
+        );
+        await expect(
+          summaryPanel
+            .locator('.tags-section, [class*="tags"]')
+            .getByText(tagDisplayName)
+        ).toBeVisible();
+      });
+    } finally {
+      const { apiContext: cleanupContext, afterAction: cleanupAfterAction } =
+        await createNewPage(browser);
+      await deleteArticleByFqn(cleanupContext, article.fullyQualifiedName);
+      await cleanupAfterAction();
+    }
+  });
+
   test('Quick link lifecycle validates, creates, edits, and deletes from card', async ({
     page,
   }) => {
@@ -636,7 +688,7 @@
       url.pathname.includes('/context-center/articles/')
     );
     await waitForAllLoadersToDisappear(page);
     await page.waitForTimeout(500);
 
     await navigateToArticles(page);
     const rightPanel = page.getByTestId('knowledge-center-right-panel');
@@ -1201,7 +1253,7 @@
         .click();
       await page.getByTestId('save').click();
 
       await page.waitForSelector(
         '[role="dialog"].description-markdown-editor',
         { state: 'hidden' }
       );
@@ -1456,7 +1508,7 @@
           .getByTestId('entity-header-display-name')
           .fill(newDisplayName);
         await page.getByText('Unsaved').waitFor({ state: 'visible' });
         await page.waitForTimeout(400);
         await page.getByRole('link', { name: 'Articles' }).click();
       });
 

openmetadata-ui/src/main/resources/ui/src/utils/EntityByFqnUtils.test.ts

@@ -18,6 +18,7 @@ import * as apiCollectionsAPI from '../rest/apiCollectionsAPI';
 import * as apiEndpointsAPI from '../rest/apiEndpointsAPI';
 import * as databaseAPI from '../rest/databaseAPI';
 import * as glossaryAPI from '../rest/glossaryAPI';
+import * as knowledgeCenterAPI from '../rest/knowledgeCenterAPI';
 import * as serviceAPI from '../rest/serviceAPI';
 import * as tableAPI from '../rest/tableAPI';
 import * as testAPI from '../rest/testAPI';
@@ -26,6 +27,7 @@ import { getEntityByFqnUtil } from './EntityByFqnUtils';
 jest.mock('../rest/tableAPI');
 jest.mock('../rest/databaseAPI');
 jest.mock('../rest/glossaryAPI');
+jest.mock('../rest/knowledgeCenterAPI');
 jest.mock('../rest/serviceAPI');
 jest.mock('../rest/alertsAPI');
 jest.mock('../rest/apiCollectionsAPI');
@@ -235,6 +237,48 @@ describe('EntityByFqnUtils', () => {
       expect(result).toEqual(mockEventSubData);
     });
 
+    it('should fetch KNOWLEDGE_PAGE entity forwarding the requested fields', async () => {
+      const mockPageData = { id: '1', name: 'test-article' };
+      (knowledgeCenterAPI.getKnowledgePageByFqn as jest.Mock).mockResolvedValue(
+        mockPageData
+      );
+
+      const result = await getEntityByFqnUtil(
+        EntityType.KNOWLEDGE_PAGE,
+        mockFqn,
+        mockFields
+      );
+
+      expect(knowledgeCenterAPI.getKnowledgePageByFqn).toHaveBeenCalledWith(
+        mockFqn,
+        {
+          fields: mockFields,
+        }
+      );
+      expect(result).toEqual(mockPageData);
+    });
+
+    it('should fetch KNOWLEDGE_CENTER entity forwarding the requested fields', async () => {
+      const mockPageData = { id: '1', name: 'test-article' };
+      (knowledgeCenterAPI.getKnowledgePageByFqn as jest.Mock).mockResolvedValue(
+        mockPageData
+      );
+
+      const result = await getEntityByFqnUtil(
+        EntityType.KNOWLEDGE_CENTER,
+        mockFqn,
+        mockFields
+      );
+
+      expect(knowledgeCenterAPI.getKnowledgePageByFqn).toHaveBeenCalledWith(
+        mockFqn,
+        {
+          fields: mockFields,
+        }
+      );
+      expect(result).toEqual(mockPageData);
+    });
+
     it('should return null for unknown entity type', async () => {
       const result = await getEntityByFqnUtil('UNKNOWN_TYPE', mockFqn);
 

openmetadata-ui/src/main/resources/ui/src/utils/EntityByFqnUtils.ts

@@ -57,7 +57,7 @@
   entityType: string,
   entityFQN: string,
   fields?: string
 ): Promise<EntityUnion> | null => {
   switch (entityType) {
     case EntityType.TABLE:
       return getTableDetailsByFQN(entityFQN, { fields });
@@ -213,7 +213,7 @@
 
     case EntityType.KNOWLEDGE_PAGE:
     case EntityType.KNOWLEDGE_CENTER:
-      return getKnowledgePageByFqn(entityFQN);
+      return getKnowledgePageByFqn(entityFQN, { fields });
 
     default:
       return null;