@react-native-firebase/firestore 14.7.0 → 14.9.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.
 
+# [14.9.0](https://github.com/invertase/react-native-firebase/compare/v14.8.1...v14.9.0) (2022-04-27)
+
+### Features
+
+- **firestore:** named query and data bundle APIs ([#6199](https://github.com/invertase/react-native-firebase/issues/6199)) ([96591e0](https://github.com/invertase/react-native-firebase/commit/96591e0dac957383c503e94fbf7bf0379d5569f2))
+
+## [14.8.1](https://github.com/invertase/react-native-firebase/compare/v14.8.0...v14.8.1) (2022-04-25)
+
+**Note:** Version bump only for package @react-native-firebase/firestore
+
+# [14.8.0](https://github.com/invertase/react-native-firebase/compare/v14.7.0...v14.8.0) (2022-04-19)
+
+**Note:** Version bump only for package @react-native-firebase/firestore
+
 # [14.7.0](https://github.com/invertase/react-native-firebase/compare/v14.6.0...v14.7.0) (2022-03-23)
 
 **Note:** Version bump only for package @react-native-firebase/firestore

package/__tests__/firestore.test.ts

@@ -329,4 +329,46 @@ describe('Storage', function () {
       });
     });
   });
+
+  describe('loadBundle()', function () {
+    it('throws if bundle is not a string', async function () {
+      try {
+        // @ts-ignore the type is incorrect *on purpose* to test type checking in javascript
+        firebase.firestore().loadBundle(123);
+        return Promise.reject(new Error('Did not throw an Error.'));
+      } catch (e: any) {
+        return expect(e.message).toContain("'bundle' must be a string value");
+      }
+    });
+
+    it('throws if bundle is empty string', async function () {
+      try {
+        firebase.firestore().loadBundle('');
+        return Promise.reject(new Error('Did not throw an Error.'));
+      } catch (e: any) {
+        return expect(e.message).toContain("'bundle' must be a non-empty string");
+      }
+    });
+  });
+
+  describe('namedQuery()', function () {
+    it('throws if queryName is not a string', async function () {
+      try {
+        // @ts-ignore the type is incorrect *on purpose* to test type checking in javascript
+        firebase.firestore().namedQuery(123);
+        return Promise.reject(new Error('Did not throw an Error.'));
+      } catch (e: any) {
+        return expect(e.message).toContain("'queryName' must be a string value");
+      }
+    });
+
+    it('throws if queryName is empty string', async function () {
+      try {
+        firebase.firestore().namedQuery('');
+        return Promise.reject(new Error('Did not throw an Error.'));
+      } catch (e: any) {
+        return expect(e.message).toContain("'queryName' must be a non-empty string");
+      }
+    });
+  });
 });

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

@@ -24,8 +24,10 @@ 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.LoadBundleTask;
 import io.invertase.firebase.common.UniversalFirebaseModule;
 import io.invertase.firebase.common.UniversalFirebasePreferences;
+import java.nio.charset.StandardCharsets;
 import java.util.Map;
 import java.util.Objects;
 
@@ -104,6 +106,11 @@ public class UniversalFirebaseFirestoreModule extends UniversalFirebaseModule {
         });
   }
 
+  LoadBundleTask loadBundle(String appName, String bundle) {
+    byte[] bundleData = bundle.getBytes(StandardCharsets.UTF_8);
+    return getFirestoreForApp(appName).loadBundle(bundleData);
+  }
+
   Task<Void> clearPersistence(String appName) {
     return getFirestoreForApp(appName).clearPersistence();
   }

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

@@ -50,6 +50,41 @@ public class ReactNativeFirebaseFirestoreCollectionModule extends ReactNativeFir
     collectionSnapshotListeners.clear();
   }
 
