josh - chaneg the return to null instead of unknown

Signed-off-by: Jialiang Liang <[email protected]>

Author: RyanL1997

src/plugins/dashboard/public/application/embeddable/grid/dashboard_grid.test.tsx

@@ -364,11 +364,11 @@ test('synchronizeNow does nothing when feature flag is disabled', async () => {
   expect(startLoadingSpy).not.toHaveBeenCalled();
 });
 
-test('synchronizeNow does nothing when metadata contains unknown values', async () => {
+test('synchronizeNow does nothing when metadata contains invalid values', async () => {
   const { props, options } = prepare({ isDirectQuerySyncEnabled: true });
 
   (extractIndexInfoFromDashboard as jest.Mock).mockResolvedValue({
-    parts: { datasource: 'ds', database: 'db', index: 'unknown' },
+    parts: { datasource: 'ds', database: 'db', index: null },
     mapping: { lastRefreshTime: 123456, refreshInterval: 30000 },
     mdsId: '',
   });
@@ -390,11 +390,12 @@ test('synchronizeNow does nothing when metadata contains unknown values', async
   expect(startLoadingSpy).not.toHaveBeenCalled();
 });
 
+// New tests for recent changes
 test('synchronizeNow exits early when feature flag is disabled and datasource is invalid', async () => {
   const { props, options } = prepare({ isDirectQuerySyncEnabled: false });
 
   (extractIndexInfoFromDashboard as jest.Mock).mockResolvedValue({
-    parts: { datasource: 'ds', database: 'db', index: 'unknown' },
+    parts: { datasource: 'ds', database: 'db', index: null },
     mapping: { lastRefreshTime: 123456, refreshInterval: 30000 },
     mdsId: '',
   });
@@ -420,7 +421,7 @@ test('synchronizeNow exits early when feature flag is enabled but datasource is
   const { props, options } = prepare({ isDirectQuerySyncEnabled: true });
 
   (extractIndexInfoFromDashboard as jest.Mock).mockResolvedValue({
-    parts: { datasource: 'ds', database: '', index: 'idx' },
+    parts: { datasource: 'ds', database: null, index: 'idx' },
     mapping: { lastRefreshTime: 123456, refreshInterval: 30000 },
     mdsId: '',
   });
@@ -468,7 +469,7 @@ test('areDataSourceParamsValid returns false for invalid datasource params', asy
   const { props, options } = prepare({ isDirectQuerySyncEnabled: true });
 
   (extractIndexInfoFromDashboard as jest.Mock).mockResolvedValue({
-    parts: { datasource: 'ds', database: 'unknown', index: 'idx' },
+    parts: { datasource: 'ds', database: null, index: 'idx' },
     mapping: { lastRefreshTime: 123456, refreshInterval: 30000 },
     mdsId: '',
   });

src/plugins/dashboard/public/application/embeddable/grid/dashboard_grid.tsx

@@ -175,9 +175,9 @@ class DashboardGridUi extends React.Component<DashboardGridProps, State> {
   // item.
   private gridItems = {} as { [key: string]: HTMLDivElement | null };
 
-  private extractedDatasource?: string;
-  private extractedDatabase?: string;
-  private extractedIndex?: string;
+  private extractedDatasource?: string | null;
+  private extractedDatabase?: string | null;
+  private extractedIndex?: string | null;
 
   constructor(props: DashboardGridProps) {
     super(props);
@@ -303,18 +303,11 @@ class DashboardGridUi extends React.Component<DashboardGridProps, State> {
 
   /**
    * Validates if the extracted datasource, database, and index are present and valid.
-   * Returns true if all values are non-empty and not 'unknown', false otherwise.
+   * Returns true if all values are non-null, false otherwise.
    */
   private areDataSourceParamsValid(): boolean {
     const { extractedDatasource, extractedDatabase, extractedIndex } = this;
-    return (
-      !!extractedDatasource &&
-      !!extractedDatabase &&
-      !!extractedIndex &&
-      extractedDatasource !== 'unknown' &&
-      extractedDatabase !== 'unknown' &&
-      extractedIndex !== 'unknown'
-    );
+    return !!extractedDatasource && !!extractedDatabase && !!extractedIndex;
   }
 
   /**
@@ -352,9 +345,7 @@ class DashboardGridUi extends React.Component<DashboardGridProps, State> {
    * and triggers the sync process if direct query sync is enabled.
    */
   private synchronizeNow = () => {
-    if (!this.isDirectQuerySyncEnabled() || !this.areDataSourceParamsValid()) {
-      return;
-    }
+    if (!this.isDirectQuerySyncEnabled() || !this.areDataSourceParamsValid()) return;
 
     const { extractedDatasource, extractedDatabase, extractedIndex } = this;
 

src/plugins/dashboard/public/application/utils/direct_query_sync/direct_query_sync.test.ts

@@ -104,30 +104,39 @@ describe('resolveConcreteIndex', () => {
 });
 
 describe('extractIndexParts', () => {
-  it('correctly extracts parts from a full index name', () => {
-    const result = extractIndexParts('flint_datasource1_database1_my_index');
+  it('correctly extracts parts from a mapping name', () => {
+    const result = extractIndexParts('datasource1.database1.my_index');
     expect(result).toEqual({
       datasource: 'datasource1',
       database: 'database1',
       index: 'my_index',
     });
   });
 
-  it('handles missing parts with unknown values', () => {
-    const result = extractIndexParts('flint_datasource1');
+  it('handles missing parts with null values', () => {
+    const result = extractIndexParts('datasource1');
     expect(result).toEqual({
       datasource: 'datasource1',
-      database: 'unknown',
-      index: 'unknown',
+      database: null,
+      index: null,
     });
   });
 
-  it('handles empty index name', () => {
+  it('handles empty mapping name with null values', () => {
     const result = extractIndexParts('');
     expect(result).toEqual({
-      datasource: 'unknown',
-      database: 'unknown',
-      index: 'unknown',
+      datasource: null,
+      database: null,
+      index: null,
+    });
+  });
+
+  it('returns null values when mappingName is undefined', () => {
+    const result = extractIndexParts(undefined);
+    expect(result).toEqual({
+      datasource: null,
+      database: null,
+      index: null,
     });
   });
 });
@@ -142,6 +151,39 @@ describe('generateRefreshQuery', () => {
     const result = generateRefreshQuery(info);
     expect(result).toBe('REFRESH MATERIALIZED VIEW `datasource1`.`database1`.`my_index`');
   });
+
+  it('throws an error if datasource is null', () => {
+    const info = {
+      datasource: null,
+      database: 'database1',
+      index: 'my_index',
+    };
+    expect(() => generateRefreshQuery(info)).toThrow(
+      'Cannot generate refresh query: missing required datasource, database, or index'
+    );
+  });
+
+  it('throws an error if database is null', () => {
+    const info = {
+      datasource: 'datasource1',
+      database: null,
+      index: 'my_index',
+    };
+    expect(() => generateRefreshQuery(info)).toThrow(
+      'Cannot generate refresh query: missing required datasource, database, or index'
+    );
+  });
+
+  it('throws an error if index is null', () => {
+    const info = {
+      datasource: 'datasource1',
+      database: 'database1',
+      index: null,
+    };
+    expect(() => generateRefreshQuery(info)).toThrow(
+      'Cannot generate refresh query: missing required datasource, database, or index'
+    );
+  });
 });
 
 describe('fetchIndexMapping', () => {

src/plugins/dashboard/public/application/utils/direct_query_sync/direct_query_sync.ts

@@ -7,9 +7,9 @@ import { HttpStart, SavedObjectsClientContract } from 'src/core/public';
 import { i18n } from '@osd/i18n';
 
 interface IndexExtractionResult {
-  datasource: string;
-  database: string;
-  index: string;
+  datasource: string | null;
+  database: string | null;
+  index: string | null;
 }
 
 export const DIRECT_QUERY_BASE = '/api/directquery';
@@ -67,31 +67,31 @@ export async function resolveConcreteIndex(
   }
 }
 
-export function extractIndexParts(
-  fullIndexName: string,
-  mappingName?: string
-): IndexExtractionResult {
-  // Prefer parsing the mapping name if provided
+export function extractIndexParts(mappingName?: string): IndexExtractionResult {
+  // Use mapping name if provided; otherwise, return null values
   if (mappingName) {
     const parts = mappingName.split('.');
     return {
-      datasource: parts[0] || 'unknown',
-      database: parts[1] || 'unknown',
-      index: parts.slice(2).join('.') || 'unknown',
+      datasource: parts[0] || null,
+      database: parts[1] || null,
+      index: parts.slice(2).join('.') || null,
     };
   }
 
-  // Fallback to original regex-based parsing
-  const trimmed = fullIndexName.replace(/^flint_/, '');
-  const parts = trimmed.split('_');
   return {
-    datasource: parts[0] || 'unknown',
-    database: parts[1] || 'unknown',
-    index: parts.slice(2).join('_') || 'unknown',
+    datasource: null,
+    database: null,
+    index: null,
   };
 }
 
 export function generateRefreshQuery(info: IndexExtractionResult): string {
+  // Ensure all required fields are non-null before constructing the query
+  if (!info.datasource || !info.database || !info.index) {
+    throw new Error(
+      'Cannot generate refresh query: missing required datasource, database, or index'
+    );
+  }
   return `REFRESH MATERIALIZED VIEW \`${info.datasource}\`.\`${info.database}\`.\`${info.index}\``;
 }
 
@@ -176,7 +176,7 @@ export async function extractIndexInfoFromDashboard(
     const mappingName = val.mappings?._meta?.name;
     return {
       mapping: val.mappings._meta.properties!,
-      parts: extractIndexParts(concreteTitle, mappingName),
+      parts: extractIndexParts(mappingName),
       mdsId: selectedMdsId,
     };
   }