@react-native-firebase/firestore 15.7.1 → 16.1.0

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [16.1.0](https://github.com/invertase/react-native-firebase/compare/v16.0.0...v16.1.0) (2022-10-20)
+
+### Features
+
+- **firestore, count:** implement AggregateQuery count() on collections ([bd52301](https://github.com/invertase/react-native-firebase/commit/bd52301ad4ef35eeb4dbdab1bc4926db72d40949))
+
+### Bug Fixes
+
+- **firestore, emulator:** avoid double calls to useEmulator ([4e0d188](https://github.com/invertase/react-native-firebase/commit/4e0d188416f4ae8eb176ef024b5698bc892838d5)), closes [#5723](https://github.com/invertase/react-native-firebase/issues/5723)
+
+## [16.0.0](https://github.com/invertase/react-native-firebase/compare/v15.7.1...v16.0.0) (2022-10-19)
+
+**Note:** Version bump only for package @react-native-firebase/firestore
+
 ## [15.7.1](https://github.com/invertase/react-native-firebase/compare/v15.7.0...v15.7.1) (2022-10-19)
 
 **Note:** Version bump only for package @react-native-firebase/firestore

package/android/src/main/java/io/invertase/firebase/firestore/UniversalFirebaseFirestoreModule.java

@@ -28,11 +28,14 @@ import com.google.firebase.firestore.LoadBundleTask;
 import io.invertase.firebase.common.UniversalFirebaseModule;
 import io.invertase.firebase.common.UniversalFirebasePreferences;
 import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
 
 public class UniversalFirebaseFirestoreModule extends UniversalFirebaseModule {
 
+  private static HashMap<String, String> emulatorConfigs = new HashMap<>();
+
   UniversalFirebaseFirestoreModule(Context context, String serviceName) {
     super(context, serviceName);
   }
@@ -49,7 +52,10 @@ public class UniversalFirebaseFirestoreModule extends UniversalFirebaseModule {
     return Tasks.call(
         getExecutor(),
         () -> {
-          getFirestoreForApp(appName).useEmulator(host, port);
+          if (emulatorConfigs.get(appName) == null) {
+            emulatorConfigs.put(appName, "true");
+            getFirestoreForApp(appName).useEmulator(host, port);
+          }
           return null;
         });
   }

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

@@ -148,6 +148,36 @@ public class ReactNativeFirebaseFirestoreCollectionModule extends ReactNativeFir
             });
   }
 
+  @ReactMethod
+  public void collectionCount(
+      String appName,
+      String path,
+      String type,
+      ReadableArray filters,
+      ReadableArray orders,
+      ReadableMap options,
+      Promise promise) {
+    FirebaseFirestore firebaseFirestore = getFirestoreForApp(appName);
+    ReactNativeFirebaseFirestoreQuery firestoreQuery =
+        new ReactNativeFirebaseFirestoreQuery(
+            appName, getQueryForFirestore(firebaseFirestore, path, type), filters, orders, options);
+
+    AggregateQuery aggregateQuery = firestoreQuery.query.count();
+
+    aggregateQuery
+        .get(AggregateSource.SERVER)
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                WritableMap result = Arguments.createMap();
+                result.putDouble("count", Long.valueOf(task.getResult().getCount()).doubleValue());
+                promise.resolve(result);
+              } else {
+                rejectPromiseFirestoreException(promise, task.getException());
+              }
+            });
+  }
+
   @ReactMethod
   public void collectionGet(
       String appName,

package/ios/RNFBFirestore/RNFBFirestoreCollectionModule.m

@@ -165,6 +165,43 @@ RCT_EXPORT_METHOD(namedQueryGet
          }];
 }
 
