chore(firestore): add support for onSnapshotsInSync

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

@@ -341,4 +341,17 @@ private void sendOnSnapshotError(
             databaseId,
             listenerId));
   }
+
+  @ReactMethod
+  public void onSnapshotsInSync(Promise promise) {
+    ListenerRegistration registration = FirebaseFirestore.getInstance()
+        .addSnapshotsInSyncListener(() -> {
+          WritableMap result = Arguments.createMap();
+          getReactApplicationContext()
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+            .emit("onSnapshotsInSync", result);
+        });
+
+    promise.resolve(null);
+  }
 }

packages/firestore/e2e/DocumentReference/onSnapshotsInSync.e2e.js

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2016-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.
+ *
+ */
+const COLLECTION = 'firestore';
+const NO_RULE_COLLECTION = 'no_rules';
+const { wipe } = require('../helpers');
+import { onSnapshotsInSync } from '../../lib/modular/snapshot';
+
+describe('firestore().doc().onSnapshot()', function () {
+  before(function () {
+    return wipe();
+  });
+
+  it('onSnapshotsInSync() invokes callback and returns unsubscribe', async function () {
+    const firestore = firebase.firestore();
+    const ref = firestore.collection(COLLECTION).doc('syncTest');
+
+    await ref.set({ foo: 'bar' });
+
+    const onSync = sinon.spy();
+
+    const unsubscribeSnapshot = ref.onSnapshot(() => {});
+    const unsubscribeSync = onSnapshotsInSync(firestore, onSync);
+
+    // Allow sync to process
+    await Utils.sleep(500);
+
+    onSync.should.be.calledOnce();
+    unsubscribeSync.should.be.a.Function();
+
+    unsubscribeSnapshot();
+    unsubscribeSync();
+  });
+
+  // it('onSnapshotsInSync fires after listeners are in sync', () => {
+  //   const testDocs = {
+  //     a: { foo: 1 }
+  //   };
+  //   return withTestCollection(persistence, testDocs, async (coll, db) => {
+  //     let events = [];
+  //     const gotInitialSnapshot = (() => {
+  //       let resolve, reject;
+  //       const promise = new Promise((res, rej) => {
+  //         resolve = res;
+  //         reject = rej;
+  //       });
+  //       return { promise, resolve, reject };
+  //     })();
+  //     const docA = doc(coll, 'a');
+
+  //     onSnapshot(docA, snap => {
+  //       events.push('doc');
+  //       gotInitialSnapshot.resolve();
+  //     });
+  //     await gotInitialSnapshot.promise;
+  //     events = [];
+
+  //     const done = (() => {
+  //       let resolve, reject;
+  //       const promise = new Promise((res, rej) => {
+  //         resolve = res;
+  //         reject = rej;
+  //       });
+  //       return { promise, resolve, reject };
+  //     })();
+  //     onSnapshotsInSync(db, () => {
+  //       events.push('snapshots-in-sync');
+  //       if (events.length === 3) {
+  //         // We should have an initial snapshots-in-sync event, then a snapshot
+  //         // event for set(), then another event to indicate we're in sync
+  //         // again.
+  //         expect(events).to.deep.equal([
+  //           'snapshots-in-sync',
+  //           'doc',
+  //           'snapshots-in-sync'
+  //         ]);
+  //         done.resolve();
+  //       }
+  //     });
+
+  //     await setDoc(docA, { foo: 3 });
+  //     await done.promise;
+  //   });
+  // });
+});

packages/firestore/ios/RNFBFirestore/RNFBFirestoreModule.m

@@ -240,6 +240,14 @@
   resolve(nil);
 }
 
+RCT_EXPORT_METHOD(addSnapshotsInSyncListener:(RCTResponseSenderBlock)callback) {
+  FIRListenerRegistration *registration = [[FIRFirestore firestore]
+    addSnapshotsInSyncListener:^{
+      callback(@[]);
+    }];
+}
+
+
 - (NSMutableDictionary *)taskProgressToDictionary:(FIRLoadBundleTaskProgress *)progress {
   NSMutableDictionary *progressMap = [[NSMutableDictionary alloc] init];
   progressMap[@"bytesLoaded"] = @(progress.bytesLoaded);

packages/firestore/lib/modular/snapshot.d.ts

@@ -227,3 +227,28 @@
   left: Query<AppModelType, DbModelType>,
   right: Query<AppModelType, DbModelType>,
 ): boolean;
+
+/**
+ * Attaches a listener for a snapshots-in-sync event.
+ * The snapshots-in-sync event indicates that all listeners affected by a given change have fired, even if
+ * a single server-generated change affects multiple listeners.
+ *
+ * @param firestore
+ * @param onSync
+ */
+export declare function onSnapshotsInSync(firestore: Firestore, onSync: () => void): Unsubscribe;
+
+/**
+ * /**
+ * Attaches a listener for a snapshots-in-sync event.
+ * The snapshots-in-sync event indicates that all listeners affected by a given change have fired, even if
+ * a single server-generated change affects multiple listeners.
+ *
+ * @param firestore
+ * @param onSync
+ */
+export declare function onSnapshotsInSync(firestore: Firestore, observer: {
+  next?: (value: void) => void;
+  error?: (error: FirestoreError) => void;
+  complete?: () => void;
+}): Unsubscribe;

packages/firestore/lib/modular/snapshot.js

@@ -5,6 +5,9 @@
  */
 
 import { MODULAR_DEPRECATION_ARG } from '../../../app/lib/common';
+import { NativeEventEmitter, NativeModules } from 'react-native';
+
+const emitter = new NativeEventEmitter(NativeModules.RNFBFirestoreModule);
 
 /**
  * @param {Query | DocumentReference} reference
@@ -18,3 +21,17 @@
 export function snapshotEqual(left, right) {
   return left.isEqual.call(left, right, MODULAR_DEPRECATION_ARG);
 }
+
+// export function onSnapshotsInSync(firestore, ...args) {
+//   return firestore.addSnapshotsInSyncListener.call(firestore, ...args, MODULAR_DEPRECATION_ARG);
+// }
+
+export function onSnapshotsInSync(_firestore, callback) {
+  console.log('Registering onSnapshotsInSync');
+  if (typeof firestoreInstance.onSnapshotsInSync === 'function') {
+    return firestoreInstance.onSnapshotsInSync(callback);
+  }
+
+  console.warn('onSnapshotsInSync is not implemented');
+  return () => {};
+}