Fixed disjunctive facets.

In faceting, multi-value facet filters often send filters in the
following format:

```
{
  all: [
    {
      any: [
        { brand: 'a' },
        { brand: 'c' },
        { brand: 'c' }
      ]
    },
    {
      any: [
        { size: 'small' },
        { brand: 'medium' }
      ]
    }
  ]
}
```

When determining the fields that are currently being filterd, our
faceting logic was only looking at keys at the top level, so faceting
logic was not being applied when it should have. We are now recursing
down the filter tree to find values nested in this way.

Author: JasonStoltz

src/filters.js

@@ -1,16 +1,3 @@
-function addPropertyIfKeysDoNotMatch(object, keyToAdd, valueToAdd, skipIfKey) {
-  return {
-    ...object,
-    ...(keyToAdd !== skipIfKey && { [keyToAdd]: valueToAdd })
-  };
-}
-
-function removeObjectsFromArrayIfTheyHaveKey(array, key) {
-  return array.filter(arrayValue => {
-    return !Object.entries(arrayValue).find(([valueKey]) => key === valueKey);
-  });
-}
-
 /**
  * A helper for working with the JSON structure which represent
  * filters in API requests.
@@ -20,30 +7,59 @@ export default class Filters {
     this.filtersJSON = filtersJSON;
   }
 
-  removeFilter(filterKey) {
-    const filtersJSON = Object.entries(this.filtersJSON).reduce(
-      (acc, [key, value]) => {
-        if (!["all", "any", "none"].includes(key)) {
-          return addPropertyIfKeysDoNotMatch(acc, key, value, filterKey);
-        }
-        return {
-          ...acc,
-          [key]: removeObjectsFromArrayIfTheyHaveKey(value, filterKey)
-        };
-      },
-      {}
-    );
-    return new Filters(filtersJSON);
+  removeFilter(filterKey, filtersMap = this.filtersJSON) {
+    function go(filterKey, filtersMap) {
+      const filtered = Object.entries(filtersMap).reduce(
+        (acc, [filterName, filterValue]) => {
+          if (filterName === filterKey) {
+            return acc;
+          }
+
+          if (["all", "any", "none"].includes(filterName)) {
+            const nestedFiltersArray = filterValue;
+            filterValue = nestedFiltersArray.reduce((acc, nestedFiltersMap) => {
+              const updatedNestedFiltersMap = go(filterKey, nestedFiltersMap);
+              if (updatedNestedFiltersMap) {
+                return acc.concat(updatedNestedFiltersMap);
+              } else {
+                return acc;
+              }
+            }, []);
+          }
+
+          return {
+            ...acc,
+            [filterName]: filterValue
+          };
+        },
+        {}
+      );
+
+      if (Object.keys(filtered).length === 0) {
+        return;
+      }
+      return filtered;
+    }
+
+    const filtered = go(filterKey, filtersMap);
+    return new Filters(filtered);
   }
 
-  getListOfAppliedFilters() {
-    const set = Object.entries(this.filtersJSON).reduce((acc, [key, value]) => {
+  getListOfAppliedFilters(filters = this.filtersJSON) {
+    const set = Object.entries(filters).reduce((acc, [key, value]) => {
       if (!["all", "any", "none"].includes(key)) {
         acc.add(key);
       } else {
         value.forEach(nestedValue => {
           Object.keys(nestedValue).forEach(nestedKey => {
-            acc.add(nestedKey);
+            if (!["all", "any", "none"].includes(nestedKey)) {
+              acc.add(nestedKey);
+            } else {
+              acc = new Set([
+                ...acc,
+                ...this.getListOfAppliedFilters(nestedValue)
+              ]);
+            }
           });
         });
       }

tests/filters.spec.js

@@ -28,7 +28,7 @@ describe("Filters", () => {
       });
     });
 
-    test("can remove a nested filters", () => {
+    test("can remove a filter from any, all, or none", () => {
       const filters = new Filters({
         all: [{ c: "c" }, { d: "d" }],
         none: [{ e: "e" }, { f: "f" }],
@@ -46,9 +46,90 @@ describe("Filters", () => {
         any: []
       });
     });
+
+    test("can remove nested filters", () => {
+      const filters = new Filters({
+        all: [
+          {
+            all: [{ c: "c" }, { d: "d" }],
+            none: [{ e: "e" }, { e: "e1" }, { f: "f" }],
+            any: [
+              {
+                g: "g"
+              },
+              {
+                all: [
+                  {
+                    h: "h"
+                  },
+                  {
+                    any: [
+                      {
+                        i: "i"
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          },
+          { j: "j" }
+        ],
+        any: [
+          {
+            all: [{ k: "k" }],
+            any: [{ l: "l" }]
+          }
+        ]
+      });
+
+      expect(
+        filters
+          .removeFilter("k")
+          .removeFilter("i")
+          .removeFilter("e").filtersJSON
+      ).toEqual({
+        all: [
+          {
+            all: [{ c: "c" }, { d: "d" }],
+            none: [{ f: "f" }],
+            any: [
+              {
+                g: "g"
+              },
+              {
+                all: [
+                  {
+                    h: "h"
+                  },
+                  {
+                    any: []
+                  }
+                ]
+              }
+            ]
+          },
+          { j: "j" }
+        ],
+        any: [
+          {
+            all: [],
+            any: [{ l: "l" }]
+          }
+        ]
+      });
+    });
   });
 
   describe("#getListOfAppliedFilters", () => {
+    test("it should return a single top level value filter", () => {
+      const filters = new Filters({
+        b: "b"
+      });
+
+      expect(filters.getListOfAppliedFilters()).toEqual(["b"]);
+    });
+
     test("it should return a list of top level filters", () => {
       const filters = new Filters({
         b: ["b", "b1"]
@@ -72,5 +153,55 @@ describe("Filters", () => {
         "g"
       ]);
     });
+
+    test("it should return nested filters", () => {
+      const filters = new Filters({
+        all: [
+          {
+            all: [{ c: "c" }, { d: "d" }],
+            none: [{ e: "e" }, { e: "e1" }, { f: "f" }],
+            any: [
+              {
+                g: "g"
+              },
+              {
+                all: [
+                  {
+                    h: "h"
+                  },
+                  {
+                    any: [
+                      {
+                        i: "i"
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          },
+          { j: "j" }
+        ],
+        any: [
+          {
+            all: [{ k: "k" }],
+            any: [{ l: "l" }]
+          }
+        ]
+      });
+
+      expect(filters.getListOfAppliedFilters()).toEqual([
+        "c",
+        "d",
+        "e",
+        "f",
+        "g",
+        "h",
+        "i",
+        "j",
+        "k",
+        "l"
+      ]);
+    });
   });
 });