fix(state): nested attributes for faceting were not handled

* fix nested attributes for faceting * fix eslint issue * fix: support multi indices
algolia · May 17, 2017 · 11bd122 · 11bd122
1 parent dd2c86f
commit 11bd122
Show file tree

Hide file tree

Showing 2 changed files with 177 additions and 20 deletions.
diff --git a/packages/react-instantsearch/src/core/indexUtils.js b/packages/react-instantsearch/src/core/indexUtils.js
@@ -115,6 +115,14 @@ function refineSingleIndexWithNamespace(
   };
 }
 
+function getNamespaceAndAttributeName(id) {
+  const parts = id.match(/^([^.]*)\.(.*)/);
+  const namespace = parts && parts[1];
+  const attributeName = parts && parts[2];
+
+  return { namespace, attributeName };
+}
+
 // eslint-disable-next-line max-params
 export function getCurrentRefinementValue(
   props,
@@ -125,24 +133,67 @@ export function getCurrentRefinementValue(
   refinementsCallback
 ) {
   const index = getIndex(context);
+  const { namespace, attributeName } = getNamespaceAndAttributeName(id);
   const refinements =
-    (hasMultipleIndex(context) && has(searchState, `indices.${index}.${id}`)) ||
+    (hasMultipleIndex(context) &&
+      searchState.indices &&
+      namespace &&
+      has(searchState.indices[`${index}`][namespace], `${attributeName}`)) ||
+    (hasMultipleIndex(context) &&
+      searchState.indices &&
+      has(searchState, `indices.${index}.${id}`)) ||
+    (!hasMultipleIndex(context) &&
+      namespace &&
+      has(searchState[namespace], attributeName)) ||
     (!hasMultipleIndex(context) && has(searchState, id));
   if (refinements) {
-    const currentRefinement = hasMultipleIndex(context)
-      ? get(searchState.indices[index], id)
-      : get(searchState, id);
+    let currentRefinement;
+
+    if (hasMultipleIndex(context)) {
+      currentRefinement = namespace
+        ? get(searchState.indices[`${index}`][namespace], attributeName)
+        : get(searchState.indices[index], id);
+    } else {
+      currentRefinement = namespace
+        ? get(searchState[namespace], attributeName)
+        : get(searchState, id);
+    }
+
     return refinementsCallback(currentRefinement);
   }
+
   if (props.defaultRefinement) {
     return props.defaultRefinement;
   }
+
   return defaultValue;
 }
 
 export function cleanUpValue(searchState, context, id) {
   const index = getIndex(context);
-  return hasMultipleIndex(context)
-    ? omit(searchState, `indices.${index}.${id}`)
-    : omit(searchState, `${id}`);
+  const { namespace, attributeName } = getNamespaceAndAttributeName(id);
+  if (hasMultipleIndex(context)) {
+    return namespace
+      ? {
+          ...searchState,
+          indices: {
+            ...searchState.indices,
+            [index]: {
+              ...searchState.indices[index],
+              [namespace]: omit(
+                searchState.indices[index][namespace],
+                `${attributeName}`
+              ),
+            },
+          },
+        }
+      : omit(searchState, `indices.${index}.${id}`);
+  } else {
+    return namespace
+      ? {
+          ...searchState,
+          [namespace]: omit(searchState[namespace], `${attributeName}`),
+        }
+      : omit(searchState, `${id}`);
+  }
 }
diff --git a/packages/react-instantsearch/src/core/indexUtils.test.js b/packages/react-instantsearch/src/core/indexUtils.test.js
@@ -104,9 +104,15 @@ describe('utility method for manipulating the search state', () => {
         last: 'last',
         refinement: 'refinement',
         another: 'another',
-        namespace: { refinement: 'refinement', another: 'another' },
+        namespace: {
+          refinement: 'refinement',
+          another: 'another',
+          'nested.another': 'nested.another',
+        },
       };
 
+      expect.assertions(5); //async assertions
+
       let expectedRefinement = value => expect(value).toEqual('refinement');
 
       getCurrentRefinementValue(
@@ -129,13 +135,24 @@ describe('utility method for manipulating the search state', () => {
         expectedRefinement
       );
 
+      expectedRefinement = value => expect(value).toEqual('nested.another');
+
+      getCurrentRefinementValue(
+        {},
+        searchState,
+        context,
+        'namespace.nested.another',
+        null,
+        expectedRefinement
+      );
+
       let value = getCurrentRefinementValue(
         {},
         {},
         context,
         'refinement',
         'defaultValue',
-        expectedRefinement
+        () => {}
       );
 
       expect(value).toEqual('defaultValue');
@@ -146,7 +163,7 @@ describe('utility method for manipulating the search state', () => {
         context,
         'refinement',
         null,
-        expectedRefinement
+        () => {}
       );
 
       expect(value).toEqual('defaultRefinement');
@@ -158,7 +175,11 @@ describe('utility method for manipulating the search state', () => {
         last: 'last',
         refinement: 'refinement',
         another: 'another',
-        namespace: { refinement: 'refinement', another: 'another' },
+        namespace: {
+          refinement: 'refinement',
+          another: 'another',
+          'nested.another': 'nested.another',
+        },
       };
 
       searchState = cleanUpValue(searchState, context, 'refinement');
@@ -167,7 +188,11 @@ describe('utility method for manipulating the search state', () => {
         page: 1,
         last: 'last',
         another: 'another',
-        namespace: { refinement: 'refinement', another: 'another' },
+        namespace: {
+          refinement: 'refinement',
+          another: 'another',
+          'nested.another': 'nested.another',
+        },
       });
 
       searchState = cleanUpValue(searchState, context, 'namespace.another');
@@ -176,11 +201,27 @@ describe('utility method for manipulating the search state', () => {
         page: 1,
         last: 'last',
         another: 'another',
-        namespace: { refinement: 'refinement' },
+        namespace: {
+          refinement: 'refinement',
+          'nested.another': 'nested.another',
+        },
       });
 
       searchState = cleanUpValue(searchState, context, 'namespace.refinement');
 
+      expect(searchState).toEqual({
+        page: 1,
+        last: 'last',
+        another: 'another',
+        namespace: { 'nested.another': 'nested.another' },
+      });
+
+      searchState = cleanUpValue(
+        searchState,
+        context,
+        'namespace.nested.another'
+      );
+
       expect(searchState).toEqual({
         page: 1,
         last: 'last',
@@ -297,11 +338,18 @@ describe('utility method for manipulating the search state', () => {
         refinement: 'refinement',
         indices: {
           first: {
-            namespace: { refinement: 'refinement', another: 'another' },
+            refinement: 'refinement',
+            namespace: {
+              refinement: 'refinement',
+              another: 'another',
+              'nested.another': 'nested.another',
+            },
           },
         },
       };
 
+      expect.assertions(6); //async assertions
+
       let expectedRefinement = value => expect(value).toEqual('refinement');
 
       getCurrentRefinementValue(
@@ -313,6 +361,17 @@ describe('utility method for manipulating the search state', () => {
         expectedRefinement
       );
 
+      expectedRefinement = value => expect(value).toEqual('refinement');
+
+      getCurrentRefinementValue(
+        {},
+        searchState,
+        context,
+        'namespace.refinement',
+        null,
+        expectedRefinement
+      );
+
       expectedRefinement = value => expect(value).toEqual('another');
 
       getCurrentRefinementValue(
@@ -324,13 +383,24 @@ describe('utility method for manipulating the search state', () => {
         expectedRefinement
       );
 
+      expectedRefinement = value => expect(value).toEqual('nested.another');
+
+      getCurrentRefinementValue(
+        {},
+        searchState,
+        context,
+        'namespace.nested.another',
+        null,
+        expectedRefinement
+      );
+
       let value = getCurrentRefinementValue(
         {},
         {},
         context,
         'refinement',
         'defaultValue',
-        expectedRefinement
+        () => {}
       );
 
       expect(value).toEqual('defaultValue');
@@ -341,7 +411,7 @@ describe('utility method for manipulating the search state', () => {
         context,
         'refinement',
         null,
-        expectedRefinement
+        () => {}
       );
 
       expect(value).toEqual('defaultRefinement');
@@ -353,7 +423,11 @@ describe('utility method for manipulating the search state', () => {
         indices: {
           first: {
             refinement: 'refinement',
-            namespace: { refinement: 'refinement', another: 'another' },
+            namespace: {
+              refinement: 'refinement',
+              another: 'another',
+              'nested.another': 'nested.another',
+            },
           },
         },
       };
@@ -364,7 +438,11 @@ describe('utility method for manipulating the search state', () => {
         page: 1,
         indices: {
           first: {
-            namespace: { refinement: 'refinement', another: 'another' },
+            namespace: {
+              refinement: 'refinement',
+              another: 'another',
+              'nested.another': 'nested.another',
+            },
           },
         },
       });
@@ -373,14 +451,42 @@ describe('utility method for manipulating the search state', () => {
 
       expect(searchState).toEqual({
         page: 1,
-        indices: { first: { namespace: { refinement: 'refinement' } } },
+        indices: {
+          first: {
+            namespace: {
+              refinement: 'refinement',
+              'nested.another': 'nested.another',
+            },
+          },
+        },
       });
 
       searchState = cleanUpValue(searchState, context, 'namespace.refinement');
 
       expect(searchState).toEqual({
         page: 1,
-        indices: { first: { namespace: {} } },
+        indices: {
+          first: {
+            namespace: {
+              'nested.another': 'nested.another',
+            },
+          },
+        },
+      });
+
+      searchState = cleanUpValue(
+        searchState,
+        context,
+        'namespace.nested.another'
+      );
+
+      expect(searchState).toEqual({
+        page: 1,
+        indices: {
+          first: {
+            namespace: {},
+          },
+        },
       });
     });