Support for Aggregate Queries (#485)

* Support for Aggregate Queries

* bump to parse-server to 2.7.0

* travis.yml 6.11.4 and docs

* jest tests

* improve jest test

* fix CoreManager tests

* rebase master

Author: dplewis

integration/package.json

@@ -3,7 +3,7 @@
   "dependencies": {
     "express": "^4.13.4",
     "mocha": "^2.4.5",
-    "parse-server": "^2.6.0"
+    "parse-server": "^2.7.0"
   },
   "scripts": {
     "test": "mocha --reporter dot -t 5000"

integration/test/ParseQueryAggregateTest.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const assert = require('assert');
+const clear = require('./clear');
+const mocha = require('mocha');
+const Parse = require('../../node');
+
+const TestObject = Parse.Object.extend('TestObject');
+
+describe('Parse Aggregate Query', () => {
+  before((done) => {
+    Parse.initialize('integration', null, 'notsosecret');
+    Parse.CoreManager.set('SERVER_URL', 'http://localhost:1337/parse');
+    Parse.Storage._clear();
+    clear().then(() => {
+      const obj1 = new TestObject({score: 10, name: 'foo'});
+      const obj2 = new TestObject({score: 10, name: 'foo'});
+      const obj3 = new TestObject({score: 10, name: 'bar'});
+      const obj4 = new TestObject({score: 20, name: 'dpl'});
+      return Parse.Object.saveAll([obj1, obj2, obj3, obj4]);
+    }).then(() => {
+      return Parse.User.logOut();
+    })
+    .then(() => { done() }, () => { done() });
+  });
+
+  it('aggregate pipeline object query', (done) => {
+    const pipeline = {
+      group: { objectId: '$name' }
+    };
+    const query = new Parse.Query(TestObject);
+    query.aggregate(pipeline).then((results) => {
+      assert.equal(results.length, 3);
+      done();
+    });
+  });
+
+  it('aggregate pipeline array query', (done) => {
+    const pipeline = [
+      { group: { objectId: '$name' } }
+    ];
+    const query = new Parse.Query(TestObject);
+    query.aggregate(pipeline).then((results) => {
+      assert.equal(results.length, 3);
+      done();
+    });
+  });
+
+  it('aggregate pipeline invalid query', (done) => {
+    const pipeline = 1234;
+    const query = new Parse.Query(TestObject);
+    try {
+      query.aggregate(pipeline).then(() => {});
+    } catch (e) {
+      done();
+    }
+  });
+
+  it('distinct query', (done) => {
+    const query = new Parse.Query(TestObject);
+    query.distinct('score').then((results) => {
+      assert.equal(results.length, 2);
+      assert.equal(results[0], 10);
+      assert.equal(results[1], 20);
+      done();
+    });
+  });
+
+  it('distinct equalTo query', (done) => {
+    const query = new Parse.Query(TestObject);
+    query.equalTo('name', 'foo')
+    query.distinct('score').then((results) => {
+      assert.equal(results.length, 1);
+      assert.equal(results[0], 10);
+      done();
+    });
+  });
+});

src/CoreManager.js

@@ -71,6 +71,7 @@ type PushController = {
 };
 type QueryController = {
   find: (className: string, params: QueryJSON, options: RequestOptions) => ParsePromise;
+  aggregate: (className: string, params: any, options: RequestOptions) => ParsePromise;
 };
 type RESTController = {
   request: (method: string, path: string, data: mixed) => ParsePromise;
@@ -268,7 +269,7 @@ module.exports = {
   },
 
   setQueryController(controller: QueryController) {
-    requireMethods('QueryController', ['find'], controller);
+    requireMethods('QueryController', ['find', 'aggregate'], controller);
     config['QueryController'] = controller;
   },
 

src/ParseQuery.js

@@ -484,6 +484,91 @@ class ParseQuery {
     })._thenRunCallbacks(options);
   }
 
+  /**
+   * Executes a distinct query and returns unique values
+   *
+   * @param {String} key A field to find distinct values
+   * @param {Object} options A Backbone-style options object. Valid options
+   * are:<ul>
+   *   <li>success: Function to call when the count completes successfully.
+   *   <li>error: Function to call when the find fails.
+   *   <li>sessionToken: A valid session token, used for making a request on
+   *       behalf of a specific user.
+   * </ul>
+   *
+   * @return {Parse.Promise} A promise that is resolved with the query completes.
+   */
+  distinct(key: string, options?: FullOptions): ParsePromise {
+    options = options || {};
+
+    const distinctOptions = {
+      useMasterKey: true
+    };
+    if (options.hasOwnProperty('sessionToken')) {
+      distinctOptions.sessionToken = options.sessionToken;
+    }
+    const controller = CoreManager.getQueryController();
+    const params = {
+      distinct: key,
+      where: this._where
+    };
+
+    return controller.aggregate(
+      this.className,
+      params,
+      distinctOptions
+    ).then((results) => {
+      return results.results;
+    })._thenRunCallbacks(options);
+  }
+
+   /**
+   * Executes an aggregate query and returns aggregate results
+   *
+   * @param {Mixed} pipeline Array or Object of stages to process query
+   * @param {Object} options A Backbone-style options object. Valid options
+   * are:<ul>
+   *   <li>success: Function to call when the count completes successfully.
+   *   <li>error: Function to call when the find fails.
+   *   <li>sessionToken: A valid session token, used for making a request on
+   *       behalf of a specific user.
+   * </ul>
+   *
+   * @return {Parse.Promise} A promise that is resolved with the query completes.
+   */
+  aggregate(pipeline: mixed, options?: FullOptions): ParsePromise {
+    options = options || {};
+
+    const aggregateOptions = {
+      useMasterKey: true
+    };
+    if (options.hasOwnProperty('sessionToken')) {
+      aggregateOptions.sessionToken = options.sessionToken;
+    }
+    const controller = CoreManager.getQueryController();
+    let stages = {};
+
+    if (Array.isArray(pipeline)) {
+      pipeline.forEach((stage) => {
+        for (let op in stage) {
+          stages[op] = stage[op];
+        }
+      });
+    } else if (pipeline && typeof pipeline === 'object') {
+      stages = pipeline;
+    } else {
+      throw new Error('Invalid pipeline must be Array or Object');
+    }
+
+    return controller.aggregate(
+      this.className,
+      stages,
+      aggregateOptions
+    ).then((results) => {
+      return results.results;
+    })._thenRunCallbacks(options);
+  }
+
   /**
    * Retrieves at most one Parse.Object that satisfies this query.
    *
@@ -1196,6 +1281,17 @@ var DefaultController = {
       params,
       options
     );
+  },
+
+  aggregate(className: string, params: any, options: RequestOptions): ParsePromise {
+    const RESTController = CoreManager.getRESTController();
+
+    return RESTController.request(
+      'GET',
+      'aggregate/' + className,
+      params,
+      options
+    );
   }
 };
 

src/__tests__/CoreManager-test.js

@@ -220,13 +220,15 @@ describe('CoreManager', () => {
     );
 
     expect(CoreManager.setQueryController.bind(null, {
-      find: function() {}
+      find: function() {},
+      aggregate: function() {}
     })).not.toThrow();
   });
 
   it('can set and get QueryController', () => {
     var controller = {
-      find: function() {}
+      find: function() {},
+      aggregate: function() {}
     };
 
     CoreManager.setQueryController(controller);