+  @ReactMethod
+  public void namedQueryOnSnapshot(
+      String appName,
+      String queryName,
+      String type,
+      ReadableArray filters,
+      ReadableArray orders,
+      ReadableMap options,
+      int listenerId,
+      ReadableMap listenerOptions) {
+    if (collectionSnapshotListeners.get(listenerId) != null) {
+      return;
+    }
+
+    FirebaseFirestore firebaseFirestore = getFirestoreForApp(appName);
+    firebaseFirestore
+        .getNamedQuery(queryName)
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                Query query = task.getResult();
+                if (query == null) {
+                  sendOnSnapshotError(appName, listenerId, new NullPointerException());
+                } else {
+                  ReactNativeFirebaseFirestoreQuery firestoreQuery =
+                      new ReactNativeFirebaseFirestoreQuery(
+                          appName, query, filters, orders, options);
+                  handleQueryOnSnapshot(firestoreQuery, appName, listenerId, listenerOptions);
+                }
+              } else {
+                sendOnSnapshotError(appName, listenerId, task.getException());
+              }
+            });
+  }
+
   @ReactMethod
   public void collectionOnSnapshot(
       String appName,
@@ -69,34 +104,7 @@ public class ReactNativeFirebaseFirestoreCollectionModule extends ReactNativeFir
         new ReactNativeFirebaseFirestoreQuery(
             appName, getQueryForFirestore(firebaseFirestore, path, type), filters, orders, options);
 
-    MetadataChanges metadataChanges;
-
-    if (listenerOptions != null
-        && listenerOptions.hasKey("includeMetadataChanges")
-        && listenerOptions.getBoolean("includeMetadataChanges")) {
-      metadataChanges = MetadataChanges.INCLUDE;
-    } else {
-      metadataChanges = MetadataChanges.EXCLUDE;
-    }
-
-    final EventListener<QuerySnapshot> listener =
-        (querySnapshot, exception) -> {
-          if (exception != null) {
-            ListenerRegistration listenerRegistration = collectionSnapshotListeners.get(listenerId);
-            if (listenerRegistration != null) {
-              listenerRegistration.remove();
-              collectionSnapshotListeners.remove(listenerId);
-            }
-            sendOnSnapshotError(appName, listenerId, exception);
-          } else {
-            sendOnSnapshotEvent(appName, listenerId, querySnapshot, metadataChanges);
-          }
-        };
-
-    ListenerRegistration listenerRegistration =
-        firestoreQuery.query.addSnapshotListener(metadataChanges, listener);
-
-    collectionSnapshotListeners.put(listenerId, listenerRegistration);
+    handleQueryOnSnapshot(firestoreQuery, appName, listenerId, listenerOptions);
   }
 
   @ReactMethod
@@ -109,6 +117,37 @@ public class ReactNativeFirebaseFirestoreCollectionModule extends ReactNativeFir
     }
   }
 
+  @ReactMethod
+  public void namedQueryGet(
+      String appName,
+      String queryName,
+      String type,
+      ReadableArray filters,
+      ReadableArray orders,
+      ReadableMap options,
+      ReadableMap getOptions,
+      Promise promise) {
+    FirebaseFirestore firebaseFirestore = getFirestoreForApp(appName);
+    firebaseFirestore
+        .getNamedQuery(queryName)
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                Query query = task.getResult();
+                if (query == null) {
+                  rejectPromiseFirestoreException(promise, new NullPointerException());
+                } else {
+                  ReactNativeFirebaseFirestoreQuery firestoreQuery =
+                      new ReactNativeFirebaseFirestoreQuery(
+                          appName, query, filters, orders, options);
+                  handleQueryGet(firestoreQuery, getSource(getOptions), promise);
+                }
+              } else {
+                rejectPromiseFirestoreException(promise, task.getException());
+              }
+            });
+  }
+
   @ReactMethod
   public void collectionGet(
       String appName,
@@ -120,26 +159,50 @@ public class ReactNativeFirebaseFirestoreCollectionModule extends ReactNativeFir
       ReadableMap getOptions,
       Promise promise) {
     FirebaseFirestore firebaseFirestore = getFirestoreForApp(appName);
-    ReactNativeFirebaseFirestoreQuery query =
+    ReactNativeFirebaseFirestoreQuery firestoreQuery =
         new ReactNativeFirebaseFirestoreQuery(
             appName, getQueryForFirestore(firebaseFirestore, path, type), filters, orders, options);
+    handleQueryGet(firestoreQuery, getSource(getOptions), promise);
+  }
 
