feat(firestore): support clearPersistence() & terminate() APIs

packages/app/android/src/main/java/io/invertase/firebase/common/UniversalFirebasePreferences.java

@@ -76,6 +76,10 @@ public void clearAll() {
     getPreferences().edit().clear().apply();
   }
 
+  public SharedPreferences.Editor remove(String key){
+    return getPreferences().edit().remove(key);
+  }
+
   private SharedPreferences getPreferences() {
     if (preferences == null) {
       preferences = ReactNativeFirebaseApp

packages/app/ios/RNFBApp/RNFBPreferences.h

@@ -37,6 +37,8 @@
 
 - (void)clearAll;
 
+- (void)remove:(NSString *)key;
+
 + (RNFBPreferences *)shared;
 
 @end

packages/app/ios/RNFBApp/RNFBPreferences.m

@@ -83,6 +83,10 @@ - (void)clearAll {
   [_userDefaults removePersistentDomainForName:RNFBDomainIdentifier];
 }
 
+- (void)remove:(NSString *)key {
+  [_userDefaults removeObjectForKey:key];
+}
+
 + (RNFBPreferences *)shared {
   return sharedInstance;
 }

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

@@ -20,50 +20,62 @@
 import com.google.firebase.FirebaseApp;
 import com.google.firebase.firestore.DocumentReference;
 import com.google.firebase.firestore.FirebaseFirestore;
-import com.google.firebase.firestore.FirebaseFirestoreException;
 import com.google.firebase.firestore.FirebaseFirestoreSettings;
 import com.google.firebase.firestore.Query;
 
-import java.util.HashMap;
+import java.util.WeakHashMap;
 
 import io.invertase.firebase.common.UniversalFirebasePreferences;
 
 public class UniversalFirebaseFirestoreCommon {
-  private static HashMap<String, Boolean> settingsLock = new HashMap<>();
+  static WeakHashMap<String, FirebaseFirestore> instanceCache = new WeakHashMap<>();
 
   static FirebaseFirestore getFirestoreForApp(String appName) {
+    FirebaseFirestore cachedInstance = instanceCache.get(appName);
+
+    if(cachedInstance != null){
+      return cachedInstance;
+    }
+
     FirebaseApp firebaseApp = FirebaseApp.getInstance(appName);
 
     FirebaseFirestore instance = FirebaseFirestore.getInstance(firebaseApp);
+
     setFirestoreSettings(instance, appName);
 
+    instanceCache.put(appName, instance);
+
     return instance;
   }
 
   private static void setFirestoreSettings(FirebaseFirestore firebaseFirestore, String appName) {
-    // Ensure not already been set
-    if (settingsLock.containsKey(appName)) return;
 
     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;
+
+
     int cacheSizeBytes = preferences.getIntValue(
-      UniversalFirebaseFirestoreStatics.FIRESTORE_CACHE_SIZE + "_" + appName,
+      cacheSizeKey,
       (int) firebaseFirestore.getFirestoreSettings().getCacheSizeBytes()
     );
 
     String host = preferences.getStringValue(
-      UniversalFirebaseFirestoreStatics.FIRESTORE_HOST + "_" + appName,
+      hostKey,
       firebaseFirestore.getFirestoreSettings().getHost()
     );
 
     boolean persistence = preferences.getBooleanValue(
-      UniversalFirebaseFirestoreStatics.FIRESTORE_PERSISTENCE + "_" + appName,
+      persistenceKey,
       firebaseFirestore.getFirestoreSettings().isPersistenceEnabled()
     );
 
     boolean ssl = preferences.getBooleanValue(
-      UniversalFirebaseFirestoreStatics.FIRESTORE_SSL + "_" + appName,
+      sslKey,
       firebaseFirestore.getFirestoreSettings().isSslEnabled()
     );
 
@@ -79,7 +91,8 @@ private static void setFirestoreSettings(FirebaseFirestore firebaseFirestore, St
 
     firebaseFirestore.setFirestoreSettings(firestoreSettings.build());
 
-    settingsLock.put(appName, true);
+
+    preferences.remove(cacheSizeKey).remove(hostKey).remove(persistenceKey).remove(sslKey).apply();
   }
 
   static Query getQueryForFirestore(

packages/firestore/android/src/main/java/io/invertase/firebase/firestore/UniversalFirebaseFirestoreException.java

@@ -30,7 +30,7 @@ public class UniversalFirebaseFirestoreException extends Exception {
   UniversalFirebaseFirestoreException(FirebaseFirestoreException nativeException, Throwable cause) {
     super(nativeException != null ? nativeException.getMessage() : "", cause);
 
-    String code = "unknown";
+    String code = null;
     String message = "An unknown error occurred";
 
     if (cause != null && cause.getMessage() != null && cause.getMessage().contains(":")) {

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

@@ -18,17 +18,18 @@
  */
 
 import android.content.Context;
+
 import com.google.android.gms.tasks.Task;
 import com.google.android.gms.tasks.Tasks;
 import com.google.firebase.firestore.FirebaseFirestore;
-import com.google.firebase.firestore.FirebaseFirestoreSettings;
 import io.invertase.firebase.common.UniversalFirebaseModule;
 import io.invertase.firebase.common.UniversalFirebasePreferences;
 
 import java.util.Map;
 import java.util.Objects;
 
 import static io.invertase.firebase.firestore.UniversalFirebaseFirestoreCommon.getFirestoreForApp;
+import static  io.invertase.firebase.firestore.UniversalFirebaseFirestoreCommon.instanceCache;
 
 public class UniversalFirebaseFirestoreModule extends UniversalFirebaseModule {
 
@@ -52,35 +53,41 @@ Task<Void> settings(String appName, Map<String, Object> settings) {
 
         UniversalFirebasePreferences.getSharedInstance().setIntValue(
           UniversalFirebaseFirestoreStatics.FIRESTORE_CACHE_SIZE + "_" + appName,
-          Objects.requireNonNull(cacheSizeBytesDouble).intValue()
-        );
+          Objects.requireNonNull(cacheSizeBytesDouble).intValue());
       }
 
       // settings.host
       if (settings.containsKey("host")) {
         UniversalFirebasePreferences.getSharedInstance().setStringValue(
-          UniversalFirebaseFirestoreStatics.FIRESTORE_HOST + "_" + appName,
-          (String) settings.get("host")
-        );
+          UniversalFirebaseFirestoreStatics.FIRESTORE_HOST + "_" + appName, (String) settings.get("host"));
       }
 
       // settings.persistence
       if (settings.containsKey("persistence")) {
         UniversalFirebasePreferences.getSharedInstance().setBooleanValue(
           UniversalFirebaseFirestoreStatics.FIRESTORE_PERSISTENCE + "_" + appName,
-          (boolean) settings.get("persistence")
-        );
+          (boolean) settings.get("persistence"));
       }
 
       // settings.ssl
       if (settings.containsKey("ssl")) {
         UniversalFirebasePreferences.getSharedInstance().setBooleanValue(
-          UniversalFirebaseFirestoreStatics.FIRESTORE_SSL + "_" + appName,
-          (boolean) settings.get("ssl")
-        );
+          UniversalFirebaseFirestoreStatics.FIRESTORE_SSL + "_" + appName, (boolean) settings.get("ssl"));
       }
 
       return null;
     });
   }
+
+  Task<Void> clearPersistence(String appName) {
+    return getFirestoreForApp(appName).clearPersistence();
+  }
+
+  Task<Void> terminate(String appName) {
+    FirebaseFirestore firebaseFirestore = getFirestoreForApp(appName);
+
+    instanceCache.remove(appName);
+
+    return firebaseFirestore.terminate();
+  }
 }

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

@@ -45,6 +45,17 @@ public void setLogLevel(String logLevel) {
     }
   }
 
