2.0 query bar refactoring

src/plugins/data/public/plugin.ts

@@ -33,7 +33,6 @@
 import { PluginInitializerContext, CoreSetup, CoreStart, Plugin } from 'src/core/public';
 import { ConfigSchema } from '../config';
 import {
-  Storage,
   IStorageWrapper,
   createStartServicesGetter,
 } from '../../opensearch_dashboards_utils/public';
@@ -49,6 +48,7 @@
 import { UiService } from './ui/ui_service';
 import { FieldFormatsService } from './field_formats';
 import { QueryService } from './query';
+import { createStorage, QueryStorage } from './ui';
 import {
   IndexPatternsService,
   onRedirectNoIndexPattern,
@@ -117,15 +117,15 @@
   private readonly uiService: UiService;
   private readonly fieldFormatsService: FieldFormatsService;
   private readonly queryService: QueryService;
-  private readonly storage: IStorageWrapper;
+  private readonly storage: QueryStorage;
 
   constructor(initializerContext: PluginInitializerContext<ConfigSchema>) {
     this.searchService = new SearchService(initializerContext);
     this.uiService = new UiService(initializerContext);
     this.queryService = new QueryService();
     this.fieldFormatsService = new FieldFormatsService();
     this.autocomplete = new AutocompleteService(initializerContext);
-    this.storage = new Storage(window.localStorage);
+    this.storage = createStorage({ engine: window.localStorage, prefix: 'opensearchDashboards.' });
   }
 
   public setup(
@@ -179,7 +179,7 @@
       query: queryService,
       __enhance: (enhancements: DataPublicPluginEnhancements) => {
         if (enhancements.search) searchService.__enhance(enhancements.search);
-        if (enhancements.ui) uiService.__enhance(enhancements.ui);
+        if (enhancements.ui) queryService.queryString.__enhance(enhancements.ui);
       },
     };
   }

src/plugins/data/public/query/lib/add_to_query_log.ts

@@ -32,10 +32,11 @@ import { IUiSettingsClient } from 'src/core/public';
 import { IStorageWrapper } from 'src/plugins/opensearch_dashboards_utils/public';
 import { Query } from '../../../common';
 import { getQueryLog } from './get_query_log';