-    Source source;
+  private void handleQueryOnSnapshot(
+      ReactNativeFirebaseFirestoreQuery firestoreQuery,
+      String appName,
+      int listenerId,
+      ReadableMap listenerOptions) {
+    MetadataChanges metadataChanges;
 
-    if (getOptions != null && getOptions.hasKey("source")) {
-      String optionsSource = getOptions.getString("source");
-      if ("server".equals(optionsSource)) {
-        source = Source.SERVER;
-      } else if ("cache".equals(optionsSource)) {
-        source = Source.CACHE;
-      } else {
-        source = Source.DEFAULT;
-      }
+    if (listenerOptions != null
+        && listenerOptions.hasKey("includeMetadataChanges")
+        && listenerOptions.getBoolean("includeMetadataChanges")) {
+      metadataChanges = MetadataChanges.INCLUDE;
     } else {
-      source = Source.DEFAULT;
+      metadataChanges = MetadataChanges.EXCLUDE;
     }
 
-    query
+    final EventListener<QuerySnapshot> listener =
+        (querySnapshot, exception) -> {
+          if (exception != null) {
+            ListenerRegistration listenerRegistration = collectionSnapshotListeners.get(listenerId);
+            if (listenerRegistration != null) {
+              listenerRegistration.remove();
+              collectionSnapshotListeners.remove(listenerId);
+            }
+            sendOnSnapshotError(appName, listenerId, exception);
+          } else {
+            sendOnSnapshotEvent(appName, listenerId, querySnapshot, metadataChanges);
+          }
+        };
+
+    ListenerRegistration listenerRegistration =
+        firestoreQuery.query.addSnapshotListener(metadataChanges, listener);
+
+    collectionSnapshotListeners.put(listenerId, listenerRegistration);
+  }
+
+  private void handleQueryGet(
+      ReactNativeFirebaseFirestoreQuery firestoreQuery, Source source, Promise promise) {
+    firestoreQuery
         .get(getExecutor(), source)
         .addOnCompleteListener(
             task -> {
@@ -202,4 +265,23 @@ public class ReactNativeFirebaseFirestoreCollectionModule extends ReactNativeFir
         new ReactNativeFirebaseFirestoreEvent(
             ReactNativeFirebaseFirestoreEvent.COLLECTION_EVENT_SYNC, body, appName, listenerId));
   }
+
+  private Source getSource(ReadableMap getOptions) {
+    Source source;
+
+    if (getOptions != null && getOptions.hasKey("source")) {
+      String optionsSource = getOptions.getString("source");
+      if ("server".equals(optionsSource)) {
+        source = Source.SERVER;
+      } else if ("cache".equals(optionsSource)) {
+        source = Source.CACHE;
+      } else {
+        source = Source.DEFAULT;
+      }
+    } else {
+      source = Source.DEFAULT;
+    }
+
+    return source;
+  }
 }

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

@@ -20,11 +20,14 @@ package io.invertase.firebase.firestore;
 import static io.invertase.firebase.common.RCTConvertFirebase.toHashMap;
 import static io.invertase.firebase.firestore.ReactNativeFirebaseFirestoreCommon.rejectPromiseFirestoreException;
 
+import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
 import com.google.firebase.firestore.FirebaseFirestore;
+import com.google.firebase.firestore.LoadBundleTaskProgress;
 import io.invertase.firebase.common.ReactNativeFirebaseModule;
 
 public class ReactNativeFirebaseFirestoreModule extends ReactNativeFirebaseModule {
@@ -45,6 +48,21 @@ public class ReactNativeFirebaseFirestoreModule extends ReactNativeFirebaseModul
     }
   }
 
+  @ReactMethod
+  public void loadBundle(String appName, String bundle, Promise promise) {
+    module
+        .loadBundle(appName, bundle)
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                LoadBundleTaskProgress progress = task.getResult();
+                promise.resolve(taskProgressToWritableMap(progress));
+              } else {
+                rejectPromiseFirestoreException(promise, task.getException());
+              }
+            });
+  }
+
   @ReactMethod
   public void clearPersistence(String appName, Promise promise) {
     module
@@ -142,4 +160,28 @@ public class ReactNativeFirebaseFirestoreModule extends ReactNativeFirebaseModul
               }
             });
   }
