[data / saved query] BWCA all the routes

src/plugins/data/public/query/saved_query/saved_query_service.test.ts

@@ -22,6 +22,8 @@ const {
   getSavedQueryCount,
 } = createSavedQueryService(http);
 
+const version = '1';
+
 const savedQueryAttributes: SavedQueryAttributes = {
   title: 'foo',
   description: 'bar',
@@ -45,6 +47,7 @@ describe('saved query service', () => {
       expect(http.post).toBeCalled();
       expect(http.post).toHaveBeenCalledWith('/api/saved_query/_create', {
         body: '{"title":"foo","description":"bar","query":{"language":"kuery","query":"response:200"},"filters":[]}',
+        version,
       });
     });
   });
@@ -55,6 +58,7 @@ describe('saved query service', () => {
       expect(http.put).toBeCalled();
       expect(http.put).toHaveBeenCalledWith('/api/saved_query/foo', {
         body: '{"title":"foo","description":"bar","query":{"language":"kuery","query":"response:200"},"filters":[]}',
+        version,
       });
     });
   });
@@ -67,7 +71,7 @@ describe('saved query service', () => {
       });
       const result = await getAllSavedQueries();
       expect(http.post).toBeCalled();
-      expect(http.post).toHaveBeenCalledWith('/api/saved_query/_all');
+      expect(http.post).toHaveBeenCalledWith('/api/saved_query/_all', { version });
       expect(result).toEqual([{ attributes: savedQueryAttributes }]);
     });
   });
