Adds support for multiple $in

spec/ParseRelation.spec.js

@@ -247,6 +247,56 @@ describe('Parse.Relation testing', () => {
     });
   });
   
+  it("queries on relation fields with multiple ins", (done) => {
+    var ChildObject = Parse.Object.extend("ChildObject");
+    var childObjects = [];
+    for (var i = 0; i < 10; i++) {
+      childObjects.push(new ChildObject({x: i}));
+    }
+
+    Parse.Object.saveAll(childObjects, {
+      success: function() {
+        var ParentObject = Parse.Object.extend("ParentObject");
+        var parent = new ParentObject();
+        parent.set("x", 4);
+        var relation = parent.relation("child");
+        relation.add(childObjects[0]);
+        relation.add(childObjects[1]);
+        relation.add(childObjects[2]);
+        var parent2 = new ParentObject();
+        parent2.set("x", 3);
+        var relation2 = parent2.relation("child");
+        relation2.add(childObjects[4]);
+        relation2.add(childObjects[5]);
+        relation2.add(childObjects[6]);
+        
+        var otherChild2 = parent2.relation("otherChild");
+        otherChild2.add(childObjects[0]);
+        otherChild2.add(childObjects[1]);
+        otherChild2.add(childObjects[2]);
+
+        var parents = [];
+        parents.push(parent);
+        parents.push(parent2);
+        Parse.Object.saveAll(parents, {
+          success: function() {
+            var query = new Parse.Query(ParentObject);
+            var objects = [];
+            objects.push(childObjects[0]);
+            query.containedIn("child", objects);
+            query.containedIn("otherChild", [childObjects[0]]);
+            query.find({
+              success: function(list) {
+                equal(list.length, 2, "There should be only one result");
+                done();
+              }
+            });
+          }
+        });
+      }
+    });
+  });
+
   it("Get query on relation using un-fetched parent object", (done) => {
     // Setup data model
     var Wheel = Parse.Object.extend('Wheel');

src/Controllers/DatabaseController.js

@@ -397,19 +397,20 @@ DatabaseController.prototype.owningIds = function(className, key, relatedIds) {
 // Modifies query so that it no longer has $in on relation fields, or
 // equal-to-pointer constraints on relation fields.
 // Returns a promise that resolves when query is mutated
-// TODO: this only handles one of these at a time - make it handle more
 DatabaseController.prototype.reduceInRelation = function(className, query, schema) {
   // Search for an in-relation or equal-to-relation
-  for (var key in query) {
+  // Make it sequential for now, not sure of paralleization side effects
+  return Object.keys(query).reduce((promise, key) => {
+    return promise.then(() => {
       if (query[key] &&
           (query[key]['$in'] || query[key].__type == 'Pointer')) {
-      var t = schema.getExpectedType(className, key);
-      var match = t ? t.match(/^relation<(.*)>$/) : false;
+        let t = schema.getExpectedType(className, key);
+        let match = t ? t.match(/^relation<(.*)>$/) : false;
         if (!match) {
-        continue;
+          return;
         }
-      var relatedClassName = match[1];
-      var relatedIds;
+        let relatedClassName = match[1];
+        let relatedIds;
         if (query[key]['$in']) {
           relatedIds = query[key]['$in'].map(r => r.objectId);
         } else {
@@ -417,11 +418,12 @@ DatabaseController.prototype.reduceInRelation = function(className, query, schem
         }
         return this.owningIds(className, key, relatedIds).then((ids) => {
           delete query[key];
-        query.objectId = {'$in': ids};
+          query.objectId = Object.assign({'$in': []}, query.objectId);
+          query.objectId['$in'] = query.objectId['$in'].concat(ids);
         });
       }
-  }
-  return Promise.resolve();
+    });
+  }, Promise.resolve());
 };
 
 // Modifies query so that it no longer has $relatedTo