@react-native-firebase/firestore 21.4.0 → 21.5.0

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [21.5.0](https://github.com/invertase/react-native-firebase/compare/v21.4.1...v21.5.0) (2024-11-16)
+
+### Features
+
+- **firestore:** implement `sum()` & `average()` aggregate queries ([#8115](https://github.com/invertase/react-native-firebase/issues/8115)) ([e4c57fa](https://github.com/invertase/react-native-firebase/commit/e4c57fae5558d47af06fc82412ff61dc5ae54698))
+
+### Bug Fixes
+
+- **android:** rn74 forward-port onCatalystInstanceDestroy -> invalidate ([83696ea](https://github.com/invertase/react-native-firebase/commit/83696ea4c944b2be0b8fd9f2fc1db212800cbcf8))
+
+## [21.4.1](https://github.com/invertase/react-native-firebase/compare/v21.4.0...v21.4.1) (2024-11-13)
+
+### Reverts
+
+- Revert "fix(ios, sdk): constrain transitive dependencies more tightly" ([1ff247c](https://github.com/invertase/react-native-firebase/commit/1ff247cd73804efbd52eb9490f68087685de814c))
+
 ## [21.4.0](https://github.com/invertase/react-native-firebase/compare/v21.3.0...v21.4.0) (2024-11-07)
 
 ### Features

package/RNFBFirestore.podspec

@@ -39,7 +39,7 @@ Pod::Spec.new do |s|
   end
 
   # Firebase dependencies
-  s.dependency          'Firebase/Firestore', "<= #{firebase_sdk_version}"
+  s.dependency          'Firebase/Firestore', firebase_sdk_version
 
   if defined?($RNFirebaseAsStaticFramework)
     Pod::UI.puts "#{s.name}: Using overridden static_framework value of '#{$RNFirebaseAsStaticFramework}'"

package/__tests__/firestore.test.ts

@@ -4,6 +4,10 @@ import firestore, {
   firebase,
   Filter,
   getFirestore,
+  getAggregateFromServer,
+  count,
+  average,
+  sum,
   addDoc,
   doc,
   collection,
@@ -651,6 +655,22 @@ 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();
+    });
+
+    it('`count` is properly exposed to end user', function () {
+      expect(count).toBeDefined();
+    });
+
+    it('`average` is properly exposed to end user', function () {
+      expect(average).toBeDefined();
+    });
+
+    it('`sum` is properly exposed to end user', function () {
+      expect(sum).toBeDefined();
+    });
   });
 
   describe('FirestorePersistentCacheIndexManager', function () {

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

@@ -17,6 +17,8 @@ package io.invertase.firebase.firestore;
  *
  */
 
+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.android.gms.tasks.Tasks;
 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";
@@ -39,8 +42,8 @@ public class ReactNativeFirebaseFirestoreCollectionModule extends ReactNativeFir
   }
 
   @Override
-  public void onCatalystInstanceDestroy() {
-    super.onCatalystInstanceDestroy();
+  public void invalidate() {
+    super.invalidate();
 
     for (int i = 0, size = collectionSnapshotListeners.size(); i < size; i++) {
       int key = collectionSnapshotListeners.keyAt(i);
@@ -193,6 +196,114 @@ public class ReactNativeFirebaseFirestoreCollectionModule extends ReactNativeFir
             });
   }
 
+  @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,

package/android/src/reactnative/java/io/invertase/firebase/firestore/ReactNativeFirebaseFirestoreDocumentModule.java

@@ -43,8 +43,8 @@ public class ReactNativeFirebaseFirestoreDocumentModule extends ReactNativeFireb
   }
 
   @Override
-  public void onCatalystInstanceDestroy() {
-    super.onCatalystInstanceDestroy();
+  public void invalidate() {
+    super.invalidate();
 
     for (int i = 0, size = documentSnapshotListeners.size(); i < size; i++) {
       int key = documentSnapshotListeners.keyAt(i);

package/android/src/reactnative/java/io/invertase/firebase/firestore/ReactNativeFirebaseFirestoreTransactionModule.java

@@ -45,7 +45,7 @@ public class ReactNativeFirebaseFirestoreTransactionModule extends ReactNativeFi
   }
 
   @Override
-  public void onCatalystInstanceDestroy() {
+  public void invalidate() {
     for (int i = 0, size = transactionHandlers.size(); i < size; i++) {
       int key = transactionHandlers.keyAt(i);
       ReactNativeFirebaseFirestoreTransactionHandler transactionHandler =
@@ -57,7 +57,7 @@ public class ReactNativeFirebaseFirestoreTransactionModule extends ReactNativeFi
     }
 
     transactionHandlers.clear();
-    super.onCatalystInstanceDestroy();
+    super.invalidate();
   }
 
   @ReactMethod

package/ios/RNFBFirestore/RNFBFirestoreCollectionModule.m

@@ -216,6 +216,81 @@ RCT_EXPORT_METHOD(collectionCount
                  }];
 }
 
+RCT_EXPORT_METHOD(aggregateQuery
+                  : (FIRApp *)firebaseApp
+                  : (NSString *)databaseId
+                  : (NSString *)path
+                  : (NSString *)type
+                  : (NSArray *)filters
+                  : (NSArray *)orders
+                  : (NSDictionary *)options
+                  : (NSArray *)aggregateQueries
+                  : (RCTPromiseResolveBlock)resolve
+                  : (RCTPromiseRejectBlock)reject) {
+  FIRFirestore *firestore = [RNFBFirestoreCommon getFirestoreForApp:firebaseApp
+                                                         databaseId:databaseId];
+  FIRQuery *query = [RNFBFirestoreCommon getQueryForFirestore:firestore path:path type:type];
+
+  NSMutableArray<FIRAggregateField *> *aggregateFields =
+      [[NSMutableArray<FIRAggregateField *> alloc] init];
+
+  for (NSDictionary *aggregateQuery in aggregateQueries) {
+    NSString *aggregateType = aggregateQuery[@"aggregateType"];
+    NSString *fieldPath = aggregateQuery[@"field"];
+
+    if ([aggregateType isEqualToString:@"count"]) {
+      [aggregateFields addObject:[FIRAggregateField aggregateFieldForCount]];
+    } else if ([aggregateType isEqualToString:@"sum"]) {
+      [aggregateFields addObject:[FIRAggregateField aggregateFieldForSumOfField:fieldPath]];
+    } else if ([aggregateType isEqualToString:@"average"]) {
+      [aggregateFields addObject:[FIRAggregateField aggregateFieldForAverageOfField:fieldPath]];
+    } else {
+      NSString *reason = [@"Invalid Aggregate Type: " stringByAppendingString:aggregateType];
+      [RNFBFirestoreCommon
+          promiseRejectFirestoreException:reject
+                                    error:[NSException exceptionWithName:
+                                                           @"RNFB Firestore: Invalid Aggregate Type"
+                                                                  reason:reason
+                                                                userInfo:nil]];
+      return;
+    }
+  }
+
+  FIRAggregateQuery *aggregateQuery = [query aggregate:aggregateFields];
+
+  [aggregateQuery
+      aggregationWithSource:FIRAggregateSourceServer
+                 completion:^(FIRAggregateQuerySnapshot *_Nullable snapshot,
+                              NSError *_Nullable error) {
+                   if (error) {
+                     [RNFBFirestoreCommon promiseRejectFirestoreException:reject error:error];
+                   } else {
+                     NSMutableDictionary *snapshotMap = [NSMutableDictionary dictionary];
+
+                     for (NSDictionary *aggregateQuery in aggregateQueries) {
+                       NSString *aggregateType = aggregateQuery[@"aggregateType"];
+                       NSString *fieldPath = aggregateQuery[@"field"];
+                       NSString *key = aggregateQuery[@"key"];
+
+                       if ([aggregateType isEqualToString:@"count"]) {
+                         snapshotMap[key] = snapshot.count;
+                       } else if ([aggregateType isEqualToString:@"sum"]) {
+                         NSNumber *sum = [snapshot
+                             valueForAggregateField:[FIRAggregateField
+                                                        aggregateFieldForSumOfField:fieldPath]];
+                         snapshotMap[key] = sum;
+                       } else if ([aggregateType isEqualToString:@"average"]) {
+                         NSNumber *average = [snapshot
+                             valueForAggregateField:[FIRAggregateField
+                                                        aggregateFieldForAverageOfField:fieldPath]];
+                         snapshotMap[key] = (average == nil ? [NSNull null] : average);
+                       }
+                     }
+                     resolve(snapshotMap);
+                   }
+                 }];
+}
+
 RCT_EXPORT_METHOD(collectionGet
                   : (FIRApp *)firebaseApp
                   : (NSString *)databaseId

package/lib/FirestoreAggregate.js

@@ -15,6 +15,8 @@
  *
  */
 
+import FirestoreFieldPath, { fromDotSeparatedString } from './FirestoreFieldPath';
+
 export class FirestoreAggregateQuery {
   constructor(firestore, query, collectionPath, modifiers) {
     this._firestore = firestore;
@@ -36,17 +38,55 @@ 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 };
+    }
+  }
+}
+
+export const AggregateType = {
+  SUM: 'sum',
+  AVG: 'average',
+  COUNT: 'count',
+};
+
+export class AggregateField {
+  /** Indicates the aggregation operation of this AggregateField. */
+  aggregateType;
+  _fieldPath;
+
+  /**
+   * Create a new AggregateField<T>
+   * @param aggregateType Specifies the type of aggregation operation to perform.
+   * @param _fieldPath Optionally specifies the field that is aggregated.
+   * @internal
+   */
+  constructor(aggregateType, fieldPath) {
+    this.aggregateType = aggregateType;
+    this._fieldPath = fieldPath;
+  }
+}
+
+export function fieldPathFromArgument(path) {
+  if (path instanceof FirestoreFieldPath) {
+    return path;
+  } else if (typeof path === 'string') {
+    return fromDotSeparatedString(path);
+  } else {
+    throw new Error('Field path arguments must be of type `string` or `FieldPath`');
   }
 }

package/lib/index.d.ts

@@ -921,12 +921,16 @@ export namespace FirebaseFirestoreTypes {
   /**
    * The results of executing an aggregation query.
    */
-  export interface AggregateQuerySnapshot<T extends AggregateSpec> {
+  export interface AggregateQuerySnapshot<
+    AggregateSpecType extends AggregateSpec,
+    AppModelType = DocumentData,
+    DbModelType extends DocumentData = DocumentData,
+  > {
     /**
      * The underlying query over which the aggregations recorded in this
      * `AggregateQuerySnapshot` were performed.
      */
-    get query(): Query<unknown>;
+    get query(): Query<AppModelType, DbModelType>;
 
     /**
      * Returns the results of the aggregations performed over the underlying
@@ -939,7 +943,7 @@ export namespace FirebaseFirestoreTypes {
      * @returns The results of the aggregations performed over the underlying
      * query.
      */
-    data(): AggregateSpecData<T>;
+    data(): AggregateSpecData<AggregateSpecType>;
   }
 
   /**

package/lib/modular/index.d.ts

@@ -10,6 +10,7 @@ import Query = FirebaseFirestoreTypes.Query;
 import FieldValue = FirebaseFirestoreTypes.FieldValue;
 import FieldPath = FirebaseFirestoreTypes.FieldPath;
 import PersistentCacheIndexManager = FirebaseFirestoreTypes.PersistentCacheIndexManager;
+import AggregateQuerySnapshot = FirebaseFirestoreTypes.AggregateQuerySnapshot;
 
 /** Primitive types. */
 export type Primitive = string | number | boolean | undefined | null;
@@ -495,6 +496,75 @@ export function getCountFromServer<AppModelType, DbModelType extends DocumentDat
   >
 >;
 
+/**
+ * Specifies a set of aggregations and their aliases.
+ */
+interface AggregateSpec {
+  [field: string]: AggregateFieldType;
+}
+
+/**
+ * The union of all `AggregateField` types that are supported by Firestore.
+ */
+export type AggregateFieldType =
+  | ReturnType<typeof sum>
+  | ReturnType<typeof average>
+  | ReturnType<typeof count>;
+
+export function getAggregateFromServer<
+  AggregateSpecType extends AggregateSpec,
+  AppModelType,
+  DbModelType extends DocumentData,
+>(
+  query: Query<AppModelType, DbModelType>,
+  aggregateSpec: AggregateSpecType,
+): Promise<AggregateQuerySnapshot<AggregateSpecType, AppModelType, DbModelType>>;
+
+/**
+ * Create an AggregateField object that can be used to compute the sum of
+ * a specified field over a range of documents in the result set of a query.
+ * @param field Specifies the field to sum across the result set.
+ */
+export function sum(field: string | FieldPath): AggregateField<number>;
+
+/**
+ * Create an AggregateField object that can be used to compute the average of
+ * a specified field over a range of documents in the result set of a query.
+ * @param field Specifies the field to average across the result set.
+ */
+export function average(field: string | FieldPath): AggregateField<number | null>;
+
+/**
+ * Create an AggregateField object that can be used to compute the count of
+ * documents in the result set of a query.
+ */
+export function count(): AggregateField<number>;
+
+/**
+ * Represents an aggregation that can be performed by Firestore.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export class AggregateField<T> {
+  /** A type string to uniquely identify instances of this class. */
+  readonly type = 'AggregateField';
+
+  /** Indicates the aggregation operation of this AggregateField. */
+  readonly aggregateType: AggregateType;
+
+  /**
+   * Create a new AggregateField<T>
+   * @param aggregateType Specifies the type of aggregation operation to perform.
+   * @param _internalFieldPath Optionally specifies the field that is aggregated.
+   * @internal
+   */
+  constructor(
+    aggregateType: AggregateType = 'count',
+    readonly _internalFieldPath?: InternalFieldPath,
+  ) {
+    this.aggregateType = aggregateType;
+  }
+}
+
 /**
  * Represents the task of loading a Firestore bundle.
  * It provides progress of bundle loading, as well as task completion and error events.

package/lib/modular/index.js

@@ -13,6 +13,14 @@
  */
 
 import { firebase } from '../index';
+import { isObject } from '@react-native-firebase/app/lib/common';
+import {
+  FirestoreAggregateQuerySnapshot,
+  AggregateField,
+  AggregateType,
+  fieldPathFromArgument,
+} from '../FirestoreAggregate';
+import FirestoreQuery from '../FirestoreQuery';
 
 /**
  * @param {FirebaseApp?} app
@@ -192,6 +200,91 @@ export function getCountFromServer(query) {
   return query.count().get();
 }
 
+export function getAggregateFromServer(query, aggregateSpec) {
+  if (!(query instanceof FirestoreQuery)) {
+    throw new Error(
+      '`getAggregateFromServer(*, aggregateSpec)` `query` must be an instance of `FirestoreQuery`',
+    );
+  }
+
+  if (!isObject(aggregateSpec)) {
+    throw new Error('`getAggregateFromServer(query, *)` `aggregateSpec` must be an object');
+  } else {
+    const containsOneAggregateField = Object.values(aggregateSpec).find(
+      value => value instanceof AggregateField,
+    );
+
+    if (!containsOneAggregateField) {
+      throw new Error(
+        '`getAggregateFromServer(query, *)` `aggregateSpec` must contain at least one `AggregateField`',
+      );
+    }
+  }
+  const aggregateQueries = [];
+  for (const key in aggregateSpec) {
+    if (aggregateSpec.hasOwnProperty(key)) {
+      const aggregateField = aggregateSpec[key];
+      // we ignore any fields that are not `AggregateField`
+      if (aggregateField instanceof AggregateField) {
+        switch (aggregateField.aggregateType) {
+          case AggregateType.AVG:
+          case AggregateType.SUM:
+          case AggregateType.COUNT:
+            const aggregateQuery = {
+              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' : ${aggregateField.aggregateType}`,
+            );
+        }
+      }
+    }
+  }
+
+  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));
+}
+
+/**
+ * Create an AggregateField object that can be used to compute the sum of
+ * a specified field over a range of documents in the result set of a query.
+ * @param field Specifies the field to sum across the result set.
+ */
+export function sum(field) {
+  return new AggregateField(AggregateType.SUM, fieldPathFromArgument(field));
+}
+
+/**
+ * Create an AggregateField object that can be used to compute the average of
+ * a specified field over a range of documents in the result set of a query.
+ * @param field Specifies the field to average across the result set.
+ */
+export function average(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, null);
+}
+
 /**
  * @param {Firestore} firestore
  * @param {ReadableStream<Uint8Array> | ArrayBuffer | string} bundleData

package/lib/version.js

@@ -1,2 +1,2 @@
 // Generated by genversion.
-module.exports = '21.4.0';
+module.exports = '21.5.0';

package/lib/web/RNFBFirestoreModule.js

@@ -11,6 +11,10 @@ import {
   getDoc,
   getDocs,
   getCount,
+  getAggregate,
+  count,
+  average,
+  sum,
   deleteDoc,
   setDoc,
   updateDoc,
@@ -215,6 +219,44 @@ export default {
     });
   },
 
+  aggregateQuery(appName, databaseId, path, type, filters, orders, options, aggregateQueries) {
+    return guard(async () => {
+      const firestore = getCachedFirestoreInstance(appName, databaseId);
+      const queryRef =
+        type === 'collectionGroup' ? collectionGroup(firestore, path) : collection(firestore, path);
+      const query = buildQuery(queryRef, filters, orders, options);
+      const aggregateSpec = {};
+
+      for (let i = 0; i < aggregateQueries.length; i++) {
+        const aggregateQuery = aggregateQueries[i];
+        const { aggregateType, field, key } = aggregateQuery;
+
+        switch (aggregateType) {
+          case 'count':
+            aggregateSpec[key] = count();
+            break;
+          case 'average':
+            aggregateSpec[key] = average(field);
+            break;
+          case 'sum':
+            aggregateSpec[key] = sum(field);
+            break;
+        }
+      }
+      const result = await getAggregate(query, aggregateSpec);
+
+      const data = result.data();
+      const response = {};
+      for (let i = 0; i < aggregateQueries.length; i++) {
+        const aggregateQuery = aggregateQueries[i];
+        const { key } = aggregateQuery;
+        response[key] = data[key];
+      }
+
+      return response;
+    });
+  },
+
   /**
    * Get a collection from Firestore.
    * @param {string} appName - The app name.

package/lib/web/query.js

@@ -108,5 +108,5 @@ function getFilterConstraint(filter) {
     throw new Error('Invalid filter operator');
   }
 
-  throw new Error('Invaldi filter.');
+  throw new Error('Invalid filter.');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-firebase/firestore",
-  "version": "21.4.0",
+  "version": "21.5.0",
   "author": "Invertase <oss@invertase.io> (http://invertase.io)",
   "description": "React Native Firebase - Cloud Firestore is a NoSQL cloud database to store and sync data between your React Native application and Firebase's database. The API matches the Firebase Web SDK whilst taking advantage of the native SDKs performance and offline capabilities.",
   "main": "lib/index.js",
@@ -27,10 +27,10 @@
     "firestore"
   ],
   "peerDependencies": {
-    "@react-native-firebase/app": "21.4.0"
+    "@react-native-firebase/app": "21.5.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "227e1ed54cf668cbc701c0ed2542b8ec66957e1e"
+  "gitHead": "ca6b846408d5f1773adb84b94c6dcb8c6a7c658a"
 }