+  @ReactMethod
+  public void clearPersistence(String appName, Promise promise) {
+    module.clearPersistence(appName).addOnCompleteListener(task -> {
+      if (task.isSuccessful()) {
+        promise.resolve(null);
+      } else {
+        rejectPromiseFirestoreException(promise, task.getException());
+      }
+    });
+  }
+
   @ReactMethod
   public void disableNetwork(String appName, Promise promise) {
     module.disableNetwork(appName).addOnCompleteListener(task -> {
@@ -77,4 +88,15 @@ public void settings(String appName, ReadableMap settings, Promise promise) {
       }
     });
   }
+
+  @ReactMethod
+  public void terminate(String appName, Promise promise) {
+    module.terminate(appName).addOnCompleteListener(task -> {
+      if (task.isSuccessful()) {
+        promise.resolve(null);
+      } else {
+        rejectPromiseFirestoreException(promise, task.getException());
+      }
+    });
+  }
 }

packages/firestore/e2e/firestore.e2e.js

@@ -318,4 +318,35 @@ describe('firestore()', () => {
       }
     });
   });
+
+  describe('Clear cached data persistence', () => {
+    it('should clear any cached data', async () => {
+      const db = firebase.firestore();
+      const id = 'foobar';
+      const ref = db.doc(`v6/${id}`);
+      await ref.set({ foo: 'bar' });
+
+      try {
+        await db.clearPersistence();
+        return Promise.reject(new Error('Did not throw an Error.'));
+      } catch (error) {
+        error.code.should.equal('firestore/failed-precondition');
+      }
+
+      const doc = await ref.get({ source: 'cache' });
+
+      should(doc.id).equal(id);
+
+      await db.terminate();
+      await db.clearPersistence();
+
+      try {
+        await ref.get({ source: 'cache' });
+        return Promise.reject(new Error('Did not throw an Error.'));
+      } catch (error) {
+        error.code.should.equal('firestore/unavailable');
+        return Promise.resolve();
+      }
+    });
+  });
 });

packages/firestore/ios/RNFBFirestore/RNFBFirestoreCommon.h

@@ -41,3 +41,4 @@ extern NSString *const FIRESTORE_CACHE_SIZE;
 extern NSString *const FIRESTORE_HOST;
 extern NSString *const FIRESTORE_PERSISTENCE;
 extern NSString *const FIRESTORE_SSL;
+extern NSMutableDictionary * instanceCache;

