Allow an array of matches in the patern matching rules

This allows setting multiple matches (a combination of subject, predicate and object) for one definition. The same can be achieved by creating multiple definitions with the same callback/options and a different single match pattern.
Using an object (instead of array) for a `match` is still allowed: this is backwards compatible.

This also changes two aspects of how deltas are sent through:
When a delta matches multiple patterns (matches), it will send the same change sets multiple times to the same url, for every match that is in the rules.
When using an array for `match`es, the change set will only be sent once.

When using in conjunction with `sendMatchesOnly`, all patterns matching those defined in `match`es will be sent in one change set together. When not using an array for `match`es, multiple change sets with "one type of match" each would be sent to the url.

Author: Ruben

README.md

@@ -58,7 +58,7 @@ export default [
 
 The exported property contains an array of definitions, each linking a match to a callback.
 
-  - `match`: Pattern to match against.  Any supplied key must match, anything unspecified is ignored.
+  - `match`: Pattern to match against.  Any supplied key must match, anything unspecified is ignored. Can pass multiple patterns as a list, which will be combined as an "or" (one valid pattern results in a match).
   - `match.subject`: Matches the subject.  Both `type` and `value` may be specified.
   - `match.predicate`: Matches the predicade.  Both `type` and `value` may be specified.
   - `match.object`: Matches the object.  Both `type` and `value` may be specified.
@@ -72,7 +72,7 @@ The exported property contains an array of definitions, each linking a match to
   - `options.ignoreFromSelf`: Don't inform about changes that originated from the microservice to be informed (based on the hostname).
   - `options.retry`: (experimental) How many times the request is sent again on failure.  Defaults to 0. Warning: in case of retries, deltas may be received out of order!
   - `options.retryTimeout`: (experimental) How much time is left in between retries (in ms).  Currently defaults to 250ms.
-  - `options.sendMatchesOnly`: Only send triples that match, removing the other triples from the changes.
+  - `options.sendMatchesOnly`: Only send triples that match the pattern(s), removing the other triples from the changes.
 
 ### Modifying quads
 #### Normalize datetime

matching.js

@@ -6,7 +6,7 @@ import { DEBUG_TRIPLE_MATCHES_SPEC } from './env';
  * @param {Array<Object>} changeSets - An array of change set objects,
  * each containing `insert` and `delete` properties.
  * @param {Object} entry - An object containing the matching criteria.
- * @param {Array} entry.match - The pattern used to filter the triples
+ * @param {Array} entry.match - The pattern(s) used to filter the triples
  * in the `insert` and `delete` arrays.
  * @returns {Array<Object>} A new array of change set objects with
  * filtered `insert` and `delete` properties.
@@ -22,19 +22,30 @@ export function filterChangesetsOnPattern(changeSets, entry) {
       effectiveInsert: effectiveInsert.filter((triple) => tripleMatchesSpec(triple, entry.match)),
       effectiveDelete: effectiveDelete.filter((triple) => tripleMatchesSpec(triple, entry.match)),
     };
-    filteredChangesets.push(clonedChangeSet);
-  };
+    // do not keep empty change sets
+    if( clonedChangeSet.insert.length > 0 
+      || clonedChangeSet.delete.length > 0 
+      || clonedChangeSet.effectiveInsert.length > 0 
+      || clonedChangeSet.effectiveDelete.length > 0 ) {
+      filteredChangesets.push(clonedChangeSet);
+    }
+  }
   return filteredChangesets;
 }
 
 export function tripleMatchesSpec( triple, matchSpec ) {
-  // form of triple is {s, p, o}, same as matchSpec
+  const matches = Array.isArray(matchSpec) ? matchSpec : [matchSpec];
   if(DEBUG_TRIPLE_MATCHES_SPEC)
     console.log(`Does ${JSON.stringify(triple)} match ${JSON.stringify(matchSpec)}?`);
 
-  for( let key in matchSpec ){
-    // key is one of s, p, o
-    const subMatchSpec = matchSpec[key];
+  return matches.some((match) => tripleMatchesPattern(triple, match));
+}
+
+function tripleMatchesPattern( triple, pattern ) {
+  // form of triple is {s, p, o} or {subject, predicate, object}, same as pattern
+  for( let key in pattern ){
+    // key is one of subject, predicate, object
+    const subMatchSpec = pattern[key];
     const subMatchValue = triple[key];
 
     if( subMatchSpec && !subMatchValue )
@@ -45,7 +56,7 @@ export function tripleMatchesSpec( triple, matchSpec ) {
       if( subMatchSpec[subKey] !== subMatchValue[subKey] )
         return false;
   }
-  return true; // no false matches found, let's send a response
+  return true; // no false matches found
 }