Support query.map, query.filter, query.reduce (#987)

* Support query.map()

* nit

* filter and reduce

Author: dplewis

integration/test/ParseQueryTest.js

@@ -1947,4 +1947,55 @@ describe('Parse Query', () => {
       done();
     });
   });
+
+  it('can return results in map', async () => {
+    const obj1 = new TestObject({ foo: 'bar' });
+    const obj2 = new TestObject({ foo: 'baz' });
+    const obj3 = new TestObject({ foo: 'bin' });
+    await Parse.Object.saveAll([obj1, obj2, obj3]);
+    let i = 0;
+    const mapQuery = new Parse.Query(TestObject);
+    const results = await mapQuery.map((object, index, query) => {
+      assert.equal(index, i);
+      assert.equal(query, mapQuery);
+      i += 1;
+      return object.get('foo');
+    });
+    assert.equal(results.includes('bar'), true);
+    assert.equal(results.includes('baz'), true);
+    assert.equal(results.includes('bin'), true);
+    assert.equal(results.length, 3);
+  });
+
+  it('can return results in filter', async () => {
+    const obj1 = new TestObject({ foo: 'bar' });
+    const obj2 = new TestObject({ foo: 'baz' });
+    const obj3 = new TestObject({ foo: 'bin' });
+    await Parse.Object.saveAll([obj1, obj2, obj3]);
+    let i = 0;
+    const filterQuery = new Parse.Query(TestObject);
+    const results = await filterQuery.filter((object, index, query) => {
+      assert.equal(index, i);
+      assert.equal(query, filterQuery);
+      i += 1;
+      return object.get('foo') === 'bar';
+    });
+    assert.equal(results[0].get('foo'), 'bar');
+    assert.equal(results.length, 1);
+  });
+
+  it('can return results in reduce', async () => {
+    const obj1 = new TestObject({ number: 1 });
+    const obj2 = new TestObject({ number: 2 });
+    const obj3 = new TestObject({ number: 3 });
+    await Parse.Object.saveAll([obj1, obj2, obj3]);
+    let i = 0;
+    const reduceQuery = new Parse.Query(TestObject);
+    const result = await reduceQuery.reduce((accumulator, object, index) => {
+      assert.equal(index, i);
+      i += 1;
+      return accumulator + object.get('number');
+    }, 0);
+    assert.equal(result, 6);
+  });
 });

src/ParseQuery.js

@@ -910,6 +910,103 @@ class ParseQuery {
     });
   }
 
