Add ability to search Object columns (#727)

* Add ability to search Object columns

* Added more comparisons for Object columns

exists, does not exist, equal to, not equal to, greater than, greater than or equal, less than, less than or equal.

* Added exists and does not exist constraints for objects.

* Make key exist and key does not exist work with strings instead of json

Author: ssamuli

CHANGELOG.md

@@ -3,6 +3,7 @@
 ### NEXT RELEASE
 
 * _Contributing to this repo? Add info about your change here to be included in next release_
+* Improvement: Add ability to search Object columns, thanks to [Samuli Siivinen](https://github.com/ssamuli)
 * Improvement: Added/fixed a filtering option "contains string" for String fields. Case insensitive for now.
 
 ### 1.0.27

src/components/BrowserFilter/FilterRow.react.js

@@ -31,6 +31,7 @@ function compareValue(info, value, onChangeCompareTo, active) {
   switch (info.type) {
     case null:
       return null;
+    case 'Object':
     case 'String':
       return <input type='text' value={value} onChange={(e) => onChangeCompareTo(e.target.value)} ref={setFocus}/>;
     case 'Pointer':

src/lib/Filters.js

@@ -90,7 +90,47 @@ export const Constraints = {
   doesNotContainAny: {
     name: 'does not contain',
     field: 'Array',
-  }
+  },
+  keyExists: {
+    name: 'key exists',
+    field: 'Object',
+    composable: true
+  },
+  keyDne: {
+    name: 'key does not exist',
+    field: 'Object',
+    composable: true
+  },
+  keyEq: {
+    name: 'key equals',
+    field: 'Object',
+    composable: true
+  },
+  keyNeq: {
+    name: 'key does not equal',
+    field: 'Object',
+    composable: true
+  },
+  keyGt: {
+    name: 'key greater than',
+    field: 'Object',
+    composable: true
+  },
+  keyGte: {
+    name: 'key greater than/equal',
+    field: 'Object',
+    composable: true
+  },
+  keyLt: {
+    name: 'key less than',
+    field: 'Object',
+    composable: true
+  },
+  keyLte: {
+    name: 'key less than/equal',
+    field: 'Object',
+    composable: true
+  },
 };
 
 export const FieldConstraints = {
@@ -99,6 +139,18 @@ export const FieldConstraints = {
   'Number': [ 'exists', 'dne', 'eq', 'neq', 'lt', 'lte', 'gt', 'gte' ],
   'String': [ 'exists', 'dne', 'eq', 'neq', 'starts', 'ends', 'stringContainsString' ],
   'Date': [ 'exists', 'dne', 'before', 'after' ],
+  'Object': [
+    'exists',
+    'dne',
+    'keyExists',
+    'keyDne',
+    'keyEq',
+    'keyNeq',
+    'keyGt',
+    'keyGte',
+    'keyLt',
+    'keyLte'
+  ],
   'Array': [
     'exists',
     'dne',
@@ -116,6 +168,7 @@ export const DefaultComparisons = {
   'Boolean': false,
   'Number': '',
   'String': '',
+  'Object': '',
   'Date': Parse._encode(new Date()),
 };
 

src/lib/queryFromFilters.js

@@ -21,6 +21,13 @@ export default function queryFromFilters(className, filters) {
   return query;
 }
 
+function addQueryConstraintFromObject(query, filter, constraintType) {
+  let compareTo = JSON.parse(filter.get('compareTo'));
+  for (let key of Object.keys(compareTo)) {
+    query[constraintType](filter.get('field')+'.'+key, compareTo[key]);
+  }
+}
+
 function addConstraint(query, filter) {
   switch (filter.get('constraint')) {
     case 'exists':
@@ -73,6 +80,30 @@ function addConstraint(query, filter) {
     case 'stringContainsString':
       query.matches(filter.get('field'), filter.get('compareTo'), 'i');
       break;
+    case 'keyExists':
+      query.exists(filter.get('field') + '.' + filter.get('compareTo'));
+      break;
+    case 'keyDne':
+      query.doesNotExist(filter.get('field') + '.' + filter.get('compareTo'));
+      break;
+    case 'keyEq':
+      addQueryConstraintFromObject(query, filter, 'equalTo');
+      break;
+    case 'keyNeq':
+      addQueryConstraintFromObject(query, filter, 'notEqualTo');
+      break;
+    case 'keyGt':
+      addQueryConstraintFromObject(query, filter, 'greaterThan');
+      break;
+    case 'keyGte':
+      addQueryConstraintFromObject(query, filter, 'greaterThanOrEqualTo');
+      break;
+    case 'keyLt':
+      addQueryConstraintFromObject(query, filter, 'lessThan');
+      break;
+    case 'keyLte':
+      addQueryConstraintFromObject(query, filter, 'lessThanOrEqualTo');
+      break;
   }
   return query;
 }