@blaze-cms/react-page-builder 0.132.0 → 0.133.0-admin-updates.0

package/tests/unit/src/helpers/build-raw-query.test.js

@@ -43,17 +43,17 @@ describe('build raw query', () => {
     id,
     itemsToDisplay
   } = MOCKED_ARGS;
-  const rawQuery = buildRawQuery(
+  const rawQuery = buildRawQuery({
     docType,
     operator,
-    {
+    searchValues: {
       searchValuesText,
       searchValuesCheckboxSelectRange,
       searchValuesCheckboxOr: searchValuesCheckboxOrEmpty
     },
     filterData,
     id
-  );
+  });
 
   it('should always return an object', () => {
     expect(typeof rawQuery).toBe('object');
@@ -64,65 +64,65 @@ describe('build raw query', () => {
   });
 
   it('should return an object with only checkbox & select search values', () => {
-    const rawQueryCheckboxSelect = buildRawQuery(
+    const rawQueryCheckboxSelect = buildRawQuery({
       docType,
       operator,
-      {
+      searchValues: {
         searchValuesText: SEARCH_VALUES_TEXT_EMPTY,
         searchValuesCheckboxSelectRange: SEARCH_VALUES_CHECKBOX_SELECT,
         searchValuesCheckboxOr: searchValuesCheckboxOrEmpty
       },
       filterData,
       id
-    );
+    });
 
     expect(rawQueryCheckboxSelect).toEqual(RAW_QUERY_CHECKBOX_SELECT);
   });
 
   it('should return an object with only checkbox & select search values when checkbox has OR operator', () => {
-    const rawQueryCheckboxSelect = buildRawQuery(
+    const rawQueryCheckboxSelect = buildRawQuery({
       docType,
       operator,
-      {
+      searchValues: {
         searchValuesText: SEARCH_VALUES_TEXT_EMPTY,
         searchValuesCheckboxSelectRange: SEARCH_VALUES_CHECKBOX_SELECT,
         searchValuesCheckboxOr
       },
       filterData,
       id
-    );
+    });
 
     expect(rawQueryCheckboxSelect).toEqual(RAW_QUERY_CHECKBOX_SELECT_CHECKBOX_HAS_OR_OPERATOR);
   });
 
   it('should return an object with all search values (checkbox, select, text) - and same operator', () => {
-    const rawQueryCheckboxSelectTextSameOp = buildRawQuery(
+    const rawQueryCheckboxSelectTextSameOp = buildRawQuery({
       docType,
-      AND_OPERATOR,
-      {
+      operator: AND_OPERATOR,
+      searchValues: {
         searchValuesText: SEARCH_VALUES_TEXT,
         searchValuesCheckboxSelectRange: SEARCH_VALUES_CHECKBOX_SELECT,
         searchValuesCheckboxOr: searchValuesCheckboxOrEmpty
       },
       filterData,
       id
-    );
+    });
 
     expect(rawQueryCheckboxSelectTextSameOp).toEqual(RAW_QUERY_ALL_SEARCH_VALUE_SAME_OPERATOR);
   });
 
   it('should return an object with all search values (checkbox, select, text) - and different operator', () => {
-    const rawQueryCheckboxSelectTextDifferentOp = buildRawQuery(
+    const rawQueryCheckboxSelectTextDifferentOp = buildRawQuery({
       docType,
       operator,
-      {
+      searchValues: {
         searchValuesText: SEARCH_VALUES_TEXT,
         searchValuesCheckboxSelectRange: SEARCH_VALUES_CHECKBOX_SELECT,
         searchValuesCheckboxOr: searchValuesCheckboxOrEmpty
       },
       filterData,
       id
-    );
+    });
 
     expect(rawQueryCheckboxSelectTextDifferentOp).toEqual(
       RAW_QUERY_ALL_SEARCH_VALUE_DIFFERENT_OPERATOR
@@ -130,17 +130,17 @@ describe('build raw query', () => {
   });
 
   it('should return an object with all search values (checkbox, select, text) - same operator for text and checkbox with OR operator', () => {
-    const rawQueryCheckboxSelectTextSameOp = buildRawQuery(
+    const rawQueryCheckboxSelectTextSameOp = buildRawQuery({
       docType,
-      AND_OPERATOR,
-      {
+      operator: AND_OPERATOR,
+      searchValues: {
         searchValuesText: SEARCH_VALUES_TEXT,
         searchValuesCheckboxSelectRange: SEARCH_VALUES_CHECKBOX_SELECT,
         searchValuesCheckboxOr
       },
       filterData,
       id
-    );
+    });
 
     expect(rawQueryCheckboxSelectTextSameOp).toEqual(
       RAW_QUERY_ALL_SEARCH_VALUE_SAME_OPERATOR_TEXT_CHECKBOX_HAS_OR_OPERATOR
@@ -148,17 +148,17 @@ describe('build raw query', () => {
   });
 
   it('should return an object with all search values (checkbox, select, text) - and different operator for text and checkbox with OR operator', () => {
-    const rawQueryCheckboxSelectTextDifferentOp = buildRawQuery(
+    const rawQueryCheckboxSelectTextDifferentOp = buildRawQuery({
       docType,
       operator,
-      {
+      searchValues: {
         searchValuesText: SEARCH_VALUES_TEXT,
         searchValuesCheckboxSelectRange: SEARCH_VALUES_CHECKBOX_SELECT,
         searchValuesCheckboxOr
       },
       filterData,
       id
-    );
+    });
 
     expect(rawQueryCheckboxSelectTextDifferentOp).toEqual(
       RAW_QUERY_ALL_SEARCH_VALUE_DIFFERENT_OPERATOR_TEXT_CHECKBOX_HAS_OR_OPERATOR
@@ -166,15 +166,15 @@ describe('build raw query', () => {
   });
 
   it('should return an object with featured & sponsored filter set on list', () => {
-    const rawQueryMoreCheckboxFilters = buildRawQuery(
+    const rawQueryMoreCheckboxFilters = buildRawQuery({
       docType,
       operator,
-      {
+      searchValues: {
         searchValuesText,
         searchValuesCheckboxSelectRange,
         searchValuesCheckboxOr: searchValuesCheckboxOrEmpty
       },
-      {
+      filterData: {
         filterValues: { checkboxFilters: ['featured', 'sponsored'], listFilterValues: {} },
         filterOperator: AND,
         relations: [],
@@ -182,42 +182,42 @@ describe('build raw query', () => {
         azFilter: 'x'
       },
       id
-    );
+    });
 
     expect(rawQueryMoreCheckboxFilters).toEqual(RAW_QUERY_CHECKBOX_FILTERS);
   });
 
   it('should return an object with just one checkbox filter set on list', () => {
-    const rawQueryOneCheckboxFilter = buildRawQuery(
+    const rawQueryOneCheckboxFilter = buildRawQuery({
       docType,
       operator,
-      {
+      searchValues: {
         searchValuesText,
         searchValuesCheckboxSelectRange,
         searchValuesCheckboxOr: searchValuesCheckboxOrEmpty
       },
-      {
+      filterData: {
         filterValues: { checkboxFilters: ['sponsored'], listFilterValues: {} },
         filterOperator: AND,
         relations: [],
         stringProps: []
       },
       id
-    );
+    });
 
     expect(rawQueryOneCheckboxFilter).toEqual(RAW_QUERY_ONE_CHECKBOX_FILTERS);
   });
 
   it('should return an object with just one checkbox filter set on list & other filter values', () => {
-    const rawQueryOneCheckboxFilterMoreValues = buildRawQuery(
+    const rawQueryOneCheckboxFilterMoreValues = buildRawQuery({
       docType,
       operator,
-      {
+      searchValues: {
         searchValuesText,
         searchValuesCheckboxSelectRange,
         searchValuesCheckboxOr: searchValuesCheckboxOrEmpty
       },
-      {
+      filterData: {
         filterValues: {
           checkboxFilters: ['sponsored'],
           listFilterValues: {
@@ -230,7 +230,7 @@ describe('build raw query', () => {
         stringProps: ['name', 'category.name']
       },
       id
-    );
+    });
 
     expect(rawQueryOneCheckboxFilterMoreValues).toEqual(
       RAW_QUERY_ONE_CHECKBOX_FILTERS_AND_OTHER_FILTERS
@@ -238,15 +238,15 @@ describe('build raw query', () => {
   });
 
   it('should return an object with just one checkbox filter set on list & other filter values plus itemsToDIsplayIds', () => {
-    const rawQueryOneCheckboxFilterMoreItemsToDisplayValues = buildRawQuery(
+    const rawQueryOneCheckboxFilterMoreItemsToDisplayValues = buildRawQuery({
       docType,
       operator,
-      {
+      searchValues: {
         searchValuesText,
         searchValuesCheckboxSelectRange,
         searchValuesCheckboxOr: searchValuesCheckboxOrEmpty
       },
-      {
+      filterData: {
         filterValues: {
           checkboxFilters: ['sponsored'],
           listFilterValues: {
@@ -261,21 +261,21 @@ describe('build raw query', () => {
       },
       id,
       itemsToDisplay
-    );
+    });
 
     expect(rawQueryOneCheckboxFilterMoreItemsToDisplayValues).toEqual(RAW_QUERY_ITEMS_TO_DISPLAY);
   });
 
   it('should return an object with just one checkbox filter set on list & other filter values when the filter operator is OR', () => {
-    const rawQueryOneCheckboxFilterMoreValues = buildRawQuery(
+    const rawQueryOneCheckboxFilterMoreValues = buildRawQuery({
       docType,
       operator,
-      {
+      searchValues: {
         searchValuesText,
         searchValuesCheckboxSelectRange,
         searchValuesCheckboxOr: searchValuesCheckboxOrEmpty
       },
-      {
+      filterData: {
         filterValues: {
           checkboxFilters: ['featured'],
           listFilterValues: { 'authors.firstname': ['John', 'Paul'], price: ['33'] }
@@ -285,7 +285,7 @@ describe('build raw query', () => {
         stringProps: ['author.firstname']
       },
       id
-    );
+    });
 
     expect(rawQueryOneCheckboxFilterMoreValues).toEqual(
       RAW_QUERY_ONE_CHECKBOX_FILTERS_AND_OTHER_FILTERS_OR_OPERATOR
@@ -293,15 +293,15 @@ describe('build raw query', () => {
   });
 
   it('should return an object with just one checkbox filter set on list & other filter values when the filter operator is OR plus itemsToDIsplayIds', () => {
-    const rawQueryOneCheckboxFilterMoreItemsToDisplayValues = buildRawQuery(
+    const rawQueryOneCheckboxFilterMoreItemsToDisplayValues = buildRawQuery({
       docType,
       operator,
-      {
+      searchValues: {
         searchValuesText,
         searchValuesCheckboxSelectRange,
         searchValuesCheckboxOr: searchValuesCheckboxOrEmpty
       },
-      {
+      filterData: {
         filterValues: {
           checkboxFilters: ['sponsored'],
           listFilterValues: { metaTitle: ['meta', 'more-meta'], slug: ['slug-link'] }
@@ -312,7 +312,7 @@ describe('build raw query', () => {
       },
       id,
       itemsToDisplay
-    );
+    });
 
     expect(rawQueryOneCheckboxFilterMoreItemsToDisplayValues).toEqual(
       RAW_QUERY_OR_OPERATOR_ITEMS_TO_DISPLAY
@@ -320,15 +320,15 @@ describe('build raw query', () => {
   });
 
   it('should return corresponding query when there are items to display and should apply sort is passed as true', () => {
-    const rawQueryWithShouldApplySort = buildRawQuery(
+    const rawQueryWithShouldApplySort = buildRawQuery({
       docType,
       operator,
-      {
+      searchValues: {
         searchValuesText,
         searchValuesCheckboxSelectRange,
         searchValuesCheckboxOr: searchValuesCheckboxOrEmpty
       },
-      {
+      filterData: {
         filterValues: {
           checkboxFilters: ['sponsored'],
           listFilterValues: { url: ['/url', '/alternative-url'], date: ['29-03-2020'] }
@@ -339,28 +339,52 @@ describe('build raw query', () => {
       },
       id,
       itemsToDisplay,
-      true
-    );
+      shouldApplySort: true
+    });
 
     expect(rawQueryWithShouldApplySort).toEqual(RAW_QUERY_WITH_SHOULD_APPLY_SORT);
   });
 
   it('should return query with aggs if requested', () => {
-    const queryWithAggs = buildRawQuery(
+    const queryWithAggs = buildRawQuery({
       docType,
       operator,
-      {
+      searchValues: {
         searchValuesText,
         searchValuesCheckboxSelectRange,
         searchValuesCheckboxOr: searchValuesCheckboxOrEmpty
       },
       filterData,
       id,
-      [],
-      true,
-      { shouldReturnAggs: true, isAZ: true }
-    );
+      itemsToDisplay: [],
+      shouldApplySort: true,
+      azOptions: { shouldReturnAggs: true, isAZ: true }
+    });
 
     expect(queryWithAggs).toEqual(RAW_QUERY_WITH_AGGS);
   });
+
+  it('should return query with aggs if requested using custom az param', () => {
+    const customProperty = 'lastname';
+    const queryWithAggs = buildRawQuery({
+      docType,
+      operator,
+      searchValues: {
+        searchValuesText,
+        searchValuesCheckboxSelectRange,
+        searchValuesCheckboxOr: searchValuesCheckboxOrEmpty
+      },
+      filterData,
+      id,
+      itemsToDisplay: [],
+      shouldApplySort: true,
+      azOptions: {
+        shouldReturnAggs: true,
+        isAZ: true,
+        sortProperties: [{ propsToDisplay: [customProperty] }]
+      }
+    });
+
+    expect(JSON.stringify(queryWithAggs)).toContain(`${customProperty}.keyword`);
+  });
 });

package/tests/unit/src/helpers/build-sort-values.test.js

@@ -0,0 +1,34 @@
+import '@testing-library/jest-dom/extend-expect';
+import buildSortValues from '../../../../src/helpers/build-sort-values';
+
+describe('buildSortValues helper function', () => {
+  it('should return an object with empty sort array if no sortFilters are passed', () => {
+    const noSort = buildSortValues();
+    const emptySortFilters = buildSortValues([]);
+    expect(noSort).toEqual({ sort: [] });
+    expect(emptySortFilters).toEqual({ sort: [] });
+  });
+
+  it('should return null if no sortFilters are passed and useSortObject is true', () => {
+    const noSortUseSortObject = buildSortValues(null, [], [], true);
+    const emptySortFiltersUseSortObject = buildSortValues([], [], [], true);
+    expect(noSortUseSortObject).toEqual(null);
+    expect(emptySortFiltersUseSortObject).toEqual(null);
+  });
+
+  it('should return sort object if useSortObject is true and sortFilters match', () => {
+    const withUseSortObject = buildSortValues(
+      [
+        {
+          propsToDisplay: ['slug'],
+          sort: 'ASC',
+          label: ''
+        }
+      ],
+      [],
+      ['name', 'slug', 'metaTitle'],
+      true
+    );
+    expect(withUseSortObject).toEqual({ 'slug.keyword': 'asc' });
+  });
+});

package/tests/unit/src/helpers/get-extra-az-bits.test.js

@@ -1,21 +1,51 @@
+import { AZ_DEFAULT_PROP } from '../../../../src/constants';
 import getExtraAzBits from '../../../../src/helpers/get-extra-az-bits';
-import { AZ_AGGS, ALL_AZ_SORT } from '../../../../src/constants';
 
 describe('getExtraAzBits helper function', () => {
+  // shouldReturnAggs, isAZ, azSortProperty, azFilter
+  const customProperty = 'lastname';
+
   it('should return empty object if isAz is false', () => {
-    const noExtraBits = getExtraAzBits(false, false);
+    const noExtraBits = getExtraAzBits({ shouldReturnAggs: false, isAZ: false });
     const noExtraBits2 = getExtraAzBits(false, true, 'a');
     expect(noExtraBits).toEqual({});
     expect(noExtraBits2).toEqual({});
   });
 
   it('should return AZ_AGGS if shouldReturnAggs and isAz is true', () => {
-    const withAggs = getExtraAzBits(true, true);
-    expect(withAggs).toEqual(AZ_AGGS);
+    const withAggs = getExtraAzBits({ shouldReturnAggs: true, isAZ: true });
+    propertyCheck(withAggs);
+    expect(withAggs).toMatchSnapshot();
   });
 
   it('should return ALL_AZ_SORT if shouldReturnAggs is false and is Az and no Az filter is passed', () => {
-    const withAggs = getExtraAzBits(false, true, '');
-    expect(withAggs).toEqual(ALL_AZ_SORT);
+    const withAggs = getExtraAzBits({ shouldReturnAggs: false, isAZ: true, azFilter: '' });
+    propertyCheck(withAggs);
+    expect(withAggs).toMatchSnapshot();
+  });
+
+  it('should return AZ_AGGS if shouldReturnAggs and isAz is true with custom property', () => {
+    const withAggs = getExtraAzBits({
+      shouldReturnAggs: true,
+      isAZ: true,
+      azSortProperty: customProperty
+    });
+    propertyCheck(withAggs, customProperty);
+    expect(withAggs).toMatchSnapshot();
+  });
+
+  it('should return ALL_AZ_SORT if shouldReturnAggs is false and is Az and no Az filter is passed with custom property', () => {
+    const withAggs = getExtraAzBits({
+      shouldReturnAggs: false,
+      isAZ: true,
+      azFilter: '',
+      azSortProperty: customProperty
+    });
+    propertyCheck(withAggs, customProperty);
+    expect(withAggs).toMatchSnapshot();
   });
 });
+
+function propertyCheck(result, property = AZ_DEFAULT_PROP) {
+  expect(JSON.stringify(result)).toContain(`${property}.keyword`);
+}

package/tests/unit/src/helpers/get-generic-render-variables.test.js

@@ -1,8 +1,6 @@
 import '@testing-library/jest-dom/extend-expect';
 import getGenericRenderVariables from '../../../../src/helpers/get-generic-render-variables';
 
-const IS_TEXT_SEARCH_FILTER_APPLIED_TRUE = true;
-const IS_TEXT_SEARCH_FILTER_APPLIED_FALSE = false;
 const RAW_QUERY_STRINGIFIED = '{}';
 const SORT_VALUE = 'updated:desc';
 const STRING_PROPS_EMPTY = [];
@@ -18,88 +16,87 @@ const mockedProps = overrides => ({
 
 describe('get card/list render variables', () => {
   it('should always return an object', () => {
-    const variables = getGenericRenderVariables();
-    const variablesWithProps = getGenericRenderVariables([], mockedProps(), STRING_PROPS_EMPTY);
+    const variables = getGenericRenderVariables({});
+    const variablesWithProps = getGenericRenderVariables({
+      relations: [],
+      filterProps: mockedProps(),
+      stringProps: STRING_PROPS_EMPTY
+    });
 
     expect(typeof variables).toBe('object');
     expect(typeof variablesWithProps).toBe('object');
   });
 
   it('should return an object with correct data', () => {
-    const { limit, sort, offset } = getGenericRenderVariables(
-      [],
-      mockedProps(),
-      STRING_PROPS_EMPTY
-    );
+    const { limit, sort, offset } = getGenericRenderVariables({
+      relations: [],
+      filterProps: mockedProps(),
+      stringProps: STRING_PROPS_EMPTY
+    });
 
     expect(limit).toEqual(50);
     expect(offset).toEqual(2);
     expect(sort).toEqual(SORT_VALUE);
   });
 
-  it('should return an object with sort being undefined when text-search filter applied', () => {
-    const { sort } = getGenericRenderVariables(
-      [],
-      mockedProps(),
-      STRING_PROPS_EMPTY,
-      RAW_QUERY_STRINGIFIED,
-      IS_TEXT_SEARCH_FILTER_APPLIED_TRUE
-    );
-
-    expect(sort).toBeFalsy();
-  });
-
   it('should return an object with correct sort when text-search filter not applied', () => {
-    const { sort } = getGenericRenderVariables(
-      [],
-      mockedProps(),
-      STRING_PROPS_EMPTY,
-      RAW_QUERY_STRINGIFIED,
-      IS_TEXT_SEARCH_FILTER_APPLIED_FALSE
-    );
+    const { sort } = getGenericRenderVariables({
+      relations: [],
+      filterProps: mockedProps(),
+      stringProps: STRING_PROPS_EMPTY,
+      rawQuery: RAW_QUERY_STRINGIFIED,
+      isTextSearchFilterApplied: false
+    });
 
     expect(sort).toEqual(SORT_VALUE);
   });
 
   it('should return an object with correct data when no arguments passed to function', () => {
-    const { sort, offset } = getGenericRenderVariables();
-
+    const { sort, offset } = getGenericRenderVariables({});
     expect(sort).toBeFalsy();
     expect(offset).toEqual(0);
   });
 
   it('should return an object with correct data when no sortby is passed', () => {
-    const { sort, offset } = getGenericRenderVariables(mockedProps({ sortby: [] }));
+    const { sort, offset } = getGenericRenderVariables({ relations: mockedProps({ sortby: [] }) });
 
     expect(sort).toBeFalsy();
     expect(offset).toEqual(0);
   });
 
   it('should return correct sort data when we pass an array', () => {
-    const { sort } = getGenericRenderVariables(
-      [],
-      mockedProps({ sortby: ['length'] }),
-      STRING_PROPS_EMPTY
-    );
+    const { sort } = getGenericRenderVariables({
+      relations: [],
+      filterProps: mockedProps({ sortby: ['length'] }),
+      stringProps: STRING_PROPS_EMPTY
+    });
     expect(sort).toEqual('length:desc');
   });
 
   it('should return correct sort data when when there is a prop that is of type string', () => {
-    const { sort } = getGenericRenderVariables([], mockedProps({ sortby: 'name' }), STRING_PROPS);
+    const { sort } = getGenericRenderVariables({
+      relations: [],
+      filterProps: mockedProps({ sortby: 'name' }),
+      stringProps: STRING_PROPS
+    });
     expect(sort).toEqual('name.keyword:desc');
   });
 
   it('should return correct sort data sortby is an array', () => {
-    const { sort } = getGenericRenderVariables([], mockedProps({ sortby: ['name'] }), STRING_PROPS);
+    const { sort } = getGenericRenderVariables({
+      relations: [],
+      filterProps: mockedProps({ sortby: ['name'] }),
+      stringProps: STRING_PROPS
+    });
     expect(sort).toEqual('name.keyword:desc');
   });
 
   it("should return correct sort data when when there is a prop that is of type string and it's also a relation prop", () => {
-    const { sort } = getGenericRenderVariables(
-      [{ localField: 'entity', entityIdentifier: 'entity' }],
-      mockedProps({ sortby: 'entity.name', sort: 'ASC' }),
-      ['entity.name']
-    );
+    const { sort } = getGenericRenderVariables({
+      relations: [{ localField: 'entity', entityIdentifier: 'entity' }],
+      filterProps: mockedProps({ sortby: 'entity.name', sort: 'ASC' }),
+      stringProps: ['entity.name']
+    });
 
     expect(sort).toEqual('entity.name.keyword:asc');
   });
@@ -107,21 +104,21 @@ describe('get card/list render variables', () => {
   it("should return correct sort data when when there is a prop that is not of type string but it's a relation prop", () => {
     const localField = 'entityField';
     const sortby = `${localField}.length`;
-    const { sort } = getGenericRenderVariables(
-      [{ localField, entityIdentifier: 'entity' }],
-      mockedProps({ sortby, sort: 'ASC' }),
-      []
-    );
+    const { sort } = getGenericRenderVariables({
+      relations: [{ localField, entityIdentifier: 'entity' }],
+      filterProps: mockedProps({ sortby, sort: 'ASC' }),
+      stringProps: []
+    });
 
     expect(sort).toEqual(`${sortby}:asc`);
   });
 
   it('should return correct sort data when when there is a relation prop that is of type string but with updated value', () => {
-    const { sort } = getGenericRenderVariables(
-      [{ localField: 'tag', entityIdentifier: 'tags' }],
-      mockedProps({ sortby: 'tag.name', sort: 'ASC' }),
-      ['tags.name']
-    );
+    const { sort } = getGenericRenderVariables({
+      relations: [{ localField: 'tag', entityIdentifier: 'tags' }],
+      filterProps: mockedProps({ sortby: 'tag.name', sort: 'ASC' }),
+      stringProps: ['tags.name']
+    });
 
     expect(sort).toEqual('tag.name.keyword:asc');
   });