+
+  private WritableMap taskProgressToWritableMap(LoadBundleTaskProgress progress) {
+    WritableMap writableMap = Arguments.createMap();
+    writableMap.putDouble("bytesLoaded", progress.getBytesLoaded());
+    writableMap.putInt("documentsLoaded", progress.getDocumentsLoaded());
+    writableMap.putDouble("totalBytes", progress.getTotalBytes());
+    writableMap.putInt("totalDocuments", progress.getTotalDocuments());
+
+    LoadBundleTaskProgress.TaskState taskState = progress.getTaskState();
+    String convertedState = "Running";
+    switch (taskState) {
+      case RUNNING:
+        convertedState = "Running";
+        break;
+      case SUCCESS:
+        convertedState = "Success";
+        break;
+      case ERROR:
+        convertedState = "Error";
+        break;
+    }
+    writableMap.putString("taskState", convertedState);
+    return writableMap;
+  }
 }

package/ios/RNFBFirestore/RNFBFirestoreCollectionModule.m

@@ -61,6 +61,42 @@ RCT_EXPORT_MODULE();
 #pragma mark -
 #pragma mark Firebase Firestore Methods
 
+RCT_EXPORT_METHOD(namedQueryOnSnapshot
+                  : (FIRApp *)firebaseApp
+                  : (NSString *)name
+                  : (NSString *)type
+                  : (NSArray *)filters
+                  : (NSArray *)orders
+                  : (NSDictionary *)options
+                  : (nonnull NSNumber *)listenerId
+                  : (NSDictionary *)listenerOptions) {
+  if (collectionSnapshotListeners[listenerId]) {
+    return;
+  }
+
+  FIRFirestore *firestore = [RNFBFirestoreCommon getFirestoreForApp:firebaseApp];
+  [[FIRFirestore firestore] getQueryNamed:name
+                               completion:^(FIRQuery *query) {
+                                 if (query == nil) {
+                                   [self sendSnapshotError:firebaseApp
+                                                listenerId:listenerId
+                                                     error:nil];
+                                   return;
+                                 }
+
+                                 RNFBFirestoreQuery *firestoreQuery =
+                                     [[RNFBFirestoreQuery alloc] initWithModifiers:firestore
+                                                                             query:query
+                                                                           filters:filters
+                                                                            orders:orders
+                                                                           options:options];
+                                 [self handleQueryOnSnapshot:firebaseApp
+                                              firestoreQuery:firestoreQuery
+                                                  listenerId:listenerId
+                                             listenerOptions:listenerOptions];
+                               }];
+}
+
 RCT_EXPORT_METHOD(collectionOnSnapshot
                   : (FIRApp *)firebaseApp
                   : (NSString *)path
@@ -82,33 +118,10 @@ RCT_EXPORT_METHOD(collectionOnSnapshot
                                                                              filters:filters
                                                                               orders:orders
                                                                              options:options];
-
-  BOOL includeMetadataChanges = NO;
-  if (listenerOptions[KEY_INCLUDE_METADATA_CHANGES] != nil) {
-    includeMetadataChanges = [listenerOptions[KEY_INCLUDE_METADATA_CHANGES] boolValue];
-  }
-
-  __weak RNFBFirestoreCollectionModule *weakSelf = self;
-  id listenerBlock = ^(FIRQuerySnapshot *snapshot, NSError *error) {
-    if (error) {
-      id<FIRListenerRegistration> listener = collectionSnapshotListeners[listenerId];
-      if (listener) {
-        [listener remove];
-        [collectionSnapshotListeners removeObjectForKey:listenerId];
-      }
-      [weakSelf sendSnapshotError:firebaseApp listenerId:listenerId error:error];
-    } else {
-      [weakSelf sendSnapshotEvent:firebaseApp
-                       listenerId:listenerId
-                         snapshot:snapshot
-           includeMetadataChanges:includeMetadataChanges];
-    }
-  };
-
-  id<FIRListenerRegistration> listener = [[firestoreQuery instance]
-      addSnapshotListenerWithIncludeMetadataChanges:includeMetadataChanges
-                                           listener:listenerBlock];
-  collectionSnapshotListeners[listenerId] = listener;
+  [self handleQueryOnSnapshot:firebaseApp
+               firestoreQuery:firestoreQuery
+                   listenerId:listenerId
+              listenerOptions:listenerOptions];
 }
 
 RCT_EXPORT_METHOD(collectionOffSnapshot : (FIRApp *)firebaseApp : (nonnull NSNumber *)listenerId) {
@@ -119,6 +132,39 @@ RCT_EXPORT_METHOD(collectionOffSnapshot : (FIRApp *)firebaseApp : (nonnull NSNum
   }
 }
 
+RCT_EXPORT_METHOD(namedQueryGet
+                  : (FIRApp *)firebaseApp
+                  : (NSString *)name
+                  : (NSString *)type
+                  : (NSArray *)filters
+                  : (NSArray *)orders
+                  : (NSDictionary *)options
+                  : (NSDictionary *)getOptions
+                  : (RCTPromiseResolveBlock)resolve
+                  : (RCTPromiseRejectBlock)reject) {
+  FIRFirestore *firestore = [RNFBFirestoreCommon getFirestoreForApp:firebaseApp];
+  [[FIRFirestore firestore]
+      getQueryNamed:name
+         completion:^(FIRQuery *query) {
+           if (query == nil) {
+             return [RNFBFirestoreCommon promiseRejectFirestoreException:reject error:nil];
+           }
+
+           RNFBFirestoreQuery *firestoreQuery =
+               [[RNFBFirestoreQuery alloc] initWithModifiers:firestore
+                                                       query:query
+                                                     filters:filters
+                                                      orders:orders
+                                                     options:options];
+           FIRFirestoreSource source = [self getSource:getOptions];
+           [self handleQueryGet:firebaseApp
+                 firestoreQuery:firestoreQuery
+                         source:source
+                        resolve:resolve
+                         reject:reject];
+         }];
+}
+
 RCT_EXPORT_METHOD(collectionGet
                   : (FIRApp *)firebaseApp
                   : (NSString *)path
@@ -137,21 +183,51 @@ RCT_EXPORT_METHOD(collectionGet
                                                                              filters:filters
                                                                               orders:orders
                                                                              options:options];
+  FIRFirestoreSource source = [self getSource:getOptions];
+  [self handleQueryGet:firebaseApp
+        firestoreQuery:firestoreQuery
+                source:source
+               resolve:resolve
+                reject:reject];
+}
 
-  FIRFirestoreSource source;
+- (void)handleQueryOnSnapshot:(FIRApp *)firebaseApp
+               firestoreQuery:(RNFBFirestoreQuery *)firestoreQuery
+                   listenerId:(nonnull NSNumber *)listenerId
+              listenerOptions:(NSDictionary *)listenerOptions {
+  BOOL includeMetadataChanges = NO;
+  if (listenerOptions[KEY_INCLUDE_METADATA_CHANGES] != nil) {
+    includeMetadataChanges = [listenerOptions[KEY_INCLUDE_METADATA_CHANGES] boolValue];
+  }
 
-  if (getOptions[@"source"]) {
-    if ([getOptions[@"source"] isEqualToString:@"server"]) {
-      source = FIRFirestoreSourceServer;
-    } else if ([getOptions[@"source"] isEqualToString:@"cache"]) {
-      source = FIRFirestoreSourceCache;
+  __weak RNFBFirestoreCollectionModule *weakSelf = self;
+  id listenerBlock = ^(FIRQuerySnapshot *snapshot, NSError *error) {
+    if (error) {
+      id<FIRListenerRegistration> listener = collectionSnapshotListeners[listenerId];
+      if (listener) {
+        [listener remove];
+        [collectionSnapshotListeners removeObjectForKey:listenerId];
+      }
+      [weakSelf sendSnapshotError:firebaseApp listenerId:listenerId error:error];
     } else {
-      source = FIRFirestoreSourceDefault;
+      [weakSelf sendSnapshotEvent:firebaseApp
+                       listenerId:listenerId
+                         snapshot:snapshot
+           includeMetadataChanges:includeMetadataChanges];
     }
-  } else {
-    source = FIRFirestoreSourceDefault;
-  }
+  };
 
+  id<FIRListenerRegistration> listener = [[firestoreQuery instance]
+      addSnapshotListenerWithIncludeMetadataChanges:includeMetadataChanges
+                                           listener:listenerBlock];
+  collectionSnapshotListeners[listenerId] = listener;
+}
+
+- (void)handleQueryGet:(FIRApp *)firebaseApp
+        firestoreQuery:(RNFBFirestoreQuery *)firestoreQuery
+                source:(FIRFirestoreSource)source
+               resolve:(RCTPromiseResolveBlock)resolve
+                reject:(RCTPromiseRejectBlock)reject {
   [[firestoreQuery instance]
       getDocumentsWithSource:source
                   completion:^(FIRQuerySnapshot *snapshot, NSError *error) {
@@ -209,4 +285,22 @@ RCT_EXPORT_METHOD(collectionGet
                    }];
 }
 
+- (FIRFirestoreSource)getSource:(NSDictionary *)getOptions {
+  FIRFirestoreSource source;
+
+  if (getOptions[@"source"]) {
+    if ([getOptions[@"source"] isEqualToString:@"server"]) {
+      source = FIRFirestoreSourceServer;
+    } else if ([getOptions[@"source"] isEqualToString:@"cache"]) {
+      source = FIRFirestoreSourceCache;
+    } else {
+      source = FIRFirestoreSourceDefault;
+    }
+  } else {
+    source = FIRFirestoreSourceDefault;
+  }
+
+  return source;
+}
+
 @end

package/ios/RNFBFirestore/RNFBFirestoreModule.m

@@ -107,6 +107,23 @@ RCT_EXPORT_METHOD(settings
   resolve([NSNull null]);
 }
 
+RCT_EXPORT_METHOD(loadBundle
+                  : (FIRApp *)firebaseApp
+                  : (nonnull NSString *)bundle
+                  : (RCTPromiseResolveBlock)resolve
+                  : (RCTPromiseRejectBlock)reject) {
+  NSData *bundleData = [bundle dataUsingEncoding:NSUTF8StringEncoding];
+  [[RNFBFirestoreCommon getFirestoreForApp:firebaseApp]
+      loadBundle:bundleData
+      completion:^(FIRLoadBundleTaskProgress *progress, NSError *error) {
+        if (error) {
+          [RNFBFirestoreCommon promiseRejectFirestoreException:reject error:error];
+        } else {
+          resolve([self taskProgressToDictionary:progress]);
+        }
+      }];
+}
+
 RCT_EXPORT_METHOD(clearPersistence
                   : (FIRApp *)firebaseApp
                   : (RCTPromiseResolveBlock)resolve
@@ -164,4 +181,27 @@ RCT_EXPORT_METHOD(terminate
   }];
 }
 
+- (NSMutableDictionary *)taskProgressToDictionary:(FIRLoadBundleTaskProgress *)progress {
+  NSMutableDictionary *progressMap = [[NSMutableDictionary alloc] init];
+  progressMap[@"bytesLoaded"] = @(progress.bytesLoaded);
+  progressMap[@"documentsLoaded"] = @(progress.documentsLoaded);
+  progressMap[@"totalBytes"] = @(progress.totalBytes);
+  progressMap[@"totalDocuments"] = @(progress.totalDocuments);
+
+  NSString *state;
+  switch (progress.state) {
+    case FIRLoadBundleTaskStateError:
+      state = @"Error";
+      break;
+    case FIRLoadBundleTaskStateSuccess:
+      state = @"Success";
+      break;
+    case FIRLoadBundleTaskStateInProgress:
+      state = @"Running";
+      break;
+  }
+  progressMap[@"taskState"] = state;
+  return progressMap;
+}
+
 @end

package/lib/FirestoreQuery.js

@@ -31,10 +31,11 @@ import { parseSnapshotArgs } from './utils';
 let _id = 0;
 
 export default class FirestoreQuery {
-  constructor(firestore, collectionPath, modifiers) {
+  constructor(firestore, collectionPath, modifiers, queryName) {
     this._firestore = firestore;
     this._collectionPath = collectionPath;
     this._modifiers = modifiers;
+    this._queryName = queryName;
   }
 
   get firestore() {
@@ -134,6 +135,7 @@ export default class FirestoreQuery {
       this._firestore,
       this._collectionPath,
       this._handleQueryCursor('endAt', docOrField, fields),
+      this._queryName,
     );
   }
 
@@ -142,6 +144,7 @@ export default class FirestoreQuery {
       this._firestore,
       this._collectionPath,
       this._handleQueryCursor('endBefore', docOrField, fields),
+      this._queryName,
     );
   }
 
@@ -164,6 +167,19 @@ export default class FirestoreQuery {
       );
     }
 
+    if (!isUndefined(this._queryName)) {
+      return this._firestore.native
+        .namedQueryGet(
+          this._queryName,
+          this._modifiers.type,
+          this._modifiers.filters,
+          this._modifiers.orders,
+          this._modifiers.options,
+          options,
+        )
+        .then(data => new FirestoreQuerySnapshot(this._firestore, this, data));
+    }
+
     this._modifiers.validatelimitToLast();
 
     return this._firestore.native
@@ -219,7 +235,7 @@ export default class FirestoreQuery {
 
     const modifiers = this._modifiers._copy().limit(limit);
 
-    return new FirestoreQuery(this._firestore, this._collectionPath, modifiers);
+    return new FirestoreQuery(this._firestore, this._collectionPath, modifiers, this._queryName);
   }
 
   limitToLast(limitToLast) {
@@ -231,7 +247,7 @@ export default class FirestoreQuery {
 
     const modifiers = this._modifiers._copy().limitToLast(limitToLast);
 
-    return new FirestoreQuery(this._firestore, this._collectionPath, modifiers);
+    return new FirestoreQuery(this._firestore, this._collectionPath, modifiers, this._queryName);
   }
 
   onSnapshot(...args) {
@@ -285,15 +301,27 @@ export default class FirestoreQuery {
       this._firestore.native.collectionOffSnapshot(listenerId);
     };
 
-    this._firestore.native.collectionOnSnapshot(
-      this._collectionPath.relativeName,
-      this._modifiers.type,
-      this._modifiers.filters,
-      this._modifiers.orders,
-      this._modifiers.options,
-      listenerId,
-      snapshotListenOptions,
-    );
+    if (!isUndefined(this._queryName)) {
+      this._firestore.native.namedQueryOnSnapshot(
+        this._queryName,
+        this._modifiers.type,
+        this._modifiers.filters,
+        this._modifiers.orders,
+        this._modifiers.options,
+        listenerId,
+        snapshotListenOptions,
+      );
+    } else {
+      this._firestore.native.collectionOnSnapshot(
+        this._collectionPath.relativeName,
+        this._modifiers.type,
+        this._modifiers.filters,
+        this._modifiers.orders,
+        this._modifiers.options,
+        listenerId,
+        snapshotListenOptions,
+      );
+    }
 
     return unsubscribe;
   }
@@ -343,7 +371,7 @@ export default class FirestoreQuery {
       throw new Error(`firebase.firestore().collection().orderBy() ${e.message}`);
     }
 
-    return new FirestoreQuery(this._firestore, this._collectionPath, modifiers);
+    return new FirestoreQuery(this._firestore, this._collectionPath, modifiers, this._queryName);
   }
 
   startAfter(docOrField, ...fields) {
@@ -351,6 +379,7 @@ export default class FirestoreQuery {
       this._firestore,
       this._collectionPath,
       this._handleQueryCursor('startAfter', docOrField, fields),
+      this._queryName,
     );
   }
 
@@ -359,6 +388,7 @@ export default class FirestoreQuery {
       this._firestore,
       this._collectionPath,
       this._handleQueryCursor('startAt', docOrField, fields),
+      this._queryName,
     );
   }
 
@@ -421,6 +451,6 @@ export default class FirestoreQuery {
       throw new Error(`firebase.firestore().collection().where() ${e.message}`);
     }
 
-    return new FirestoreQuery(this._firestore, this._collectionPath, modifiers);
+    return new FirestoreQuery(this._firestore, this._collectionPath, modifiers, this._queryName);
   }
 }

