@react-native-firebase/database 26.4.0 → 27.0.0

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

@@ -29,6 +29,7 @@ import com.google.firebase.database.*;
 import io.invertase.firebase.common.RNFBHandleCollisionException;
 import io.invertase.firebase.common.ReactNativeFirebaseEventEmitter;
 import io.invertase.firebase.common.ReactNativeFirebaseModule;
+import io.invertase.firebase.common.UniversalFirebasePreferences;
 import java.util.Objects;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
@@ -374,6 +375,88 @@ public class NativeRNFBTurboDatabaseQuery extends NativeRNFBTurboDatabaseQuerySp
     }
   }
 
+  // Static because the SDK keeps keepSynced registrations across a JS reload.
+  private static final RNFBDatabaseKeepSyncedRegistry keepSyncedRegistry =
+      new RNFBDatabaseKeepSyncedRegistry();
+
+  // reference.toString() is the full URL, so a null dbURL and the default URL give the same key.
+  private static String locationKey(String app, DatabaseReference reference) {
+    return app + "|" + reference;
+  }
+
+  private static final java.util.regex.Pattern PERMISSION_DENIED_REASON =
+      java.util.regex.Pattern.compile(
+          "permission.?denied", java.util.regex.Pattern.CASE_INSENSITIVE);
+
+  /**
+   * Single request/response read backing modular get(). Offline, Query.get() waits for the
+   * connection, like once(). It uses once() instead when:
+   *
+   * <ul>
+   *   <li>disk persistence is on: Query.get() then resolves from disk after 3s, even online;
+   *   <li>RTDB debug logging is on: a get in flight when the socket drops is resent on reconnect
+   *       only because PersistentConnectionImpl.sendGet's early return sits inside {@code if
+   *       (logger.logsDebug())};
+   *   <li>the app keeps anything at this location synced (see RNFBDatabaseKeepSyncedRegistry).
+   * </ul>
+   */
+  @Override
+  public void get(String app, String dbURL, String path, ReadableArray modifiers, Promise promise) {
+    DatabaseReference reference = getDatabaseForApp(app, dbURL).getReference(path);
+    ReactNativeFirebaseDatabaseQuery databaseQuery = getDatabaseQueryInstance(reference, modifiers);
+
+    UniversalFirebasePreferences preferences = UniversalFirebasePreferences.getSharedInstance();
+    String location = locationKey(app, reference);
+    if (modifiers.size() > 0
+        || preferences.getBooleanValue(UniversalDatabaseStatics.DATABASE_PERSISTENCE_ENABLED, false)
+        || preferences.getBooleanValue(UniversalDatabaseStatics.DATABASE_LOGGING_ENABLED, false)
+        || !keepSyncedRegistry.beginNativeGet(location)) {
+      addOnceValueEventListener(databaseQuery, promise);
+      return;
+    }
+
+    databaseQuery
+        .query
+        .get()
+        .addOnCompleteListener(
+            getTask -> {
+              keepSyncedRegistry.endNativeGet(location);
+              if (!getTask.isSuccessful()) {
+                Exception exception = getTask.getException();
+                // Query.get() surfaces a server error as a plain Exception carrying only the
+                // reply's reason text. Map a denial to the error once() gives, so callers see the
+                // same code and DatabaseQuery._get need not re-ask the server.
+                if (exception != null
+                    && exception.getMessage() != null
+                    && PERMISSION_DENIED_REASON.matcher(exception.getMessage()).find()) {
+                  rejectPromiseDatabaseException(
+                      promise,
+                      new UniversalDatabaseException(
+                          DatabaseError.PERMISSION_DENIED, exception.getMessage(), exception));
+                  return;
+                }
+                ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(promise, exception);
+                return;
+              }
+              DataSnapshot dataSnapshot = getTask.getResult();
+              // Serialise off the main thread, as addOnceValueEventListener does.
+              try {
+                Tasks.call(turboSupport.getExecutor(), () -> snapshotToMap(dataSnapshot))
+                    .addOnCompleteListener(
+                        task -> {
+                          if (task.isSuccessful()) {
+                            promise.resolve(task.getResult());
+                          } else {
+                            ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(
+                                promise, task.getException());
+                          }
+                        });
+              } catch (java.util.concurrent.RejectedExecutionException e) {
+                ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(promise, e);
+              }
+            });
+  }
+
   @Override
   public void on(String app, String dbURL, ReadableMap props) {
     String key = props.getString("key");
@@ -414,7 +497,15 @@ public class NativeRNFBTurboDatabaseQuery extends NativeRNFBTurboDatabaseQuerySp
       boolean enabled,
       Promise promise) {
     DatabaseReference reference = getDatabaseForApp(app, dbURL).getReference(path);
-    getDatabaseQueryInstance(key, reference, modifiers).query.keepSynced(enabled);
-    promise.resolve(null);
+    Query query = getDatabaseQueryInstance(key, reference, modifiers).query;
+    // Resolve only after the SDK apply runs (now, or after endNativeGet when deferred).
+    keepSyncedRegistry.keepSynced(
+        locationKey(app, reference),
+        key,
+        enabled,
+        () -> {
+          query.keepSynced(enabled);
+          promise.resolve(null);
+        });
   }
 }

