feat(filter) Adds code to allow filters to match objects with missing… (Avocarrot#4)

* feat(filter) Adds code to allow filters to match objects with missing and/or empty values

* refactor(parseFilter) Avoids check for boolean and instead coerces value to boolean

Author: giorgosera

README.md

@@ -78,11 +78,15 @@ q.or(filters); //returns an array of all objects in `arr` that satisfy SOME of t
 
 ## Filters
 
-`field` - The name of the property we will filter on
+*`field`* - The name of the property we will filter on
 
-`value` - The value of the property we will filter on
+*`value`* - The value of the property we will filter on
 
-`operator` - The filter operator. Supported operators `equals`, `contains`, `gt`, `gte`, `lt`, `lte`, `ne`
+*`operator`* - The filter operator. Supported operators `equals`, `contains`, `gt`, `gte`, `lt`, `lte`, `ne`
+
+*`matchMissing`* - If `true` the filter will be satisfied even if `field` property is not present on the object. Default is `false`.
+
+*`matchEmpty`* - If `true` the filter will be satisfied even if `value` property is empty. Empty values are `[]`, `undefined`, `null`, `''` and `{}`. Default is `false`.
 
 ## Contributing
 

lib/filter.js

@@ -11,12 +11,40 @@ exports.parseFilter = (filter) => {
     throw new Error('Invalid filter operator');
   }
 
+  filter.matchMissing = !!filter.matchMissing;
+  filter.matchEmpty = !!filter.matchEmpty;
+
   return filter;
 };
 
+
+const isEmpty = (val) => {
+  if (val == null) {
+    return true;
+  }
+  if (Array.isArray(val) || typeof val === 'string') {
+    return val.length === 0;
+  }
+  if (typeof val === 'object') {
+    return Object.keys(val).length === 0;
+  }
+  return false;
+};
+
 exports.isSatisfied = (filter, obj) => {
   const field = filter.field;
   const value = filter.value;
   const operator = operators[filter.operator];
-  return obj.hasOwnProperty(field) ? operator(obj[field], value) : false;
+  const matchMissing = filter.matchMissing || false;
+  const matchEmpty = filter.matchEmpty || false;
+
+  if (!obj.hasOwnProperty(field)) {
+    return matchMissing;
+  }
+
+  if (isEmpty(obj[field])) {
+    return matchEmpty;
+  }
+
+  return operator(obj[field], value);
 };

package.json

@@ -1,6 +1,6 @@
 {
   "name": "query-objects",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "A utility library which filters objects from an array of objects based on a set of filter conditions",
   "main": "index.js",
   "scripts": {

test/lib/filter.spec.js

@@ -32,9 +32,23 @@ describe('Filter module tests', () => {
   });
 
   it('isSatisfied(filter, obj) should return true if `filter` is satisfied by `obj` otherwise false', () => {
-    isSatisfied({field: 'foo', value: 'bar', operator: 'equals'}, {'foo': 'bar'}).should.be.true;
-    isSatisfied({field: 'foo', value: 'bar', operator: 'equals'}, {'foo': 'baz'}).should.be.false;
-    isSatisfied({field: 'foo', value: 'bar', operator: 'equals'}, {'fiz': 'bar'}).should.be.false;
+    let filter = {field: 'foo', value: 'bar', operator: 'equals'};
+    isSatisfied(filter, {'foo': 'bar'}).should.be.true;
+    isSatisfied(filter, {'foo': 'baz'}).should.be.false;
+    isSatisfied(filter, {'fiz': 'bar'}).should.be.false;
+
+    // Test `matchMissing`
+    filter.matchMissing = true;
+    isSatisfied(filter, {}).should.be.true;
+
+    // Test `matchEmpty`
+    filter.matchEmpty = true;
+    isSatisfied(filter, {'foo': null}).should.be.true;
+    isSatisfied(filter, {'foo': []}).should.be.true;
+    isSatisfied(filter, {'foo': undefined}).should.be.true;
+    isSatisfied(filter, {'foo': ''}).should.be.true;
+    isSatisfied(filter, {'foo': {}}).should.be.true;
+
   });
 
 });