[reference only] Custom stateful search bar filter editor

packages/kbn-es-query/README.md

@@ -13,7 +13,7 @@ buildEsQuery(indexPattern, queries, filters, config)
 Generates the Elasticsearch query DSL from combining the queries and filters provided.
 
 ```javascript
-buildQueryFromFilters(filters, indexPattern)
+buildQueryFromFilters(filters, indexPattern, ignoreFilterIfFieldNotInIndex, allowLeadingWildcards, queryStringOptions, dateFormatTZ)
 ```
 
 Generates the Elasticsearch query DSL from the given filters.
@@ -72,6 +72,12 @@ buildRangeFilter(field, params, indexPattern)
 
 Creates a filter (`RangeFilter`) where the value for the given field is in the given range. `params` should contain `lt`, `lte`, `gt`, and/or `gte`.
 
+```javascript
+buildSavedQueryFilter(savedQueryId)
+```
+
+Creates a filter (`SavedQueryFilter`) corresponding to a saved query. `params` should be an object containing the saved query.
+
 ## kuery
 
 This folder contains the code corresponding to generating Elasticsearch queries using the Kibana query language.

packages/kbn-es-query/src/es_query/__tests__/build_es_query.js

@@ -134,6 +134,71 @@ describe('build query', function () {
       expect(result).to.eql(expectedResult);
     });
 
+    it('should build an Elasticsearch query from a saved query', function () {
+      const filters = {
+        meta: {
+          alias: null,
+          disabled: false,
+          key: 'Bytes more than 2000 onlu',
+          negate: false,
+          params: {
+            savedQuery: {
+              attributes: {
+                description: 'no filters at all',
+                query: {
+                  language: 'kuery',
+                  query: 'bytes >= 2000'
+                },
+                title: 'Bytes more than 2000 only',
+              },
+              id: 'Bytes more than 2000 only',
+            }
+          },
+          type: 'savedQuery',
+          value: undefined,
+        },
+        saved_query: 'Bytes more than 2000 only'
+      };
+      const config = {
+        allowLeadingWildcards: true,
+        queryStringOptions: {},
+      };
+      const expectedResult = {
+        bool: {
+          must: [],
+          filter: [
+            {
+              bool: {
+                must: [],
+                filter: [
+                  {
+                    bool: {
+                      should: [
+                        {
+                          range: {
+                            bytes: {
+                              gte: 2000
+                            }
+                          }
+                        }
+                      ],
+                      minimum_should_match: 1
+                    }
+                  }
+                ],
+                should: [],
+                must_not: []
+              }
+            }
+          ],
+          should: [],
+          must_not: [],
+        }
+      };
+      const result = buildEsQuery(indexPattern, [], [filters], config);
+
+      expect(result).to.eql(expectedResult);
+    });
   });
 
 });

packages/kbn-es-query/src/es_query/__tests__/from_filters.js

@@ -17,8 +17,29 @@
  * under the License.
  */
 
