[data views] composite runtime fields in api layer

packages/kbn-optimizer/limits.yml

@@ -100,7 +100,7 @@ pageLoadAssetSize:
   bfetch: 22837
   kibanaUtils: 79713
   data: 491273
-  dataViews: 41532
+  dataViews: 42532
   expressions: 140958
   fieldFormats: 65209
   kibanaReact: 74422

src/plugins/data_view_field_editor/public/open_editor.tsx

@@ -19,6 +19,7 @@ import {
   UsageCollectionStart,
   DataViewsPublicPluginStart,
   FieldFormatsStart,
+  RuntimeType,
 } from './shared_imports';
 
 import type { PluginStart, InternalFieldType, CloseEditor } from './types';
@@ -104,7 +105,12 @@ export const getFieldEditorOpener =
       }
 
       const isNewRuntimeField = !fieldName;
-      const isExistingRuntimeField = field && field.runtimeField && !field.isMapped;
+      const isExistingRuntimeField =
+        field &&
+        field.runtimeField &&
+        !field.isMapped &&
+        // treat composite field instances as mapped fields for field editing purposes
+        field.runtimeField.type !== ('composite' as RuntimeType);
       const fieldTypeToProcess: InternalFieldType =
         isNewRuntimeField || isExistingRuntimeField ? 'runtime' : 'concrete';
 

src/plugins/data_view_management/public/components/edit_index_pattern/indexed_fields_table/components/table/table.test.tsx

@@ -10,7 +10,7 @@ import React from 'react';
 import { shallow } from 'enzyme';
 import { DataView } from 'src/plugins/data_views/public';
 import { IndexedFieldItem } from '../../types';
-import { Table, renderFieldName, getConflictModalContent } from './table';
+import { Table, renderFieldName, getConflictModalContent, showDelete } from './table';
 import { overlayServiceMock, themeServiceMock } from 'src/core/public/mocks';
 
 const theme = themeServiceMock.createStartContract();
@@ -198,4 +198,42 @@ describe('Table', () => {
       })
     ).toMatchSnapshot();
   });
+
+  test('showDelete', () => {
+    const runtimeFields = [
+      {
+        name: 'customer',
+        info: [],
+        excluded: false,
+        kbnType: 'string',
+        type: 'keyword',
+        isMapped: false,
+        isUserEditable: true,
+        hasRuntime: true,
+        runtimeField: {
+          type: 'keyword',
+        },
+      },
+      {
+        name: 'thing',
+        info: [],
+        excluded: false,
+        kbnType: 'string',
+        type: 'keyword',
+        isMapped: false,
+        isUserEditable: true,
+        hasRuntime: true,
+        runtimeField: {
+          type: 'composite',
+        },
+      },
+    ] as IndexedFieldItem[];
+
+    // indexed field
+    expect(showDelete(items[0])).toBe(false);
+    // runtime field - primitive type
+    expect(showDelete(runtimeFields[0])).toBe(true);
+    // runtime field - composite type
+    expect(showDelete(runtimeFields[1])).toBe(false);
+  });
 });

src/plugins/data_view_management/public/components/edit_index_pattern/indexed_fields_table/components/table/table.tsx

@@ -33,6 +33,9 @@ import { toMountPoint } from '../../../../../../../kibana_react/public';
 import { DataView } from '../../../../../../../data_views/public';
 import { IndexedFieldItem } from '../../types';
 
+export const showDelete = (field: IndexedFieldItem) =>
+  !field.isMapped && field.isUserEditable && field.runtimeField?.type !== 'composite';
+
 // localized labels
 const additionalInfoAriaLabel = i18n.translate(
   'indexPatternManagement.editIndexPattern.fields.table.additionalInfoAriaLabel',
@@ -454,7 +457,7 @@ export class Table extends PureComponent<IndexedFieldProps> {
             onClick: (field) => deleteField(field.name),
             type: 'icon',
             'data-test-subj': 'deleteField',
-            available: (field) => !field.isMapped && field.isUserEditable,
+            available: showDelete,
           },
         ],
         width: '40px',

src/plugins/data_view_management/public/components/edit_index_pattern/indexed_fields_table/indexed_fields_table.test.tsx

@@ -94,6 +94,8 @@ const fields = [
     name: 'runtime',
     displayName: 'runtime',
     runtimeField,
+    esTypes: ['long'],
+    type: 'number',
   },
 ].map(mockFieldToIndexPatternField);
 

src/plugins/data_views/common/constants.ts

