[Data Plugin] combine autocomplete provider and suggestions provider

src/plugins/data/public/autocomplete/autocomplete_service.ts

@@ -0,0 +1,77 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { CoreSetup } from 'src/core/public';
+import { QuerySuggestionsGetFn } from './providers/query_suggestion_provider';
+import {
+ setupValueSuggestionProvider,
+ ValueSuggestionsGetFn,
+} from './providers/value_suggestion_provider';
+
+export class AutocompleteService {
+ private readonly querySuggestionProviders: Map<string, QuerySuggestionsGetFn> = new Map();
+ private getValueSuggestions?: ValueSuggestionsGetFn;
+
+ private addQuerySuggestionProvider = (
+ language: string,
+ provider: QuerySuggestionsGetFn
+ ): void => {
+ if (language && provider) {
+ this.querySuggestionProviders.set(language, provider);
+ }
+ };
+
+ private getQuerySuggestions: QuerySuggestionsGetFn = args => {
+ const { language } = args;
+ const provider = this.querySuggestionProviders.get(language);
+
+ if (provider) {
+ return provider(args);
+ }
+ };
+
+ private hasQuerySuggestions = (language: string) => this.querySuggestionProviders.has(language);
+
+ /** @public **/
+ public setup(core: CoreSetup) {
+ this.getValueSuggestions = setupValueSuggestionProvider(core);
+
+ return {
+ addQuerySuggestionProvider: this.addQuerySuggestionProvider,
+
+ /** @obsolete **/
+ /** please use "getProvider" only from the start contract **/
+ getQuerySuggestions: this.getQuerySuggestions,
+ };
+ }
+
+ /** @public **/
+ public start() {
+ return {
+ getQuerySuggestions: this.getQuerySuggestions,
+ hasQuerySuggestions: this.hasQuerySuggestions,
+ getValueSuggestions: this.getValueSuggestions!,
+ };
+ }
+
+ /** @internal **/
+ public clearProviders(): void {
+ this.querySuggestionProviders.clear();
+ }
+}

src/plugins/data/public/suggestions_provider/index.ts → src/plugins/data/public/autocomplete/index.ts

@@ -17,4 +17,5 @@
  * under the License.
  */
 
-export { getSuggestionsProvider } from './value_suggestions';
+export { AutocompleteService } from './autocomplete_service';
+export { QuerySuggestion, QuerySuggestionType, QuerySuggestionsGetFn } from './types';

src/plugins/data/public/autocomplete_provider/types.ts → src/plugins/data/public/autocomplete/providers/query_suggestion_provider.ts

@@ -17,56 +17,40 @@
  * under the License.
  */
 
-import { AutocompleteProviderRegister } from '.';
-import { IIndexPattern, IFieldType } from '../../common';
+import { IFieldType, IIndexPattern } from '../../../common/index_patterns';
 
-export type AutocompletePublicPluginSetup = Pick<
- AutocompleteProviderRegister,
- 'addProvider' | 'getProvider'
->;
-export type AutocompletePublicPluginStart = Pick<AutocompleteProviderRegister, 'getProvider'>;
+export type QuerySuggestionType = 'field' | 'value' | 'operator' | 'conjunction' | 'recentSearch';
 
-/** @public **/
-export type AutocompleteProvider = (args: {
- config: {
- get(configKey: string): any;
- };
- indexPatterns: IIndexPattern[];
- boolFilter?: any;
-}) => GetSuggestions;
+export type QuerySuggestionsGetFn = (
+ args: QuerySuggestionsGetFnArgs
+) => Promise<QuerySuggestion[]> | undefined;
 
-/** @public **/
-export type GetSuggestions = (args: {
+interface QuerySuggestionsGetFnArgs {
+ language: string;
+ indexPatterns: IIndexPattern[];
  query: string;
  selectionStart: number;
  selectionEnd: number;
  signal?: AbortSignal;
-}) => Promise<AutocompleteSuggestion[]>;
-
-/** @public **/
-export type AutocompleteSuggestionType =
- | 'field'
- | 'value'
- | 'operator'
- | 'conjunction'
- | 'recentSearch';
-
-// A union type allows us to do easy type guards in the code. For example, if I want to ensure I'm
-// working with a FieldAutocompleteSuggestion, I can just do `if ('field' in suggestion)` and the
-// TypeScript compiler will narrow the type to the parts of the union that have a field prop.
-/** @public **/
-export type AutocompleteSuggestion = BasicAutocompleteSuggestion | FieldAutocompleteSuggestion;
+ boolFilter?: any;
+}
 