+
+/*
+ * 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/LICENSE2.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 expect from '@kbn/expect';
-import { buildQueryFromFilters } from '../from_filters';
+import { buildQueryFromFilters, translateToQuery } from '../from_filters';
+import indexPattern from '../../__fixtures__/index_pattern_response.json';
 
 describe('build query', function () {
   describe('buildQueryFromFilters', function () {
@@ -121,5 +142,203 @@ describe('build query', function () {
 
       expect(result.filter).to.eql(expectedESQueries);
     });
+
+    it('should convert a saved query filter into an ES query', function () {
+      const savedQueryFilter = {
+        '$state': {
+          store: 'appState',
+        },
+        meta: {
+          alias: null,
+          disabled: false,
+          key: 'Bytes more than 2000 onlu',
+          negate: false,
+          params: {
+            savedQuery: {
+              attributes: {
+                description: 'no filters at all',
+                query: {
+                  language: 'kuery',
+                  query: 'bytes >= 2000'
+                },
+                title: 'Bytes more than 2000 only',
+              },
+              id: 'Bytes more than 2000 only',
+            }
+          },
+          type: 'savedQuery',
+          value: undefined,
+        },
+        saved_query: 'Bytes more than 2000 only'
+      };
+      const expectedESQueries = [
+        {
+          bool: {
+            must: [],
+            filter: [
+              {
+                bool: {
+                  should: [
+                    {
+                      range: {
+                        bytes: {
+                          gte: 2000
+                        }
+                      }
+                    }
+                  ],
+                  minimum_should_match: 1
+                }
+              }
+            ],
+            should: [],
+            must_not: []
+          }
+        }];
+      const result = buildQueryFromFilters([savedQueryFilter]);
+      expect(result.filter).to.eql(expectedESQueries);
+    });
+  });
+  describe('translateToQuery', function () {
+    it('should extract the contents of a saved query', function () {
+      const savedQueryFilter = {
+        '$state': {
+          store: 'appState',
+        },
+        meta: {
+          alias: null,
+          disabled: false,
+          key: 'Bytes more than 2000 only',
+          negate: false,
+          params: {
+            savedQuery: {
+              attributes: {
+                description: 'no filters at all',
+                query: {
+                  language: 'kuery',
+                  query: 'bytes >= 2000'
+                },
+                title: 'Bytes more than 2000 only',
+              },
+              id: 'Bytes more than 2000 only',
+            }
+          },
+          type: 'savedQuery',
+          value: undefined,
+        },
+        saved_query: 'Bytes more than 2000 only'
+      };
+      const expectedResult = {
+        bool: {
+          filter: [
+            {
+              bool: {
+                minimum_should_match: 1,
+                should: [{ range: { bytes: { gte: 2000 } } }],
+              }
+            }
+          ],
+          must: [],
+          must_not: [],
+          should: [],
+        }
+      };
+      const result = translateToQuery(savedQueryFilter, { indexPattern });
+      expect(result).to.eql(expectedResult);
+    });
+
+    it('should extract and translate saved query filters that contain saved query filters', function () {
+      const savedQueryFilter = {
+        '$state': {
+          store: 'appState',
+        },
+        meta: {
+          alias: null,
+          disabled: false,
+          key: 'Compound',
+          negate: false,
+          params: {
+            savedQuery: {
+              attributes: {
+                description: 'Compound saved query',
+                filters: [
+                  {
+                    '$state': {
+                      store: 'appState',
+                    },
+                    meta: {
+                      alias: null,
+                      disabled: false,
+                      key: 'Ok response',
+                      negate: false,
+                      params: {
+                        savedQuery: {
+                          attributes: {
+                            description: 'saved query',
+                            query: {
+                              language: 'kuery',
+                              query: 'response.keyword: 200'
+                            },
+                            title: 'Ok response',
+                          },
+                          id: 'Ok response',
+                        }
+                      },
+                      type: 'savedQuery',
+                      value: undefined,
+                    },
+                    saved_query: 'Ok response'
+                  }],
+                query: {
+                  language: 'kuery',
+                  query: ''
+                },
+                title: 'Compound',
+              },
+              id: 'Compound',
+            }
+          },
+          type: 'savedQuery',
+          value: undefined,
+        },
+        saved_query: 'Compound'
+      };
+      const expectedResult = {
+        bool: {
+          filter: [
+            {
+              match_all: {}
+            },
+            {
+              bool: {
+                filter: [
+                  {
+                    bool: {
+                      minimum_should_match: 1,
+                      should: [
+                        {
+                          match: {
+                            'response.keyword': 200
+                          }
+                        }
+                      ]
+                    }
+                  }
+                ],
+                must: [],
+                must_not: [],
+                should: [],
+              }
+            }
+          ],
+          must: [],
+          must_not: [],
+          should: [],
+        }
+      };
+      const result = translateToQuery(savedQueryFilter, { indexPattern });
+      expect(result).to.eql(expectedResult);
+    });
   });
 });
+

packages/kbn-es-query/src/es_query/build_es_query.js

@@ -29,6 +29,7 @@ import { buildQueryFromLucene } from './from_lucene';
  * @param config - an objects with query:allowLeadingWildcards and query:queryString:options UI
  * settings in form of { allowLeadingWildcards, queryStringOptions }
  * config contains dateformat:tz
+ * @param allSavedQueries - an array of saved queries from which filters are built. Used in buildQueryFromFilters
  */
 export function buildEsQuery(
   indexPattern,
@@ -47,7 +48,13 @@ export function buildEsQuery(
   const queriesByLanguage = groupBy(validQueries, 'language');
   const kueryQuery = buildQueryFromKuery(indexPattern, queriesByLanguage.kuery, config.allowLeadingWildcards, config.dateFormatTZ);
   const luceneQuery = buildQueryFromLucene(queriesByLanguage.lucene, config.queryStringOptions, config.dateFormatTZ);
-  const filterQuery = buildQueryFromFilters(filters, indexPattern, config.ignoreFilterIfFieldNotInIndex);
+  const filterQuery = buildQueryFromFilters(
+    filters,
+    indexPattern,
+    config.ignoreFilterIfFieldNotInIndex,
+    config.allowLeadingWildcards,
+    config.queryStringOptions,
+    config.dateFormatTZ);
 
   return {
     bool: {