@react-native-firebase/firestore 20.2.1 → 20.4.0

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [20.4.0](https://github.com/invertase/react-native-firebase/compare/v20.3.0...v20.4.0) (2024-08-13)
+
+### Features
+
+- **firestore:** support for `PersistentCacheIndexManager` ([#7910](https://github.com/invertase/react-native-firebase/issues/7910)) ([0b0de45](https://github.com/invertase/react-native-firebase/commit/0b0de45513cd3aab9f7037fd8468a63cf96aa62c))
+- **firestore:** support for second database ([#7949](https://github.com/invertase/react-native-firebase/issues/7949)) ([eec08a0](https://github.com/invertase/react-native-firebase/commit/eec08a06f41dd96d13778fbed2afcaaac238fca4))
+
+## [20.3.0](https://github.com/invertase/react-native-firebase/compare/v20.2.1...v20.3.0) (2024-07-19)
+
+**Note:** Version bump only for package @react-native-firebase/firestore
+
 ## [20.2.1](https://github.com/invertase/react-native-firebase/compare/v20.2.0...v20.2.1) (2024-07-17)
 
 ### Bug Fixes

package/__tests__/firestore.test.ts

@@ -1,6 +1,61 @@
 import { describe, expect, it } from '@jest/globals';
 
-import firestore, { firebase, Filter } from '../lib';
+import firestore, {
+  firebase,
+  Filter,
+  getFirestore,
+  addDoc,
+  doc,
+  collection,
+  collectionGroup,
+  setDoc,
+  updateDoc,
+  enableNetwork,
+  disableNetwork,
+  clearPersistence,
+  terminate,
+  waitForPendingWrites,
+  initializeFirestore,
+  setLogLevel,
+  runTransaction,
+  getCountFromServer,
+  loadBundle,
+  namedQuery,
+  writeBatch,
+  Bytes,
+  FieldPath,
+  FieldValue,
+  deleteField,
+  serverTimestamp,
+  arrayUnion,
+  arrayRemove,
+  increment,
+  GeoPoint,
+  query,
+  where,
+  or,
+  and,
+  orderBy,
+  startAt,
+  startAfter,
+  endAt,
+  endBefore,
+  limit,
+  limitToLast,
+  getDoc,
+  getDocFromCache,
+  getDocFromServer,
+  getDocs,
+  getDocsFromCache,
+  getDocsFromServer,
+  deleteDoc,
+  onSnapshot,
+  Timestamp,
+  getPersistentCacheIndexManager,
+  deleteAllPersistentCacheIndexes,
+  disablePersistentCacheIndexAutoCreation,
+  enablePersistentCacheIndexAutoCreation,
+} from '../lib';
 
 const COLLECTION = 'firestore';
 
@@ -372,6 +427,12 @@ describe('Firestore', function () {
         return expect(e.message).toContain("'queryName' must be a non-empty string");
       }
     });
+  });
+
+  describe('modular', function () {
+    it('`getFirestore` function is properly exposed to end user', function () {
+      expect(getFirestore).toBeDefined();
+    });
 
     it('`Filter` is properly exposed to end user', async function () {
       const filter1 = Filter('name', '==', 'Tim');
@@ -384,5 +445,235 @@ describe('Firestore', function () {
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       const query2 = Filter.or(filter1, filter2);
     });
+
+    it('`doc` function is properly exposed to end user', function () {
+      expect(doc).toBeDefined();
+    });
+
+    it('`collection` function is properly exposed to end user', function () {
+      expect(collection).toBeDefined();
+    });
+
+    it('`collectionGroup` function is properly exposed to end user', function () {
+      expect(collectionGroup).toBeDefined();
+    });
+
+    it('`setDoc` function is properly exposed to end user', function () {
+      expect(setDoc).toBeDefined();
+    });
+
+    it('`updateDoc` function is properly exposed to end user', function () {
+      expect(updateDoc).toBeDefined();
+    });
+
+    it('`addDoc` function is properly exposed to end user', function () {
+      expect(addDoc).toBeDefined();
+    });
+
+    it('`enableNetwork` function is properly exposed to end user', function () {
+      expect(enableNetwork).toBeDefined();
+    });
+
+    it('`disableNetwork` function is properly exposed to end user', function () {
+      expect(disableNetwork).toBeDefined();
+    });
+
+    it('`clearPersistence` function is properly exposed to end user', function () {
+      expect(clearPersistence).toBeDefined();
+    });
+
+    it('`terminate` function is properly exposed to end user', function () {
+      expect(terminate).toBeDefined();
+    });
+
+    it('`waitForPendingWrites` function is properly exposed to end user', function () {
+      expect(waitForPendingWrites).toBeDefined();
+    });
+
+    it('`initializeFirestore` function is properly exposed to end user', function () {
+      expect(initializeFirestore).toBeDefined();
+    });
+
+    it('`setLogLevel` function is properly exposed to end user', function () {
+      expect(setLogLevel).toBeDefined();
+    });
+
+    it('`runTransaction` function is properly exposed to end user', function () {
+      expect(runTransaction).toBeDefined();
+    });
+
+    it('`getCountFromServer` function is properly exposed to end user', function () {
+      expect(getCountFromServer).toBeDefined();
+    });
+
+    it('`loadBundle` function is properly exposed to end user', function () {
+      expect(loadBundle).toBeDefined();
+    });
+
+    it('`namedQuery` function is properly exposed to end user', function () {
+      expect(namedQuery).toBeDefined();
+    });
+
+    it('`writeBatch` function is properly exposed to end user', function () {
+      expect(writeBatch).toBeDefined();
+    });
+
+    it('`Bytes` class is properly exposed to end user', function () {
+      expect(Bytes).toBeDefined();
+    });
+
+    it('`FieldPath` class is properly exposed to end user', function () {
+      expect(FieldPath).toBeDefined();
+    });
+
+    it('`FieldValue` is properly exposed to end user', function () {
+      expect(FieldValue).toBeDefined();
+    });
+
+    it('`deleteField` function is properly exposed to end user', function () {
+      expect(deleteField).toBeDefined();
+    });
+
+    it('`serverTimestamp` function is properly exposed to end user', function () {
+      expect(serverTimestamp).toBeDefined();
+    });
+
+    it('`arrayUnion` function is properly exposed to end user', function () {
+      expect(arrayUnion).toBeDefined();
+    });
+
+    it('`arrayRemove` function is properly exposed to end user', function () {
+      expect(arrayRemove).toBeDefined();
+    });
+
+    it('`increment` function is properly exposed to end user', function () {
+      expect(increment).toBeDefined();
+    });
+
+    it('`GeoPoint` is properly exposed to end user', function () {
+      expect(GeoPoint).toBeDefined();
+    });
+
+    it('`query` function is properly exposed to end user', function () {
+      expect(query).toBeDefined();
+    });
+
+    it('`where` function is properly exposed to end user', function () {
+      expect(where).toBeDefined();
+    });
+
+    it('`or` function is properly exposed to end user', function () {
+      expect(or).toBeDefined();
+    });
+
+    it('`and` function is properly exposed to end user', function () {
+      expect(and).toBeDefined();
+    });
+
+    it('`orderBy` function is properly exposed to end user', function () {
+      expect(orderBy).toBeDefined();
+    });
+
+    it('`startAt` function is properly exposed to end user', function () {
+      expect(startAt).toBeDefined();
+    });
+
+    it('`startAfter` function is properly exposed to end user', function () {
+      expect(startAfter).toBeDefined();
+    });
+
+    it('`endAt` function is properly exposed to end user', function () {
+      expect(endAt).toBeDefined();
+    });
+
+    it('`endBefore` function is properly exposed to end user', function () {
+      expect(endBefore).toBeDefined();
+    });
+
+    it('`limit` function is properly exposed to end user', function () {
+      expect(limit).toBeDefined();
+    });
+
+    it('`limitToLast` function is properly exposed to end user', function () {
+      expect(limitToLast).toBeDefined();
+    });
+
+    it('`getDoc` function is properly exposed to end user', function () {
+      expect(getDoc).toBeDefined();
+    });
+
+    it('`getDocFromCache` function is properly exposed to end user', function () {
+      expect(getDocFromCache).toBeDefined();
+    });
+
+    it('`getDocFromServer` function is properly exposed to end user', function () {
+      expect(getDocFromServer).toBeDefined();
+    });
+
+    it('`getDocs` function is properly exposed to end user', function () {
+      expect(getDocs).toBeDefined();
+    });
+
+    it('`getDocsFromCache` function is properly exposed to end user', function () {
+      expect(getDocsFromCache).toBeDefined();
+    });
+
+    it('`getDocsFromServer` function is properly exposed to end user', function () {
+      expect(getDocsFromServer).toBeDefined();
+    });
+
+    it('`deleteDoc` function is properly exposed to end user', function () {
+      expect(deleteDoc).toBeDefined();
+    });
+
+    it('`onSnapshot` function is properly exposed to end user', function () {
+      expect(onSnapshot).toBeDefined();
+    });
+
+    it('`Timestamp` is properly exposed to end user', function () {
+      expect(Timestamp).toBeDefined();
+    });
+
+    it('`getPersistentCacheIndexManager` is properly exposed to end user', function () {
+      expect(getPersistentCacheIndexManager).toBeDefined();
+      const indexManager = getPersistentCacheIndexManager(firebase.firestore());
+      expect(indexManager!.constructor.name).toEqual('FirestorePersistentCacheIndexManager');
+    });
+
+    it('`deleteAllPersistentCacheIndexes` is properly exposed to end user', function () {
+      expect(deleteAllPersistentCacheIndexes).toBeDefined();
+    });
+
+    it('`disablePersistentCacheIndexAutoCreation` is properly exposed to end user', function () {
+      expect(disablePersistentCacheIndexAutoCreation).toBeDefined();
+    });
+
+    it('`enablePersistentCacheIndexAutoCreation` is properly exposed to end user', function () {
+      expect(enablePersistentCacheIndexAutoCreation).toBeDefined();
+    });
+  });
+
+  describe('FirestorePersistentCacheIndexManager', function () {
+    it('is exposed to end user', function () {
+      const firestore1 = firebase.firestore();
+      firestore1.settings({ persistence: true });
+      const indexManager = firestore1.persistentCacheIndexManager();
+      expect(indexManager).toBeDefined();
+      expect(indexManager.constructor.name).toEqual('FirestorePersistentCacheIndexManager');
+
+      expect(indexManager.enableIndexAutoCreation).toBeInstanceOf(Function);
+      expect(indexManager.disableIndexAutoCreation).toBeInstanceOf(Function);
+      expect(indexManager.deleteAllIndexes).toBeInstanceOf(Function);
+
+      const firestore2 = firebase.firestore();
+      firestore2.settings({ persistence: false });
+
+      const nullIndexManager = firestore2.persistentCacheIndexManager();
+
+      expect(nullIndexManager).toBeNull();
+
+      const nullIndexManagerModular = getPersistentCacheIndexManager(firestore2);
+      expect(nullIndexManagerModular).toBeNull();
+    });
   });
 });

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

@@ -29,8 +29,13 @@ import java.util.WeakHashMap;
 public class UniversalFirebaseFirestoreCommon {
   static WeakHashMap<String, WeakReference<FirebaseFirestore>> instanceCache = new WeakHashMap<>();
 
-  static FirebaseFirestore getFirestoreForApp(String appName) {
-    WeakReference<FirebaseFirestore> cachedInstance = instanceCache.get(appName);
+  static String createFirestoreKey(String appName, String databaseId) {
+    return appName + ":" + databaseId;
+  }
+
+  static FirebaseFirestore getFirestoreForApp(String appName, String databaseId) {
+    String firestoreKey = createFirestoreKey(appName, databaseId);
+    WeakReference<FirebaseFirestore> cachedInstance = instanceCache.get(firestoreKey);
 
     if (cachedInstance != null) {
       return cachedInstance.get();
@@ -38,24 +43,27 @@ public class UniversalFirebaseFirestoreCommon {
 
     FirebaseApp firebaseApp = FirebaseApp.getInstance(appName);
 
-    FirebaseFirestore instance = FirebaseFirestore.getInstance(firebaseApp);
+    FirebaseFirestore instance = FirebaseFirestore.getInstance(firebaseApp, databaseId);
 
-    setFirestoreSettings(instance, appName);
+    setFirestoreSettings(instance, firestoreKey);
 
     instanceCache.put(appName, new WeakReference<FirebaseFirestore>(instance));
 
     return instance;
   }
 
-  private static void setFirestoreSettings(FirebaseFirestore firebaseFirestore, String appName) {
+  private static void setFirestoreSettings(
+      FirebaseFirestore firebaseFirestore, String firestoreKey) {
 
     UniversalFirebasePreferences preferences = UniversalFirebasePreferences.getSharedInstance();
     FirebaseFirestoreSettings.Builder firestoreSettings = new FirebaseFirestoreSettings.Builder();
 
-    String cacheSizeKey = UniversalFirebaseFirestoreStatics.FIRESTORE_CACHE_SIZE + "_" + appName;
-    String hostKey = UniversalFirebaseFirestoreStatics.FIRESTORE_HOST + "_" + appName;
-    String persistenceKey = UniversalFirebaseFirestoreStatics.FIRESTORE_PERSISTENCE + "_" + appName;
-    String sslKey = UniversalFirebaseFirestoreStatics.FIRESTORE_SSL + "_" + appName;
+    String cacheSizeKey =
+        UniversalFirebaseFirestoreStatics.FIRESTORE_CACHE_SIZE + "_" + firestoreKey;
+    String hostKey = UniversalFirebaseFirestoreStatics.FIRESTORE_HOST + "_" + firestoreKey;
+    String persistenceKey =
+        UniversalFirebaseFirestoreStatics.FIRESTORE_PERSISTENCE + "_" + firestoreKey;
+    String sslKey = UniversalFirebaseFirestoreStatics.FIRESTORE_SSL + "_" + firestoreKey;
 
     int cacheSizeBytes =
         preferences.getIntValue(

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

@@ -17,6 +17,7 @@ package io.invertase.firebase.firestore;
  *
  */
 
+import static io.invertase.firebase.firestore.UniversalFirebaseFirestoreCommon.createFirestoreKey;
 import static io.invertase.firebase.firestore.UniversalFirebaseFirestoreCommon.getFirestoreForApp;
 import static io.invertase.firebase.firestore.UniversalFirebaseFirestoreCommon.instanceCache;
 
@@ -40,27 +41,28 @@ public class UniversalFirebaseFirestoreModule extends UniversalFirebaseModule {
     super(context, serviceName);
   }
 
-  Task<Void> disableNetwork(String appName) {
-    return getFirestoreForApp(appName).disableNetwork();
+  Task<Void> disableNetwork(String appName, String databaseId) {
+    return getFirestoreForApp(appName, databaseId).disableNetwork();
   }
 
-  Task<Void> enableNetwork(String appName) {
-    return getFirestoreForApp(appName).enableNetwork();
+  Task<Void> enableNetwork(String appName, String databaseId) {
+    return getFirestoreForApp(appName, databaseId).enableNetwork();
   }
 
-  Task<Void> useEmulator(String appName, String host, int port) {
+  Task<Void> useEmulator(String appName, String databaseId, String host, int port) {
     return Tasks.call(
         getExecutor(),
         () -> {
-          if (emulatorConfigs.get(appName) == null) {
-            emulatorConfigs.put(appName, "true");
-            getFirestoreForApp(appName).useEmulator(host, port);
+          String firestoreKey = createFirestoreKey(appName, databaseId);
+          if (emulatorConfigs.get(firestoreKey) == null) {
+            emulatorConfigs.put(firestoreKey, "true");
+            getFirestoreForApp(appName, databaseId).useEmulator(host, port);
           }
           return null;
         });
   }
 
-  Task<Void> settings(String appName, Map<String, Object> settings) {
+  Task<Void> settings(String firestoreKey, Map<String, Object> settings) {
     return Tasks.call(
         getExecutor(),
         () -> {
@@ -70,7 +72,7 @@ public class UniversalFirebaseFirestoreModule extends UniversalFirebaseModule {
 
             UniversalFirebasePreferences.getSharedInstance()
                 .setIntValue(
-                    UniversalFirebaseFirestoreStatics.FIRESTORE_CACHE_SIZE + "_" + appName,
+                    UniversalFirebaseFirestoreStatics.FIRESTORE_CACHE_SIZE + "_" + firestoreKey,
                     Objects.requireNonNull(cacheSizeBytesDouble).intValue());
           }
 
@@ -78,7 +80,7 @@ public class UniversalFirebaseFirestoreModule extends UniversalFirebaseModule {
           if (settings.containsKey("host")) {
             UniversalFirebasePreferences.getSharedInstance()
                 .setStringValue(
-                    UniversalFirebaseFirestoreStatics.FIRESTORE_HOST + "_" + appName,
+                    UniversalFirebaseFirestoreStatics.FIRESTORE_HOST + "_" + firestoreKey,
                     (String) settings.get("host"));
           }
 
@@ -86,7 +88,7 @@ public class UniversalFirebaseFirestoreModule extends UniversalFirebaseModule {
           if (settings.containsKey("persistence")) {
             UniversalFirebasePreferences.getSharedInstance()
                 .setBooleanValue(
-                    UniversalFirebaseFirestoreStatics.FIRESTORE_PERSISTENCE + "_" + appName,
+                    UniversalFirebaseFirestoreStatics.FIRESTORE_PERSISTENCE + "_" + firestoreKey,
                     (boolean) settings.get("persistence"));
           }
 
@@ -94,7 +96,7 @@ public class UniversalFirebaseFirestoreModule extends UniversalFirebaseModule {
           if (settings.containsKey("ssl")) {
             UniversalFirebasePreferences.getSharedInstance()
                 .setBooleanValue(
-                    UniversalFirebaseFirestoreStatics.FIRESTORE_SSL + "_" + appName,
+                    UniversalFirebaseFirestoreStatics.FIRESTORE_SSL + "_" + firestoreKey,
                     (boolean) settings.get("ssl"));
           }
 
@@ -104,7 +106,7 @@ public class UniversalFirebaseFirestoreModule extends UniversalFirebaseModule {
                 .setStringValue(
                     UniversalFirebaseFirestoreStatics.FIRESTORE_SERVER_TIMESTAMP_BEHAVIOR
                         + "_"
-                        + appName,
+                        + firestoreKey,
                     (String) settings.get("serverTimestampBehavior"));
           }
 
@@ -112,25 +114,25 @@ public class UniversalFirebaseFirestoreModule extends UniversalFirebaseModule {
         });
   }
 
-  LoadBundleTask loadBundle(String appName, String bundle) {
+  LoadBundleTask loadBundle(String appName, String databaseId, String bundle) {
     byte[] bundleData = bundle.getBytes(StandardCharsets.UTF_8);
-    return getFirestoreForApp(appName).loadBundle(bundleData);
+    return getFirestoreForApp(appName, databaseId).loadBundle(bundleData);
   }
 
-  Task<Void> clearPersistence(String appName) {
-    return getFirestoreForApp(appName).clearPersistence();
+  Task<Void> clearPersistence(String appName, String databaseId) {
+    return getFirestoreForApp(appName, databaseId).clearPersistence();
   }
 
-  Task<Void> waitForPendingWrites(String appName) {
-    return getFirestoreForApp(appName).waitForPendingWrites();
+  Task<Void> waitForPendingWrites(String appName, String databaseId) {
+    return getFirestoreForApp(appName, databaseId).waitForPendingWrites();
   }
 
-  Task<Void> terminate(String appName) {
-    FirebaseFirestore firebaseFirestore = getFirestoreForApp(appName);
-
-    if (instanceCache.get(appName) != null) {
-      instanceCache.get(appName).clear();
-      instanceCache.remove(appName);
+  Task<Void> terminate(String appName, String databaseId) {
+    FirebaseFirestore firebaseFirestore = getFirestoreForApp(appName, databaseId);
+    String firestoreKey = createFirestoreKey(appName, databaseId);
+    if (instanceCache.get(firestoreKey) != null) {
+      instanceCache.get(firestoreKey).clear();
+      instanceCache.remove(firestoreKey);
     }
 
     return firebaseFirestore.terminate();