packages/firestore/ios/RNFBFirestore/RNFBFirestoreCommon.m

@@ -24,14 +24,27 @@
 NSString *const FIRESTORE_PERSISTENCE = @"firebase_firestore_persistence";
 NSString *const FIRESTORE_SSL = @"firebase_firestore_ssl";
 
-__strong NSMutableDictionary *settingsLock;
+NSMutableDictionary * instanceCache;
 
 @implementation RNFBFirestoreCommon
-
 + (FIRFirestore *)getFirestoreForApp:(FIRApp *)app {
-  FIRFirestore *instance = [FIRFirestore firestoreForApp:app];
-  [self setFirestoreSettings:instance appName:[RNFBSharedUtils getAppJavaScriptName:app.name]];
-  return instance;
+    if(instanceCache == nil){
+      instanceCache = [[NSMutableDictionary alloc] init];
+    }
+
+    FIRFirestore * cachedInstance = instanceCache[[app name]];
+
+    if(cachedInstance){
+      return cachedInstance;
+    }
+
+    FIRFirestore *instance = [FIRFirestore firestoreForApp:app];
+
+    [self setFirestoreSettings:instance appName:[RNFBSharedUtils getAppJavaScriptName:app.name]];
+
+    instanceCache[[app name]] = instance;
+
+    return instance;
 }
 
 + (dispatch_queue_t)getFirestoreQueue {
@@ -44,16 +57,6 @@ + (dispatch_queue_t)getFirestoreQueue {
 }
 
 + (void)setFirestoreSettings:(FIRFirestore *)firestore appName:(NSString *)appName {
-  @synchronized(settingsLock) {
-    if (settingsLock == nil) {
-      settingsLock = [[NSMutableDictionary alloc] init];
-    }
-
-    // Prevent setting if already set
-    if (settingsLock[appName]) {
-      return;
-    }
-
     FIRFirestoreSettings *firestoreSettings = [[FIRFirestoreSettings alloc] init];
     RNFBPreferences *preferences = [RNFBPreferences shared];
 
@@ -79,9 +82,12 @@ + (void)setFirestoreSettings:(FIRFirestore *)firestore appName:(NSString *)appNa
     NSString *sslKey = [NSString stringWithFormat:@"%@_%@", FIRESTORE_SSL, appName];
     firestoreSettings.sslEnabled = (BOOL) [preferences getBooleanValue:sslKey defaultValue:firestore.settings.sslEnabled];
 
-    settingsLock[appName] = @(YES);
     firestore.settings = firestoreSettings;
-  }
+
+    [preferences remove:cacheKey];
+    [preferences remove:hostKey];
+    [preferences remove:persistenceKey];
+    [preferences remove:sslKey];
 }
 
 + (FIRDocumentReference *)getDocumentForFirestore:(FIRFirestore *)firestore path:(NSString *)path; {

packages/firestore/ios/RNFBFirestore/RNFBFirestoreModule.m

@@ -103,4 +103,36 @@ + (BOOL)requiresMainQueueSetup {
   resolve([NSNull null]);
 }
 
+RCT_EXPORT_METHOD(clearPersistence:
+  (FIRApp *) firebaseApp
+    : (RCTPromiseResolveBlock) resolve
+    : (RCTPromiseRejectBlock)reject
+) {
+  [[RNFBFirestoreCommon getFirestoreForApp:firebaseApp] clearPersistenceWithCompletion:^(NSError *error) {
+    if (error) {
+      [RNFBFirestoreCommon promiseRejectFirestoreException:reject error:error];
+    } else {
+      resolve(nil);
+    }
+  }];
+}
+
+RCT_EXPORT_METHOD(terminate:
+  (FIRApp *) firebaseApp
+    : (RCTPromiseResolveBlock) resolve
+    : (RCTPromiseRejectBlock)reject
+) {
+    FIRFirestore *instance = [RNFBFirestoreCommon getFirestoreForApp:firebaseApp];
+
+    [instance terminateWithCompletion:^(NSError *error) {
+      if (error) {
+        [RNFBFirestoreCommon promiseRejectFirestoreException:reject error:error];
+      } else {
+        [instanceCache removeObjectForKey: [firebaseApp name]];
+        resolve(nil);
+      }
+    }];
+}
+
+
 @end

packages/firestore/lib/index.d.ts

@@ -1939,6 +1939,28 @@ export namespace FirebaseFirestoreTypes {
      * @param settings A `Settings` object.
      */
     settings(settings: Settings): Promise<void>;
+    /**
+     * Aimed primarily at clearing up any data cached from running tests. Needs to be executed before any database calls
+     * are made.
+     *
+     * #### Example
+     *
+     *```js
+     * await firebase.firestore().clearPersistence();
+     * ```
+     */
+    clearPersistence(): Promise<void>;
+    /**
+     * Typically called to ensure a new Firestore instance is initialized before calling
+     * `firebase.firestore().clearPersistence()`.
+     *
+     * #### Example
+     *
+     *```js
+     * await firebase.firestore().terminate();
+     * ```
+     */
+    terminate(): Promise<void>;
   }
 }