@react-native-firebase/database 26.4.0 → 27.0.0

package/CHANGELOG.md

@@ -3,6 +3,27 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [27.0.0](https://github.com/invertase/react-native-firebase/compare/v26.4.0...v27.0.0) (2026-10-19)
+
+### ⚠ BREAKING CHANGES
+
+- **app, sdk:** bump Firebase Android 35, Apple 13, and JS 13
+
+### Features
+
+- **app, sdk:** bump Firebase Android 35, Apple 13, and JS 13 ([0ca03d1](https://github.com/invertase/react-native-firebase/commit/0ca03d11b0c271fb37cfbee8a0c3074a21969f0b))
+- **database:** get() uses the native one-shot read on Android and web ([65cf63c](https://github.com/invertase/react-native-firebase/commit/65cf63c963b3914a4aa0e450caefae7a621d383b)), closes [firebase-ios-sdk#12168](https://github.com/invertase/firebase-ios-sdk/issues/12168)
+
+### Bug Fixes
+
+- **app,database:** resolve platform native module when bundlers apply package exports ([959d91f](https://github.com/invertase/react-native-firebase/commit/959d91fc79d7155d1d9a08e1f836789e6e6d6156))
+- **database, android:** settle keepSynced promise after SDK apply ([61100f2](https://github.com/invertase/react-native-firebase/commit/61100f27700eda0b5f69ec21ebd991ca97ce316d))
+- **database, android:** surface onDisconnect errors; cover deny reject arms ([1a4a4d6](https://github.com/invertase/react-native-firebase/commit/1a4a4d63e5f41042d9ddba55375b6a758f9829d5))
+- **database:** decode iOS null sentinels before writes ([501bec8](https://github.com/invertase/react-native-firebase/commit/501bec812fab11614cae0622a93b6d16687819dd))
+- **database:** keep get() from cancelling any keepSynced at the location on Android ([befb08c](https://github.com/invertase/react-native-firebase/commit/befb08c2f225ea65031ffa71ad173a68cf411dfd)), closes [firebase-android-sdk#8433](https://github.com/invertase/firebase-android-sdk/issues/8433)
+- **database:** only fall back to once() for locations kept synced ([6a7eddb](https://github.com/invertase/react-native-firebase/commit/6a7eddb837f6c003eaa6f6da8697e4b402da4861))
+- **database:** skip once retry after observer-shaped get errors ([6e18ddf](https://github.com/invertase/react-native-firebase/commit/6e18ddffa2f74445b843dc0d992b41232254ccb3))
+
 ## [26.4.0](https://github.com/invertase/react-native-firebase/compare/v26.3.3...v26.4.0) (2026-09-05)
 
 ### Bug Fixes

package/RNFBDatabase.podspec

@@ -29,7 +29,8 @@ Pod::Spec.new do |s|
   s.ios.deployment_target = firebase_ios_target
   s.macos.deployment_target = firebase_macos_target
   s.tvos.deployment_target = firebase_tvos_target
-  s.source_files        = 'ios/**/*.{h,m,mm,cpp}'
+  s.swift_version       = '5.10'
+  s.source_files        = 'ios/**/*.{h,m,mm,cpp,swift}'
   s.private_header_files = [
     'ios/RNFBDatabase/RNFBDatabaseModule.h',
     'ios/RNFBDatabase/RNFBDatabaseReferenceModule.h',
@@ -38,11 +39,16 @@ Pod::Spec.new do |s|
     'ios/RNFBDatabase/RNFBDatabaseTransactionModule.h',
     'ios/RNFBDatabase/RNFBDatabaseQueryRegistry.h',
     'ios/RNFBDatabase/RNFBDatabaseListenerRegistry.h',
+    'ios/RNFBDatabase/RNFBDatabaseNullSentinelDecoder.h',
     'ios/generated/**/*.h',
   ]
-  s.exclude_files       = 'ios/generated/RCTThirdPartyComponentsProvider.*', 'ios/generated/RCTAppDependencyProvider.*', 'ios/generated/RCTModuleProviders.*', 'ios/generated/RCTModulesConformingToProtocolsProvider.*', 'ios/generated/RCTUnstableModulesRequiringMainQueueSetupProvider.*', 'ios/*UnitTests/**'
+  # CocoaPods FileList uses FNM_PATHNAME: `ios/*UnitTests/**` does not match nested
+  # paths like `ios/RNFBDatabaseUnitTests/HostStubs/**` (those would compile into the pod).
+  s.exclude_files       = 'ios/generated/RCTThirdPartyComponentsProvider.*', 'ios/generated/RCTAppDependencyProvider.*', 'ios/generated/RCTModuleProviders.*', 'ios/generated/RCTModulesConformingToProtocolsProvider.*', 'ios/generated/RCTUnstableModulesRequiringMainQueueSetupProvider.*', 'ios/*UnitTests/**/*'
 
+  # DEFINES_MODULE is required for the generated RNFBDatabase-Swift.h interface.
   s.pod_target_xcconfig = {
+    "DEFINES_MODULE" => "YES",
     "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/ios/generated/RNFBDatabaseTurboModules\" \"$(PODS_TARGET_SRCROOT)/ios/generated\"",
     "CLANG_ALLOW_NON_MODULAR_INCLUDES_IN_FRAMEWORK_MODULES" => "YES",
   }

package/android/build.gradle

@@ -13,6 +13,7 @@ buildscript {
 
     dependencies {
       classpath("com.android.tools.build:gradle:8.4.0")
+      classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.findProperty('kotlinVersion') ?: '2.4.0'}")
     }
   }
 }
@@ -21,6 +22,8 @@ plugins {
   id "io.invertase.gradle.build" version "1.5"
 }
 
+apply plugin: "org.jetbrains.kotlin.android"
+
 def appProject
 if (findProject(':@react-native-firebase_app')) {
   appProject = project(':@react-native-firebase_app')
@@ -95,6 +98,8 @@ dependencies {
   implementation "com.google.firebase:firebase-database"
 
   testImplementation "junit:junit:4.13.2"
+  testImplementation "org.robolectric:robolectric:4.14.1"
+  testImplementation "org.mockito:mockito-core:5.14.2"
 }
 
 ReactNative.shared.applyPackageVersion()

package/android/src/main/java/io/invertase/firebase/database/RNFBDatabaseKeepSyncedRegistry.java

@@ -0,0 +1,106 @@
+package io.invertase.firebase.database;
+
+/*
+ * 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.
+ *
+ */
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Keeps the native one-shot get away from the app's keepSynced, by location.
+ *
+ * <p>When Query.get() misses the cache, it turns keepSynced on and then off for the location's
+ * default spec. Turning it off removes every keepSynced registration at the location, whatever its
+ * query, without unlistening, which cancels the app's keepSynced there (firebase-android-sdk#8433).
+ * So a location with anything kept synced is read with once(), and a keepSynced call on a location
+ * waits for the native gets in flight there.
+ */
+final class RNFBDatabaseKeepSyncedRegistry {
+  // Keys of the queries kept synced, by location.
+  private final Map<String, Set<String>> keptSynced = new HashMap<>();
+  // Native gets in flight, by location.
+  private final Map<String, Integer> nativeGets = new HashMap<>();
+  // keepSynced calls waiting for those gets, in call order, by location.
+  private final Map<String, List<Runnable>> deferred = new HashMap<>();
+
+  /**
+   * Records keepSynced for the query with this key at the location, and runs {@code apply} now, or
+   * after the location's native gets complete (call order preserved). {@code apply} is the SDK
+   * {@code Query.keepSynced} call and any caller completion that must wait for it (for example
+   * settling a TurboModule Promise). A native get only starts while nothing at the location is kept
+   * synced, so the SDK has no keepSynced there in the meantime.
+   */
+  synchronized void keepSynced(String location, String queryKey, boolean enabled, Runnable apply) {
+    Set<String> queryKeys = keptSynced.get(location);
+    if (enabled) {
+      if (queryKeys == null) {
+        queryKeys = new HashSet<>();
+        keptSynced.put(location, queryKeys);
+      }
+      queryKeys.add(queryKey);
+    } else if (queryKeys != null) {
+      queryKeys.remove(queryKey);
+      if (queryKeys.isEmpty()) {
+        keptSynced.remove(location);
+      }
+    }
+
+    if (!nativeGets.containsKey(location)) {
+      apply.run();
+      return;
+    }
+    List<Runnable> waiting = deferred.get(location);
+    if (waiting == null) {
+      waiting = new ArrayList<>();
+      deferred.put(location, waiting);
+    }
+    waiting.add(apply);
+  }
+
+  /** Counts a native get on the location, or returns false if anything there is kept synced. */
+  synchronized boolean beginNativeGet(String location) {
+    if (keptSynced.containsKey(location)) {
+      return false;
+    }
+    Integer inFlight = nativeGets.get(location);
+    nativeGets.put(location, inFlight == null ? 1 : inFlight + 1);
+    return true;
+  }
+
+  /**
+   * Ends a native get. After the location's last one, runs the keepSynced calls that waited for it,
+   * in call order.
+   */
+  synchronized void endNativeGet(String location) {
+    int inFlight = nativeGets.get(location) - 1;
+    if (inFlight > 0) {
+      nativeGets.put(location, inFlight);
+      return;
+    }
+    nativeGets.remove(location);
+    List<Runnable> waiting = deferred.remove(location);
+    if (waiting != null) {
+      for (Runnable apply : waiting) {
+        apply.run();
+      }
+    }
+  }
+}

package/android/src/main/java/io/invertase/firebase/database/RNFBDatabaseListenerRegistry.kt

@@ -0,0 +1,133 @@
+package io.invertase.firebase.database
+
+/*
+ * 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.
+ *
+ */
+
+import io.invertase.firebase.common.RNFBHandleCollisionException
+import io.invertase.firebase.common.RNFBHandleMap
+
+/**
+ * Per-query value/child listener maps. Unique [putValue]/[putChild]; callers [takeValue]/
+ * [takeChild] or [takeAll] then remove the SDK listener outside the HandleMap lock. Null values are
+ * not stored so [hasListeners] can use occupancy.
+ *
+ * Null-key note: [getValue]/[getChild]/[takeValue]/[takeChild]/[hasEventListener] accept
+ * `String?` and return null/false for a null key (Java `HashMap` interop). TurboModule/`ReadableMap`
+ * paths can pass a null `eventRegistrationKey` into remove/`hasEventListener`. Put keys stay
+ * non-null `String` (null-key put from Java NPEs via Kotlin null-check; swallowed at add call sites).
+ */
+internal class RNFBDatabaseListenerRegistry {
+  private val occupancyLock = Any()
+  private val valueListeners = RNFBHandleMap<String, Any>()
+  private val childListeners = RNFBHandleMap<String, Any>()
+  private var occupancy = 0
+
+  @Throws(RNFBHandleCollisionException::class)
+  fun putValue(
+    eventRegistrationKey: String,
+    listener: Any?,
+  ) {
+    if (listener == null) {
+      throw NullPointerException("listener")
+    }
+    synchronized(occupancyLock) {
+      valueListeners.put(eventRegistrationKey, listener)
+      occupancy++
+    }
+  }
+
+  @Throws(RNFBHandleCollisionException::class)
+  fun putChild(
+    eventRegistrationKey: String,
+    listener: Any?,
+  ) {
+    if (listener == null) {
+      throw NullPointerException("listener")
+    }
+    synchronized(occupancyLock) {
+      childListeners.put(eventRegistrationKey, listener)
+      occupancy++
+    }
+  }
+
+  fun getValue(eventRegistrationKey: String?): Any? = if (eventRegistrationKey == null) null else valueListeners.get(eventRegistrationKey)
+
+  fun getChild(eventRegistrationKey: String?): Any? = if (eventRegistrationKey == null) null else childListeners.get(eventRegistrationKey)
+
+  fun takeValue(eventRegistrationKey: String?): Any? {
+    synchronized(occupancyLock) {
+      if (eventRegistrationKey == null) {
+        return null
+      }
+      val listener = valueListeners.take(eventRegistrationKey)
+      if (listener != null) {
+        occupancy--
+      }
+      return listener
+    }
+  }
+
+  fun takeChild(eventRegistrationKey: String?): Any? {
+    synchronized(occupancyLock) {
+      if (eventRegistrationKey == null) {
+        return null
+      }
+      val listener = childListeners.take(eventRegistrationKey)
+      if (listener != null) {
+        occupancy--
+      }
+      return listener
+    }
+  }
+
+  fun takeAllValues(): List<Any> {
+    synchronized(occupancyLock) {
+      val remaining = valueListeners.takeAll()
+      occupancy -= remaining.size
+      return remaining
+    }
+  }
+
+  fun takeAllChildren(): List<Any> {
+    synchronized(occupancyLock) {
+      val remaining = childListeners.takeAll()
+      occupancy -= remaining.size
+      return remaining
+    }
+  }
+
+  fun takeAll(): List<Any> {
+    val remaining = ArrayList<Any>()
+    remaining.addAll(takeAllValues())
+    remaining.addAll(takeAllChildren())
+    return remaining
+  }
+
+  fun hasEventListener(eventRegistrationKey: String?): Boolean {
+    if (eventRegistrationKey == null) {
+      return false
+    }
+    return valueListeners.get(eventRegistrationKey) != null ||
+      childListeners.get(eventRegistrationKey) != null
+  }
+
+  fun hasListeners(): Boolean {
+    synchronized(occupancyLock) {
+      return occupancy > 0
+    }
+  }
+}

package/android/src/main/java/io/invertase/firebase/database/RNFBDatabaseQueryRegistry.kt

@@ -0,0 +1,76 @@
+package io.invertase.firebase.database
+
+/*
+ * 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.
+ *
+ */
+
+import io.invertase.firebase.common.RNFBHandleCollisionException
+import io.invertase.firebase.common.RNFBHandleMap
+
+/**
+ * Cached query map. Unique [put]; callers [take], [takeIfIdle], or [takeAllAndRemove] then
+ * `removeAllEventListeners()` outside the HandleMap lock.
+ *
+ * Null-key note: [get]/[take]/[takeIfIdle] accept `String?` and return null / no-op for a null key
+ * (Java `HashMap` interop). TurboModule `off(queryKey, …)` can pass a null `queryKey`. Put keys stay
+ * non-null `String`.
+ */
+internal class RNFBDatabaseQueryRegistry {
+  private val map = RNFBHandleMap<String, DatabaseQueryHandle?>()
+
+  @Throws(RNFBHandleCollisionException::class)
+  fun put(
+    queryKey: String,
+    query: DatabaseQueryHandle?,
+  ) {
+    map.put(queryKey, query)
+  }
+
+  fun get(queryKey: String?): DatabaseQueryHandle? = if (queryKey == null) null else map.get(queryKey)
+
+  fun take(queryKey: String?): DatabaseQueryHandle? = if (queryKey == null) null else map.take(queryKey)
+
+  /**
+   * Removes the mapping when the query has no listeners. Reads [DatabaseQueryHandle.hasListeners]
+   * outside the HandleMap lock (avoids nesting `occupancyLock`), then identity-takes and put-backs if
+   * listeners appeared.
+   */
+  fun takeIfIdle(queryKey: String?) {
+    if (queryKey == null) {
+      return
+    }
+    val query = map.get(queryKey) ?: return
+    if (query.hasListeners() == true) {
+      return
+    }
+    val taken = map.takeIf(queryKey) { q -> q === query } ?: return
+    if (taken.hasListeners() == true) {
+      // Prefer put-back so an active query stays registered. If a concurrent put claimed the
+      // slot, putIfAbsent fails and this taken query would be an orphan with listeners — clear
+      // them so SDK callbacks are not left attached outside the registry.
+      if (!map.putIfAbsent(queryKey, taken)) {
+        taken.removeAllEventListeners()
+      }
+    }
+  }
+
+  fun takeAllAndRemove() {
+    val remaining = map.takeAll()
+    for (query in remaining) {
+      query?.removeAllEventListeners()
+    }
+  }
+}

package/android/src/main/java/io/invertase/firebase/database/RNFBDatabaseTransactionRegistry.kt

@@ -0,0 +1,67 @@
+package io.invertase.firebase.database
+
+/*
+ * 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.
+ *
+ */
+
+import io.invertase.firebase.common.RNFBHandleCollisionException
+import io.invertase.firebase.common.RNFBHandleMap
+
+/**
+ * Transaction handler map. Unique [put] (occupied id aborts the incoming handler, then throws);
+ * callers [take] or [takeAllAndAbort] then `abort()` outside the HandleMap lock. Replace is
+ * [registerReplacing] (atomic last wins).
+ */
+internal class RNFBDatabaseTransactionRegistry {
+  private val map = RNFBHandleMap<Int, DatabaseAbortable?>()
+
+  @Throws(RNFBHandleCollisionException::class)
+  fun put(
+    transactionId: Int,
+    handler: DatabaseAbortable?,
+  ) {
+    try {
+      map.put(transactionId, handler)
+    } catch (collision: RNFBHandleCollisionException) {
+      handler?.abort()
+      throw collision
+    }
+  }
+
+  /** Atomic replace (last wins). The replaced handler is not aborted (Firebase retry). */
+  fun registerReplacing(
+    transactionId: Int,
+    handler: DatabaseAbortable?,
+  ) {
+    map.putReplacing(transactionId, handler)
+  }
+
+  fun get(transactionId: Int): DatabaseAbortable? = map.get(transactionId)
+
+  fun take(transactionId: Int): DatabaseAbortable? = map.take(transactionId)
+
+  fun takeAndAbort(transactionId: Int) {
+    val handler = map.take(transactionId)
+    handler?.abort()
+  }
+
+  fun takeAllAndAbort() {
+    val remaining = map.takeAll()
+    for (handler in remaining) {
+      handler?.abort()
+    }
+  }
+}

package/android/src/main/java/io/invertase/firebase/database/UniversalFirebaseDatabaseOnDisconnectModule.java

@@ -21,6 +21,7 @@ import static io.invertase.firebase.database.UniversalFirebaseDatabaseCommon.get
 
 import android.content.Context;
 import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
 import com.google.firebase.database.OnDisconnect;
 import io.invertase.firebase.common.UniversalFirebaseModule;
 import java.util.Map;
@@ -32,33 +33,125 @@ public class UniversalFirebaseDatabaseOnDisconnectModule extends UniversalFireba
   }
 
   Task<Void> onDisconnectCancel(String appName, String dbURL, String path) {
-    return getDatabaseForApp(appName, dbURL).getReference(path).onDisconnect().cancel();
+    TaskCompletionSource<Void> taskCompletionSource = new TaskCompletionSource<>();
+    OnDisconnect onDisconnect = getDatabaseForApp(appName, dbURL).getReference(path).onDisconnect();
+
+    onDisconnect.cancel(
+        (databaseError, databaseReference) -> {
+          if (databaseError != null) {
+            taskCompletionSource.setException(
+                new UniversalDatabaseException(
+                    databaseError.getCode(),
+                    databaseError.getMessage(),
+                    databaseError.toException()));
+          } else {
+            taskCompletionSource.setResult(null);
+          }
+        });
+
+    return taskCompletionSource.getTask();
   }
 
   Task<Void> onDisconnectRemove(String appName, String dbURL, String path) {
-    return getDatabaseForApp(appName, dbURL).getReference(path).onDisconnect().removeValue();
+    TaskCompletionSource<Void> taskCompletionSource = new TaskCompletionSource<>();
+    OnDisconnect onDisconnect = getDatabaseForApp(appName, dbURL).getReference(path).onDisconnect();
+
+    onDisconnect.removeValue(
+        (databaseError, databaseReference) -> {
+          if (databaseError != null) {
+            taskCompletionSource.setException(
+                new UniversalDatabaseException(
+                    databaseError.getCode(),
+                    databaseError.getMessage(),
+                    databaseError.toException()));
+          } else {
+            taskCompletionSource.setResult(null);
+          }
+        });
+
+    return taskCompletionSource.getTask();
   }
 
   Task<Void> onDisconnectSet(String appName, String dbURL, String path, Object value) {
-    return getDatabaseForApp(appName, dbURL).getReference(path).onDisconnect().setValue(value);
+    TaskCompletionSource<Void> taskCompletionSource = new TaskCompletionSource<>();
+    OnDisconnect onDisconnect = getDatabaseForApp(appName, dbURL).getReference(path).onDisconnect();
+
+    onDisconnect.setValue(
+        value,
+        (databaseError, databaseReference) -> {
+          if (databaseError != null) {
+            taskCompletionSource.setException(
+                new UniversalDatabaseException(
+                    databaseError.getCode(),
+                    databaseError.getMessage(),
+                    databaseError.toException()));
+          } else {
+            taskCompletionSource.setResult(null);
+          }
+        });
+
+    return taskCompletionSource.getTask();
   }
 
   Task<Void> onDisconnectSetWithPriority(
       String appName, String dbURL, String path, Object value, Object priority) {
+    TaskCompletionSource<Void> taskCompletionSource = new TaskCompletionSource<>();
     OnDisconnect onDisconnect = getDatabaseForApp(appName, dbURL).getReference(path).onDisconnect();
 
     if (priority instanceof String) {
-      return onDisconnect.setValue(value, (String) priority);
+      onDisconnect.setValue(
+          value,
+          (String) priority,
+          (databaseError, databaseReference) -> {
+            if (databaseError != null) {
+              taskCompletionSource.setException(
+                  new UniversalDatabaseException(
+                      databaseError.getCode(),
+                      databaseError.getMessage(),
+                      databaseError.toException()));
+            } else {
+              taskCompletionSource.setResult(null);
+            }
+          });
     } else {
-      return onDisconnect.setValue(value, (double) priority);
+      onDisconnect.setValue(
+          value,
+          (double) priority,
+          (databaseError, databaseReference) -> {
+            if (databaseError != null) {
+              taskCompletionSource.setException(
+                  new UniversalDatabaseException(
+                      databaseError.getCode(),
+                      databaseError.getMessage(),
+                      databaseError.toException()));
+            } else {
+              taskCompletionSource.setResult(null);
+            }
+          });
     }
+
+    return taskCompletionSource.getTask();
   }
 
   Task<Void> onDisconnectUpdate(
       String appName, String dbURL, String path, Map<String, Object> values) {
-    return getDatabaseForApp(appName, dbURL)
-        .getReference(path)
-        .onDisconnect()
-        .updateChildren(values);
+    TaskCompletionSource<Void> taskCompletionSource = new TaskCompletionSource<>();
+    OnDisconnect onDisconnect = getDatabaseForApp(appName, dbURL).getReference(path).onDisconnect();
+
+    onDisconnect.updateChildren(
+        values,
+        (databaseError, databaseReference) -> {
+          if (databaseError != null) {
+            taskCompletionSource.setException(
+                new UniversalDatabaseException(
+                    databaseError.getCode(),
+                    databaseError.getMessage(),
+                    databaseError.toException()));
+          } else {
+            taskCompletionSource.setResult(null);
+          }
+        });
+
+    return taskCompletionSource.getTask();
   }
 }

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

@@ -18,12 +18,12 @@ package io.invertase.firebase.database;
  */
 
 import static io.invertase.firebase.common.RCTConvertFirebase.toHashMap;
+import static io.invertase.firebase.database.ReactNativeFirebaseDatabaseCommon.rejectPromiseDatabaseException;
 
 import com.facebook.fbreact.specs.NativeRNFBTurboDatabaseOnDisconnectSpec;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReadableMap;
-import io.invertase.firebase.common.ReactNativeFirebaseModule;
 import java.util.Map;
 
 public class NativeRNFBTurboDatabaseOnDisconnect extends NativeRNFBTurboDatabaseOnDisconnectSpec {
@@ -44,8 +44,7 @@ public class NativeRNFBTurboDatabaseOnDisconnect extends NativeRNFBTurboDatabase
               if (task.isSuccessful()) {
                 promise.resolve(task.getResult());
               } else {
-                ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(
-                    promise, task.getException());
+                rejectPromiseDatabaseException(promise, task.getException());
               }
             });
   }
@@ -59,8 +58,7 @@ public class NativeRNFBTurboDatabaseOnDisconnect extends NativeRNFBTurboDatabase
               if (task.isSuccessful()) {
                 promise.resolve(task.getResult());
               } else {
-                ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(
-                    promise, task.getException());
+                rejectPromiseDatabaseException(promise, task.getException());
               }
             });
   }
@@ -75,8 +73,7 @@ public class NativeRNFBTurboDatabaseOnDisconnect extends NativeRNFBTurboDatabase
               if (task.isSuccessful()) {
                 promise.resolve(task.getResult());
               } else {
-                ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(
-                    promise, task.getException());
+                rejectPromiseDatabaseException(promise, task.getException());
               }
             });
   }
@@ -92,8 +89,7 @@ public class NativeRNFBTurboDatabaseOnDisconnect extends NativeRNFBTurboDatabase
               if (task.isSuccessful()) {
                 promise.resolve(task.getResult());
               } else {
-                ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(
-                    promise, task.getException());
+                rejectPromiseDatabaseException(promise, task.getException());
               }
             });
   }
@@ -110,8 +106,7 @@ public class NativeRNFBTurboDatabaseOnDisconnect extends NativeRNFBTurboDatabase
               if (task.isSuccessful()) {
                 promise.resolve(task.getResult());
               } else {
-                ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(
-                    promise, task.getException());
+                rejectPromiseDatabaseException(promise, task.getException());
               }
             });
   }