+  /**
+   * Iterates over each result of a query, calling a callback for each one. If
+   * the callback returns a promise, the iteration will not continue until
+   * that promise has been fulfilled. If the callback returns a rejected
+   * promise, then iteration will stop with that error. The items are
+   * processed in an unspecified order. The query may not have any sort order,
+   * and may not use limit or skip.
+   * @param {Function} callback Callback <ul>
+   *   <li>currentObject: The current Parse.Object being processed in the array.</li>
+   *   <li>index: The index of the current Parse.Object being processed in the array.</li>
+   *   <li>query: The query map was called upon.</li>
+   * </ul>
+   *
+   * @param {Object} options Valid options are:<ul>
+   *   <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
+   *     be used for this request.
+   *   <li>sessionToken: A valid session token, used for making a request on
+   *       behalf of a specific user.
+   * </ul>
+   * @return {Promise} A promise that will be fulfilled once the
+   *     iteration has completed.
+   */
+  async map(callback: (currentObject: ParseObject, index: number, query: ParseQuery) => any, options?: BatchOptions): Promise<Array<any>> {
+    const array = [];
+    let index = 0;
+    await this.each((object) => {
+      array.push(callback(object, index, this));
+      index += 1;
+    }, options);
+    return array;
+  }
+
+  /**
+   * Iterates over each result of a query, calling a callback for each one. If
+   * the callback returns a promise, the iteration will not continue until
+   * that promise has been fulfilled. If the callback returns a rejected
+   * promise, then iteration will stop with that error. The items are
+   * processed in an unspecified order. The query may not have any sort order,
+   * and may not use limit or skip.
+   * @param {Function} callback Callback <ul>
+   *   <li>accumulator: The accumulator accumulates the callback's return values. It is the accumulated value previously returned in the last invocation of the callback.</li>
+   *   <li>currentObject: The current Parse.Object being processed in the array.</li>
+   *   <li>index: The index of the current Parse.Object being processed in the array.</li>
+   * </ul>
+   * @param {Mixed} initialValue A value to use as the first argument to the first call of the callback. If no initialValue is supplied, the first object in the query will be used and skipped.
+   * @param {Object} options Valid options are:<ul>
+   *   <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
+   *     be used for this request.
+   *   <li>sessionToken: A valid session token, used for making a request on
+   *       behalf of a specific user.
+   * </ul>
+   * @return {Promise} A promise that will be fulfilled once the
+   *     iteration has completed.
+   */
+  async reduce(callback: (accumulator: any, currentObject: ParseObject, index: number) => any, initialValue: any, options?: BatchOptions): Promise<Array<any>> {
+    const objects = [];
+    await this.each((object) => {
+      objects.push(object);
+    }, options);
+    return objects.reduce(callback, initialValue);
+  }
+
+  /**
+   * Iterates over each result of a query, calling a callback for each one. If
+   * the callback returns a promise, the iteration will not continue until
+   * that promise has been fulfilled. If the callback returns a rejected
+   * promise, then iteration will stop with that error. The items are
+   * processed in an unspecified order. The query may not have any sort order,
+   * and may not use limit or skip.
+   * @param {Function} callback Callback <ul>
+   *   <li>currentObject: The current Parse.Object being processed in the array.</li>
+   *   <li>index: The index of the current Parse.Object being processed in the array.</li>
+   *   <li>query: The query filter was called upon.</li>
+   * </ul>
+   *
+   * @param {Object} options Valid options are:<ul>
+   *   <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
+   *     be used for this request.
+   *   <li>sessionToken: A valid session token, used for making a request on
+   *       behalf of a specific user.
+   * </ul>
+   * @return {Promise} A promise that will be fulfilled once the
+   *     iteration has completed.
+   */
+  async filter(callback: (currentObject: ParseObject, index: number, query: ParseQuery) => boolean, options?: BatchOptions): Promise<Array<ParseObject>> {
+    const array = [];
+    let index = 0;
+    await this.each((object) => {
+      const flag = callback(object, index, this);
+      if (flag) {
+        array.push(object);
+      }
+      index += 1;
+    }, options);
+    return array;
+  }
+
   /** Query Conditions **/
 
   /**

src/__tests__/ParseQuery-test.js

@@ -1580,6 +1580,66 @@ describe('ParseQuery', () => {
     });
   });
 
+  it('can iterate over results with map()', async () => {
+    CoreManager.setQueryController({
+      aggregate() {},
+      find() {
+        return Promise.resolve({
+          results: [
+            { objectId: 'I55', size: 'medium', name: 'Product 55' },
+            { objectId: 'I89', size: 'small', name: 'Product 89' },
+            { objectId: 'I91', size: 'small', name: 'Product 91' },
+          ]
+        });
+      }
+    });
+
+    const q = new ParseQuery('Item');
+
+    const results = await q.map((object) => object.attributes.size);
+    expect(results.length).toBe(3);
+  });
+
+  it('can iterate over results with reduce()', async () => {
+    CoreManager.setQueryController({
+      aggregate() {},
+      find() {
+        return Promise.resolve({
+          results: [
+            { objectId: 'I55', number: 1 },
+            { objectId: 'I89', number: 2 },
+            { objectId: 'I91', number: 3 },
+          ]
+        });
+      }
+    });
+
+    const q = new ParseQuery('Item');
+
+    const result = await q.reduce((accumulator, object) => accumulator + object.attributes.number, 0);
+    expect(result).toBe(6);
+  });
+
+  it('can iterate over results with filter()', async () => {
+    CoreManager.setQueryController({
+      aggregate() {},
+      find() {
+        return Promise.resolve({
+          results: [
+            { objectId: 'I55', size: 'medium', name: 'Product 55' },
+            { objectId: 'I89', size: 'small', name: 'Product 89' },
+            { objectId: 'I91', size: 'small', name: 'Product 91' },
+          ]
+        });
+      }
+    });
+
+    const q = new ParseQuery('Item');
+
+    const results = await q.filter((object) => object.attributes.size === 'small');
+    expect(results.length).toBe(2);
+  });
+
   it('returns an error when iterating over an invalid query', (done) => {
     const q = new ParseQuery('Item');
     q.limit(10);