feat(firestore): support for aggregate queries including sum() & average()

packages/firestore/__tests__/firestore.test.ts

@@ -4,6 +4,7 @@ import firestore, {
   firebase,
   Filter,
   getFirestore,
+  getAggregateFromServer,
   addDoc,
   doc,
   collection,
@@ -651,6 +652,10 @@ describe('Firestore', function () {
     it('`enablePersistentCacheIndexAutoCreation` is properly exposed to end user', function () {
       expect(enablePersistentCacheIndexAutoCreation).toBeDefined();
     });
+
+    it('`getAggregateFromServer` is properly exposed to end user', function () {
+      expect(getAggregateFromServer).toBeDefined();
+    });
   });
 
   describe('FirestorePersistentCacheIndexManager', function () {

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;
@@ -28,6 +30,7 @@
 import com.google.firebase.firestore.*;
 import io.invertase.firebase.common.ReactNativeFirebaseEventEmitter;
 import io.invertase.firebase.common.ReactNativeFirebaseModule;
+import java.util.ArrayList;
 
 public class ReactNativeFirebaseFirestoreCollectionModule extends ReactNativeFirebaseModule {
   private static final String SERVICE_NAME = "FirestoreCollection";
@@ -193,6 +196,114 @@ public void collectionCount(
             });
   }
 
+  @ReactMethod
+  public void aggregateQuery(
+      String appName,
+      String databaseId,
+      String path,
+      String type,
+      ReadableArray filters,
+      ReadableArray orders,
+      ReadableMap options,
+      ReadableArray aggregateQueries,
+      Promise promise) {
+    FirebaseFirestore firebaseFirestore = getFirestoreForApp(appName, databaseId);
+    ReactNativeFirebaseFirestoreQuery firestoreQuery =
+        new ReactNativeFirebaseFirestoreQuery(
+            appName,
+            databaseId,
+            getQueryForFirestore(firebaseFirestore, path, type),
+            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");
+      if (aggregateType == null) aggregateType = "";
+      String fieldPath = aggregateQuery.getString("field");
+
+      switch (aggregateType) {
+        case "count":
+          aggregateFields.add(AggregateField.count());
+          break;
+        case "sum":
+          aggregateFields.add(AggregateField.sum(fieldPath));
+          break;
+        case "average":
+          aggregateFields.add(AggregateField.average(fieldPath));
+          break;
+        default:
+          rejectPromiseWithCodeAndMessage(
+              promise, "firestore/invalid-argument", "Invalid AggregateType: " + aggregateType);
+          return;
+      }
+    }
+    AggregateQuery firestoreAggregateQuery =
+        firestoreQuery.query.aggregate(
+            aggregateFields.get(0),
+            aggregateFields.subList(1, aggregateFields.size()).toArray(new AggregateField[0]));
+
+    firestoreAggregateQuery
+        .get(AggregateSource.SERVER)
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                WritableMap result = Arguments.createMap();
+                AggregateQuerySnapshot snapshot = task.getResult();
+
+                for (int k = 0; k < aggregateQueries.size(); k++) {
+                  ReadableMap aggQuery = aggregateQueries.getMap(k);
+                  String aggType = aggQuery.getString("aggregateType");
+                  if (aggType == null) aggType = "";
+                  String field = aggQuery.getString("field");
+                  String key = aggQuery.getString("key");
+
+                  if (key == null) {
+                    rejectPromiseWithCodeAndMessage(
+                        promise, "firestore/invalid-argument", "key may not be null");
+                    return;
+                  }
+
+                  switch (aggType) {
+                    case "count":
+                      result.putDouble(key, Long.valueOf(snapshot.getCount()).doubleValue());
+                      break;
+                    case "sum":
+                      Number sum = (Number) snapshot.get(sum(field));
+                      if (sum == null) {
+                        rejectPromiseWithCodeAndMessage(
+                            promise, "firestore/unknown", "sum unexpectedly null");
+                        return;
+                      }
+                      result.putDouble(key, sum.doubleValue());
+                      break;
+                    case "average":
+                      Number average = snapshot.get(average(field));
+                      if (average == null) {
+                        result.putNull(key);
+                      } else {
+                        result.putDouble(key, average.doubleValue());
+                      }
+                      break;
+                    default:
+                      rejectPromiseWithCodeAndMessage(
+                          promise,
+                          "firestore/invalid-argument",
+                          "Invalid AggregateType: " + aggType);
+                      return;
+                  }
+                }
+
+                promise.resolve(result);
+              } else {
+                rejectPromiseFirestoreException(promise, task.getException());
+              }
+            });
+  }
+
   @ReactMethod
   public void collectionGet(
       String appName,