-interface BasicAutocompleteSuggestion {
+interface BasicQuerySuggestion {
+ type: QuerySuggestionType;
  description?: string;
  end: number;
  start: number;
  text: string;
- type: AutocompleteSuggestionType;
  cursorIndex?: number;
 }
 
-export type FieldAutocompleteSuggestion = BasicAutocompleteSuggestion & {
+interface FieldQuerySuggestion extends BasicQuerySuggestion {
  type: 'field';
  field: IFieldType;
-};
+}
+
+// A union type allows us to do easy type guards in the code. For example, if I want to ensure I'm
+// working with a FieldAutocompleteSuggestion, I can just do `if ('field' in suggestion)` and the
+// TypeScript compiler will narrow the type to the parts of the union that have a field prop.
+/** @public **/
+export type QuerySuggestion = BasicQuerySuggestion | FieldQuerySuggestion;

src/plugins/data/public/suggestions_provider/value_suggestions.test.ts → src/plugins/data/public/autocomplete/providers/value_suggestion_provider.test.ts

@@ -17,98 +17,121 @@
  * under the License.
  */
 
-import { stubIndexPattern, stubFields } from '../stubs';
-import { getSuggestionsProvider } from './value_suggestions';
-import { IUiSettingsClient } from 'kibana/public';
+import { stubIndexPattern, stubFields } from '../../stubs';
+import { setupValueSuggestionProvider, ValueSuggestionsGetFn } from './value_suggestion_provider';
+import { IUiSettingsClient, CoreSetup } from 'kibana/public';
 
-describe('getSuggestions', () => {
- let getSuggestions: any;
+describe('FieldSuggestions', () => {
+ let getValueSuggestions: ValueSuggestionsGetFn;
  let http: any;
+ let shouldSuggestValues: boolean;
 
- describe('with value suggestions disabled', () => {
- beforeEach(() => {
- const config = { get: (key: string) => false } as IUiSettingsClient;
- http = { fetch: jest.fn() };
- getSuggestions = getSuggestionsProvider(config, http);
- });
+ beforeEach(() => {
+ const uiSettings = { get: (key: string) => shouldSuggestValues } as IUiSettingsClient;
+ http = { fetch: jest.fn() };
 
+ getValueSuggestions = setupValueSuggestionProvider({ http, uiSettings } as CoreSetup);
+ });
+
+ describe('with value suggestions disabled', () => {
  it('should return an empty array', async () => {
- const index = stubIndexPattern.id;
- const [field] = stubFields;
- const query = '';
- const suggestions = await getSuggestions(index, field, query);
+ const suggestions = await getValueSuggestions({
+ indexPattern: stubIndexPattern,
+ field: stubFields[0],
+ query: '',
+ });
+
  expect(suggestions).toEqual([]);
  expect(http.fetch).not.toHaveBeenCalled();
  });
  });
 
  describe('with value suggestions enabled', () => {
- beforeEach(() => {
- const config = { get: (key: string) => true } as IUiSettingsClient;
- http = { fetch: jest.fn() };
- getSuggestions = getSuggestionsProvider(config, http);
- });
+ shouldSuggestValues = true;
 
  it('should return true/false for boolean fields', async () => {
- const index = stubIndexPattern.id;
  const [field] = stubFields.filter(({ type }) => type === 'boolean');
- const query = '';
- const suggestions = await getSuggestions(index, field, query);
+ const suggestions = await getValueSuggestions({
+ indexPattern: stubIndexPattern,
+ field,
+ query: '',
+ });
+
  expect(suggestions).toEqual([true, false]);
  expect(http.fetch).not.toHaveBeenCalled();
  });
 
  it('should return an empty array if the field type is not a string or boolean', async () => {
- const index = stubIndexPattern.id;
  const [field] = stubFields.filter(({ type }) => type !== 'string' && type !== 'boolean');
- const query = '';
- const suggestions = await getSuggestions(index, field, query);
+ const suggestions = await getValueSuggestions({
+ indexPattern: stubIndexPattern,
+ field,
+ query: '',
+ });
+
  expect(suggestions).toEqual([]);
  expect(http.fetch).not.toHaveBeenCalled();
  });
 
  it('should return an empty array if the field is not aggregatable', async () => {
- const index = stubIndexPattern.id;
  const [field] = stubFields.filter(({ aggregatable }) => !aggregatable);
- const query = '';
- const suggestions = await getSuggestions(index, field, query);
+ const suggestions = await getValueSuggestions({
+ indexPattern: stubIndexPattern,
+ field,
+ query: '',
+ });
+
  expect(suggestions).toEqual([]);
  expect(http.fetch).not.toHaveBeenCalled();
  });
 
  it('should otherwise request suggestions', async () => {
- const index = stubIndexPattern.id;
  const [field] = stubFields.filter(
  ({ type, aggregatable }) => type === 'string' && aggregatable
  );
- const query = '';
- await getSuggestions(index, field, query);
+
+ await getValueSuggestions({
+ indexPattern: stubIndexPattern,
+ field,
+ query: '',
+ });
+
  expect(http.fetch).toHaveBeenCalled();
  });
 
  it('should cache results if using the same index/field/query/filter', async () => {
- const index = stubIndexPattern.id;
  const [field] = stubFields.filter(
  ({ type, aggregatable }) => type === 'string' && aggregatable
  );
- const query = '';
- await getSuggestions(index, field, query);
- await getSuggestions(index, field, query);
+ const args = {
+ indexPattern: stubIndexPattern,
+ field,
+ query: '',
+ };
+
+ await getValueSuggestions(args);
+ await getValueSuggestions(args);
+
  expect(http.fetch).toHaveBeenCalledTimes(1);
  });
 
  it('should cache results for only one minute', async () => {
- const index = stubIndexPattern.id;
  const [field] = stubFields.filter(
  ({ type, aggregatable }) => type === 'string' && aggregatable
  );
- const query = '';
+ const args = {
+ indexPattern: stubIndexPattern,
+ field,
+ query: '',
+ };
 
  const { now } = Date;
  Date.now = jest.fn(() => 0);
- await getSuggestions(index, field, query);
+
+ await getValueSuggestions(args);
+
  Date.now = jest.fn(() => 60 * 1000);
- await getSuggestions(index, field, query);
+ await getValueSuggestions(args);
  Date.now = now;
 
  expect(http.fetch).toHaveBeenCalledTimes(2);
@@ -118,14 +141,54 @@ describe('getSuggestions', () => {
  const fields = stubFields.filter(
  ({ type, aggregatable }) => type === 'string' && aggregatable
  );
- await getSuggestions('index', fields[0], '');
- await getSuggestions('index', fields[0], 'query');
- await getSuggestions('index', fields[1], '');
- await getSuggestions('index', fields[1], 'query');
- await getSuggestions('logstash-*', fields[0], '');
- await getSuggestions('logstash-*', fields[0], 'query');
- await getSuggestions('logstash-*', fields[1], '');
- await getSuggestions('logstash-*', fields[1], 'query');
+
+ await getValueSuggestions({
+ indexPattern: stubIndexPattern,
+ field: fields[0],
+ query: '',
+ });
+ await getValueSuggestions({
+ indexPattern: stubIndexPattern,
+ field: fields[0],
+ query: 'query',
+ });
+ await getValueSuggestions({
+ indexPattern: stubIndexPattern,
+ field: fields[1],
+ query: '',
+ });
+ await getValueSuggestions({
+ indexPattern: stubIndexPattern,
+ field: fields[1],
+ query: 'query',
+ });
+
+ const customIndexPattern = {
+ ...stubIndexPattern,
+ title: 'customIndexPattern',
+ };
+
+ await getValueSuggestions({
+ indexPattern: customIndexPattern,
+ field: fields[0],
+ query: '',
+ });
+ await getValueSuggestions({
+ indexPattern: customIndexPattern,
+ field: fields[0],
+ query: 'query',
+ });
+ await getValueSuggestions({
+ indexPattern: customIndexPattern,
+ field: fields[1],
+ query: '',
+ });
+ await getValueSuggestions({
+ indexPattern: customIndexPattern,
+ field: fields[1],
+ query: 'query',
+ });
+
  expect(http.fetch).toHaveBeenCalledTimes(8);
  });
  });