package/android/src/reactnative/java/io/invertase/firebase/database/generated/java/com/facebook/fbreact/specs/NativeRNFBTurboDatabaseQuerySpec.java

@@ -38,6 +38,10 @@ public abstract class NativeRNFBTurboDatabaseQuerySpec extends ReactContextBaseJ
   @DoNotStrip
   public abstract void once(String app, String dbURL, String path, ReadableArray modifiers, String eventType, Promise promise);
 
+  @ReactMethod
+  @DoNotStrip
+  public abstract void get(String app, String dbURL, String path, ReadableArray modifiers, Promise promise);
+
   @ReactMethod
   @DoNotStrip
   public abstract void on(String app, String dbURL, ReadableMap props);

package/android/src/reactnative/java/io/invertase/firebase/database/generated/jni/RNFBDatabaseTurboModules-generated.cpp

@@ -89,6 +89,11 @@ static facebook::jsi::Value __hostFunction_NativeRNFBTurboDatabaseQuerySpecJSI_o
   return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "once", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lcom/facebook/react/bridge/ReadableArray;Ljava/lang/String;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
 }
 
+static facebook::jsi::Value __hostFunction_NativeRNFBTurboDatabaseQuerySpecJSI_get(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "get", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lcom/facebook/react/bridge/ReadableArray;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
+}
+
 static facebook::jsi::Value __hostFunction_NativeRNFBTurboDatabaseQuerySpecJSI_on(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
   static jmethodID cachedMethodId = nullptr;
   return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, VoidKind, "on", "(Ljava/lang/String;Ljava/lang/String;Lcom/facebook/react/bridge/ReadableMap;)V", args, count, cachedMethodId);
@@ -107,6 +112,7 @@ static facebook::jsi::Value __hostFunction_NativeRNFBTurboDatabaseQuerySpecJSI_k
 NativeRNFBTurboDatabaseQuerySpecJSI::NativeRNFBTurboDatabaseQuerySpecJSI(const JavaTurboModule::InitParams &params)
   : JavaTurboModule(params) {
   methodMap_["once"] = MethodMetadata {5, __hostFunction_NativeRNFBTurboDatabaseQuerySpecJSI_once};
+  methodMap_["get"] = MethodMetadata {4, __hostFunction_NativeRNFBTurboDatabaseQuerySpecJSI_get};
   methodMap_["on"] = MethodMetadata {3, __hostFunction_NativeRNFBTurboDatabaseQuerySpecJSI_on};
   methodMap_["off"] = MethodMetadata {2, __hostFunction_NativeRNFBTurboDatabaseQuerySpecJSI_off};
   methodMap_["keepSynced"] = MethodMetadata {6, __hostFunction_NativeRNFBTurboDatabaseQuerySpecJSI_keepSynced};

package/android/src/reactnative/java/io/invertase/firebase/database/generated/jni/react/renderer/components/RNFBDatabaseTurboModules/RNFBDatabaseTurboModulesJSI.h

@@ -170,6 +170,7 @@ public:
 protected:
   NativeRNFBTurboDatabaseQueryCxxSpec(std::shared_ptr<CallInvoker> jsInvoker) : TurboModule(std::string{NativeRNFBTurboDatabaseQueryCxxSpec::kModuleName}, jsInvoker) {
     methodMap_["once"] = MethodMetadata {.argCount = 5, .invoker = __once};
+    methodMap_["get"] = MethodMetadata {.argCount = 4, .invoker = __get};
     methodMap_["on"] = MethodMetadata {.argCount = 3, .invoker = __on};
     methodMap_["off"] = MethodMetadata {.argCount = 2, .invoker = __off};
     methodMap_["keepSynced"] = MethodMetadata {.argCount = 6, .invoker = __keepSynced};
@@ -188,6 +189,17 @@ private:
       count <= 4 ? throw jsi::JSError(rt, "Expected argument in position 4 to be passed") : args[4].asString(rt));
   }
 
