Normalize boost data

Author: JasonStoltz

x-pack/plugins/enterprise_search/public/applications/app_search/components/relevance_tuning/relevance_tuning_logic.test.ts

@@ -256,9 +256,25 @@ describe('RelevanceTuningLogic', () => {
     });
 
     describe('initializeRelevanceTuning', () => {
-      it('should make an API call and set state based on the response', async () => {
+      it('should make an API call and set state based on the normalized response', async () => {
         mount();
-        http.get.mockReturnValueOnce(Promise.resolve(relevanceTuningProps));
+        http.get.mockReturnValueOnce(
+          Promise.resolve({
+            ...relevanceTuningProps,
+            searchSettings: {
+              ...relevanceTuningProps.searchSettings,
+              boosts: {
+                foo: [
+                  {
+                    type: 'value' as BoostType,
+                    factor: 5,
+                    value: 5,
+                  },
+                ],
+              },
+            },
+          })
+        );
         jest.spyOn(RelevanceTuningLogic.actions, 'onInitializeRelevanceTuning');
 
         RelevanceTuningLogic.actions.initializeRelevanceTuning();
@@ -267,9 +283,21 @@ describe('RelevanceTuningLogic', () => {
         expect(http.get).toHaveBeenCalledWith(
           '/api/app_search/engines/test-engine/search_settings/details'
         );
-        expect(RelevanceTuningLogic.actions.onInitializeRelevanceTuning).toHaveBeenCalledWith(
-          relevanceTuningProps
-        );
+        expect(RelevanceTuningLogic.actions.onInitializeRelevanceTuning).toHaveBeenCalledWith({
+          ...relevanceTuningProps,
+          searchSettings: {
+            ...relevanceTuningProps.searchSettings,
+            boosts: {
+              foo: [
+                {
+                  type: 'value' as BoostType,
+                  factor: 5,
+                  value: ['5'],
+                },
+              ],
+            },
+          },
+        });
       });
 
       it('handles errors', async () => {

x-pack/plugins/enterprise_search/public/applications/app_search/components/relevance_tuning/relevance_tuning_logic.ts

@@ -8,21 +8,26 @@
 import { kea, MakeLogicType } from 'kea';
 import { omit, cloneDeep, isEmpty } from 'lodash';
 
+import { setSuccessMessage, flashAPIErrors } from '../../../shared/flash_messages';
 import { HttpLogic } from '../../../shared/http';
 import { Schema, SchemaConflicts } from '../../../shared/types';
-import { setSuccessMessage, flashAPIErrors } from '../../../shared/flash_messages';
 
-import { Result } from '../result/types';
 import { EngineLogic } from '../engine';
+import { Result } from '../result/types';
 
-import { BaseBoost, Boost, BoostType, SearchSettings } from './types';
 import {
   UPDATE_SUCCESS_MESSAGE,
   RESET_CONFIRMATION_MESSAGE,
   DELETE_SUCCESS_MESSAGE,
   DELETE_CONFIRMATION_MESSAGE,
 } from './constants';
-import { filterIfTerm, parseBoostCenter, removeBoostStateProps } from './utils';
+import { BaseBoost, Boost, BoostType, SearchSettings } from './types';
+import {
+  filterIfTerm,
+  parseBoostCenter,
+  removeBoostStateProps,
+  normalizeBoostValues,
+} from './utils';
 
 interface RelevanceTuningProps {
   searchSettings: SearchSettings;
@@ -60,8 +65,8 @@ interface RelevanceTuningActions {
     name: string,
     boostIndex: number,
     valueIndex: number,
-    value: string | number
-  ): { name: string; boostIndex: number; valueIndex: number; value: string | number };
+    value: string
+  ): { name: string; boostIndex: number; valueIndex: number; value: string };
   updateBoostCenter(
     name: string,
     boostIndex: number,
@@ -252,7 +257,13 @@ export const RelevanceTuningLogic = kea<
 
       try {
         const response = await http.get(url);
-        actions.onInitializeRelevanceTuning(response);
+        actions.onInitializeRelevanceTuning({
+          ...response,
+          searchSettings: {
+            ...response.searchSettings,
+            boosts: normalizeBoostValues(response.searchSettings.boosts),
+          },
+        });
       } catch (e) {
         flashAPIErrors(e);
       }

x-pack/plugins/enterprise_search/public/applications/app_search/components/relevance_tuning/types.ts

@@ -12,18 +12,19 @@ export interface BaseBoost {
   function?: string;
 }
 
-export interface Boost extends BaseBoost {
+// A boost that comes from the server, before we normalize it has a much looser schema
+export interface RawBoost extends BaseBoost {
   type: BoostType;
   newBoost?: boolean;
   center?: string | number;
-  value?: Array<string | number>;
+  value?: string | number | boolean | object | Array<string | number | boolean | object>;
   factor: number;
 }
 
-export interface BoostObject {
-  [key: string]: Boost[];
+// We normalize raw boosts to make them safer and easier to work with
+export interface Boost extends RawBoost {
+  value?: string[];
 }
-
 export interface SearchSettings {
   boosts: Record<string, Boost[]>;
   search_fields: Record<

x-pack/plugins/enterprise_search/public/applications/app_search/components/relevance_tuning/utils.test.ts

@@ -0,0 +1,80 @@
+/*
+ * 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 { BoostType } from './types';
+import { normalizeBoostValues } from './utils';
+
+describe('normalizeBoostValues', () => {
+  const boosts = {
+    foo: [
+      {
+        type: 'value' as BoostType,
+        factor: 9.5,
+        value: 1,
+      },
+      {
+        type: 'value' as BoostType,
+        factor: 9.5,
+        value: '1',
+      },
+      {
+        type: 'value' as BoostType,
+        factor: 9.5,
+        value: [1],
+      },
+      {
+        type: 'value' as BoostType,
+        factor: 9.5,
+        value: ['1'],
+      },
+      {
+        type: 'value' as BoostType,
+        factor: 9.5,
+        value: [
+          '1',
+          1,
+          '2',
+          2,
+          true,
+          {
+            b: 'a',
+          },
+          {},
+        ],
+      },
+    ],
+    bar: [
+      {
+        type: 'proximity' as BoostType,
+        factor: 9.5,
+      },
+    ],
+    sp_def: [
+      {
+        type: 'functional' as BoostType,
+        factor: 5,
+      },
+    ],
+  };
+
+  it('renders', () => {
+    expect(normalizeBoostValues(boosts)).toEqual({
+      bar: [{ factor: 9.5, type: 'proximity' }],
+      foo: [
+        { factor: 9.5, type: 'value', value: ['1'] },
+        { factor: 9.5, type: 'value', value: ['1'] },
+        { factor: 9.5, type: 'value', value: ['1'] },
+        { factor: 9.5, type: 'value', value: ['1'] },
+        {
+          factor: 9.5,
+          type: 'value',
+          value: ['1', '1', '2', '2', 'true', '[object Object]', '[object Object]'],
+        },
+      ],
+      sp_def: [{ type: 'functional', factor: 5 }],
+    });
+  });
+});

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

@@ -5,12 +5,12 @@
  * 2.0.
  */
 
-import { cloneDeep } from 'lodash';
+import { cloneDeep, omit } from 'lodash';
 
 import { NUMBER } from '../../../shared/constants/field_types';
 import { SchemaTypes } from '../../../shared/types';
 
-import { SearchSettings } from './types';
+import { RawBoost, Boost, SearchSettings, BoostType } from './types';
 
 // If the user hasn't entered a filter, then we can skip filtering the array entirely
 export const filterIfTerm = (array: string[], filterTerm: string): string[] => {
@@ -34,3 +34,30 @@ export const parseBoostCenter = (fieldType: SchemaTypes, value: string | number)
   }
   return value;
 };
+
+const toArray = <T>(v: T | T[]): T[] => (Array.isArray(v) ? v : [v]);
+const toString = <T>(v1: T) => String(v1);
+
+const normalizeBoostValue = (boost: RawBoost): Boost => {
+  if (!boost.hasOwnProperty('value')) {
+    // Can't simply do `return boost` here as TS can't infer the correct type
+    return omit(boost, 'value');
+  }
+
+  return {
+    ...boost,
+    type: boost.type as BoostType,
+    value: toArray(boost.value).map(toString),
+  };
+};
+
+// Data may have been set to invalid types directly via the public App Search API. Since these are invalid, we don't want to deal
+// with them as valid types in the UI. For that reason, we stringify all values here, as the data comes in.
+// Additionally, values can be in single values or in arrays.
+export const normalizeBoostValues = (boosts: Record<string, RawBoost[]>): Record<string, Boost[]> =>
+  Object.entries(boosts).reduce((newBoosts, [fieldName, boostList]) => {
+    return {
+      ...newBoosts,
+      [fieldName]: boostList.map(normalizeBoostValue),
+    };
+  }, {});