package/lib/index.d.ts

@@ -720,6 +720,10 @@ export namespace FirebaseFirestoreTypes {
      * });
      * ```
      *
+     * Please be careful using this operator. It may not be reliable enough for use in strict accounting, as it
+     * appears writes may be dropped in situations not fully understood yet, but possibly correlated with increment frequency.
+     * See https://github.com/invertase/react-native-firebase/discussions/5914
+     *
      * @param n The value to increment by.
      */
     static increment(n: number): FieldValue;
@@ -1829,6 +1833,44 @@ export namespace FirebaseFirestoreTypes {
     ): WriteBatch;
   }
 
+  /**
+   * Represents the state of bundle loading tasks.
+   *
+   * Both 'Error' and 'Success' are sinking state: task will abort or complete and there will be no more
+   * updates after they are reported.
+   */
+  export type TaskState = 'Error' | 'Running' | 'Success';
+
+  /**
+   * Represents a progress update or a final state from loading bundles.
+   */
+  export interface LoadBundleTaskProgress {
+    /**
+     * How many bytes have been loaded.
+     */
+    bytesLoaded: number;
+
+    /**
+     * How many documents have been loaded.
+     */
+    documentsLoaded: number;
+
+    /**
+     * Current task state.
+     */
+    taskState: TaskState;
+
+    /**
+     * How many bytes are in the bundle being loaded.
+     */
+    totalBytes: number;
+
+    /**
+     * How many documents are in the bundle being loaded.
+     */
+    totalDocuments: number;
+  }
+
   /**
    * `firebase.firestore.X`
    */
@@ -2024,6 +2066,29 @@ export namespace FirebaseFirestoreTypes {
      * @param settings A `Settings` object.
      */
     settings(settings: Settings): Promise<void>;
+    /**
+     * Loads a Firestore bundle into the local cache.
+     *
+     * #### Example
+     *
+     * ```js
+     * const resp = await fetch('/createBundle');
+     * const bundleString = await resp.text();
+     * await firestore().loadBundle(bundleString);
+     * ```
+     */
+    loadBundle(bundle: string): Promise<LoadBundleTaskProgress>;
+    /**
+     * Reads a Firestore Query from local cache, identified by the given name.
+     *
+     * #### Example
+     *
+     * ```js
+     * const query = firestore().namedQuery('latest-stories-query');
+     * const storiesSnap = await query.get({ source: 'cache' });
+     * ```
+     */
+    namedQuery<T extends DocumentData = DocumentData>(name: string): Query<T>;
     /**
      * Aimed primarily at clearing up any data cached from running tests. Needs to be executed before any database calls
      * are made.

package/lib/index.js

@@ -84,6 +84,30 @@ class FirebaseFirestoreModule extends FirebaseModule {
     return new FirestoreWriteBatch(this);
   }
 
+  loadBundle(bundle) {
+    if (!isString(bundle)) {
+      throw new Error("firebase.firestore().loadBundle(*) 'bundle' must be a string value.");
+    }
+
+    if (bundle === '') {
+      throw new Error("firebase.firestore().loadBundle(*) 'bundle' must be a non-empty string.");
+    }
+
+    return this.native.loadBundle(bundle);
+  }
+
+  namedQuery(queryName) {
+    if (!isString(queryName)) {
+      throw new Error("firebase.firestore().namedQuery(*) 'queryName' must be a string value.");
+    }
+
+    if (queryName === '') {
+      throw new Error("firebase.firestore().namedQuery(*) 'queryName' must be a non-empty string.");
+    }
+
+    return new FirestoreQuery(this, this._referencePath, new FirestoreQueryModifiers(), queryName);
+  }
+
   async clearPersistence() {
     await this.native.clearPersistence();
   }
@@ -164,6 +188,7 @@ class FirebaseFirestoreModule extends FirebaseModule {
       this,
       this._referencePath.child(collectionId),
       new FirestoreQueryModifiers().asCollectionGroupQuery(),
+      undefined,
     );
   }
 

package/lib/version.js

@@ -1,2 +1,2 @@
 // generated by genversion
-module.exports = '14.7.0';
+module.exports = '14.9.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-firebase/firestore",
-  "version": "14.7.0",
+  "version": "14.9.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": "14.7.0"
+    "@react-native-firebase/app": "14.9.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "ef7895cd49eed3a4d103df624e52315250c68ab3"
+  "gitHead": "0fd4b4fc65467c4342442b22afb20a7f8cff0ada"
 }