[Maps] add Top term aggregation

x-pack/legacy/plugins/maps/common/constants.ts

@@ -117,16 +117,16 @@ export const DRAW_TYPE = {
   POLYGON: 'POLYGON',
 };
 
-export const METRIC_TYPE = {
+export const AGG_TYPE = {
   AVG: 'avg',
   COUNT: 'count',
   MAX: 'max',
   MIN: 'min',
   SUM: 'sum',
+  TERMS: 'terms',
   UNIQUE_COUNT: 'cardinality',
 };
 
-export const COUNT_AGG_TYPE = METRIC_TYPE.COUNT;
 export const COUNT_PROP_LABEL = i18n.translate('xpack.maps.aggs.defaultCountLabel', {
   defaultMessage: 'count',
 });

x-pack/legacy/plugins/maps/public/components/metric_editor.js

@@ -12,17 +12,16 @@ import { EuiFieldText, EuiFormRow } from '@elastic/eui';
 
 import { MetricSelect, METRIC_AGGREGATION_VALUES } from './metric_select';
 import { SingleFieldSelect } from './single_field_select';
-import { METRIC_TYPE } from '../../common/constants';
+import { AGG_TYPE } from '../../common/constants';
+import { getTermsFields } from '../index_pattern_util';
 
 function filterFieldsForAgg(fields, aggType) {
   if (!fields) {
     return [];
   }
 
-  if (aggType === METRIC_TYPE.UNIQUE_COUNT) {
-    return fields.filter(field => {
-      return field.aggregatable;
-    });
+  if (aggType === AGG_TYPE.UNIQUE_COUNT || aggType === AGG_TYPE.TERMS) {
+    return getTermsFields(fields);
   }
 
   return fields.filter(field => {
@@ -38,7 +37,7 @@ export function MetricEditor({ fields, metricsFilter, metric, onChange, removeBu
     };
 
     // unset field when new agg type does not support currently selected field.
-    if (metric.field && metricAggregationType !== METRIC_TYPE.COUNT) {
+    if (metric.field && metricAggregationType !== AGG_TYPE.COUNT) {
       const fieldsForNewAggType = filterFieldsForAgg(fields, metricAggregationType);
       const found = fieldsForNewAggType.find(field => {
         return field.name === metric.field;
@@ -64,7 +63,7 @@ export function MetricEditor({ fields, metricsFilter, metric, onChange, removeBu
   };
 
   let fieldSelect;
-  if (metric.type && metric.type !== METRIC_TYPE.COUNT) {
+  if (metric.type && metric.type !== AGG_TYPE.COUNT) {
     fieldSelect = (
       <EuiFormRow
         label={i18n.translate('xpack.maps.metricsEditor.selectFieldLabel', {

x-pack/legacy/plugins/maps/public/components/metric_select.js

@@ -8,44 +8,50 @@ import React from 'react';
 import PropTypes from 'prop-types';
 import { i18n } from '@kbn/i18n';
 import { EuiComboBox } from '@elastic/eui';
-import { METRIC_TYPE } from '../../common/constants';
+import { AGG_TYPE } from '../../common/constants';
 
 const AGG_OPTIONS = [
   {
     label: i18n.translate('xpack.maps.metricSelect.averageDropDownOptionLabel', {
       defaultMessage: 'Average',
     }),
-    value: METRIC_TYPE.AVG,
+    value: AGG_TYPE.AVG,
   },
   {
     label: i18n.translate('xpack.maps.metricSelect.countDropDownOptionLabel', {
       defaultMessage: 'Count',
     }),
-    value: METRIC_TYPE.COUNT,
+    value: AGG_TYPE.COUNT,
   },
   {
     label: i18n.translate('xpack.maps.metricSelect.maxDropDownOptionLabel', {
       defaultMessage: 'Max',
     }),
-    value: METRIC_TYPE.MAX,
+    value: AGG_TYPE.MAX,
   },
   {
     label: i18n.translate('xpack.maps.metricSelect.minDropDownOptionLabel', {
       defaultMessage: 'Min',
     }),
-    value: METRIC_TYPE.MIN,
+    value: AGG_TYPE.MIN,
   },
   {
     label: i18n.translate('xpack.maps.metricSelect.sumDropDownOptionLabel', {
       defaultMessage: 'Sum',
     }),
-    value: METRIC_TYPE.SUM,
+    value: AGG_TYPE.SUM,
+  },
+  {
+    label: i18n.translate('xpack.maps.metricSelect.termsDropDownOptionLabel', {
+      defaultMessage: 'Top term',
+    }),
+    value: AGG_TYPE.TERMS,
   },
   {
     label: i18n.translate('xpack.maps.metricSelect.cardinalityDropDownOptionLabel', {
       defaultMessage: 'Unique count',
     }),
-    value: METRIC_TYPE.UNIQUE_COUNT,
+    value: AGG_TYPE.UNIQUE_COUNT,
   },
 ];
 

x-pack/legacy/plugins/maps/public/components/metrics_editor.js

@@ -10,7 +10,7 @@ import { i18n } from '@kbn/i18n';
 import { FormattedMessage } from '@kbn/i18n/react';
 import { EuiButtonEmpty, EuiSpacer, EuiTextAlign } from '@elastic/eui';
 import { MetricEditor } from './metric_editor';
-import { METRIC_TYPE } from '../../common/constants';
+import { AGG_TYPE } from '../../common/constants';
 
 export function MetricsEditor({ fields, metrics, onChange, allowMultipleMetrics, metricsFilter }) {
   function renderMetrics() {
@@ -100,6 +100,6 @@ MetricsEditor.propTypes = {
 };
 
 MetricsEditor.defaultProps = {
-  metrics: [{ type: METRIC_TYPE.COUNT }],
+  metrics: [{ type: AGG_TYPE.COUNT }],
   allowMultipleMetrics: true,
 };

x-pack/legacy/plugins/maps/public/connected_components/layer_panel/join_editor/resources/metrics_expression.js

@@ -16,7 +16,7 @@ import {
 } from '@elastic/eui';
 import { MetricsEditor } from '../../../../components/metrics_editor';
 import { FormattedMessage } from '@kbn/i18n/react';
-import { METRIC_TYPE } from '../../../../../common/constants';
+import { AGG_TYPE } from '../../../../../common/constants';
 
 export class MetricsExpression extends Component {
   state = {
@@ -59,7 +59,7 @@ export class MetricsExpression extends Component {
   render() {
     const metricExpressions = this.props.metrics
       .filter(({ type, field }) => {
-        if (type === METRIC_TYPE.COUNT) {
+        if (type === AGG_TYPE.COUNT) {
           return true;
         }
 
@@ -70,7 +70,7 @@ export class MetricsExpression extends Component {
       })
       .map(({ type, field }) => {
         // do not use metric label so field and aggregation are not obscured.
-        if (type === METRIC_TYPE.COUNT) {
+        if (type === AGG_TYPE.COUNT) {
           return 'count';
         }
 
@@ -130,5 +130,5 @@ MetricsExpression.propTypes = {
 };
 
 MetricsExpression.defaultProps = {
-  metrics: [{ type: METRIC_TYPE.COUNT }],
+  metrics: [{ type: AGG_TYPE.COUNT }],
 };

x-pack/legacy/plugins/maps/public/connected_components/layer_panel/join_editor/resources/metrics_expression.test.js

@@ -4,6 +4,12 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
+jest.mock('../../../../components/metrics_editor', () => ({
+  MetricsEditor: () => {
+    return <div>mockMetricsEditor</div>;
+  },
+}));
+
 import React from 'react';
 import { shallow } from 'enzyme';
 import { MetricsExpression } from './metrics_expression';

x-pack/legacy/plugins/maps/public/layers/fields/es_agg_field.js

@@ -5,9 +5,10 @@
  */
 
 import { AbstractField } from './field';
-import { COUNT_AGG_TYPE } from '../../../common/constants';
+import { AGG_TYPE } from '../../../common/constants';
 import { isMetricCountable } from '../util/is_metric_countable';
 import { ESAggMetricTooltipProperty } from '../tooltips/es_aggmetric_tooltip_property';
+import { getField, addFieldToDSL } from '../util/es_agg_utils';
 
 export class ESAggMetricField extends AbstractField {
   static type = 'ES_AGG';
@@ -34,22 +35,21 @@ export class ESAggMetricField extends AbstractField {
   }
 
   isValid() {
-    return this.getAggType() === COUNT_AGG_TYPE ? true : !!this._esDocField;
+    return this.getAggType() === AGG_TYPE.COUNT ? true : !!this._esDocField;
   }
 
   async getDataType() {
-    // aggregations only provide numerical data
-    return 'number';
+    return this.getAggType() === AGG_TYPE.TERMS ? 'string' : 'number';
   }
 
   getESDocFieldName() {
     return this._esDocField ? this._esDocField.getName() : '';
   }
 
   getRequestDescription() {
-    return this.getAggType() !== COUNT_AGG_TYPE
+    return this.getAggType() !== AGG_TYPE.COUNT
       ? `${this.getAggType()} ${this.getESDocFieldName()}`
-      : COUNT_AGG_TYPE;
+      : AGG_TYPE.COUNT;
   }
 
   async createTooltipProperty(value) {
@@ -63,18 +63,13 @@ export class ESAggMetricField extends AbstractField {
     );
   }
 
-  makeMetricAggConfig() {
-    const metricAggConfig = {
-      id: this.getName(),
-      enabled: true,
-      type: this.getAggType(),
-      schema: 'metric',
-      params: {},
+  getValueAggDsl(indexPattern) {
+    const field = getField(indexPattern, this.getESDocFieldName());
+    const aggType = this.getAggType();
+    const aggBody = aggType === AGG_TYPE.TERMS ? { size: 1 } : {};
+    return {
+      [aggType]: addFieldToDSL(aggBody, field),
     };
-    if (this.getAggType() !== COUNT_AGG_TYPE) {
-      metricAggConfig.params = { field: this.getESDocFieldName() };
-    }
-    return metricAggConfig;
   }
 
   supportsFieldMeta() {
@@ -85,4 +80,8 @@ export class ESAggMetricField extends AbstractField {
   async getOrdinalFieldMetaRequest(config) {
     return this._esDocField.getOrdinalFieldMetaRequest(config);
   }
+
+  async getCategoricalFieldMetaRequest() {
+    return this._esDocField.getCategoricalFieldMetaRequest();
+  }
 }

x-pack/legacy/plugins/maps/public/layers/fields/es_agg_field.test.js

@@ -5,24 +5,24 @@
  */
 
 import { ESAggMetricField } from './es_agg_field';
-import { METRIC_TYPE } from '../../../common/constants';
+import { AGG_TYPE } from '../../../common/constants';
 
 describe('supportsFieldMeta', () => {
   test('Non-counting aggregations should support field meta', () => {
-    const avgMetric = new ESAggMetricField({ aggType: METRIC_TYPE.AVG });
+    const avgMetric = new ESAggMetricField({ aggType: AGG_TYPE.AVG });
     expect(avgMetric.supportsFieldMeta()).toBe(true);
-    const maxMetric = new ESAggMetricField({ aggType: METRIC_TYPE.MAX });
+    const maxMetric = new ESAggMetricField({ aggType: AGG_TYPE.MAX });
     expect(maxMetric.supportsFieldMeta()).toBe(true);
-    const minMetric = new ESAggMetricField({ aggType: METRIC_TYPE.MIN });
+    const minMetric = new ESAggMetricField({ aggType: AGG_TYPE.MIN });
     expect(minMetric.supportsFieldMeta()).toBe(true);
   });
 
   test('Counting aggregations should not support field meta', () => {
-    const countMetric = new ESAggMetricField({ aggType: METRIC_TYPE.COUNT });
+    const countMetric = new ESAggMetricField({ aggType: AGG_TYPE.COUNT });
     expect(countMetric.supportsFieldMeta()).toBe(false);
-    const sumMetric = new ESAggMetricField({ aggType: METRIC_TYPE.SUM });
+    const sumMetric = new ESAggMetricField({ aggType: AGG_TYPE.SUM });
     expect(sumMetric.supportsFieldMeta()).toBe(false);
-    const uniqueCountMetric = new ESAggMetricField({ aggType: METRIC_TYPE.UNIQUE_COUNT });
+    const uniqueCountMetric = new ESAggMetricField({ aggType: AGG_TYPE.UNIQUE_COUNT });
     expect(uniqueCountMetric.supportsFieldMeta()).toBe(false);
   });
 });

x-pack/legacy/plugins/maps/public/layers/sources/es_agg_source.js

@@ -8,8 +8,7 @@ import { AbstractESSource } from './es_source';
 import { ESAggMetricField } from '../fields/es_agg_field';
 import { ESDocField } from '../fields/es_doc_field';
 import {
-  METRIC_TYPE,
-  COUNT_AGG_TYPE,
+  AGG_TYPE,
   COUNT_PROP_LABEL,
   COUNT_PROP_NAME,
   FIELD_ORIGIN,
@@ -18,23 +17,6 @@ import {
 export const AGG_DELIMITER = '_of_';
 
 export class AbstractESAggSource extends AbstractESSource {
-  static METRIC_SCHEMA_CONFIG = {
-    group: 'metrics',
-    name: 'metric',
-    title: 'Value',
-    min: 1,
-    max: Infinity,
-    aggFilter: [
-      METRIC_TYPE.AVG,
-      METRIC_TYPE.COUNT,
-      METRIC_TYPE.MAX,
-      METRIC_TYPE.MIN,
-      METRIC_TYPE.SUM,
-      METRIC_TYPE.UNIQUE_COUNT,
-    ],
-    defaults: [{ schema: 'metric', type: METRIC_TYPE.COUNT }],
-  };
-
   constructor(descriptor, inspectorAdapters) {
     super(descriptor, inspectorAdapters);
     this._metricFields = this._descriptor.metrics
@@ -81,7 +63,7 @@ export class AbstractESAggSource extends AbstractESSource {
     if (metrics.length === 0) {
       metrics.push(
         new ESAggMetricField({
-          aggType: COUNT_AGG_TYPE,
+          aggType: AGG_TYPE.COUNT,
           source: this,
           origin: this.getOriginForField(),
         })
@@ -91,15 +73,23 @@ export class AbstractESAggSource extends AbstractESSource {
   }
 
   formatMetricKey(aggType, fieldName) {
-    return aggType !== COUNT_AGG_TYPE ? `${aggType}${AGG_DELIMITER}${fieldName}` : COUNT_PROP_NAME;
+    return aggType !== AGG_TYPE.COUNT ? `${aggType}${AGG_DELIMITER}${fieldName}` : COUNT_PROP_NAME;
   }
 
   formatMetricLabel(aggType, fieldName) {
-    return aggType !== COUNT_AGG_TYPE ? `${aggType} of ${fieldName}` : COUNT_PROP_LABEL;
+    return aggType !== AGG_TYPE.COUNT ? `${aggType} of ${fieldName}` : COUNT_PROP_LABEL;
   }
 
-  createMetricAggConfigs() {
-    return this.getMetricFields().map(esAggMetric => esAggMetric.makeMetricAggConfig());
+  getValueAggsDsl(indexPattern) {
+    const valueAggsDsl = {};
+    this.getMetricFields()
+      .filter(esAggMetric => {
+        return esAggMetric.getAggType() !== AGG_TYPE.COUNT;
+      })
+      .forEach(esAggMetric => {
+        valueAggsDsl[esAggMetric.getName()] = esAggMetric.getValueAggDsl(indexPattern);
+      });
+    return valueAggsDsl;
   }
 
   async getNumberFields() {