+RCT_EXPORT_METHOD(collectionCount
+                  : (FIRApp *)firebaseApp
+                  : (NSString *)path
+                  : (NSString *)type
+                  : (NSArray *)filters
+                  : (NSArray *)orders
+                  : (NSDictionary *)options
+                  : (RCTPromiseResolveBlock)resolve
+                  : (RCTPromiseRejectBlock)reject) {
+  FIRFirestore *firestore = [RNFBFirestoreCommon getFirestoreForApp:firebaseApp];
+  FIRQuery *query = [RNFBFirestoreCommon getQueryForFirestore:firestore path:path type:type];
+  RNFBFirestoreQuery *firestoreQuery = [[RNFBFirestoreQuery alloc] initWithModifiers:firestore
+                                                                               query:query
+                                                                             filters:filters
+                                                                              orders:orders
+                                                                             options:options];
+
+  // NOTE: There is only "server" as the source at the moment. So this
+  // is unused for the time being. Using "FIRAggregateSourceServer".
+  // NSString *source = arguments[@"source"];
+
+  FIRAggregateQuery *aggregateQuery = [firestoreQuery.query count];
+
+  [aggregateQuery
+      aggregationWithSource:FIRAggregateSourceServer
+                 completion:^(FIRAggregateQuerySnapshot *_Nullable snapshot,
+                              NSError *_Nullable error) {
+                   if (error) {
+                     [RNFBFirestoreCommon promiseRejectFirestoreException:reject error:error];
+                   } else {
+                     NSMutableDictionary *snapshotMap = [NSMutableDictionary dictionary];
+                     snapshotMap[@"count"] = snapshot.count;
+                     resolve(snapshotMap);
+                   }
+                 }];
+}
+
 RCT_EXPORT_METHOD(collectionGet
                   : (FIRApp *)firebaseApp
                   : (NSString *)path

package/ios/RNFBFirestore/RNFBFirestoreModule.m

@@ -20,6 +20,8 @@
 #import "RNFBFirestoreCommon.h"
 #import "RNFBPreferences.h"
 
+NSMutableDictionary *emulatorConfigs;
+
 @implementation RNFBFirestoreModule
 #pragma mark -
 #pragma mark Module Setup
@@ -142,13 +144,19 @@ RCT_EXPORT_METHOD(useEmulator
                   : (FIRApp *)firebaseApp
                   : (nonnull NSString *)host
                   : (NSInteger)port) {
-  FIRFirestore *firestore = [RNFBFirestoreCommon getFirestoreForApp:firebaseApp];
-  [firestore useEmulatorWithHost:host port:port];
-
-  // It is not sufficient to just use emulator. You have toggle SSL off too.
-  FIRFirestoreSettings *settings = firestore.settings;
-  settings.sslEnabled = FALSE;
-  firestore.settings = settings;
+  if (emulatorConfigs == nil) {
+    emulatorConfigs = [[NSMutableDictionary alloc] init];
+  }
+  if (!emulatorConfigs[firebaseApp.name]) {
+    FIRFirestore *firestore = [RNFBFirestoreCommon getFirestoreForApp:firebaseApp];
+    [firestore useEmulatorWithHost:host port:port];
+    emulatorConfigs[firebaseApp.name] = @YES;
+
+    // It is not sufficient to just use emulator. You have toggle SSL off too.
+    FIRFirestoreSettings *settings = firestore.settings;
+    settings.sslEnabled = FALSE;
+    firestore.settings = settings;
+  }
 }
 
 RCT_EXPORT_METHOD(waitForPendingWrites

package/lib/FirestoreAggregate.js

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2022-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+export class FirestoreAggregateQuery {
+  constructor(firestore, query, collectionPath, modifiers) {
+    this._firestore = firestore;
+    this._query = query;
+    this._collectionPath = collectionPath;
+    this._modifiers = modifiers;
+  }
+
+  get query() {
+    return this._query;
+  }
+
+  get() {
+    return this._firestore.native
+      .collectionCount(
+        this._collectionPath.relativeName,
+        this._modifiers.type,
+        this._modifiers.filters,
+        this._modifiers.orders,
+        this._modifiers.options,
+      )
+      .then(data => new FirestoreAggregateQuerySnapshot(this._query, data));
+  }
+}
+
+export class FirestoreAggregateQuerySnapshot {
+  constructor(query, data) {
+    this._query = query;
+    this._data = data;
+  }
+
+  data() {
+    return { count: this._data.count };
+  }
+}

package/lib/FirestoreQuery.js

@@ -26,6 +26,7 @@ import NativeError from '@react-native-firebase/app/lib/internal/NativeFirebaseE
 import FirestoreDocumentSnapshot from './FirestoreDocumentSnapshot';
 import FirestoreFieldPath, { fromDotSeparatedString } from './FirestoreFieldPath';
 import FirestoreQuerySnapshot from './FirestoreQuerySnapshot';
+import { FirestoreAggregateQuery } from './FirestoreAggregate';
 import { parseSnapshotArgs } from './utils';
 
 let _id = 0;
@@ -130,6 +131,15 @@ export default class FirestoreQuery {
     return modifiers.setFieldsCursor(cursor, allFields);
   }
 
+  count() {
+    return new FirestoreAggregateQuery(
+      this._firestore,
+      this,
+      this._collectionPath,
+      this._modifiers,
+    );
+  }
+
   endAt(docOrField, ...fields) {
     return new FirestoreQuery(
       this._firestore,

package/lib/index.d.ts

@@ -840,11 +840,107 @@ export namespace FirebaseFirestoreTypes {
     source: 'default' | 'server' | 'cache';
   }
 
+  /**
+   * 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. */
+    type = 'AggregateField';
+  }
+
+  /**
+   * The union of all `AggregateField` types that are supported by Firestore.
+   */
+  export type AggregateFieldType = AggregateField<number>;
+
+  /**
+   * A type whose property values are all `AggregateField` objects.
+   */
+  export interface AggregateSpec {
+    [field: string]: AggregateFieldType;
+  }
+
+  /**
+   * A type whose keys are taken from an `AggregateSpec`, and whose values are the
+   * result of the aggregation performed by the corresponding `AggregateField`
+   * from the input `AggregateSpec`.
+   */
+  export type AggregateSpecData<T extends AggregateSpec> = {
+    [P in keyof T]: T[P] extends AggregateField<infer U> ? U : never;
+  };
+
+  /**
+   * The results of executing an aggregation query.
+   */
+  export interface AggregateQuerySnapshot<T extends AggregateSpec> {
+    /**
+     * The underlying query over which the aggregations recorded in this
+     * `AggregateQuerySnapshot` were performed.
+     */
+    get query(): Query<unknown>;
+
+    /**
+     * Returns the results of the aggregations performed over the underlying
+     * query.
+     *
+     * The keys of the returned object will be the same as those of the
+     * `AggregateSpec` object specified to the aggregation method, and the values
+     * will be the corresponding aggregation result.
+     *
+     * @returns The results of the aggregations performed over the underlying
+     * query.
+     */
+    data(): AggregateSpecData<T>;
+  }
+
+  /**
+   * The results of requesting an aggregated query.
+   */
+  export interface AggregateQuery<T extends AggregateSpec> {
+    /**
+     * The underlying query for this instance.
+     */
+    get query(): Query<unknown>;
+
+    /**
+     * Executes the query and returns the results as a AggregateQuerySnapshot.
+     *
+     *
+     * #### Example
+     *
+     * ```js
+     * const querySnapshot = await firebase.firestore()
+     *   .collection('users')
+     *   .count()
+     *   .get();
+     * ```
+     *
+     * @param options An object to configure the get behavior.
+     */
+    get(): Promise<AggregateQuerySnapshot<T>>;
+  }
+
   /**
    * A Query refers to a `Query` which you can read or listen to. You can also construct refined `Query` objects by
    * adding filters and ordering.
    */
   export interface Query<T extends DocumentData = DocumentData> {
+    /**
+     * Calculates the number of documents in the result set of the given query, without actually downloading
+     * the documents.
+     *
+     * Using this function to count the documents is efficient because only the final count, not the
+     * documents' data, is downloaded. This function can even count the documents if the result set
+     * would be prohibitively large to download entirely (e.g. thousands of documents).
+     *
+     * The result received from the server is presented, unaltered, without considering any local state.
+     * That is, documents in the local cache are not taken into consideration, neither are local
+     * modifications not yet synchronized with the server. Previously-downloaded results, if any,
+     *  are not used: every request using this source necessarily involves a round trip to the server.
+     */
+    count(): AggregateQuery<{ count: AggregateField<number> }>;
+
     /**
      * Creates and returns a new Query that ends at the provided document (inclusive). The end
      * position is relative to the order of the query. The document must contain all of the

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-firebase/firestore",
-  "version": "15.7.1",
+  "version": "16.1.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": "15.7.1"
+    "@react-native-firebase/app": "16.1.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "7845819f67e955d75b5756d30c2f5b55a68c9062"
+  "gitHead": "f2d1363b89fb046388f8336b08852c1ea0c285f2"
 }