@@ -14,6 +14,7 @@ export const RUNTIME_FIELD_TYPES = [
   'ip',
   'boolean',
   'geo_point',
+  'composite',
 ] as const;
 
 /**

src/plugins/data_views/common/data_views/data_view.test.ts

@@ -16,7 +16,7 @@ import { IndexPatternField } from '../fields';
 
 import { fieldFormatsMock } from '../../../field_formats/common/mocks';
 import { FieldFormat } from '../../../field_formats/common';
-import { RuntimeField } from '../types';
+import { RuntimeField, RuntimeTypeExceptComposite } from '../types';
 import { stubLogstashFields } from '../field.stub';
 import { stubbedSavedObjectIndexPattern } from '../data_view.stub';
 
@@ -37,6 +37,8 @@ const runtimeField = {
   name: 'runtime_field',
   runtimeField: runtimeFieldScript,
   scripted: false,
+  esTypes: ['keyword'],
+  type: 'string',
 };
 
 fieldFormatsMock.getInstance = jest.fn().mockImplementation(() => new MockFieldFormatter()) as any;
@@ -223,20 +225,80 @@ describe('IndexPattern', () => {
       },
     };
 
+    const runtimeWithAttrs = {
+      ...runtime,
+      popularity: 5,
+      customLabel: 'custom name',
+      format: {
+        id: 'bytes',
+      },
+    };
+
+    const runtimeComposite = {
+      type: 'composite' as RuntimeField['type'],
+      script: {
+        source: "emit('hello world');",
+      },
+      fields: {
+        a: {
+          type: 'keyword' as RuntimeTypeExceptComposite,
+        },
+        b: {
+          type: 'long' as RuntimeTypeExceptComposite,
+        },
+      },
+    };
+
+    const runtimeCompositeWithAttrs = {
+      type: runtimeComposite.type,
+      script: runtimeComposite.script,
+      fields: {
+        a: {
+          ...runtimeComposite.fields.a,
+          popularity: 3,
+          customLabel: 'custom name a',
+          format: {
+            id: 'bytes',
+          },
+        },
+        b: {
+          ...runtimeComposite.fields.b,
+          popularity: 4,
+          customLabel: 'custom name b',
+          format: {
+            id: 'bytes',
+          },
+        },
+      },
+    };
+
     beforeEach(() => {
       const formatter = {
         toJSON: () => ({ id: 'bytes' }),
       } as FieldFormat;
       indexPattern.getFormatterForField = () => formatter;
+      indexPattern.getFormatterForFieldNoDefault = () => undefined;
     });
 
     test('add and remove runtime field to existing field', () => {
-      indexPattern.addRuntimeField('@tags', runtime);
+      indexPattern.addRuntimeField('@tags', runtimeWithAttrs);
       expect(indexPattern.toSpec().runtimeFieldMap).toEqual({
         '@tags': runtime,
         runtime_field: runtimeField.runtimeField,
       });
-      expect(indexPattern.toSpec()!.fields!['@tags'].runtimeField).toEqual(runtime);
+      const field = indexPattern.toSpec()!.fields!['@tags'];
+      expect(field.runtimeField).toEqual(runtime);
+      expect(field.count).toEqual(5);
+      expect(field.format).toEqual({
+        id: 'bytes',
+      });
+      expect(field.customLabel).toEqual('custom name');
+      expect(indexPattern.toSpec().fieldAttrs).toEqual({
+        '@tags': {
+          customLabel: 'custom name',
+          count: 5,
+        },
+      });
 
       indexPattern.removeRuntimeField('@tags');
       expect(indexPattern.toSpec().runtimeFieldMap).toEqual({
@@ -246,11 +308,12 @@ describe('IndexPattern', () => {
     });
 
     test('add and remove runtime field as new field', () => {
-      indexPattern.addRuntimeField('new_field', runtime);
+      indexPattern.addRuntimeField('new_field', runtimeWithAttrs);
       expect(indexPattern.toSpec().runtimeFieldMap).toEqual({
         runtime_field: runtimeField.runtimeField,
         new_field: runtime,
       });
+      expect(indexPattern.getRuntimeField('new_field')).toMatchSnapshot();
       expect(indexPattern.toSpec()!.fields!.new_field.runtimeField).toEqual(runtime);
 
       indexPattern.removeRuntimeField('new_field');
@@ -260,6 +323,35 @@ describe('IndexPattern', () => {
       expect(indexPattern.toSpec()!.fields!.new_field).toBeUndefined();
     });
 
+    test('add and remove composite runtime field as new fields', () => {
+      const fieldCount = indexPattern.fields.length;
+      indexPattern.addRuntimeField('new_field', runtimeCompositeWithAttrs);
+      expect(indexPattern.toSpec().runtimeFieldMap).toEqual({
+        runtime_field: runtimeField.runtimeField,
+        new_field: runtimeComposite,
+      });
+      expect(indexPattern.fields.length - fieldCount).toEqual(2);
+      expect(indexPattern.getRuntimeField('new_field')).toMatchSnapshot();
+      expect(indexPattern.toSpec()!.fields!['new_field.a']).toBeDefined();
+      expect(indexPattern.toSpec()!.fields!['new_field.b']).toBeDefined();
+      expect(indexPattern.toSpec()!.fieldAttrs).toEqual({
+        'new_field.a': {
+          count: 3,
+          customLabel: 'custom name a',
+        },
+        'new_field.b': {
+          count: 4,
+          customLabel: 'custom name b',
+        },
+      });
+
+      indexPattern.removeRuntimeField('new_field');
+      expect(indexPattern.toSpec().runtimeFieldMap).toEqual({
+        runtime_field: runtimeField.runtimeField,
+      });
+      expect(indexPattern.toSpec()!.fields!.new_field).toBeUndefined();
+    });
+
     test('should not allow runtime field with * in name', async () => {
       try {
         await indexPattern.addRuntimeField('test*123', runtime);