Add a findAll method to ParseQuery (#1233)

* Add a findAll method to ParseQuery

* Add unit tests for ParseQuery.findAll method

Author: codeKonami

integration/test/ParseQueryTest.js

@@ -1223,6 +1223,18 @@ describe('Parse Query', () => {
     });
   });
 
+  it('can return all objects with findAll', async () => {
+    const objs = [...Array(101)].map(() => new Parse.Object('Container'));
+
+    await Parse.Object.saveAll(objs);
+
+    const query = new Parse.Query('Container');
+
+    const result = await query.findAll();
+
+    assert.equal(result.length, 101);
+  });
+
   it('can include nested objects via array', (done) => {
     const child = new TestObject();
     const parent = new Parse.Object('Container');

src/ParseQuery.js

@@ -673,6 +673,28 @@ class ParseQuery {
     });
   }
 
+  /**
+   * Retrieves a complete list of ParseObjects that satisfy this query.
+   * Using `eachBatch` under the hood to fetch all the valid objects.
+   *
+   * @param {Object} options Valid options are:<ul>
+   *   <li>batchSize: How many objects to yield in each batch (default: 100)
+   *   <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 is resolved with the results when
+   * the query completes.
+   */
+  async findAll(options?: BatchOptions): Promise<Array<ParseObject>> {
+    let result: ParseObject[] = [];
+    await this.eachBatch((objects: ParseObject[]) => {
+      result = [...result, ...objects];
+    }, options);
+    return result;
+  }
+
   /**
    * Counts the number of objects that match this query.
    * Either options.success or options.error is called when the count

src/__tests__/ParseQuery-test.js

@@ -1638,6 +1638,110 @@ describe('ParseQuery', () => {
     });
   });
 
+  describe('return all objects with .findAll()', () => {
+    let findMock;
+    beforeEach(() => {
+      findMock = jest.fn();
+      findMock.mockReturnValueOnce(Promise.resolve({
+        results: [
+          { objectId: 'I55', size: 'medium', name: 'Product 55' },
+          { objectId: 'I89', size: 'small', name: 'Product 89' },
+        ]
+      }));
+      findMock.mockReturnValueOnce(Promise.resolve({
+        results: [
+          { objectId: 'I91', size: 'small', name: 'Product 91' },
+        ]
+      }));
+      CoreManager.setQueryController({
+        aggregate() {},
+        find: findMock,
+      });
+    });
+
+    it('passes query attributes through to the REST API', async () => {
+      const q = new ParseQuery('Item');
+      q.containedIn('size', ['small', 'medium']);
+      q.matchesKeyInQuery(
+        'name',
+        'productName',
+        new ParseQuery('Review').equalTo('stars', 5)
+      );
+      q.equalTo('valid', true);
+      q.select('size', 'name');
+      q.includeAll();
+      q.hint('_id_');
+
+      await q.findAll();
+      expect(findMock).toHaveBeenCalledTimes(1);
+      const [className, params, options] = findMock.mock.calls[0];
+      expect(className).toBe('Item')
+      expect(params).toEqual({
+        limit: 100,
+        order: 'objectId',
+        keys: 'size,name',
+        include: '*',
+        hint: '_id_',
+        where: {
+          size: {
+            $in: ['small', 'medium']
+          },
+          name: {
+            $select: {
+              key: 'productName',
+              query: {
+                className: 'Review',
+                where: {
+                  stars: 5
+                }
+              }
+            }
+          },
+          valid: true
+        }
+      });
+      expect(options.requestTask).toBeDefined();
+    });
+
+    it('passes options through to the REST API', async () => {
+      const batchOptions = {
+        useMasterKey: true,
+        sessionToken: '1234',
+        batchSize: 50,
+      };
+      const q = new ParseQuery('Item');
+      await q.findAll(batchOptions);
+      expect(findMock).toHaveBeenCalledTimes(1);
+      const [className, params, options] = findMock.mock.calls[0];
+      expect(className).toBe('Item');
+      expect(params).toEqual({
+        limit: 50,
+        order: 'objectId',
+        where: {},
+      });
+      expect(options.useMasterKey).toBe(true);
+      expect(options.sessionToken).toEqual('1234');
+    });
+
+    it('only makes one request when the results fit in one page', async () => {
+      const q = new ParseQuery('Item');
+      await q.findAll();
+      expect(findMock).toHaveBeenCalledTimes(1);
+    });
+
+    it('makes more requests when the results do not fit in one page', async () => {
+      const q = new ParseQuery('Item');
+      await q.findAll({ batchSize: 2 });
+      expect(findMock).toHaveBeenCalledTimes(2);
+    })
+
+    it('Returns all objects', async () => {
+      const q = new ParseQuery('Item');
+      const results = await q.findAll();
+      expect(results.map(obj => obj.attributes.size)).toEqual(['medium', 'small']);
+    });
+  });
+
   it('can iterate over results with each()', (done) => {
     CoreManager.setQueryController({
       aggregate() {},