[App Search] Schema: Set up server routes, grand foray into shared/connected Kea logic

x-pack/plugins/enterprise_search/public/applications/app_search/components/engines/components/tables/utils.ts

@@ -10,7 +10,7 @@ import { EngineDetails } from '../../../engine/types';
 
 export const getConflictingEnginesFromConflictingField = (
   conflictingField: SchemaConflictFieldTypes
-): string[] => Object.values(conflictingField).flat();
+) => Object.values(conflictingField).flat() as string[];
 
 export const getConflictingEnginesFromSchemaConflicts = (
   schemaConflicts: SchemaConflicts

x-pack/plugins/enterprise_search/public/applications/app_search/components/schema/schema_meta_engine_logic.test.ts

@@ -0,0 +1,113 @@
+/*
+ * 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; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { LogicMounter, mockHttpValues } from '../../../__mocks__';
+
+import { nextTick } from '@kbn/test/jest';
+
+import { SchemaType } from '../../../shared/schema/types';
+
+import { MetaEngineSchemaLogic } from './schema_meta_engine_logic';
+
+describe('MetaEngineSchemaLogic', () => {
+  const { mount } = new LogicMounter(MetaEngineSchemaLogic);
+  const { http } = mockHttpValues;
+
+  const MOCK_RESPONSE = {
+    schema: {
+      some_text_field: SchemaType.Text,
+      some_number_field: SchemaType.Number,
+    },
+    fields: {
+      some_text_field: {
+        text: ['source-engine-a', 'source-engine-b'],
+      },
+    },
+    conflictingFields: {
+      some_number_field: {
+        number: ['source-engine-a'],
+        text: ['source-engine-b'],
+      },
+    },
+  };
+
+  const DEFAULT_VALUES = {
+    dataLoading: true,
+    schema: {},
+    fields: {},
+    conflictingFields: {},
+    conflictingFieldsCount: 0,
+    hasConflicts: false,
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('has expected default values', () => {
+    mount();
+    expect(MetaEngineSchemaLogic.values).toEqual(DEFAULT_VALUES);
+  });
+
+  describe('actions', () => {
+    describe('onMetaEngineSchemaLoad', () => {
+      it('stores the API response in state', () => {
+        mount();
+
+        MetaEngineSchemaLogic.actions.onMetaEngineSchemaLoad(MOCK_RESPONSE);
+
+        expect(MetaEngineSchemaLogic.values).toEqual({
+          ...DEFAULT_VALUES,
+          fields: MOCK_RESPONSE.fields,
+          conflictingFields: MOCK_RESPONSE.conflictingFields,
+          hasConflicts: true,
+          conflictingFieldsCount: 1,
+        });
+      });
+    });
+  });
+
+  describe('selectors', () => {
+    describe('conflictingFieldsCount', () => {
+      it('returns the number of conflicting fields', () => {
+        mount({ conflictingFields: { field_a: {}, field_b: {} } });
+        expect(MetaEngineSchemaLogic.values.conflictingFieldsCount).toEqual(2);
+      });
+    });
+
+    describe('hasConflictingFields', () => {
+      it('returns true when the conflictingFields obj has items', () => {
+        mount({ conflictingFields: { field_c: {} } });
+        expect(MetaEngineSchemaLogic.values.hasConflicts).toEqual(true);
+      });
+
+      it('returns false when the conflictingFields obj is empty', () => {
+        mount({ conflictingFields: {} });
+        expect(MetaEngineSchemaLogic.values.hasConflicts).toEqual(false);
+      });
+    });
+  });
+
+  describe('listeners', () => {
+    describe('loadSourceEngineSchema', () => {
+      it('calls the base loadSchema listener and onSchemaLoad', async () => {
+        http.get.mockReturnValueOnce(Promise.resolve(MOCK_RESPONSE));
+        mount();
+        jest.spyOn(MetaEngineSchemaLogic.actions, 'loadSchema');
+        jest.spyOn(MetaEngineSchemaLogic.actions, 'onMetaEngineSchemaLoad');
+
+        MetaEngineSchemaLogic.actions.loadMetaEngineSchema();
+        await nextTick();
+
+        expect(MetaEngineSchemaLogic.actions.loadSchema).toHaveBeenCalled();
+        expect(MetaEngineSchemaLogic.actions.onMetaEngineSchemaLoad).toHaveBeenCalledWith(
+          MOCK_RESPONSE
+        );
+      });
+    });
+  });
+});

x-pack/plugins/enterprise_search/public/applications/app_search/components/schema/schema_meta_engine_logic.ts

@@ -0,0 +1,66 @@
+/*
+ * 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; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { kea, MakeLogicType } from 'kea';
+
+import { SchemaBaseLogic, SchemaBaseValues, SchemaBaseActions } from './schema_base_logic';
+import { MetaEngineSchemaApiResponse } from './types';
+
+interface MetaEngineSchemaValues extends SchemaBaseValues {
+  fields: MetaEngineSchemaApiResponse['fields'];
+  conflictingFields: MetaEngineSchemaApiResponse['conflictingFields'];
+  conflictingFieldsCount: number;
+  hasConflicts: boolean;
+}
+
+interface MetaEngineSchemaActions extends SchemaBaseActions {
+  loadMetaEngineSchema(): void;
+  onMetaEngineSchemaLoad(response: MetaEngineSchemaApiResponse): MetaEngineSchemaApiResponse;
+}
+
+export const MetaEngineSchemaLogic = kea<
+  MakeLogicType<MetaEngineSchemaValues, MetaEngineSchemaActions>
+>({
+  path: ['enterprise_search', 'app_search', 'meta_engine_schema_logic'],
+  connect: {
+    values: [SchemaBaseLogic, ['dataLoading', 'schema']],
+    actions: [SchemaBaseLogic, ['loadSchema', 'setSchema']],
+  },
+  actions: {
+    loadMetaEngineSchema: true,
+    onMetaEngineSchemaLoad: (response) => response,
+  },
+  reducers: {
+    fields: [
+      {},
+      {
+        onMetaEngineSchemaLoad: (_, { fields }) => fields,
+      },
+    ],
+    conflictingFields: [
+      {},
+      {
+        onMetaEngineSchemaLoad: (_, { conflictingFields }) => conflictingFields,
+      },
+    ],
+  },
+  selectors: {
+    conflictingFieldsCount: [
+      (selectors) => [selectors.conflictingFields],
+      (conflictingFields) => Object.keys(conflictingFields).length,
+    ],
+    hasConflicts: [
+      (selectors) => [selectors.conflictingFieldsCount],
+      (conflictingFieldsCount) => conflictingFieldsCount > 0,
+    ],
+  },
+  listeners: ({ actions }) => ({
+    loadMetaEngineSchema: async () => {
+      await actions.loadSchema(actions.onMetaEngineSchemaLoad);
+    },
+  }),
+});

x-pack/plugins/enterprise_search/public/applications/shared/schema/types.ts

@@ -31,7 +31,7 @@ export type Schema = Record<string, SchemaType>;
 
 // This is a mapping of schema field types ("text", "number", "geolocation", "date")
 // to the names of source engines which utilize that type
-export type SchemaConflictFieldTypes = Record<SchemaType, string[]>;
+export type SchemaConflictFieldTypes = Partial<Record<SchemaType, string[]>>;
 
 export interface SchemaConflict {
   fieldTypes: SchemaConflictFieldTypes;