@@ -82,6 +86,7 @@ describe('saved query service', () => {
       expect(http.post).toBeCalled();
       expect(http.post).toHaveBeenCalledWith('/api/saved_query/_find', {
         body: '{"page":1,"perPage":50,"search":""}',
+        version,
       });
       expect(result).toEqual({
         queries: [{ attributes: savedQueryAttributes }],
@@ -94,23 +99,23 @@ describe('saved query service', () => {
     it('should get the given ID', async () => {
       await getSavedQuery('my_id');
       expect(http.get).toBeCalled();
-      expect(http.get).toHaveBeenCalledWith('/api/saved_query/my_id');
+      expect(http.get).toHaveBeenCalledWith('/api/saved_query/my_id', { version });
     });
   });
 
   describe('deleteSavedQuery', function () {
     it('should delete the given ID', async () => {
       await deleteSavedQuery('my_id');
       expect(http.delete).toBeCalled();
-      expect(http.delete).toHaveBeenCalledWith('/api/saved_query/my_id');
+      expect(http.delete).toHaveBeenCalledWith('/api/saved_query/my_id', { version });
     });
   });
 
   describe('getSavedQueryCount', function () {
     it('should get the total', async () => {
       await getSavedQueryCount();
       expect(http.get).toBeCalled();
-      expect(http.get).toHaveBeenCalledWith('/api/saved_query/_count');
+      expect(http.get).toHaveBeenCalledWith('/api/saved_query/_count', { version });
     });
   });
 });

src/plugins/data/public/query/saved_query/saved_query_service.ts

@@ -10,25 +10,30 @@ import { HttpStart } from '@kbn/core/public';
 import { SavedQuery } from './types';
 import type { SavedQueryAttributes } from '../../../common';
 
+const version = '1';
+
 export const createSavedQueryService = (http: HttpStart) => {
   const createQuery = async (attributes: SavedQueryAttributes, { overwrite = false } = {}) => {
     const savedQuery = await http.post<SavedQuery>('/api/saved_query/_create', {
       body: JSON.stringify(attributes),
+      version,
     });
     return savedQuery;
   };
 
   const updateQuery = async (id: string, attributes: SavedQueryAttributes) => {
     const savedQuery = await http.put<SavedQuery>(`/api/saved_query/${id}`, {
       body: JSON.stringify(attributes),
+      version,
     });
     return savedQuery;
   };
 
   // we have to tell the saved objects client how many to fetch, otherwise it defaults to fetching 20 per page
   const getAllSavedQueries = async (): Promise<SavedQuery[]> => {
     const { savedQueries } = await http.post<{ savedQueries: SavedQuery[] }>(
-      '/api/saved_query/_all'
+      '/api/saved_query/_all',
+      { version }
     );
     return savedQueries;
   };
@@ -44,21 +49,22 @@ export const createSavedQueryService = (http: HttpStart) => {
       total: number;
     }>('/api/saved_query/_find', {
       body: JSON.stringify({ page, perPage, search }),
+      version,
     });
 
     return { total, queries };
   };
 
   const getSavedQuery = (id: string): Promise<SavedQuery> => {
-    return http.get<SavedQuery>(`/api/saved_query/${id}`);
+    return http.get<SavedQuery>(`/api/saved_query/${id}`, { version });
   };
 
   const deleteSavedQuery = (id: string) => {
-    return http.delete<{}>(`/api/saved_query/${id}`);
+    return http.delete<{}>(`/api/saved_query/${id}`, { version });
   };
 
   const getSavedQueryCount = async (): Promise<number> => {
-    return http.get<number>('/api/saved_query/_count');
+    return http.get<number>('/api/saved_query/_count', { version });
   };
 
   return {

src/plugins/data/server/query/route_types.ts

@@ -0,0 +1,128 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+import type { SerializableRecord } from '@kbn/utility-types';
+
+/*
+ * These types are used to define the shape of the response from the saved query API
+ */
+
+// @ts-expect-error
+interface MatchAllFilterMetaRestResponse extends FilterMetaRestResponse, SerializableRecord {
+  field: string;
+  formattedValue: string;
+}
+
+type PhrasesFilterMetaRestResponse = FilterMetaRestResponse & {
+  params: PhraseFilterValue[]; // The unformatted values
+  field?: string;
+};
+
+interface RangeFilterParamsRestResponse extends SerializableRecord {
+  from?: number | string;
+  to?: number | string;
+  gt?: number | string;
+  lt?: number | string;
+  gte?: number | string;
+  lte?: number | string;
+  format?: string;
+}
+
+type RangeFilterMetaRestResponse = FilterMetaRestResponse & {
+  params?: RangeFilterParamsRestResponse;
+  field?: string;
+  formattedValue?: string;
+  type: 'range';
+};
+
+type PhraseFilterValue = string | number | boolean;
+
+interface PhraseFilterMetaParamsRestResponse extends SerializableRecord {
+  query: PhraseFilterValue; // The unformatted value
+}
+
+type PhraseFilterMetaRestResponse = FilterMetaRestResponse & {
+  params?: PhraseFilterMetaParamsRestResponse;
+  field?: string;
+  index?: string;
+};
+
+type FilterMetaParamsRestResponse =
+  | FilterRestResponse
+  | FilterRestResponse[]
+  | RangeFilterMetaRestResponse
+  | RangeFilterParamsRestResponse
+  | PhraseFilterMetaRestResponse
+  | PhraseFilterMetaParamsRestResponse
+  | PhrasesFilterMetaRestResponse
+  | MatchAllFilterMetaRestResponse
+  | string
+  | string[]
+  | boolean
+  | boolean[]
+  | number
+  | number[];
+
+interface QueryRestResponse {
+  query: string | { [key: string]: any };
+  language: string;
+}
+
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+type FilterMetaRestResponse = {
+  alias?: string | null;
+  disabled?: boolean;
+  negate?: boolean;
+  // controlledBy is there to identify who owns the filter
+  controlledBy?: string;
+  // allows grouping of filters
+  group?: string;
+  // index and type are optional only because when you create a new filter, there are no defaults
+  index?: string;
+  isMultiIndex?: boolean;
+  type?: string;
+  key?: string;
+  params?: FilterMetaParamsRestResponse;
+  value?: string;
+};
+
+type FilterStateStoreRestResponse = 'appState' | 'globalState';
+
+interface FilterRestResponse {
+  $state?: {
+    store: FilterStateStoreRestResponse;
+  };
+  meta: FilterMetaRestResponse;
+  query?: Record<string, any>;
+}
+
+interface RefreshIntervalRestResponse {
+  pause: boolean;
+  value: number;
+}
+
+interface TimeRangeRestResponse {
+  from: string;
+  to: string;
+  mode?: 'absolute' | 'relative';
+}
+
+type SavedQueryTimeFilterRestResponse = TimeRangeRestResponse & {
+  refreshInterval: RefreshIntervalRestResponse;
+};
+
+export interface SavedQueryRestResponse {
+  id: string;
+  attributes: {
+    filters: FilterRestResponse[];
+    title: string;
+    description: string;
+    query: QueryRestResponse;
+    timefilter?: SavedQueryTimeFilterRestResponse | undefined;
+  };
+}