+  static jsi::Value __get(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+    static_assert(
+      bridging::getParameterCount(&T::get) == 5,
+      "Expected get(...) to have 5 parameters");
+    return bridging::callFromJs<jsi::Value>(rt, &T::get,  static_cast<NativeRNFBTurboDatabaseQueryCxxSpec*>(&turboModule)->jsInvoker_, static_cast<T*>(&turboModule),
+      count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asString(rt),
+      count <= 1 ? throw jsi::JSError(rt, "Expected argument in position 1 to be passed") : args[1].asString(rt),
+      count <= 2 ? throw jsi::JSError(rt, "Expected argument in position 2 to be passed") : args[2].asString(rt),
+      count <= 3 ? throw jsi::JSError(rt, "Expected argument in position 3 to be passed") : args[3].asObject(rt).asArray(rt));
+  }
+
   static jsi::Value __on(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
     static_assert(
       bridging::getParameterCount(&T::on) == 4,

package/android/src/test/java/io/invertase/firebase/database/RNFBDatabaseKeepSyncedRegistryTest.java

@@ -0,0 +1,174 @@
+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 static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.junit.Test;
+
+public class RNFBDatabaseKeepSyncedRegistryTest {
+  private static final String LOCATION = "[DEFAULT]|https://db.example.com/users/1";
+  private static final String OTHER_LOCATION = "[DEFAULT]|https://db.example.com/users/2";
+
+  private final RNFBDatabaseKeepSyncedRegistry registry = new RNFBDatabaseKeepSyncedRegistry();
+  private final List<String> applied = new ArrayList<>();
+
+  private void keepSynced(String location, String queryKey, boolean enabled) {
+    registry.keepSynced(location, queryKey, enabled, () -> applied.add(queryKey + "=" + enabled));
+  }
+
+  @Test
+  public void beginNativeGet_nothingKeptSynced_returnsTrue() {
+    assertTrue(registry.beginNativeGet(LOCATION));
+  }
+
+  @Test
+  public void beginNativeGet_locationKeptSynced_returnsFalse() {
+    keepSynced(LOCATION, "plain", true);
+    assertFalse(registry.beginNativeGet(LOCATION));
+  }
+
+  @Test
+  public void beginNativeGet_queryAtLocationKeptSynced_returnsFalse() {
+    keepSynced(LOCATION, "limitToLast(1)", true);
+    assertFalse(registry.beginNativeGet(LOCATION));
+  }
+
+  @Test
+  public void beginNativeGet_otherLocationKeptSynced_returnsTrue() {
+    keepSynced(OTHER_LOCATION, "plain", true);
+    assertTrue(registry.beginNativeGet(LOCATION));
+  }
+
+  @Test
+  public void beginNativeGet_afterKeepSyncedFalse_returnsTrue() {
+    keepSynced(LOCATION, "plain", true);
+    keepSynced(LOCATION, "plain", false);
+    assertTrue(registry.beginNativeGet(LOCATION));
+  }
+
+  @Test
+  public void beginNativeGet_untilEveryQueryAtLocationIsCleared_returnsFalse() {
+    keepSynced(LOCATION, "plain", true);
+    keepSynced(LOCATION, "limitToLast(1)", true);
+    keepSynced(LOCATION, "plain", false);
+    assertFalse(registry.beginNativeGet(LOCATION));
+    keepSynced(LOCATION, "limitToLast(1)", false);
+    assertTrue(registry.beginNativeGet(LOCATION));
+  }
+
+  @Test
+  public void keepSynced_noNativeGetInFlight_appliesNow() {
+    keepSynced(LOCATION, "plain", true);
+    assertEquals(Collections.singletonList("plain=true"), applied);
+  }
+
+  @Test
+  public void keepSynced_disableWhenNothingKept_stillApplies() {
+    keepSynced(LOCATION, "plain", false);
+    assertEquals(Collections.singletonList("plain=false"), applied);
+    assertTrue(registry.beginNativeGet(LOCATION));
+  }
+
+  @Test
+  public void keepSynced_noNativeGetInFlight_runsApplyBeforeCallerCompletion() {
+    List<String> order = new ArrayList<>();
+    registry.keepSynced(
+        LOCATION,
+        "plain",
+        true,
+        () -> {
+          order.add("sdk");
+          order.add("promise");
+        });
+    assertEquals(Arrays.asList("sdk", "promise"), order);
+  }
+
+  @Test
+  public void keepSynced_nativeGetInFlight_waitsForItInCallOrder() {
+    registry.beginNativeGet(LOCATION);
+    keepSynced(LOCATION, "plain", true);
+    keepSynced(LOCATION, "limitToLast(1)", true);
+    keepSynced(LOCATION, "plain", false);
+    assertTrue(applied.isEmpty());
+
+    registry.endNativeGet(LOCATION);
+    assertEquals(Arrays.asList("plain=true", "limitToLast(1)=true", "plain=false"), applied);
+  }
+
+  @Test
+  public void keepSynced_nativeGetInFlight_runsEachApplyBeforeItsCallerCompletion() {
+    List<String> order = new ArrayList<>();
+    registry.beginNativeGet(LOCATION);
+    registry.keepSynced(
+        LOCATION,
+        "plain",
+        true,
+        () -> {
+          order.add("sdk-true");
+          order.add("promise-true");
+        });
+    registry.keepSynced(
+        LOCATION,
+        "plain",
+        false,
+        () -> {
+          order.add("sdk-false");
+          order.add("promise-false");
+        });
+    assertTrue(order.isEmpty());
+
+    registry.endNativeGet(LOCATION);
+    assertEquals(Arrays.asList("sdk-true", "promise-true", "sdk-false", "promise-false"), order);
+  }
+
+  @Test
+  public void keepSynced_nativeGetInFlight_makesLaterGetsUseOnce() {
+    registry.beginNativeGet(LOCATION);
+    keepSynced(LOCATION, "plain", true);
+    assertFalse(registry.beginNativeGet(LOCATION));
+  }
+
+  @Test
+  public void keepSynced_nativeGetInFlightAtOtherLocation_appliesNow() {
+    registry.beginNativeGet(OTHER_LOCATION);
+    keepSynced(LOCATION, "plain", true);
+    assertEquals(Collections.singletonList("plain=true"), applied);
+  }
+
+  @Test
+  public void endNativeGet_waitsForTheLastGetAtLocation() {
+    registry.beginNativeGet(LOCATION);
+    registry.beginNativeGet(LOCATION);
+    keepSynced(LOCATION, "plain", true);
+
+    registry.endNativeGet(LOCATION);
+    assertTrue(applied.isEmpty());
+    registry.endNativeGet(LOCATION);
+    assertEquals(Collections.singletonList("plain=true"), applied);
+
+    keepSynced(LOCATION, "plain", false);
+    assertEquals(Arrays.asList("plain=true", "plain=false"), applied);
+  }
+}

package/android/src/test/java/io/invertase/firebase/database/RNFBDatabaseListenerRegistryTest.java

@@ -109,6 +109,37 @@ public class RNFBDatabaseListenerRegistryTest {
     assertFalse(registry.hasListeners());
   }
 
+  @Test
+  public void getValue_nullKey_returnsNull_noNpe() {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    assertNull(registry.getValue(null));
+  }
+
+  @Test
+  public void getChild_nullKey_returnsNull_noNpe() {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    assertNull(registry.getChild(null));
+  }
+
+  @Test
+  public void takeValue_nullKey_returnsNull_noNpe() {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    assertNull(registry.takeValue(null));
+    assertFalse(registry.hasListeners());
+  }
+
+  @Test
+  public void takeChild_nullKey_returnsNull_noNpe() {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    assertNull(registry.takeChild(null));
+  }
+
+  @Test
+  public void hasEventListener_nullKey_returnsFalse_noNpe() {
+    RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();
+    assertFalse(registry.hasEventListener(null));
+  }
+
   @Test
   public void takeChild_missingKey_isNoOp() {
     RNFBDatabaseListenerRegistry registry = new RNFBDatabaseListenerRegistry();

package/android/src/test/java/io/invertase/firebase/database/RNFBDatabaseQueryRegistryTest.java

@@ -209,6 +209,42 @@ public class RNFBDatabaseQueryRegistryTest {
     assertEquals(2, query.calls.get());
   }
 
+  /**
+   * Outside idle check saw the original query; before identity-take, a concurrent take+put replaced
+   * the mapping — takeIf predicate fails and the replacement stays registered.
+   */
+  @Test
+  public void takeIfIdle_identityMismatch_leavesReplacement() throws Exception {
+    RNFBDatabaseQueryRegistry registry = new RNFBDatabaseQueryRegistry();
+    GatedFakeQuery original = new GatedFakeQuery();
+    original.listeners = false;
+    registry.put("q", original);
+
+    FakeQuery replacement = new FakeQuery();
+    replacement.listeners = true;
+
+    CountDownLatch takeDone = new CountDownLatch(1);
+    Thread takeThread =
+        new Thread(
+            () -> {
+              try {
+                registry.takeIfIdle("q");
+              } finally {
+                takeDone.countDown();
+              }
+            });
+    takeThread.start();
+
+    assertTrue(original.hasListenersEntered.await(5, TimeUnit.SECONDS));
+    assertSame(original, registry.take("q"));
+    registry.put("q", replacement);
+    original.allowHasListenersReturn.countDown();
+    assertTrue(takeDone.await(5, TimeUnit.SECONDS));
+
+    assertSame(replacement, registry.get("q"));
+    assertEquals(0, replacement.removeCount);
+  }
+
   /**
    * After identity-take, listeners appear but a concurrent put claimed the slot — put-back fails;
    * orphan must clear listeners so SDK callbacks are not left outside the registry.
@@ -431,4 +467,23 @@ public class RNFBDatabaseQueryRegistryTest {
     registry.takeIfIdle("missing");
     assertNull(registry.get("missing"));
   }
+
+  @Test
+  public void get_nullKey_returnsNull_noNpe() {
+    RNFBDatabaseQueryRegistry registry = new RNFBDatabaseQueryRegistry();
+    assertNull(registry.get(null));
+  }
+
+  @Test
+  public void take_nullKey_returnsNull_noNpe() {
+    RNFBDatabaseQueryRegistry registry = new RNFBDatabaseQueryRegistry();
+    assertNull(registry.take(null));
+  }
+
+  @Test
+  public void takeIfIdle_nullKey_isNoOp() {
+    RNFBDatabaseQueryRegistry registry = new RNFBDatabaseQueryRegistry();
+    registry.takeIfIdle(null);
+    assertNull(registry.get(null));
+  }
 }

package/android/src/test/java/io/invertase/firebase/database/UniversalFirebaseDatabaseOnDisconnectCancelErrorTest.java

@@ -0,0 +1,137 @@
+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 static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.WritableMap;
+import com.google.android.gms.tasks.Task;
+import com.google.firebase.database.DatabaseError;
+import com.google.firebase.database.DatabaseReference;
+import com.google.firebase.database.FirebaseDatabase;
+import com.google.firebase.database.OnDisconnect;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.MockedStatic;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.shadows.ShadowLooper;
+
+/**
+ * onDisconnect.cancel() is not rejected by RTDB {@code .write: false} (e2e wire evidence in
+ * writePermissionDenied.e2e.js). Drive the CompletionListener error arm + TurboModule reject with a
+ * mocked Firebase OnDisconnect — AndroidTest-AD-1.
+ */
+@RunWith(RobolectricTestRunner.class)
+public class UniversalFirebaseDatabaseOnDisconnectCancelErrorTest {
+
+  private static void stubCancelWithPermissionDenied(
+      OnDisconnect onDisconnect, DatabaseReference ref) {
+    doAnswer(
+            invocation -> {
+              DatabaseReference.CompletionListener listener = invocation.getArgument(0);
+              listener.onComplete(DatabaseError.fromCode(DatabaseError.PERMISSION_DENIED), ref);
+              return null;
+            })
+        .when(onDisconnect)
+        .cancel(any(DatabaseReference.CompletionListener.class));
+  }
+
+  @Test
+  public void onDisconnectCancel_taskFailsWithUniversalDatabaseException() {
+    Context context = mock(Context.class);
+    FirebaseDatabase firebaseDatabase = mock(FirebaseDatabase.class);
+    DatabaseReference reference = mock(DatabaseReference.class);
+    OnDisconnect onDisconnect = mock(OnDisconnect.class);
+
+    when(firebaseDatabase.getReference("nope/foo")).thenReturn(reference);
+    when(reference.onDisconnect()).thenReturn(onDisconnect);
+    stubCancelWithPermissionDenied(onDisconnect, reference);
+
+    try (MockedStatic<UniversalFirebaseDatabaseCommon> common =
+        mockStatic(UniversalFirebaseDatabaseCommon.class)) {
+      common
+          .when(() -> UniversalFirebaseDatabaseCommon.getDatabaseForApp(anyString(), anyString()))
+          .thenReturn(firebaseDatabase);
+
+      UniversalFirebaseDatabaseOnDisconnectModule module =
+          new UniversalFirebaseDatabaseOnDisconnectModule(context, "DatabaseOnDisconnect");
+
+      Task<Void> task = module.onDisconnectCancel("app", "https://example.com", "nope/foo");
+
+      assertTrue(task.isComplete());
+      assertFalse(task.isSuccessful());
+      assertTrue(task.getException() instanceof UniversalDatabaseException);
+      UniversalDatabaseException databaseException =
+          (UniversalDatabaseException) task.getException();
+      assertTrue(databaseException.getCode().contains("permission-denied"));
+    }
+  }
+
+  @Test
+  public void turboOnDisconnectCancel_rejectsPromiseOnDatabaseError() {
+    ReactApplicationContext reactContext = mock(ReactApplicationContext.class);
+    when(reactContext.getApplicationContext()).thenReturn(reactContext);
+
+    FirebaseDatabase firebaseDatabase = mock(FirebaseDatabase.class);
+    DatabaseReference reference = mock(DatabaseReference.class);
+    OnDisconnect onDisconnect = mock(OnDisconnect.class);
+
+    when(firebaseDatabase.getReference("nope/foo")).thenReturn(reference);
+    when(reference.onDisconnect()).thenReturn(onDisconnect);
+    stubCancelWithPermissionDenied(onDisconnect, reference);
+
+    Promise promise = mock(Promise.class);
+    WritableMap userInfo = mock(WritableMap.class);
+
+    try (MockedStatic<UniversalFirebaseDatabaseCommon> common =
+            mockStatic(UniversalFirebaseDatabaseCommon.class);
+        MockedStatic<com.facebook.react.bridge.Arguments> arguments =
+            mockStatic(com.facebook.react.bridge.Arguments.class)) {
+      common
+          .when(() -> UniversalFirebaseDatabaseCommon.getDatabaseForApp(anyString(), anyString()))
+          .thenReturn(firebaseDatabase);
+      arguments.when(com.facebook.react.bridge.Arguments::createMap).thenReturn(userInfo);
+
+      NativeRNFBTurboDatabaseOnDisconnect turbo =
+          new NativeRNFBTurboDatabaseOnDisconnect(reactContext);
+      turbo.onDisconnectCancel("app", "https://example.com", "nope/foo", promise);
+
+      // addOnCompleteListener without an executor posts to the main looper.
+      ShadowLooper.idleMainLooper();
+
+      ArgumentCaptor<String> code = ArgumentCaptor.forClass(String.class);
+      ArgumentCaptor<String> message = ArgumentCaptor.forClass(String.class);
+      verify(promise).reject(code.capture(), message.capture(), any(WritableMap.class));
+      assertTrue(code.getValue().contains("permission-denied"));
+      assertNotNull(message.getValue());
+    }
+  }
+}

package/dist/module/DatabaseQuery.js

@@ -17,10 +17,24 @@
  *
  */
 
-import { isBoolean, isFunction, isNull, isNumber, isObject, isString, isUndefined, pathIsEmpty, pathToUrlEncodedString, ReferenceBase } from '@react-native-firebase/app/dist/module/common';
+import { isBoolean, isFunction, isIOS, isNull, isNumber, isObject, isString, isUndefined, pathIsEmpty, pathToUrlEncodedString, ReferenceBase } from '@react-native-firebase/app/dist/module/common';
 import DatabaseDataSnapshot from "./DatabaseDataSnapshot.js";
 import DatabaseSyncTree from "./DatabaseSyncTree.js";
 const eventTypes = ['value', 'child_added', 'child_changed', 'child_moved', 'child_removed'];
+
+/** `.info/*` is client-local metadata that only the listener path serves. */
+const INFO_PATH = /^\/?\.info(\/|$)/;
+
+/**
+ * True when native/web get already produced an observer-shaped `database/*` code.
+ * Android Query.get() non-denial failures use SharedUtils.getExceptionMap → `database/unknown`;
+ * those still fall through to `once('value')`. Specific codes mean once already ran (or a
+ * denial was mapped to once's code) — do not ask the server again.
+ */
+function isObserverShapedDatabaseError(error) {
+  const code = error?.code;
+  return typeof code === 'string' && code.startsWith('database/') && code !== 'database/unknown';
+}
 let DatabaseReferenceClass = null;
 export function provideReferenceClass(databaseReference) {
   DatabaseReferenceClass = databaseReference;
@@ -180,6 +194,43 @@ export default class DatabaseQuery extends ReferenceBase {
     listeners += 1;
     return callback;
   }
+
+  /**
+   * One-shot read backing modular `get()`: on Android and web, the SDKs' single request/response
+   * read (`Query.get()`, web `get()`) instead of the listen -> data -> unlisten exchange
+   * `once('value')` performs. On iOS the native `get` is still the single-event observer; see
+   * `RNFBDatabaseQueryHelper get:`.
+   *
+   * Callers keep `once('value')` semantics, with one exception noted below:
+   * - iOS failures pass straight through (native get already is `once`).
+   * - On Android / web, an error whose code is already a specific `database/*` value (anything
+   *   other than `database/unknown`) passes through: Android maps Query.get() permission denials
+   *   to the same code `once` gives, and when native get already used `addOnceValueEventListener`
+   *   (persistence, logging, keepSynced) its cancellations are those codes too — do not call
+   *   `once('value')` again. Only a plain Query.get() failure is rejected as `database/unknown`
+   *   (SharedUtils.getExceptionMap); that path still retries as `once('value')`.
+   * - Queries (any orderBy / limit / range modifier) use `once('value')`: `get()` parity for
+   *   unindexed queries is unverified.
+   * - `.info/*` paths use `once('value')`: the one-shot reads go to the server tree, not the
+   *   client-local `.info` tree.
+   *
+   * The exception: the one-shot read resolves with the server's reply as it was when the read was
+   * sent, where `once('value')` layered this client's pending writes over it. A local write made to
+   * an overlapping path while a `get()` is in flight is therefore not in its result, as with the
+   * web SDK's `get()`.
+   */
+  _get() {
+    const modifiers = this._modifiers._copy().toArray();
+    if (modifiers.length > 0 || INFO_PATH.test(this.path)) {
+      return this.once('value');
+    }
+    return this._database.native.get(this.path, modifiers).then(result => new DatabaseDataSnapshot(this.ref, result), error => {
+      if (isIOS || isObserverShapedDatabaseError(error)) {
+        return Promise.reject(error);
+      }
+      return this.once('value');
+    });
+  }
   once(eventType, successCallBack, failureCallbackOrContext, context) {
     if (!eventTypes.includes(eventType)) {
       throw new Error(`firebase.database().ref().once(*) 'eventType' must be one of ${eventTypes.join(', ')}.`);