feat: COUNT Queries

dev/src/reference.ts

@@ -1606,7 +1606,7 @@ export class Query<T = firestore.DocumentData> implements firestore.Query<T> {
    * result set.
    */
   count(): AggregateQuery<{count: firestore.AggregateField<number>}> {
-    return this.aggregate({count: AggregateField.count()});
+    return this._aggregate({count: AggregateField.count()});
   }
 
   /**
@@ -1615,7 +1615,7 @@ export class Query<T = firestore.DocumentData> implements firestore.Query<T> {
    * @param aggregates the aggregations to perform.
    * @return an `AggregateQuery` that performs the given aggregations.
    */
-  aggregate<T extends firestore.AggregateSpec>(
+  _aggregate<T extends firestore.AggregateSpec>(
     aggregates: T
   ): AggregateQuery<T> {
     return new AggregateQuery(this, aggregates);
@@ -2881,10 +2881,6 @@ export class AggregateQuery<T extends firestore.AggregateSpec>
     return this._query;
   }
 
-  get aggregates(): T {
-    return this._aggregates;
-  }
-
   get(): Promise<AggregateQuerySnapshot<T>> {
     return this._get();
   }
@@ -2938,7 +2934,7 @@ export class AggregateQuery<T extends firestore.AggregateSpec>
             new AggregateQuerySnapshot<T>(this, readTime, data)
           );
         } else {
-          callback(Error('unexpected'));
+          callback(Error('RunAggregationQueryResponse is missing result'));
         }
       },
     });
@@ -2968,11 +2964,11 @@ export class AggregateQuery<T extends firestore.AggregateSpec>
             backendStream.unpipe(stream);
             // If a non-transactional query failed, attempt to restart.
             // Transactional queries are retried via the transaction runner.
-            if (!transactionId && !isPermanentRpcError(err, 'runQuery')) {
+            if (!transactionId && !isPermanentRpcError(err, 'runAggregationQuery')) {
               logger(
-                'Query._stream',
+                'AggregateQuery._stream',
                 tag,
-                'Query failed with retryable stream error:',
+                'AggregateQuery failed with retryable stream error:',
                 err
               );
               streamActive.resolve(/* active= */ true);
@@ -3093,14 +3089,6 @@ export class AggregateQuerySnapshot<T extends firestore.AggregateSpec>
     return this._readTime;
   }
 
-  getCount(): number {
-    const count = this._data.count;
-    if (typeof count === 'number') {
-      return count;
-    }
-    throw new Error('Unexpected count is ' + typeof count);
-  }
-
   isEqual(other: firestore.AggregateQuerySnapshot<T>): boolean {
     if (this === other) {
       return true;

dev/system-test/firestore.ts

@@ -2155,21 +2155,21 @@ describe.only('Aggregates', () => {
   it('counts 0 document from non-existent collection', async () => {
     const count = randomCol.count();
     const res = await firestore.runTransaction(f => f.get(count));
-    expect(res.getCount()).to.equal(0);
+    expect(res.data().count).to.equal(0);
   });
 
   it('counts 0 document from filtered empty collection', async () => {
     await randomCol.doc('doc').set({foo: 'bar'});
     const count = randomCol.where('foo', '==', 'notbar').count();
     const res = await firestore.runTransaction(f => f.get(count));
-    expect(res.getCount()).to.equal(0);
+    expect(res.data().count).to.equal(0);
   });
 
   it('counts 1 document', async () => {
     await randomCol.doc('doc').set({foo: 'bar'});
     const count = randomCol.count();
     const res = await firestore.runTransaction(f => f.get(count));
-    expect(res.getCount()).to.equal(1);
+    expect(res.data().count).to.equal(1);
   });
 
   it('counts multiple documents with filter', async () => {
@@ -2179,7 +2179,7 @@ describe.only('Aggregates', () => {
     await randomCol.doc('doc3').set({notfoo: 'bar'});
     const count = randomCol.where('foo', '==', 'bar').count();
     const res = await firestore.runTransaction(f => f.get(count));
-    expect(res.getCount()).to.equal(2);
+    expect(res.data().count).to.equal(2);
   });
 
   it('counts up to limit', async () => {
@@ -2193,7 +2193,7 @@ describe.only('Aggregates', () => {
     await randomCol.doc('doc8').set({foo: 'bar'});
     const count = randomCol.limit(5).count();
     const res = await firestore.runTransaction(f => f.get(count));
-    expect(res.getCount()).to.equal(5);
+    expect(res.data().count).to.equal(5);
   });
 
   it('counts with orderBy', async () => {
@@ -2208,11 +2208,11 @@ describe.only('Aggregates', () => {
 
     const count1 = randomCol.orderBy('foo2').count();
     const res1 = await firestore.runTransaction(f => f.get(count1));
-    expect(res1.getCount()).to.equal(3);
+    expect(res1.data().count).to.equal(3);
 
     const count2 = randomCol.orderBy('foo3').count();
     const res2 = await firestore.runTransaction(f => f.get(count2));
-    expect(res2.getCount()).to.equal(0);
+    expect(res2.data().count).to.equal(0);
   });
 });
 

types/firestore.d.ts

@@ -1713,14 +1713,6 @@ declare namespace FirebaseFirestore {
      */
     count(): AggregateQuery<{count: AggregateField<number>}>;
 
-    /**
-     * Returns `AggregateQuery` for given aggregates based on this `Query`.
-     *
-     * @param aggregates Specify aliases with aggregate functions.
-     * @return An AggregateQuery that contains given aggregates.
-     */
-    aggregate<T extends AggregateSpec>(aggregates: T): AggregateQuery<T>;
-
     /**
      * Returns true if this `Query` is equal to the provided one.
      *
@@ -2092,8 +2084,6 @@ declare namespace FirebaseFirestore {
 
     readonly query: Query<unknown>;
 
-    readonly aggregates: T;
-
     get(): Promise<AggregateQuerySnapshot<T>>;
 
     /**