[Data] Provide datatable utility functions (#126572)

* Extract datatable utilities into a separate service
* Add getField utility function
* Add getFieldFormat utility function
* Add field format setter utility functions
* Add data view field setter utility functions
* Add getInterval utility function

src/plugins/data/common/datatable_utilities/datatable_utilities_service.test.ts

@@ -0,0 +1,123 @@
+/*
+ * 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 { createStubDataView } from 'src/plugins/data_views/common/mocks';
+import type { DataViewsContract } from 'src/plugins/data_views/common';
+import type { DatatableColumn } from 'src/plugins/expressions/common';
+import { FieldFormat } from 'src/plugins/field_formats/common';
+import { fieldFormatsMock } from 'src/plugins/field_formats/common/mocks';
+import type { AggsCommonStart } from '../search';
+import { DatatableUtilitiesService } from './datatable_utilities_service';
+
+describe('DatatableUtilitiesService', () => {
+  let aggs: jest.Mocked<AggsCommonStart>;
+  let dataViews: jest.Mocked<DataViewsContract>;
+  let datatableUtilitiesService: DatatableUtilitiesService;
+
+  beforeEach(() => {
+    aggs = {
+      createAggConfigs: jest.fn(),
+      types: { get: jest.fn() },
+    } as unknown as typeof aggs;
+    dataViews = {
+      get: jest.fn(),
+    } as unknown as typeof dataViews;
+
+    datatableUtilitiesService = new DatatableUtilitiesService(aggs, dataViews, fieldFormatsMock);
+  });
+
+  describe('clearField', () => {
+    it('should delete the field reference', () => {
+      const column = { meta: { field: 'foo' } } as DatatableColumn;
+
+      datatableUtilitiesService.clearField(column);
+
+      expect(column).not.toHaveProperty('meta.field');
+    });
+  });
+
+  describe('clearFieldFormat', () => {
+    it('should remove field format', () => {
+      const column = { meta: { params: { id: 'number' } } } as DatatableColumn;
+      datatableUtilitiesService.clearFieldFormat(column);
+
+      expect(column).not.toHaveProperty('meta.params');
+    });
+  });
+
+  describe('getDataView', () => {
+    it('should return a data view instance', async () => {
+      const column = { meta: { index: 'index' } } as DatatableColumn;
+      const dataView = {} as ReturnType<DataViewsContract['get']>;
+      dataViews.get.mockReturnValue(dataView);
+
+      await expect(datatableUtilitiesService.getDataView(column)).resolves.toBe(dataView);
+      expect(dataViews.get).toHaveBeenCalledWith('index');
+    });
+
+    it('should return undefined when there is no index metadata', async () => {
+      const column = { meta: {} } as DatatableColumn;
+
+      await expect(datatableUtilitiesService.getDataView(column)).resolves.toBeUndefined();
+      expect(dataViews.get).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('getField', () => {
+    it('should return a data view field instance', async () => {
+      const column = { meta: { field: 'field', index: 'index' } } as DatatableColumn;
+      const dataView = createStubDataView({ spec: {} });
+      const field = {};
+      spyOn(datatableUtilitiesService, 'getDataView').and.returnValue(dataView);
+      spyOn(dataView, 'getFieldByName').and.returnValue(field);
+
+      await expect(datatableUtilitiesService.getField(column)).resolves.toBe(field);
+      expect(dataView.getFieldByName).toHaveBeenCalledWith('field');
+    });
+
+    it('should return undefined when there is no field metadata', async () => {
+      const column = { meta: {} } as DatatableColumn;
+
+      await expect(datatableUtilitiesService.getField(column)).resolves.toBeUndefined();
+    });
+  });
+
+  describe('getFieldFormat', () => {
+    it('should deserialize field format', () => {
+      const column = { meta: { params: { id: 'number' } } } as DatatableColumn;
+      const fieldFormat = datatableUtilitiesService.getFieldFormat(column);
+
+      expect(fieldFormat).toBeInstanceOf(FieldFormat);
+    });
+  });
+
+  describe('getInterval', () => {
+    it('should return a histogram interval', () => {
+      const column = {
+        meta: { sourceParams: { params: { interval: '1d' } } },
+      } as unknown as DatatableColumn;
+
+      expect(datatableUtilitiesService.getInterval(column)).toBe('1d');
+    });
+  });
+
+  describe('setFieldFormat', () => {
+    it('should set new field format', () => {
+      const column = { meta: {} } as DatatableColumn;
+      const fieldFormat = fieldFormatsMock.deserialize({ id: 'number' });
+      datatableUtilitiesService.setFieldFormat(column, fieldFormat);
+
+      expect(column.meta.params).toEqual(
+        expect.objectContaining({
+          id: expect.anything(),
+          params: undefined,
+        })
+      );
+    });
+  });
+});

src/plugins/data/common/datatable_utilities/datatable_utilities_service.ts

@@ -0,0 +1,93 @@
+/*
+ * 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 { DataView, DataViewsContract, DataViewField } from 'src/plugins/data_views/common';
+import type { DatatableColumn } from 'src/plugins/expressions/common';
+import type { FieldFormatsStartCommon, FieldFormat } from 'src/plugins/field_formats/common';
+import type { AggsCommonStart, AggConfig, CreateAggConfigParams, IAggType } from '../search';
+
+export class DatatableUtilitiesService {
+  constructor(
+    private aggs: AggsCommonStart,
+    private dataViews: DataViewsContract,
+    private fieldFormats: FieldFormatsStartCommon
+  ) {
+    this.getAggConfig = this.getAggConfig.bind(this);
+    this.getDataView = this.getDataView.bind(this);
+    this.getField = this.getField.bind(this);
+    this.isFilterable = this.isFilterable.bind(this);
+  }
+
+  clearField(column: DatatableColumn): void {
+    delete column.meta.field;
+  }
+
+  clearFieldFormat(column: DatatableColumn): void {
+    delete column.meta.params;
+  }
+
+  async getAggConfig(column: DatatableColumn): Promise<AggConfig | undefined> {
+    const dataView = await this.getDataView(column);
+
+    if (!dataView) {
+      return;
+    }
+
+    const { aggs } = await this.aggs.createAggConfigs(
+      dataView,
+      column.meta.sourceParams && [column.meta.sourceParams as CreateAggConfigParams]
+    );
+
+    return aggs[0];
+  }
+
+  async getDataView(column: DatatableColumn): Promise<DataView | undefined> {
+    if (!column.meta.index) {
+      return;
+    }
+
+    return this.dataViews.get(column.meta.index);
+  }
+
+  async getField(column: DatatableColumn): Promise<DataViewField | undefined> {
+    if (!column.meta.field) {
+      return;
+    }
+
+    const dataView = await this.getDataView(column);
+    if (!dataView) {
+      return;
+    }
+
+    return dataView.getFieldByName(column.meta.field);
+  }
+
+  getFieldFormat(column: DatatableColumn): FieldFormat | undefined {
+    return this.fieldFormats.deserialize(column.meta.params);
+  }
+
+  getInterval(column: DatatableColumn): string | undefined {
+    const params = column.meta.sourceParams?.params as { interval: string } | undefined;
+
+    return params?.interval;
+  }
+
+  isFilterable(column: DatatableColumn): boolean {
+    if (column.meta.source !== 'esaggs') {
+      return false;
+    }
+
+    const aggType = this.aggs.types.get(column.meta.sourceParams?.type as string) as IAggType;
+
+    return Boolean(aggType.createFilter);
+  }
+
+  setFieldFormat(column: DatatableColumn, fieldFormat: FieldFormat): void {
+    column.meta.params = fieldFormat.toJSON();
+  }
+}

src/plugins/data/common/datatable_utilities/index.ts

@@ -0,0 +1,9 @@
+/*
+ * 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.
+ */
+
+export * from './datatable_utilities_service';

src/plugins/data/common/datatable_utilities/mock.ts

@@ -0,0 +1,22 @@
+/*
+ * 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 { DatatableUtilitiesService } from './datatable_utilities_service';
+
+export function createDatatableUtilitiesMock(): jest.Mocked<DatatableUtilitiesService> {
+  return {
+    clearField: jest.fn(),
+    clearFieldFormat: jest.fn(),
+    getAggConfig: jest.fn(),
+    getDataView: jest.fn(),
+    getField: jest.fn(),
+    getFieldFormat: jest.fn(),
+    isFilterable: jest.fn(),
+    setFieldFormat: jest.fn(),
+  } as unknown as jest.Mocked<DatatableUtilitiesService>;
+}

src/plugins/data/common/index.ts

@@ -10,6 +10,7 @@
 /* eslint-disable @kbn/eslint/no_export_all */
 
 export * from './constants';
+export * from './datatable_utilities';
 export * from './es_query';
 export * from './kbn_field_types';
 export * from './query';

src/plugins/data/common/mocks.ts

@@ -7,3 +7,4 @@
  */
 
 export * from '../../data_views/common/fields/fields.mocks';
+export * from './datatable_utilities/mock';

src/plugins/data/common/search/aggs/aggs_service.test.ts

@@ -206,11 +206,10 @@ describe('Aggs service', () => {
   describe('start()', () => {
     test('exposes proper contract', () => {
       const start = service.start(startDeps);
-      expect(Object.keys(start).length).toBe(4);
+      expect(Object.keys(start).length).toBe(3);
       expect(start).toHaveProperty('calculateAutoTimeExpression');
       expect(start).toHaveProperty('createAggConfigs');
       expect(start).toHaveProperty('types');
-      expect(start).toHaveProperty('datatableUtilities');
     });
 
     test('types registry returns uninitialized type providers', () => {

src/plugins/data/common/search/aggs/aggs_service.ts

@@ -17,7 +17,6 @@ import {
   getCalculateAutoTimeExpression,
 } from './';
 import { AggsCommonSetup, AggsCommonStart } from './types';
-import { getDatatableColumnUtilities } from './utils/datatable_column_meta';
 
 /** @internal */
 export const aggsRequiredUiSettings = [
@@ -67,11 +66,7 @@ export class AggsCommonService {
     };
   }
 
-  public start({
-    getConfig,
-    getIndexPattern,
-    isDefaultTimezone,
-  }: AggsCommonStartDependencies): AggsCommonStart {
+  public start({ getConfig }: AggsCommonStartDependencies): AggsCommonStart {
     const aggTypesStart = this.aggTypesRegistry.start();
     const calculateAutoTimeExpression = getCalculateAutoTimeExpression(getConfig);
 
@@ -86,11 +81,6 @@ export class AggsCommonService {
 
     return {
       calculateAutoTimeExpression,
-      datatableUtilities: getDatatableColumnUtilities({
-        getIndexPattern,
-        createAggConfigs,
-        aggTypesStart,
-      }),
       createAggConfigs,
       types: aggTypesStart,
     };

src/plugins/data/common/search/aggs/types.ts

@@ -7,7 +7,6 @@
  */
 
 import { Assign } from '@kbn/utility-types';
-import { DatatableColumn } from 'src/plugins/expressions';
 import { IndexPattern } from '../..';
 import {
   aggAvg,
@@ -88,7 +87,6 @@ import {
   CreateAggConfigParams,
   getCalculateAutoTimeExpression,
   METRIC_TYPES,
-  AggConfig,
   aggFilteredMetric,
   aggSinglePercentile,
 } from './';
@@ -111,11 +109,6 @@ export interface AggsCommonSetup {
 
 export interface AggsCommonStart {
   calculateAutoTimeExpression: ReturnType<typeof getCalculateAutoTimeExpression>;
-  datatableUtilities: {
-    getIndexPattern: (column: DatatableColumn) => Promise<IndexPattern | undefined>;
-    getAggConfig: (column: DatatableColumn) => Promise<AggConfig | undefined>;
-    isFilterable: (column: DatatableColumn) => boolean;
-  };
   createAggConfigs: (
     indexPattern: IndexPattern,
     configStates?: CreateAggConfigParams[]