@react-native-firebase/database 20.1.0 → 20.2.1

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.
 
+## [20.2.1](https://github.com/invertase/react-native-firebase/compare/v20.2.0...v20.2.1) (2024-07-17)
+
+**Note:** Version bump only for package @react-native-firebase/database
+
+## [20.2.0](https://github.com/invertase/react-native-firebase/compare/v20.1.0...v20.2.0) (2024-07-15)
+
+### Features
+
+- **other:** Add Database support ([#7887](https://github.com/invertase/react-native-firebase/issues/7887)) ([fbb773a](https://github.com/invertase/react-native-firebase/commit/fbb773a87c167bdc92265fe261aeb777d4660cd7))
+
+### Bug Fixes
+
+- **database:** set priority on child snapshot if available ([#7897](https://github.com/invertase/react-native-firebase/issues/7897)) ([9028ae4](https://github.com/invertase/react-native-firebase/commit/9028ae4785eb17239ae2ab49d343a39c01a349e7))
+
 ## [20.1.0](https://github.com/invertase/react-native-firebase/compare/v20.0.0...v20.1.0) (2024-06-04)
 
 **Note:** Version bump only for package @react-native-firebase/database

package/android/src/reactnative/java/io/invertase/firebase/database/ReactNativeFirebaseDatabaseCommon.java

@@ -24,10 +24,13 @@ import android.util.Log;
 import com.facebook.react.bridge.*;
 import com.google.firebase.database.DataSnapshot;
 import com.google.firebase.database.MutableData;
+import java.util.HashMap;
 import javax.annotation.Nullable;
 
 public class ReactNativeFirebaseDatabaseCommon {
   private static final String TAG = "DatabaseCommon";
+  private static final String childPrioritiesKey = "childPriorities";
+  private static final String childKeysKey = "childKeys";
 
   /**
    * @param promise
@@ -61,12 +64,13 @@ public class ReactNativeFirebaseDatabaseCommon {
    */
   public static WritableMap snapshotToMap(DataSnapshot dataSnapshot) {
     WritableMap snapshot = Arguments.createMap();
-
+    HashMap<String, Object> childProperties = getChildProperties(dataSnapshot);
     snapshot.putString("key", dataSnapshot.getKey());
     snapshot.putBoolean("exists", dataSnapshot.exists());
     snapshot.putBoolean("hasChildren", dataSnapshot.hasChildren());
     snapshot.putDouble("childrenCount", dataSnapshot.getChildrenCount());
-    snapshot.putArray("childKeys", getChildKeys(dataSnapshot));
+    snapshot.putArray(childKeysKey, (ReadableArray) childProperties.get(childKeysKey));
+    snapshot.putMap(childPrioritiesKey, (WritableMap) childProperties.get(childPrioritiesKey));
     mapPutValue("priority", dataSnapshot.getPriority(), snapshot);
 
     if (!dataSnapshot.hasChildren()) {
@@ -369,15 +373,29 @@ public class ReactNativeFirebaseDatabaseCommon {
    * @param snapshot
    * @return
    */
-  public static WritableArray getChildKeys(DataSnapshot snapshot) {
+  public static HashMap<String, Object> getChildProperties(DataSnapshot snapshot) {
     WritableArray childKeys = Arguments.createArray();
-
+    WritableMap childPriorities = Arguments.createMap();
+    HashMap<String, Object> childProperties = new HashMap<>();
     if (snapshot.hasChildren()) {
       for (DataSnapshot child : snapshot.getChildren()) {
         childKeys.pushString(child.getKey());
+
+        Object priority = child.getPriority();
+        // Priority can be String, Double or null
+        if (priority instanceof String) {
+          childPriorities.putString(child.getKey(), (String) priority);
+        } else if (priority instanceof Double) {
+          childPriorities.putDouble(child.getKey(), (Double) priority);
+        } else if (priority == null) {
+          childPriorities.putNull(child.getKey());
+        }
       }
     }
 
-    return childKeys;
+    childProperties.put(childKeysKey, childKeys);
+    childProperties.put(childPrioritiesKey, childPriorities);
+
+    return childProperties;
   }
 }

package/ios/RNFBDatabase/RNFBDatabaseCommon.m

@@ -26,6 +26,9 @@ NSString *const DATABASE_PERSISTENCE_ENABLED = @"firebase_database_persistence_e
 NSString *const DATABASE_LOGGING_ENABLED = @"firebase_database_logging_enabled";
 NSString *const DATABASE_PERSISTENCE_CACHE_SIZE = @"firebase_database_persistence_cache_size_bytes";
 
+NSString *const childPrioritiesKey = @"childPriorities";
+NSString *const childKeysKey = @"childKeys";
+
 @implementation RNFBDatabaseCommon
 
 + (void)load {
@@ -250,28 +253,32 @@ NSString *const DATABASE_PERSISTENCE_CACHE_SIZE = @"firebase_database_persistenc
   } else {
     [snapshot setValue:[NSNull null] forKey:@"key"];
   }
+  NSMutableDictionary *childProperties = [self getSnapshotChildProperties:dataSnapshot];
   [snapshot setValue:@(dataSnapshot.exists) forKey:@"exists"];
   [snapshot setValue:@(dataSnapshot.hasChildren) forKey:@"hasChildren"];
   [snapshot setValue:@(dataSnapshot.childrenCount) forKey:@"childrenCount"];
-  [snapshot setValue:[self getSnapshotChildKeys:dataSnapshot] forKey:@"childKeys"];
+  [snapshot setValue:childProperties[childKeysKey] forKey:childKeysKey];
+  [snapshot setValue:childProperties[childPrioritiesKey] forKey:childPrioritiesKey];
   [snapshot setValue:dataSnapshot.priority forKey:@"priority"];
   [snapshot setValue:dataSnapshot.value forKey:@"value"];
 
   return snapshot;
 }
 
-+ (NSMutableArray *)getSnapshotChildKeys:(FIRDataSnapshot *)dataSnapshot {
++ (NSMutableDictionary *)getSnapshotChildProperties:(FIRDataSnapshot *)dataSnapshot {
   NSMutableArray *childKeys = [NSMutableArray array];
+  NSMutableDictionary *childPriorities = [[NSMutableDictionary alloc] init];
   if (dataSnapshot.childrenCount > 0) {
     NSEnumerator *children = [dataSnapshot children];
     FIRDataSnapshot *child;
     child = [children nextObject];
     while (child) {
       [childKeys addObject:child.key];
+      [childPriorities setValue:child.priority forKey:child.key];
       child = [children nextObject];
     }
   }
-  return childKeys;
+  return @{childKeysKey : childKeys, childPrioritiesKey : childPriorities};
 }
 
 @end

package/lib/DatabaseDataSnapshot.js

@@ -15,7 +15,13 @@
  *
  */
 
-import { isArray, isFunction, isObject, isString } from '@react-native-firebase/app/lib/common';
+import {
+  isArray,
+  isFunction,
+  isObject,
+  isString,
+  isNumber,
+} from '@react-native-firebase/app/lib/common';
 import { deepGet } from '@react-native-firebase/app/lib/common/deeps';
 
 export default class DatabaseDataSnapshot {
@@ -61,11 +67,19 @@ export default class DatabaseDataSnapshot {
 
     const childRef = this._ref.child(path);
 
+    let childPriority = null;
+    if (this._snapshot.childPriorities) {
+      const childPriorityValue = this._snapshot.childPriorities[childRef.key];
+      if (isString(childPriorityValue) || isNumber(childPriorityValue)) {
+        childPriority = childPriorityValue;
+      }
+    }
     return new DatabaseDataSnapshot(childRef, {
       value,
       key: childRef.key,
       exists: value !== null,
       childKeys: isObject(value) ? Object.keys(value) : [],
+      priority: childPriority,
     });
   }
 

package/lib/DatabaseSyncTree.js

@@ -16,9 +16,9 @@
  */
 
 import { isString } from '@react-native-firebase/app/lib/common';
+import { getReactNativeModule } from '@react-native-firebase/app/lib/internal/nativeModule';
 import NativeError from '@react-native-firebase/app/lib/internal/NativeFirebaseError';
 import SharedEventEmitter from '@react-native-firebase/app/lib/internal/SharedEventEmitter';
-import { NativeModules } from 'react-native';
 import DatabaseDataSnapshot from './DatabaseDataSnapshot';
 
 class DatabaseSyncTree {
@@ -39,7 +39,7 @@ class DatabaseSyncTree {
   }
 
   get native() {
-    return NativeModules.RNFBDatabaseQueryModule;
+    return getReactNativeModule('RNFBDatabaseQueryModule');
   }
 
   // from upstream EventEmitter: initialize registrations for an emitter key

package/lib/DatabaseTransaction.js

@@ -16,6 +16,7 @@
  */
 
 import NativeError from '@react-native-firebase/app/lib/internal/NativeFirebaseError';
+import { isOther } from '@react-native-firebase/app/lib/common';
 
 let transactionId = 0;
 
@@ -59,7 +60,11 @@ export default class DatabaseTransaction {
       started: true,
     };
 
-    this._database.native.transactionStart(reference.path, id, applyLocally);
+    if (isOther) {
+      this._database.native.transactionStart(reference.path, id, applyLocally, transactionUpdater);
+    } else {
+      this._database.native.transactionStart(reference.path, id, applyLocally);
+    }
   }
 
   /**

package/lib/index.js

@@ -21,10 +21,12 @@ import {
   FirebaseModule,
   getFirebaseRoot,
 } from '@react-native-firebase/app/lib/internal';
+import { setReactNativeModule } from '@react-native-firebase/app/lib/internal/nativeModule';
 import DatabaseReference from './DatabaseReference';
 import DatabaseStatics from './DatabaseStatics';
 import DatabaseTransaction from './DatabaseTransaction';
 import version from './version';
+import fallBackModule from './web/RNFBDatabaseModule';
 
 const namespace = 'database';
 
@@ -222,3 +224,7 @@ export * from './modular';
 // database().X(...);
 // firebase.database().X(...);
 export const firebase = getFirebaseRoot();
+
+for (let i = 0; i < nativeModuleName.length; i++) {
+  setReactNativeModule(nativeModuleName[i], fallBackModule);
+}

package/lib/version.js

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

package/lib/web/RNFBDatabaseModule.android.js

@@ -0,0 +1,2 @@
+// No-op for android.
+export default {};

package/lib/web/RNFBDatabaseModule.ios.js

@@ -0,0 +1,2 @@
+// No-op for ios.
+export default {};

package/lib/web/RNFBDatabaseModule.js

@@ -0,0 +1,545 @@
+import {
+  getApp,
+  getDatabase,
+  connectDatabaseEmulator,
+  enableLogging,
+  goOnline,
+  goOffline,
+  ref,
+  set,
+  update,
+  setWithPriority,
+  remove,
+  setPriority,
+  onDisconnect,
+  onValue,
+  onChildAdded,
+  onChildChanged,
+  onChildMoved,
+  onChildRemoved,
+  runTransaction,
+} from '@react-native-firebase/app/lib/internal/web/firebaseDatabase';
+import { guard, getWebError, emitEvent } from '@react-native-firebase/app/lib/internal/web/utils';
+import { getQueryInstance } from './query';
+
+// Converts a DataSnapshot to an object.
+function snapshotToObject(snapshot) {
+  const childKeys = [];
+
+  if (snapshot.hasChildren()) {
+    snapshot.forEach(childSnapshot => {
+      childKeys.push(childSnapshot.key);
+    });
+  }
+
+  return {
+    key: snapshot.key,
+    exists: snapshot.exists(),
+    hasChildren: snapshot.hasChildren(),
+    childrenCount: snapshot.size,
+    childKeys,
+    priority: snapshot.priority,
+    value: snapshot.val(),
+  };
+}
+
+function getDatabaseWebError(error) {
+  // Possible to override messages/codes here if necessary.
+  return getWebError(error);
+}
+
+// Converts a DataSnapshot and previous child name to an object.
+function snapshotWithPreviousChildToObject(snapshot, previousChildName) {
+  return {
+    snapshot: snapshotToObject(snapshot),
+    previousChildName,
+  };
+}
+
+const appInstances = {};
+const databaseInstances = {};
+const onDisconnectRef = {};
+const listeners = {};
+const emulatorForApp = {};
+
+function getCachedAppInstance(appName) {
+  return (appInstances[appName] ??= getApp(appName));
+}
+
+// Returns a cached Database instance.
+function getCachedDatabaseInstance(appName, dbURL) {
+  let instance = databaseInstances[`${appName}|${dbURL}`];
+  if (!instance) {
+    instance = getDatabase(getCachedAppInstance(appName), dbURL);
+    // Relying on internals here so need to be careful between SDK versions.
+    if (emulatorForApp[appName] && !instance._instanceStarted) {
+      const { host, port } = emulatorForApp[appName];
+      connectDatabaseEmulator(instance, host, port);
+      emulatorForApp[appName].connected = true;
+    }
+  }
+  return instance;
+}
+
+// Returns a cached onDisconnect instance.
+function getCachedOnDisconnectInstance(ref) {
+  return (onDisconnectRef[ref.key] ??= onDisconnect(ref));
+}
+
+export default {
+  /**
+   * Reconnects to the server.
+   * @param {string} appName - The app name.
+   * @param {string} dbURL - The database URL.
+   * @returns {Promise<void>}
+   */
+  goOnline(appName, dbURL) {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      goOnline(db);
+    });
+  },
+
+  /**
+   * Disconnects from the server.
+   * @param {string} appName - The app name.
+   * @param {string} dbURL - The database URL.
+   * @returns {Promise<void>}
+   */
+  goOffline(appName, dbURL) {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      goOffline(db);
+    });
+  },
+
+  setPersistenceEnabled() {
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        'The Firebase Database `setPersistenceEnabled` method is not available in the this environment.',
+      );
+    }
+    return Promise.resolve();
+  },
+
+  /**
+   * Sets the logging enabled state.
+   * @param {string} appName - The app name, not used.
+   * @param {string} dbURL - The database URL, not used.
+   * @param {boolean} enabled - The logging enabled state.
+   */
+  setLoggingEnabled(app, dbURL, enabled) {
+    return guard(async () => {
+      enableLogging(enabled);
+    });
+  },
+
+  setPersistenceCacheSizeBytes() {
+    // no-op on other platforms
+    return Promise.resolve();
+  },
+
+  /**
+   * Connects to the Firebase database emulator.
+   * @param {string} appName - The app name.
+   * @param {string} dbURL - The database URL.
+   * @param {string} host - The emulator host.
+   * @param {number} port - The emulator
+   * @returns {Promise<void>}
+   */
+  useEmulator(appName, dbURL, host, port) {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      connectDatabaseEmulator(db, host, port);
+      emulatorForApp[appName] = { host, port };
+    });
+  },
+
+  /**
+   * Reference
+   */
+
+  /**
+   * Sets a value at the specified path.
+   * @param {string} appName - The app name.
+   * @param {string} dbURL - The database URL.
+   * @param {string} path - The path.
+   * @param {object} props - The properties
+   * @returns {Promise<void>}
+   */
+  set(appName, dbURL, path, props) {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      const value = props.value;
+      await set(dbRef, value);
+    });
+  },
+
+  /**
+   * Updates the specified path with the provided values.
+   * @param {string} appName - The app name.
+   * @param {string} dbURL - The database URL.
+   * @param {string} path - The path.
+   * @param {object} props - The properties
+   * @returns {Promise<void>}
+   */
+  update(appName, dbURL, path, props) {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      const values = props.values;
+      await update(dbRef, values);
+    });
+  },
+
+  /**
+   * Sets a value at the specified path with a priority.
+   * @param {string} appName - The app name.
+   * @param {string} dbURL - The database URL.
+   * @param {string} path - The path.
+   * @param {object} props - The properties, including value and priority.
+   * @returns {Promise<void>}
+   */
+  setWithPriority(appName, dbURL, path, props) {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      const value = props.value;
+      const priority = props.priority;
+      await setWithPriority(dbRef, value, priority);
+    });
+  },
+
+  /**
+   * Removes the nodd at the specified path.
+   * @param {string} appName - The app name.
+   * @param {string} dbURL - The database URL.
+   * @param {string} path - The path.
+   * @returns {Promise<void>}
+   */
+  remove(appName, dbURL, path) {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      await remove(dbRef);
+    });
+  },
+
+  /**
+   * Sets the priority of the node at the specified path.
+   * @param {string} appName - The app name.
+   * @param {string} dbURL - The database URL.
+   * @param {string} path - The path.
+   * @param {object} props - The properties, including priority.
+   * @returns {Promise<void>}
+   */
+  setPriority(appName, dbURL, path, props) {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      const priority = props.priority;
+      await setPriority(dbRef, priority);
+    });
+  },
+
+  /**
+   * Query
+   */
+
+  /**
+   * Listens for data changes at the specified path once.
+   * @param {string} appName - The app name.
+   * @param {string} dbURL - The database URL.
+   * @param {string} path - The path.
+   * @param {object} modifiers - The modifiers.
+   * @param {string} eventType - The event type.
+   * @returns {Promise<object>}
+   */
+  once(appName, dbURL, path, modifiers, eventType) {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      const queryRef = getQueryInstance(dbRef, modifiers);
+
+      if (eventType === 'value') {
+        const snapshot = await new Promise((resolve, reject) => {
+          onValue(queryRef, resolve, reject, { onlyOnce: true });
+        });
+
+        return snapshotToObject(snapshot);
+      } else {
+        let fn = null;
+
+        if (eventType === 'child_added') {
+          fn = onChildAdded;
+        } else if (eventType === 'child_changed') {
+          fn = onChildChanged;
+        } else if (eventType === 'child_removed') {
+          fn = onChildRemoved;
+        } else if (eventType === 'child_moved') {
+          fn = onChildMoved;
+        }
+
+        if (fn) {
+          const { snapshot, previousChildName } = await new Promise((resolve, reject) => {
+            fn(
+              queryRef,
+              (snapshot, previousChildName) => {
+                resolve({ snapshot, previousChildName });
+              },
+              reject,
+              { onlyOnce: true },
+            );
+          });
+
+          return snapshotWithPreviousChildToObject(snapshot, previousChildName);
+        }
+      }
+
+      const snapshot = await get(dbRef, modifiers);
+      return snapshot;
+    });
+  },
+
+  on(appName, dbURL, props) {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const { key, modifiers, path, eventType, registration } = props;
+      const { eventRegistrationKey } = registration;
+      const dbRef = ref(db, path);
+
+      const queryRef = getQueryInstance(dbRef, modifiers);
+
+      function sendEvent(data) {
+        const event = {
+          eventName: 'database_sync_event',
+          body: {
+            data,
+            key,
+            registration,
+            eventType,
+          },
+        };
+
+        emitEvent('database_sync_event', event);
+      }
+
+      function sendError(error) {
+        const event = {
+          eventName: 'database_sync_event',
+          body: {
+            key,
+            registration,
+            error: getDatabaseWebError(error),
+          },
+        };
+
+        emitEvent('database_sync_event', event);
+      }
+
+      let listener = null;
+
+      // Ignore if the listener already exists.
+      if (listeners[eventRegistrationKey]) {
+        return;
+      }
+
+      if (eventType === 'value') {
+        listener = onValue(queryRef, snapshot => sendEvent(snapshotToObject(snapshot)), sendError);
+      } else {
+        let fn = null;
+
+        if (eventType === 'child_added') {
+          fn = onChildAdded;
+        } else if (eventType === 'child_changed') {
+          fn = onChildChanged;
+        } else if (eventType === 'child_removed') {
+          fn = onChildRemoved;
+        } else if (eventType === 'child_moved') {
+          fn = onChildMoved;
+        }
+
+        if (fn) {
+          listener = fn(
+            queryRef,
+            (snapshot, previousChildName) => {
+              sendEvent(snapshotWithPreviousChildToObject(snapshot, previousChildName));
+            },
+            sendError,
+          );
+        }
+      }
+
+      listeners[eventRegistrationKey] = listener;
+    });
+  },
+
+  off(queryKey, eventRegistrationKey) {
+    const listener = listeners[eventRegistrationKey];
+    if (listener) {
+      listener();
+      delete listeners[eventRegistrationKey];
+    }
+  },
+
+  keepSynced() {
+    return rejectPromiseWithCodeAndMessage(
+      'unsupported',
+      'This operation is not supported on this environment.',
+    );
+  },
+
+  /**
+   * OnDisconnect
+   */
+
+  /**
+   * Cancels the onDisconnect instance at the specified path.
+   * @param {string} appName - The app name.
+   * @param {string} dbURL - The database URL.
+   * @param {string} path - The path.
+   * @returns {Promise<void>}
+   */
+  onDisconnectCancel(appName, dbURL, path) {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      const instance = getCachedOnDisconnectInstance(dbRef);
+      await instance.cancel();
+
+      // Delete the onDisconnect instance from the cache.
+      delete onDisconnectRef[dbRef.key];
+    });
+  },
+
+  /**
+   * Sets a value to be written to the database on disconnect.
+   * @param {string} appName - The app name.
+   * @param {string} dbURL - The database URL.
+   * @param {string} path - The path.
+   * @returns {Promise<void>}
+   */
+  onDisconnectRemove(appName, dbURL, path) {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      const instance = getCachedOnDisconnectInstance(dbRef);
+      await instance.remove();
+    });
+  },
+
+  /**
+   * Sets a value to be written to the database on disconnect.
+   * @param {string} appName - The app name.
+   * @param {string} dbURL - The database URL.
+   * @param {string} path - The path.
+   * @param {object} props - The properties, including value.
+   * @returns {Promise<void>}
+   */
+  onDisconnectSet(appName, dbURL, path, props) {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      const instance = getCachedOnDisconnectInstance(dbRef);
+      const value = props.value;
+      await instance.set(value);
+    });
+  },
+
+  /**
+   * Sets a value to be written to the database on disconnect with a priority.
+   * @param {string} appName - The app name.
+   * @param {string} dbURL - The database URL.
+   * @param {string} path - The path.
+   * @param {object} props - The properties, including value and priority.
+   * @returns {Promise<void>}
+   */
+  onDisconnectSetWithPriority(appName, dbURL, path, props) {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      const instance = getCachedOnDisconnectInstance(dbRef);
+      const value = props.value;
+      const priority = props.priority;
+      await instance.setWithPriority(value, priority);
+    });
+  },
+
+  /**
+   * Updates the specified path with the provided values on disconnect.
+   * @param {string} appName - The app name.
+   * @param {string} dbURL - The database URL.
+   * @param {string} path - The path.
+   * @param {object} props - The properties, including values.
+   * @returns {Promise<void>}
+   */
+  onDisconnectUpdate(appName, dbURL, path, props) {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      const instance = getCachedOnDisconnectInstance(dbRef);
+      const values = props.values;
+      await instance.update(values);
+    });
+  },
+
+  /**
+   * Transaction
+   */
+
+  transactionStart(appName, dbURL, path, transactionId, applyLocally, userExecutor) {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+
+      try {
+        const { committed, snapshot } = await runTransaction(dbRef, userExecutor, {
+          applyLocally,
+        });
+
+        const event = {
+          body: {
+            committed,
+            type: 'complete',
+            snapshot: snapshotToObject(snapshot),
+          },
+          appName,
+          id: transactionId,
+          eventName: 'database_transaction_event',
+        };
+
+        emitEvent('database_transaction_event', event);
+      } catch (e) {
+        const event = {
+          body: {
+            committed: false,
+            type: 'error',
+            error: getDatabaseWebError(e),
+          },
+          appName,
+          id: transactionId,
+          eventName: 'database_transaction_event',
+        };
+
+        emitEvent('database_transaction_event', event);
+      }
+    });
+  },
+
+  /**
+   * Commits the transaction with the specified updates.
+   * @param {string} appName - The app name.
+   * @param {string} dbURL - The database URL.
+   * @param {string} transactionId - The transaction ID.
+   * @param {object} updates - The updates.
+   * @returns {Promise<void>}
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async transactionTryCommit(appName, dbURL, transactionId, updates) {
+    // We don't need to implement this as for 'Other' platforms
+    // we pass the users transaction function to the Firebase JS SDK directly.
+    throw new Error('Not implemented');
+  },
+};

package/lib/web/query.js

@@ -0,0 +1,71 @@
+import {
+  query,
+  orderByKey,
+  orderByPriority,
+  orderByValue,
+  orderByChild,
+  limitToLast,
+  limitToFirst,
+  endAt,
+  endBefore,
+  startAt,
+  startAfter,
+} from '@react-native-firebase/app/lib/internal/web/firebaseDatabase';
+
+export function getQueryInstance(dbRef, modifiers) {
+  const constraints = [];
+
+  for (const modifier of modifiers) {
+    const { type, name } = modifier;
+
+    if (type === 'orderBy') {
+      switch (name) {
+        case 'orderByKey':
+          constraints.push(orderByKey());
+          break;
+        case 'orderByPriority':
+          constraints.push(orderByPriority());
+          break;
+        case 'orderByValue':
+          constraints.push(orderByValue());
+          break;
+        case 'orderByChild':
+          constraints.push(orderByChild(modifier.key));
+          break;
+      }
+    }
+
+    if (type === 'limit') {
+      const { value } = modifier;
+
+      switch (name) {
+        case 'limitToLast':
+          constraints.push(limitToLast(value));
+          break;
+        case 'limitToFirst':
+          constraints.push(limitToFirst(value));
+          break;
+      }
+    }
+
+    if (type === 'filter') {
+      const { key, value } = modifier;
+
+      switch (name) {
+        case 'endAt':
+          constraints.push(endAt(value, key));
+          break;
+        case 'endBefore':
+          constraints.push(endBefore(value, key));
+          break;
+        case 'startAt':
+          constraints.push(startAt(value, key));
+          break;
+        case 'startAfter':
+          constraints.push(startAfter(value, key));
+          break;
+      }
+    }
+  }
+  return query(dbRef, ...constraints);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-firebase/database",
-  "version": "20.1.0",
+  "version": "20.2.1",
   "author": "Invertase <oss@invertase.io> (http://invertase.io)",
   "description": "React Native Firebase - The Firebase Realtime Database is a cloud-hosted database. Data is stored as JSON and synchronized in realtime to every connected client. React Native Firebase provides native integration with the Android & iOS Firebase SDKs, supporting both realtime data sync and offline capabilities.",
   "main": "lib/index.js",
@@ -25,10 +25,10 @@
     "realtome database"
   ],
   "peerDependencies": {
-    "@react-native-firebase/app": "20.1.0"
+    "@react-native-firebase/app": "20.2.1"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "99819b9cef23ac46080cbffe50cc85083305d04c"
+  "gitHead": "2c787c2dbefbefcc637018e1e5d74a73b39600ab"
 }