+import { QueryStorage } from '../../ui';
 
 interface AddToQueryLogDependencies {
   uiSettings: IUiSettingsClient;
-  storage: IStorageWrapper;
+  storage: QueryStorage;
 }
 
 export function createAddToQueryLog({ storage, uiSettings }: AddToQueryLogDependencies) {

src/plugins/data/public/query/lib/get_query_log.ts

@@ -29,14 +29,14 @@
  */
 
 import { IUiSettingsClient } from 'src/core/public';
-import { IStorageWrapper } from 'src/plugins/opensearch_dashboards_utils/public';
 import { PersistedLog } from '../persisted_log';
 import { UI_SETTINGS } from '../../../common';
+import { QueryStorage } from '../../ui';
 
 /** @internal */
 export function getQueryLog(
   uiSettings: IUiSettingsClient,
-  storage: IStorageWrapper,
+  storage: QueryStorage,
   appName: string,
   language: string
 ) {

src/plugins/data/public/query/persisted_log/persisted_log.ts

@@ -32,6 +32,7 @@ import _ from 'lodash';
 import * as Rx from 'rxjs';
 import { map } from 'rxjs/operators';
 import { IStorageWrapper } from 'src/plugins/opensearch_dashboards_utils/public';
+import { QueryStorage } from '../../ui';
 
 const defaultIsDuplicate = (oldItem: any, newItem: any) => {
   return _.isEqual(oldItem, newItem);
@@ -48,12 +49,12 @@ export class PersistedLog<T = any> {
   public maxLength?: number;
   public filterDuplicates?: boolean;
   public isDuplicate: (oldItem: T, newItem: T) => boolean;
-  public storage: IStorageWrapper;
+  public storage: QueryStorage;
   public items: T[];
 
   private update$ = new Rx.BehaviorSubject(undefined);
 
-  constructor(name: string, options: PersistedLogOptions<T> = {}, storage: IStorageWrapper) {
+  constructor(name: string, options: PersistedLogOptions<T> = {}, storage: QueryStorage) {
     this.name = name;
     this.maxLength =
       typeof options.maxLength === 'string'

src/plugins/data/public/query/query_service.ts

@@ -41,20 +41,21 @@ import { DataSetContract, DataSetManager } from './dataset_manager';
 import { buildOpenSearchQuery, getOpenSearchQueryConfig, IndexPatternsService } from '../../common';
 import { getUiSettings } from '../services';
 import { IndexPattern } from '..';
+import { QueryStorage } from '../ui';
 
 /**
  * Query Service
  * @internal
  */
 
 interface QueryServiceSetupDependencies {
-  storage: IStorageWrapper;
+  storage: QueryStorage;
   uiSettings: IUiSettingsClient;
 }
 
 interface QueryServiceStartDependencies {
   savedObjectsClient: SavedObjectsClientContract;
-  storage: IStorageWrapper;
+  storage: QueryStorage;
   uiSettings: IUiSettingsClient;
   indexPatterns: IndexPatternsService;
 }

src/plugins/data/public/query/query_string/history.ts

@@ -0,0 +1,91 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ *
+ * Any modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+import { BehaviorSubject } from 'rxjs';
+import { QueryStorage } from '../../ui/history/storage';
+import { Query, TimeRange } from '../..';
+
+export class QueryHistory {
+  constructor(private readonly storage: QueryStorage) {}
+
+  private changeEmitter = new BehaviorSubject<any[]>(this.getHistory() || []);
+
+  getHistoryKeys() {
+    return this.storage
+      .keys()
+      .filter((key: string) => key.indexOf('query_') === 0)
+      .sort()
+      .reverse();
+  }
+
+  getHistory() {
+    return this.getHistoryKeys().map((key) => this.storage.get(key));
+  }
+
+  // This is used as an optimization mechanism so that different components
+  // can listen for changes to history and update because changes to history can
+  // be triggered from different places in the app. The alternative would be to store
+  // this in state so that we hook into the React model, but it would require loading history
+  // every time the application starts even if a user is not going to view history.
+  change(listener: (reqs: any[]) => void) {
+    const subscription = this.changeEmitter.subscribe(listener);
+    return () => subscription.unsubscribe();
+  }
+
+  addQueryToHistory(dataSet: string, query: Query, dateRange?: TimeRange) {
+    const keys = this.getHistoryKeys();
+    keys.splice(0, 500); // only maintain most recent X;
+    keys.forEach((key) => {
+      this.storage.remove(key);
+    });
+
+    const timestamp = new Date().getTime();
+    const k = 'query_' + timestamp;
+    this.storage.set(k, {
+      dataSet,
+      time: timestamp,
+      query,
+      dateRange,
+    });
+
+    this.changeEmitter.next(this.getHistory());
+  }
+
+  updateCurrentState(content: any) {
+    const timestamp = new Date().getTime();
+    this.storage.set('editor_state', {
+      time: timestamp,
+      content,
+    });
+  }
+
+  getLegacySavedEditorState() {
+    const saved = this.storage.get('editor_state');
+    if (!saved) return;
+    const { time, content } = saved;
+    return { time, content };
+  }
+
+  /**
+   * This function should only ever be called once for a user if they had legacy state.
+   */
+  deleteLegacySavedEditorState() {
+    this.storage.remove('editor_state');
+  }
+
+  clearHistory() {
+    this.getHistoryKeys().forEach((key) => this.storage.remove(key));
+  }
+}
+
+export function createHistory(deps: { storage: QueryStorage }) {
+  return new QueryHistory(deps.storage);
+}

src/plugins/data/public/query/query_string/language_manager/language_manager.ts

@@ -0,0 +1,123 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { BehaviorSubject } from 'rxjs';
+import { CoreStart } from 'opensearch-dashboards/public';
+import { skip } from 'rxjs/operators';
+import {
+  IndexPattern,
+  SIMPLE_DATA_SET_TYPES,
+  SimpleDataSet,
+  SimpleDataSource,
+  UI_SETTINGS,
+} from '../../../../common';
+import { IndexPatternsContract } from '../../../index_patterns';
+import { QueryEnhancement, UiEnhancements } from '../../../ui/types';
+import { QueryEditorExtensionConfig } from '../../../ui';
+import { DataPublicPluginEnhancements } from '../../../types';
+
+export class LanguageManager {
+  private queryEnhancements: Map<string, QueryEnhancement>;
+  private queryEditorExtensionMap: Record<string, QueryEditorExtensionConfig>;
+  //TODO
+  //private queryEditorUISettings: Map<string, queryEditorUISettings>;
+
+  constructor(private readonly uiSettings: CoreStart['uiSettings']) {
+    this.queryEnhancements = new Map();
+    this.queryEditorExtensionMap = {};
+    //TODO
+    //this.queryEditorUISettings = new Map();
+  }
+
+  public __enhance = (enhancements: UiEnhancements) => {
+    if (!enhancements) return;
+    if (enhancements.query && enhancements.query.language) {
+      this.queryEnhancements.set(enhancements.query.language, enhancements.query);
+    }
+    if (enhancements.queryEditorExtension) {
+      this.queryEditorExtensionMap[enhancements.queryEditorExtension.id] =
+        enhancements.queryEditorExtension;
+    }
+
+    //TODO
+    //settings related to query editor UI
+    // if (enhancements.queryEditorUISettings && enhancements.queryEditorUISettings.language) {
+    //   this.queryEditorUISettings.set(
+    //     enhancements.queryEditorUISettings.language,
+    //     enhancements.queryEditorUISettings
+    //   );
+    // }
+  };
+
+  //   public initWithIndexPattern = (indexPattern: IndexPattern | null) => {
+  //     if (!this.uiSettings.get(UI_SETTINGS.QUERY_ENHANCEMENTS_ENABLED)) return;
+  //     if (!indexPattern || !indexPattern.id) {
+  //       return undefined;
+  //     }
+
+  //     this.defaultDataSet = {
+  //       id: indexPattern.id,
+  //       title: indexPattern.title,
+  //       type: SIMPLE_DATA_SET_TYPES.INDEX_PATTERN,
+  //       timeFieldName: indexPattern.timeFieldName,
+  //       fields: indexPattern.fields,
+  //       ...(indexPattern.dataSourceRef
+  //         ? {
+  //             dataSourceRef: {
+  //               id: indexPattern.dataSourceRef?.id,
+  //               name: indexPattern.dataSourceRef?.name,
+  //               type: indexPattern.dataSourceRef?.type,
+  //             } as SimpleDataSource,
+  //           }
+  //         : {}),
+  //     };
+  //   };
+
+  //   public getUpdates$ = () => {
+  //     return this.dataSet$.asObservable().pipe(skip(1));
+  //   };
+
+  public getQueryEnhancement = () => {
+    return this.queryEnhancements;
+  };
+
+  public getQueryEditorExtension = () => {
+    return this.queryEditorExtensionMap;
+  };
+
+  //   public getDefaultDataSet = () => {
+  //     return this.defaultDataSet;
+  //   };
+
+  //   public fetchDefaultDataSet = async (): Promise<SimpleDataSet | undefined> => {
+  //     const defaultIndexPatternId = this.uiSettings.get('defaultIndex');
+  //     if (!defaultIndexPatternId) {
+  //       return undefined;
+  //     }
+
+  //     const indexPattern = await this.indexPatterns?.get(defaultIndexPatternId);
+  //     if (!indexPattern || !indexPattern.id) {
+  //       return undefined;
+  //     }
+
+  //     return {
+  //       id: indexPattern.id,
+  //       title: indexPattern.title,
+  //       type: SIMPLE_DATA_SET_TYPES.INDEX_PATTERN,
+  //       timeFieldName: indexPattern.timeFieldName,
+  //       ...(indexPattern.dataSourceRef
+  //         ? {
+  //             dataSourceRef: {
+  //               id: indexPattern.dataSourceRef?.id,
+  //               name: indexPattern.dataSourceRef?.name,
+  //               type: indexPattern.dataSourceRef?.type,
+  //             } as SimpleDataSource,
+  //           }
+  //         : {}),
+  //     };
+  //   };
+}
+
+export type LanguageContract = PublicMethodsOf<LanguageManager>;