feat(firestore, android): working version of aggregate query

packages/firestore/android/src/reactnative/java/io/invertase/firebase/firestore/ReactNativeFirebaseFirestoreCollectionModule.java

@@ -17,6 +17,8 @@
  *
  */
 
+import static com.google.firebase.firestore.AggregateField.average;
+import static com.google.firebase.firestore.AggregateField.sum;
 import static io.invertase.firebase.firestore.ReactNativeFirebaseFirestoreCommon.rejectPromiseFirestoreException;
 import static io.invertase.firebase.firestore.ReactNativeFirebaseFirestoreSerialize.snapshotToWritableMap;
 import static io.invertase.firebase.firestore.UniversalFirebaseFirestoreCommon.getFirestoreForApp;
@@ -205,7 +207,8 @@ public void aggregateQuery(
     ReadableArray filters,
     ReadableArray orders,
     ReadableMap options,
-    ReadableArray aggregateQueries
+    ReadableArray aggregateQueries,
+    Promise promise
   ){
     FirebaseFirestore firebaseFirestore = getFirestoreForApp(appName, databaseId);
     ReactNativeFirebaseFirestoreQuery firestoreQuery =
@@ -216,57 +219,76 @@ public void aggregateQuery(
         filters,
         orders,
         options);
+
     ArrayList<AggregateField> aggregateFields = new ArrayList<>();
 
     for (int i = 0; i < aggregateQueries.size(); i++) {
       ReadableMap aggregateQuery = aggregateQueries.getMap(i);
+
       String aggregateType = aggregateQuery.getString("aggregateType");
-      String fieldPath = aggregateQuery.getString("fieldPath");
-      if (aggregateType && fieldPath) {
+      String fieldPath = aggregateQuery.getString("field");
+
+      assert aggregateType != null;
         switch (aggregateType) {
           case "count":
-            aggregateFields.add(AggregateField.count(fieldPath));
+            aggregateFields.add(AggregateField.count());
             break;
           case "sum":
+            assert fieldPath != null;
             aggregateFields.add(AggregateField.sum(fieldPath));
             break;
           case "average":
-            aggregateFields.add(AggregateField.avg(fieldPath));
+            assert fieldPath != null;
+            aggregateFields.add(AggregateField.average(fieldPath));
             break;
           default:
-            break;
+            throw new Error("Invalid AggregateType: " + aggregateType);
         }
-      }
+    }
+      AggregateQuery firestoreAggregateQuery = firestoreQuery.query.aggregate(aggregateFields.get(0),
+      aggregateFields.subList(1, aggregateFields.size()).toArray(new AggregateField[0]));
 
-      AggregateQuery aggregateQuery = firestoreQuery.query.aggregate(aggregateFields);
-      aggregateQuery
+      firestoreAggregateQuery
         .get(AggregateSource.SERVER)
         .addOnCompleteListener(
           task -> {
             if (task.isSuccessful()) {
               WritableMap result = Arguments.createMap();
               AggregateQuerySnapshot snapshot = task.getResult();
-              aggregateFields.forEach(aggregateField -> {
-                switch (aggregateField.getOperator()) {
+
+              for (int k = 0; k < aggregateQueries.size(); k++) {
+                ReadableMap aggQuery = aggregateQueries.getMap(k);
+                String aggType = aggQuery.getString("aggregateType");
+                String field = aggQuery.getString("field");
+                String key = aggQuery.getString("key");
+                assert key != null;
+                assert aggType != null;
+                switch (aggType) {
                   case "count":
-                    result.putDouble(aggregateField.getFieldPath(), Long.valueOf(snapshot.getCount()).doubleValue());
+                    result.putDouble(key, Long.valueOf(snapshot.getCount()).doubleValue());
                     break;
                   case "sum":
-                    result.putDouble(aggregateField.getFieldPath(), snapshot.getSum(aggregateField.getFieldPath()));
+                    assert field != null;
+                    Number sum = (Number) snapshot.get(sum(field));
+                    assert sum != null;
+                    result.putDouble(key, sum.doubleValue());
                     break;
                   case "average":
-                    result.putDouble(aggregateField.getFieldPath(), snapshot.getAverage(aggregateField.getFieldPath()));
+                    assert field != null;
+                    Number average = snapshot.get(average(field));
+                    assert average != null;
+                    result.putDouble(key, average.doubleValue());
                     break;
                   default:
-                    break;
+                    throw new Error("Invalid AggregateType: " + aggType);
                 }
               }
+
               promise.resolve(result);
             } else {
               rejectPromiseFirestoreException(promise, task.getException());
             }
           });
-    }
   }
 
   @ReactMethod

packages/firestore/lib/FirestoreAggregate.js

@@ -38,18 +38,23 @@ export class FirestoreAggregateQuery {
         this._modifiers.orders,
         this._modifiers.options,
       )
-      .then(data => new FirestoreAggregateQuerySnapshot(this._query, data));
+      .then(data => new FirestoreAggregateQuerySnapshot(this._query, data, true));
   }
 }
 
 export class FirestoreAggregateQuerySnapshot {
-  constructor(query, data) {
+  constructor(query, data, isGetCountFromServer) {
     this._query = query;
     this._data = data;
+    this._isGetCountFromServer = isGetCountFromServer;
   }
 
   data() {
-    return { count: this._data.count };
+    if (this._isGetCountFromServer) {
+      return { count: this._data.count };
+    } else {
+      return { ...this._data };
+    }
   }
 }
 
@@ -80,7 +85,7 @@ export function fieldPathFromArgument(path) {
   if (path instanceof FirestoreFieldPath) {
     return path;
   } else if (typeof path === 'string') {
-    return fromDotSeparatedString(methodName, path);
+    return fromDotSeparatedString(path);
   } else {
     throw new Error('Field path arguments must be of type `string` or `FieldPath`');
   }

packages/firestore/lib/modular/index.js

@@ -13,8 +13,12 @@
  */
 
 import { firebase } from '../index';
-import { AggregateField, AggregateType } from '../FirestoreAggregate';
-import FirestorePath from '../FirestorePath';
+import {
+  FirestoreAggregateQuerySnapshot,
+  AggregateField,
+  AggregateType,
+  fieldPathFromArgument,
+} from '../FirestoreAggregate';
 
 /**
  * @param {FirebaseApp?} app
@@ -198,37 +202,39 @@ export async function getAggregateFromServer(query, aggregateSpec) {
   const aggregateQueries = [];
   for (const key in aggregateSpec) {
     if (aggregateSpec.hasOwnProperty(key)) {
-      const value = aggregateSpec[key];
+      const aggregateField = aggregateSpec[key];
 
-      if (value instanceof AggregateField) {
-        switch (value.aggregateType) {
+      if (aggregateField instanceof AggregateField) {
+        switch (aggregateField.aggregateType) {
           case AggregateType.AVG:
           case AggregateType.SUM:
           case AggregateType.COUNT:
             const aggregateQuery = {
-              aggregateType: value.aggregateType,
-              // TODO - how is this sent over the wire? Think it is serialized automatically
-              field: value.fieldPath,
+              aggregateType: aggregateField.aggregateType,
+              field: aggregateField.fieldPath === null ? null : aggregateField.fieldPath._toPath(),
+              key,
             };
             aggregateQueries.push(aggregateQuery);
             break;
           default:
             throw new Error(
-              `"AggregateField" has an an unknown "AggregateType" : ${value.aggregateType}`,
+              `"AggregateField" has an an unknown "AggregateType" : ${aggregateField.aggregateType}`,
             );
         }
       }
     }
   }
 
-  return query._firestore.native.aggregateQuery(
-    query._collectionPath.relativeName,
-    query._modifiers.type,
-    query._modifiers.filters,
-    query._modifiers.orders,
-    query._modifiers.options,
-    aggregateQueries,
-  );
+  return query._firestore.native
+    .aggregateQuery(
+      query._collectionPath.relativeName,
+      query._modifiers.type,
+      query._modifiers.filters,
+      query._modifiers.orders,
+      query._modifiers.options,
+      aggregateQueries,
+    )
+    .then(data => new FirestoreAggregateQuerySnapshot(query, data, false));
 }
 
 /**
@@ -237,7 +243,7 @@ export async function getAggregateFromServer(query, aggregateSpec) {
  * @param field Specifies the field to sum across the result set.
  */
 export function sum(field) {
-  return new AggregateField(AggregateType.SUM, FirestorePath.fromName(field));
+  return new AggregateField(AggregateType.SUM, fieldPathFromArgument(field));
 }
 
 /**
@@ -246,15 +252,15 @@ export function sum(field) {
  * @param field Specifies the field to average across the result set.
  */
 export function average(field) {
-  return new AggregateField(AggregateType.AVG, FirestorePath.fromName(field));
+  return new AggregateField(AggregateType.AVG, fieldPathFromArgument(field));
 }
 
 /**
  * Create an AggregateField object that can be used to compute the count of
  * documents in the result set of a query.
  */
 export function count() {
-  return new AggregateField(AggregateType.COUNT);
+  return new AggregateField(AggregateType.COUNT, null);
 }
 
 /**