Multiple Datasource Support

src/plugins/data/public/data_sources/datasource/datasource.ts

@@ -0,0 +1,72 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Abstract class representing a data source. This class provides foundational
+ * interfaces for specific data sources. Any data source connection needs to extend
+ * and implement from this base class
+ *
+ * DataSourceMetaData: Represents metadata associated with the data source.
+ * SourceDataSet: Represents the dataset associated with the data source.
+ * DataSourceQueryResult: Represents the result from querying the data source.
+ */
+
+import { ConnectionStatus } from './types';
+
+export abstract class DataSource<
+  DataSourceMetaData,
+  DataSetParams,
+  SourceDataSet,
+  DataSourceQueryParams,
+  DataSourceQueryResult
+> {
+  constructor(
+    private readonly name: string,
+    private readonly type: string,
+    private readonly metadata: DataSourceMetaData
+  ) {}
+
+  getName() {
+    return this.name;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  getMetadata(): DataSourceMetaData {
+    return this.metadata;
+  }
+
+  /**
+   * Abstract method to get the dataset associated with the data source.
+   * Implementing classes need to provide the specific implementation.
+   *
+   * Data source selector needs to display data sources with pattern
+   * group (connection name) - a list of datasets. For example, get
+   * all available tables for flint datasources, and get all index
+   * patterns for OpenSearch data source
+   *
+   * @returns {SourceDataSet} Dataset associated with the data source.
+   */
+  abstract getDataSet(dataSetParams?: DataSetParams): SourceDataSet;
+
+  /**
+   * Abstract method to run a query against the data source.
+   * Implementing classes need to provide the specific implementation.
+   *
+   * @returns {DataSourceQueryResult} Result from querying the data source.
+   */
+  abstract runQuery(queryParams: DataSourceQueryParams): DataSourceQueryResult;
+
+  /**
+   * Abstract method to test the connection to the data source.
+   * Implementing classes should provide the specific logic to determine
+   * the connection status, typically indicating success or failure.
+   *
+   * @returns {ConnectionStatus | Promise<void>} Status of the connection test.
+   */
+  abstract testConnection(): ConnectionStatus | Promise<void>;
+}

src/plugins/data/public/data_sources/datasource/factory.ts

@@ -0,0 +1,68 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The DataSourceFactory is responsible for managing the registration and creation of data source classes.
+ * It serves as a registry for different data source types and provides a way to instantiate them.
+ */
+
+import { DataSourceType } from '../datasource_services';
+
+export class DataSourceFactory {
+  // Holds the singleton instance of the DataSourceFactory.
+  private static factory: DataSourceFactory;
+
+  // A dictionary holding the data source type as the key and its corresponding class constructor as the value.
+  private dataSourceClasses: { [type: string]: new (config: any) => DataSourceType } = {};
+
+  /**
+   * Private constructor to ensure only one instance of DataSourceFactory is created.
+   */
+  private constructor() {}
+
+  /**
+   * Returns the singleton instance of the DataSourceFactory. If it doesn't exist, it creates one.
+   *
+   * @returns {DataSourceFactory} The single instance of DataSourceFactory.
+   */
+  static getInstance(): DataSourceFactory {
+    if (!this.factory) {
+      this.factory = new DataSourceFactory();
+    }
+    return this.factory;
+  }
+
+  /**
+   * Registers a new data source type with its associated class.
+   * If the type has already been registered, an error is thrown.
+   *
+   * @param {string} type - The identifier for the data source type.
+   * @param {new (config: any) => DataSourceType} dataSourceClass - The constructor of the data source class.
+   * @throws {Error} Throws an error if the data source type has already been registered.
+   */
+  registerDataSourceType(type: string, dataSourceClass: new (config: any) => DataSourceType): void {
+    if (this.dataSourceClasses[type]) {
+      throw new Error('This data source type has already been registered');
+    }
+    this.dataSourceClasses[type] = dataSourceClass;
+  }
+
+  /**
+   * Creates and returns an instance of the specified data source type with the given configuration.
+   * If the type hasn't been registered, an error is thrown.
+   *
+   * @param {string} type - The identifier for the data source type.
+   * @param {any} config - The configuration for the data source instance.
+   * @returns {DataSourceType} An instance of the specified data source type.
+   * @throws {Error} Throws an error if the data source type is not supported.
+   */
+  getDataSourceInstance(type: string, config: any): DataSourceType {
+    const DataSourceClass = this.dataSourceClasses[type];
+    if (!DataSourceClass) {
+      throw new Error('Unsupported data source type');
+    }
+    return new DataSourceClass(config);
+  }
+}

src/plugins/data/public/data_sources/datasource/index.ts

@@ -0,0 +1,15 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export { DataSource } from './datasource';
+export {
+  IDataSourceMetaData,
+  ISourceDataSet,
+  IDataSetParams,
+  IDataSourceQueryParams,
+  IDataSourceQueryResult,
+  ConnectionStatus,
+} from './types';
+export { DataSourceFactory } from './factory';

src/plugins/data/public/data_sources/datasource/types.ts

@@ -0,0 +1,31 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { IndexPatternsContract } from '../../index_patterns';
+import { DataSourceType } from '../datasource_services';
+
+export interface IDataSourceMetaData {
+  name: string;
+}
+
+export interface IDataSourceGroup {
+  name: string;
+}
+
+export interface ISourceDataSet {
+  ds: DataSourceType;
+  data_sets: string[] | IndexPatternsContract;
+}
+
+export interface IDataSetParams {}
+
+export interface IDataSourceQueryParams {}
+
+export interface IDataSourceQueryResult {}
+
+export interface ConnectionStatus {
+  success: boolean;
+  info: string;
+}

src/plugins/data/public/data_sources/datasource_selector/constants.ts

@@ -0,0 +1,15 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export const SOURCE_PICKER_TITLE = 'available sources';
+export const SOURCE_PICKER_BTN_DEFAULT_TEXT = 'Select a datasource';
+export const SOURCE_PICKER_BTN_DEFAULT_WIDTH = '300px';
+export const SOURCE_PICKER_PANEL_DEFAULT_WIDTH = '500px';
+export const SOURCE_PICKER_PANEL_SEARCH_TEST_SUBJ = 'selectableDatasourcePanelSearch';
+export const SOURCE_PICKER_PANEL_TEST_SUBJ = 'selectableDatasourcePanel';
+export const SOURCE_PICKER_FOOTER_CANCEL_BTN_TEXT = 'Cancel';
+export const SOURCE_PICKER_FOOTER_SELECT_BTN_TEXT = 'Select';
+export const SOURCE_PICKER_FOOTER_SELECT_BTN_TEST_SUBJ = 'datasourcePickerSelect';
+export const SOURCE_PICKER_BTN_TEST_SUBJ = 'sourcePickerButton';

src/plugins/data/public/data_sources/datasource_selector/datasource_selectable.tsx

@@ -0,0 +1,82 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React, { useEffect, useCallback } from 'react';
+import { DataSourceSelector } from './datasource_selector';
+import { DataSourceType } from '../datasource_services';
+import { DataSourceList, DataSourceSelectableProps } from './types';
+
+export const DataSourceSelectable = ({
+  dataSources,
+  dataSourceOptionList,
+  selectedSources,
+  setSelectedSources,
+  setDataSourceOptionList,
+  onFetchDataSetError,
+  singleSelection = true,
+}: DataSourceSelectableProps) => {
+  const fetchDataSets = useCallback(
+    () => dataSources.map((ds: DataSourceType) => ds.getDataSet()),
+    [dataSources]
+  );
+
+  const isIndexPatterns = (dataset) => dataset.attributes;
+
+  useEffect(() => {
+    const getSourceOptions = (dataSource: DataSourceType, dataSet) => {
+      if (isIndexPatterns(dataSet)) {
+        return {
+          label: dataSet.attributes.title,
+          value: dataSet.id,
+          ds: dataSource,
+        };
+      }
+      return { label: dataSet, ds: dataSource };
+    };
+
+    const getSourceList = (allDataSets) => {
+      const finalList = [] as DataSourceList[];
+      allDataSets.map((curDataSet) => {
+        const existingGroup = finalList.find((item) => item.label === curDataSet.ds.getType());
+        // check if add new datasource group or add to existing one
+        if (existingGroup) {
+          existingGroup.options = [
+            ...existingGroup.options,
+            ...curDataSet.data_sets?.map((dataSet) => {
+              return getSourceOptions(curDataSet.ds, dataSet);
+            }),
+          ];
+        } else {
+          finalList.push({
+            label: curDataSet.ds.getType(),
+            options: curDataSet.data_sets?.map((dataSet) => {
+              return getSourceOptions(curDataSet.ds, dataSet);
+            }),
+          });
+        }
+      });
+      return finalList;
+    };
+
+    Promise.all(fetchDataSets())
+      .then((results) => {
+        setDataSourceOptionList([...getSourceList(results)]);
+      })
+      .catch((e) => onFetchDataSetError(e));
+  }, [dataSources, fetchDataSets, setDataSourceOptionList, onFetchDataSetError]);
+
+  const handleSourceChange = (selectedOptions) => {
+    setSelectedSources(selectedOptions);
+  };
+
+  return (
+    <DataSourceSelector
+      dataSourceList={dataSourceOptionList}
+      selectedOptions={selectedSources}
+      onDataSourceChange={handleSourceChange}
+      singleSelection={singleSelection}
+    />
+  );
+};

src/plugins/data/public/data_sources/datasource_selector/datasource_selector.test.tsx

@@ -0,0 +1,99 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+import { render, fireEvent } from '@testing-library/react';
+import { DataSourceSelector } from './datasource_selector';
+
+describe('DataSourceSelector', () => {
+  const mockOnDataSourceChange = jest.fn();
+
+  const sampleDataSources = [
+    {
+      label: 'Index patterns',
+      options: [
+        { label: 'sample_log1', value: 'sample_log1' },
+        { label: 'sample_log2', value: 'sample_log2' },
+      ],
+    },
+    {
+      label: 'EMR',
+      options: [{ label: 'EMR_cluster', value: 'EMR_cluster' }],
+    },
+  ];
+
+  const selectedSource = [{ label: 'sample_log1', value: 'sample_log1' }];
+
+  it('renders without crashing', () => {
+    const { getByText } = render(
+      <DataSourceSelector
+        dataSourceList={sampleDataSources}
+        selectedOptions={selectedSource}
+        onDataSourceChange={mockOnDataSourceChange}
+      />
+    );
+
+    expect(getByText('sample_log1')).toBeInTheDocument();
+  });
+
+  it('triggers onDataSourceChange when a data source is selected', () => {
+    const { getByTestId, getByText } = render(
+      <DataSourceSelector
+        dataSourceList={sampleDataSources}
+        selectedOptions={selectedSource}
+        onDataSourceChange={mockOnDataSourceChange}
+      />
+    );
+
+    fireEvent.click(getByTestId('comboBoxToggleListButton'));
+    fireEvent.click(getByText('sample_log2'));
+
+    expect(mockOnDataSourceChange).toHaveBeenCalledWith([
+      { label: 'sample_log2', value: 'sample_log2' },
+    ]);
+  });
+
+  it('has singleSelection set to true by default', () => {
+    const { rerender } = render(
+      <DataSourceSelector
+        dataSourceList={sampleDataSources}
+        selectedOptions={selectedSource}
+        onDataSourceChange={mockOnDataSourceChange}
+      />
+    );
+
+    let comboBox = document.querySelector('[data-test-subj="comboBoxInput"]');
+    expect(comboBox).toBeInTheDocument();
+
+    rerender(
+      <DataSourceSelector
+        dataSourceList={sampleDataSources}
+        selectedOptions={selectedSource}
+        onDataSourceChange={mockOnDataSourceChange}
+        singleSelection={false}
+      />
+    );
+
+    comboBox = document.querySelector('[data-test-subj="comboBoxInput"]');
+    expect(comboBox).toBeInTheDocument();
+  });
+
+  it('renders all data source options', () => {
+    const { getByText, getByTestId } = render(
+      <DataSourceSelector
+        dataSourceList={sampleDataSources}
+        selectedOptions={selectedSource}
+        onDataSourceChange={mockOnDataSourceChange}
+      />
+    );
+
+    fireEvent.click(getByTestId('comboBoxToggleListButton'));
+
+    expect(getByText('Index patterns')).toBeInTheDocument();
+    expect(getByText('sample_log2')).toBeInTheDocument();
+    expect(getByText('EMR')).toBeInTheDocument();
+    expect(getByText('EMR_cluster')).toBeInTheDocument();
+  });
+});