@react-native-firebase/database 26.4.0 → 27.0.0

package/ios/RNFBDatabaseUnitTests/RNFBDatabaseListenerRegistryStorageTests.swift

@@ -0,0 +1,86 @@
+/**
+ * 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 XCTest
+
+final class RNFBDatabaseListenerRegistryStorageTests: XCTestCase {
+  private var storage: RNFBDatabaseListenerRegistryStorage!
+
+  override func setUp() {
+    super.setUp()
+    storage = RNFBDatabaseListenerRegistryStorage()
+  }
+
+  func testPutIfAbsent_storesWhenFree_andIncrementsOccupancy() {
+    let handle = 7 as NSNumber
+    XCTAssertTrue(storage.putIfAbsent("k" as NSString, value: handle))
+    XCTAssertTrue(storage.get("k" as NSString) === handle)
+    XCTAssertTrue(storage.hasListeners)
+    XCTAssertTrue(storage.hasEventListener("k" as NSString))
+  }
+
+  func testPutIfAbsent_collision_keepsExistingWithoutOccupancyBump() {
+    let first = 1 as NSNumber
+    let second = 2 as NSNumber
+    XCTAssertTrue(storage.putIfAbsent("k" as NSString, value: first))
+    XCTAssertFalse(storage.putIfAbsent("k" as NSString, value: second))
+    XCTAssertTrue(storage.get("k" as NSString) === first)
+    XCTAssertTrue(storage.hasListeners)
+    XCTAssertEqual(storage.takeAll().count, 1)
+    XCTAssertFalse(storage.hasListeners)
+  }
+
+  func testGet_whenFree_isNil() {
+    XCTAssertNil(storage.get("missing" as NSString))
+    XCTAssertFalse(storage.hasEventListener("missing" as NSString))
+    XCTAssertFalse(storage.hasListeners)
+  }
+
+  func testTake_removesAndDecrementsOccupancy() {
+    let handle = 7 as NSNumber
+    XCTAssertTrue(storage.putIfAbsent("k" as NSString, value: handle))
+    XCTAssertTrue(storage.take("k" as NSString) === handle)
+    XCTAssertNil(storage.get("k" as NSString))
+    XCTAssertFalse(storage.hasListeners)
+  }
+
+  func testTake_whenFree_isNoOp() {
+    XCTAssertNil(storage.take("missing" as NSString))
+    XCTAssertFalse(storage.hasListeners)
+  }
+
+  func testTakeAll_snapshotAndLeavesEmpty() {
+    XCTAssertTrue(storage.putIfAbsent("a" as NSString, value: 1 as NSNumber))
+    XCTAssertTrue(storage.putIfAbsent("b" as NSString, value: 2 as NSNumber))
+    let remaining = storage.takeAll()
+    XCTAssertEqual(remaining.count, 2)
+    XCTAssertFalse(storage.hasListeners)
+    XCTAssertNil(storage.get("a" as NSString))
+  }
+
+  func testTakeAll_empty_isNoOp() {
+    XCTAssertEqual(storage.takeAll().count, 0)
+    XCTAssertFalse(storage.hasListeners)
+  }
+
+  func testPut_afterTake_allowsReuse() {
+    XCTAssertTrue(storage.putIfAbsent("k" as NSString, value: 1 as NSNumber))
+    XCTAssertEqual(storage.take("k" as NSString) as? NSNumber, 1)
+    XCTAssertTrue(storage.putIfAbsent("k" as NSString, value: 2 as NSNumber))
+    XCTAssertEqual(storage.get("k" as NSString) as? NSNumber, 2)
+    XCTAssertTrue(storage.hasListeners)
+  }
+}

package/ios/RNFBDatabaseUnitTests/RNFBDatabaseNullSentinelDecodeTests.m

@@ -0,0 +1,118 @@
+/**
+ * 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 <XCTest/XCTest.h>
+
+#import "RNFBDatabaseNullSentinelDecoder.h"
+
+@interface RNFBDatabaseNullSentinelDecodeTests : XCTestCase
+@end
+
+@implementation RNFBDatabaseNullSentinelDecodeTests
+
+- (NSDictionary *)nullSentinel {
+  return @{@"__rnfbNull" : @YES};
+}
+
+- (NSDictionary *)serverTimestamp {
+  return @{@".sv" : @"timestamp"};
+}
+
+#pragma mark - Reference helper seams
+
+- (void)testReferenceSet_topLevelNullSentinel_becomesNSNull {
+  NSDictionary *props = @{@"value" : [self nullSentinel]};
+  XCTAssertEqualObjects([RNFBDatabaseNullSentinelDecoder decodedValueFromProps:props],
+                        [NSNull null]);
+}
+
+- (void)testReferenceUpdate_childNullSentinel_becomesNSNull {
+  NSDictionary *props = @{@"values" : @{@"a" : [self nullSentinel], @"b" : @1}};
+  NSDictionary *decoded = [RNFBDatabaseNullSentinelDecoder decodedValuesFromProps:props];
+  XCTAssertEqualObjects(decoded[@"a"], [NSNull null]);
+  XCTAssertEqualObjects(decoded[@"b"], @1);
+}
+
+- (void)testReferenceSetWithPriority_valueAndPrioritySentinels_becomeNSNull {
+  NSDictionary *props = @{
+    @"value" : [self nullSentinel],
+    @"priority" : [self nullSentinel],
+  };
+  XCTAssertEqualObjects([RNFBDatabaseNullSentinelDecoder decodedValueFromProps:props],
+                        [NSNull null]);
+  XCTAssertEqualObjects([RNFBDatabaseNullSentinelDecoder decodedPriorityFromProps:props],
+                        [NSNull null]);
+}
+
+- (void)testReferenceSetPriority_sentinel_becomesNSNull {
+  NSDictionary *props = @{@"priority" : [self nullSentinel]};
+  XCTAssertEqualObjects([RNFBDatabaseNullSentinelDecoder decodedPriorityFromProps:props],
+                        [NSNull null]);
+}
+
+- (void)testReference_serverTimestampDictionary_unchanged {
+  NSDictionary *props = @{@"value" : [self serverTimestamp]};
+  XCTAssertEqualObjects([RNFBDatabaseNullSentinelDecoder decodedValueFromProps:props],
+                        [self serverTimestamp]);
+}
+
+#pragma mark - OnDisconnect helper seams
+
+- (void)testOnDisconnectSet_topLevelNullSentinel_becomesNSNull {
+  NSDictionary *props = @{@"value" : [self nullSentinel]};
+  XCTAssertEqualObjects([RNFBDatabaseNullSentinelDecoder decodedValueFromProps:props],
+                        [NSNull null]);
+}
+
+- (void)testOnDisconnectSetWithPriority_valueAndPrioritySentinels_becomeNSNull {
+  NSDictionary *props = @{
+    @"value" : [self nullSentinel],
+    @"priority" : [self nullSentinel],
+  };
+  XCTAssertEqualObjects([RNFBDatabaseNullSentinelDecoder decodedValueFromProps:props],
+                        [NSNull null]);
+  XCTAssertEqualObjects([RNFBDatabaseNullSentinelDecoder decodedPriorityFromProps:props],
+                        [NSNull null]);
+}
+
+- (void)testOnDisconnectUpdate_childNullSentinel_becomesNSNull {
+  NSDictionary *props = @{@"values" : @{@"gone" : [self nullSentinel]}};
+  NSDictionary *decoded = [RNFBDatabaseNullSentinelDecoder decodedValuesFromProps:props];
+  XCTAssertEqualObjects(decoded[@"gone"], [NSNull null]);
+}
+
+- (void)testOnDisconnect_serverTimestampDictionary_unchanged {
+  NSDictionary *props = @{@"value" : [self serverTimestamp]};
+  XCTAssertEqualObjects([RNFBDatabaseNullSentinelDecoder decodedValueFromProps:props],
+                        [self serverTimestamp]);
+}
+
+#pragma mark - Transaction helper seam
+
+- (void)testTransactionTryCommit_valueSentinel_becomesNSNull {
+  id decoded = [RNFBDatabaseNullSentinelDecoder decodedTransactionValue:[self nullSentinel]];
+  XCTAssertEqualObjects(decoded, [NSNull null]);
+  XCTAssertFalse([decoded isKindOfClass:[NSDictionary class]]);
+}
+
+- (void)testTransactionTryCommit_serverTimestamp_unchanged {
+  XCTAssertEqualObjects(
+      [RNFBDatabaseNullSentinelDecoder decodedTransactionValue:[self serverTimestamp]],
+      [self serverTimestamp]);
+}
+
+@end

package/ios/RNFBDatabaseUnitTests/RNFBDatabaseQueryRegistryStorageTests.swift

@@ -0,0 +1,181 @@
+/**
+ * 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 XCTest
+
+private final class FakeQueryHandle: NSObject {
+  private(set) var removeCount = 0
+  var listeners = false
+
+  @objc func removeAllEventListeners() {
+    removeCount += 1
+    listeners = false
+  }
+
+  @objc func hasListeners() -> Bool {
+    listeners
+  }
+}
+
+final class RNFBDatabaseQueryRegistryStorageTests: XCTestCase {
+  private var storage: RNFBDatabaseQueryRegistryStorage!
+
+  override func setUp() {
+    super.setUp()
+    storage = RNFBDatabaseQueryRegistryStorage()
+  }
+
+  func testPutIfAbsent_storesWhenFree() {
+    let handle = FakeQueryHandle()
+    XCTAssertTrue(storage.putIfAbsent("q1" as NSString, value: handle))
+    XCTAssertTrue(storage.get("q1" as NSString) === handle)
+  }
+
+  func testPutIfAbsent_collision_keepsExisting() {
+    let first = FakeQueryHandle()
+    let second = FakeQueryHandle()
+    XCTAssertTrue(storage.putIfAbsent("q1" as NSString, value: first))
+    XCTAssertFalse(storage.putIfAbsent("q1" as NSString, value: second))
+    XCTAssertTrue(storage.get("q1" as NSString) === first)
+  }
+
+  func testGet_whenFree_isNil() {
+    XCTAssertNil(storage.get("missing" as NSString))
+  }
+
+  func testTake_removesWithoutCallingRemove() {
+    let handle = FakeQueryHandle()
+    XCTAssertTrue(storage.putIfAbsent("q1" as NSString, value: handle))
+    XCTAssertTrue(storage.take("q1" as NSString) === handle)
+    XCTAssertNil(storage.get("q1" as NSString))
+    XCTAssertEqual(handle.removeCount, 0)
+  }
+
+  func testTake_whenFree_isNil() {
+    XCTAssertNil(storage.take("missing" as NSString))
+  }
+
+  func testTakeIfIdle_whenNoListeners_takes() {
+    let handle = FakeQueryHandle()
+    handle.listeners = false
+    XCTAssertTrue(storage.putIfAbsent("q" as NSString, value: handle))
+    XCTAssertTrue(storage.takeIfIdle("q" as NSString) === handle)
+    XCTAssertNil(storage.get("q" as NSString))
+    XCTAssertEqual(handle.removeCount, 0)
+  }
+
+  func testTakeIfIdle_whenHasListeners_leavesMapping() {
+    let handle = FakeQueryHandle()
+    handle.listeners = true
+    XCTAssertTrue(storage.putIfAbsent("q" as NSString, value: handle))
+    XCTAssertNil(storage.takeIfIdle("q" as NSString))
+    XCTAssertTrue(storage.get("q" as NSString) === handle)
+  }
+
+  func testTakeIfIdle_whenMissing_isNil() {
+    XCTAssertNil(storage.takeIfIdle("missing" as NSString))
+  }
+
+  func testTakeIfIdle_objectWithoutHasListeners_leavesMapping() {
+    let plain = NSObject()
+    XCTAssertTrue(storage.putIfAbsent("p" as NSString, value: plain))
+    XCTAssertNil(storage.takeIfIdle("p" as NSString))
+    XCTAssertTrue(storage.get("p" as NSString) === plain)
+  }
+
+  func testTakeIfIdle_putBackWhenListenersAppearAfterTake() {
+    let gated = PutBackGatedQueryHandle()
+    gated.listeners = false
+    gated.onSecondHasListenersEnter = {
+      gated.listeners = true
+    }
+    XCTAssertTrue(storage.putIfAbsent("g" as NSString, value: gated))
+    XCTAssertNil(storage.takeIfIdle("g" as NSString))
+    XCTAssertTrue(storage.get("g" as NSString) === gated)
+    XCTAssertEqual(gated.callCount, 2)
+    XCTAssertEqual(gated.removeCount, 0)
+  }
+
+  func testTakeIfIdle_putBackFails_clearsOrphanListeners() {
+    let orphan = PutBackGatedQueryHandle()
+    orphan.listeners = false
+    XCTAssertTrue(storage.putIfAbsent("q" as NSString, value: orphan))
+
+    let replacement = FakeQueryHandle()
+    replacement.listeners = true
+    orphan.onSecondHasListenersEnter = { [weak self] in
+      guard let self = self else { return }
+      XCTAssertTrue(self.storage.putIfAbsent("q" as NSString, value: replacement))
+      orphan.listeners = true
+    }
+
+    XCTAssertNil(storage.takeIfIdle("q" as NSString))
+    XCTAssertTrue(storage.get("q" as NSString) === replacement)
+    XCTAssertEqual(orphan.removeCount, 1)
+    XCTAssertFalse(orphan.listeners)
+    XCTAssertEqual(replacement.removeCount, 0)
+  }
+
+  func testRemoveAll_removesSnapshotAndLeavesEmpty() {
+    let a = FakeQueryHandle()
+    let b = FakeQueryHandle()
+    XCTAssertTrue(storage.putIfAbsent("a" as NSString, value: a))
+    XCTAssertTrue(storage.putIfAbsent("b" as NSString, value: b))
+    storage.removeAll()
+    XCTAssertEqual(a.removeCount, 1)
+    XCTAssertEqual(b.removeCount, 1)
+    XCTAssertNil(storage.get("a" as NSString))
+    XCTAssertNil(storage.get("b" as NSString))
+  }
+
+  func testRemoveAll_objectWithoutRemove_doesNotCrash() {
+    let plain = NSObject()
+    XCTAssertTrue(storage.putIfAbsent("p" as NSString, value: plain))
+    storage.removeAll()
+    XCTAssertNil(storage.get("p" as NSString))
+  }
+
+  func testPut_afterTake_allowsReuse() {
+    let first = FakeQueryHandle()
+    let second = FakeQueryHandle()
+    XCTAssertTrue(storage.putIfAbsent("q1" as NSString, value: first))
+    XCTAssertTrue(storage.take("q1" as NSString) === first)
+    XCTAssertTrue(storage.putIfAbsent("q1" as NSString, value: second))
+    XCTAssertTrue(storage.get("q1" as NSString) === second)
+  }
+}
+
+/// First `hasListeners` returns idle; second returns `listeners` (settable between calls).
+private final class PutBackGatedQueryHandle: NSObject {
+  private(set) var removeCount = 0
+  private(set) var callCount = 0
+  var listeners = false
+  var onSecondHasListenersEnter: (() -> Void)?
+
+  @objc func removeAllEventListeners() {
+    removeCount += 1
+    listeners = false
+  }
+
+  @objc func hasListeners() -> Bool {
+    callCount += 1
+    if callCount == 1 {
+      return false
+    }
+    onSecondHasListenersEnter?()
+    return listeners
+  }
+}

package/ios/RNFBDatabaseUnitTests/RNFBDatabaseUnitTests.xcodeproj/project.pbxproj

@@ -12,7 +12,15 @@
 		D8000000000000000000000C /* RNFBDatabaseListenerRegistryTests.m in Sources */ = {isa = PBXBuildFile; fileRef = D80000000000000000000009 /* RNFBDatabaseListenerRegistryTests.m */; };
 		D80000000000000000000020 /* RNFBDatabaseQueryRegistry.m in Sources */ = {isa = PBXBuildFile; fileRef = D80000000000000000000021 /* RNFBDatabaseQueryRegistry.m */; };
 		D80000000000000000000022 /* RNFBDatabaseQueryRegistryTests.m in Sources */ = {isa = PBXBuildFile; fileRef = D80000000000000000000023 /* RNFBDatabaseQueryRegistryTests.m */; };
+		D80000000000000000000030 /* RNFBNullSentinelDecoding.swift in Sources */ = {isa = PBXBuildFile; fileRef = D80000000000000000000031 /* RNFBNullSentinelDecoding.swift */; };
+		D80000000000000000000032 /* RNFBDatabaseNullSentinelDecoder.m in Sources */ = {isa = PBXBuildFile; fileRef = D80000000000000000000033 /* RNFBDatabaseNullSentinelDecoder.m */; };
+		D80000000000000000000038 /* RNFBDatabaseNullSentinelDecodeTests.m in Sources */ = {isa = PBXBuildFile; fileRef = D80000000000000000000039 /* RNFBDatabaseNullSentinelDecodeTests.m */; };
 		D80000000000000000000015 /* XCTest.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = D80000000000000000000014 /* XCTest.framework */; };
+		D80000000000000000000025 /* RNFBHandleMapStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = D80000000000000000000026 /* RNFBHandleMapStorage.swift */; };
+		D80000000000000000000028 /* RNFBDatabaseListenerRegistryStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = D80000000000000000000027 /* RNFBDatabaseListenerRegistryStorage.swift */; };
+		D8000000000000000000002A /* RNFBDatabaseListenerRegistryStorageTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D80000000000000000000029 /* RNFBDatabaseListenerRegistryStorageTests.swift */; };
+		D8000000000000000000002C /* RNFBDatabaseQueryRegistryStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = D8000000000000000000002B /* RNFBDatabaseQueryRegistryStorage.swift */; };
+		D8000000000000000000002E /* RNFBDatabaseQueryRegistryStorageTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D8000000000000000000002D /* RNFBDatabaseQueryRegistryStorageTests.swift */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXFileReference section */
@@ -25,7 +33,16 @@
 		D80000000000000000000024 /* RNFBDatabaseQueryRegistry.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = RNFBDatabaseQueryRegistry.h; path = ../RNFBDatabase/RNFBDatabaseQueryRegistry.h; sourceTree = SOURCE_ROOT; };
 		D80000000000000000000021 /* RNFBDatabaseQueryRegistry.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = RNFBDatabaseQueryRegistry.m; path = ../RNFBDatabase/RNFBDatabaseQueryRegistry.m; sourceTree = SOURCE_ROOT; };
 		D80000000000000000000023 /* RNFBDatabaseQueryRegistryTests.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNFBDatabaseQueryRegistryTests.m; sourceTree = "<group>"; };
+		D80000000000000000000031 /* RNFBNullSentinelDecoding.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = RNFBNullSentinelDecoding.swift; path = ../../../app/ios/RNFBApp/RNFBNullSentinelDecoding.swift; sourceTree = SOURCE_ROOT; };
+		D80000000000000000000033 /* RNFBDatabaseNullSentinelDecoder.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = RNFBDatabaseNullSentinelDecoder.m; path = ../RNFBDatabase/RNFBDatabaseNullSentinelDecoder.m; sourceTree = SOURCE_ROOT; };
+		D8000000000000000000003B /* RNFBDatabaseNullSentinelDecoder.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = RNFBDatabaseNullSentinelDecoder.h; path = ../RNFBDatabase/RNFBDatabaseNullSentinelDecoder.h; sourceTree = SOURCE_ROOT; };
+		D80000000000000000000039 /* RNFBDatabaseNullSentinelDecodeTests.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNFBDatabaseNullSentinelDecodeTests.m; sourceTree = "<group>"; };
 		D80000000000000000000014 /* XCTest.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = XCTest.framework; path = Platforms/MacOSX.platform/Developer/Library/Frameworks/XCTest.framework; sourceTree = DEVELOPER_DIR; };
+		D80000000000000000000026 /* RNFBHandleMapStorage.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = RNFBHandleMapStorage.swift; path = ../../../app/ios/RNFBApp/RNFBHandleMapStorage.swift; sourceTree = SOURCE_ROOT; };
+		D80000000000000000000027 /* RNFBDatabaseListenerRegistryStorage.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = RNFBDatabaseListenerRegistryStorage.swift; path = ../RNFBDatabase/RNFBDatabaseListenerRegistryStorage.swift; sourceTree = SOURCE_ROOT; };
+		D80000000000000000000029 /* RNFBDatabaseListenerRegistryStorageTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RNFBDatabaseListenerRegistryStorageTests.swift; sourceTree = "<group>"; };
+		D8000000000000000000002B /* RNFBDatabaseQueryRegistryStorage.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = RNFBDatabaseQueryRegistryStorage.swift; path = ../RNFBDatabase/RNFBDatabaseQueryRegistryStorage.swift; sourceTree = SOURCE_ROOT; };
+		D8000000000000000000002D /* RNFBDatabaseQueryRegistryStorageTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RNFBDatabaseQueryRegistryStorageTests.swift; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -61,12 +78,21 @@
 			children = (
 				D80000000000000000000007 /* RNFBHandleMap.h */,
 				D80000000000000000000008 /* RNFBHandleMap.m */,
+				D80000000000000000000026 /* RNFBHandleMapStorage.swift */,
 				D80000000000000000000016 /* RNFBDatabaseListenerRegistry.h */,
 				D80000000000000000000018 /* RNFBDatabaseListenerRegistry.m */,
+				D80000000000000000000027 /* RNFBDatabaseListenerRegistryStorage.swift */,
 				D80000000000000000000024 /* RNFBDatabaseQueryRegistry.h */,
 				D80000000000000000000021 /* RNFBDatabaseQueryRegistry.m */,
+				D80000000000000000000031 /* RNFBNullSentinelDecoding.swift */,
+				D8000000000000000000003B /* RNFBDatabaseNullSentinelDecoder.h */,
+				D80000000000000000000033 /* RNFBDatabaseNullSentinelDecoder.m */,
+				D8000000000000000000002B /* RNFBDatabaseQueryRegistryStorage.swift */,
 				D80000000000000000000009 /* RNFBDatabaseListenerRegistryTests.m */,
+				D80000000000000000000029 /* RNFBDatabaseListenerRegistryStorageTests.swift */,
 				D80000000000000000000023 /* RNFBDatabaseQueryRegistryTests.m */,
+				D80000000000000000000039 /* RNFBDatabaseNullSentinelDecodeTests.m */,
+				D8000000000000000000002D /* RNFBDatabaseQueryRegistryStorageTests.swift */,
 			);
 			name = Sources;
 			sourceTree = "<group>";
@@ -129,10 +155,18 @@
 			buildActionMask = 2147483647;
 			files = (
 				D8000000000000000000000A /* RNFBHandleMap.m in Sources */,
+				D80000000000000000000025 /* RNFBHandleMapStorage.swift in Sources */,
+				D80000000000000000000028 /* RNFBDatabaseListenerRegistryStorage.swift in Sources */,
 				D8000000000000000000000B /* RNFBDatabaseListenerRegistry.m in Sources */,
+				D8000000000000000000002C /* RNFBDatabaseQueryRegistryStorage.swift in Sources */,
 				D80000000000000000000020 /* RNFBDatabaseQueryRegistry.m in Sources */,
+				D80000000000000000000030 /* RNFBNullSentinelDecoding.swift in Sources */,
+				D80000000000000000000032 /* RNFBDatabaseNullSentinelDecoder.m in Sources */,
 				D8000000000000000000000C /* RNFBDatabaseListenerRegistryTests.m in Sources */,
+				D8000000000000000000002A /* RNFBDatabaseListenerRegistryStorageTests.swift in Sources */,
 				D80000000000000000000022 /* RNFBDatabaseQueryRegistryTests.m in Sources */,
+				D80000000000000000000038 /* RNFBDatabaseNullSentinelDecodeTests.m in Sources */,
+				D8000000000000000000002E /* RNFBDatabaseQueryRegistryStorageTests.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -181,8 +215,10 @@
 				CODE_SIGNING_REQUIRED = NO;
 				CODE_SIGN_IDENTITY = "-";
 				COMBINE_HIDPI_IMAGES = YES;
+				DEFINES_MODULE = YES;
 				GENERATE_INFOPLIST_FILE = YES;
 				HEADER_SEARCH_PATHS = (
+					"$(SRCROOT)",
 					"$(SRCROOT)/../../../app/ios",
 					"$(SRCROOT)/../../../app/ios/RNFBApp",
 					"$(SRCROOT)/../RNFBDatabase",
@@ -204,6 +240,8 @@
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = macosx;
 				SUPPORTED_PLATFORMS = macosx;
+				SWIFT_OBJC_INTERFACE_HEADER_NAME = "RNFBHandleMapStorage-Swift.inc";
+				SWIFT_VERSION = 5.10;
 			};
 			name = Debug;
 		};
@@ -215,8 +253,10 @@
 				CODE_SIGNING_REQUIRED = NO;
 				CODE_SIGN_IDENTITY = "-";
 				COMBINE_HIDPI_IMAGES = YES;
+				DEFINES_MODULE = YES;
 				GENERATE_INFOPLIST_FILE = YES;
 				HEADER_SEARCH_PATHS = (
+					"$(SRCROOT)",
 					"$(SRCROOT)/../../../app/ios",
 					"$(SRCROOT)/../../../app/ios/RNFBApp",
 					"$(SRCROOT)/../RNFBDatabase",
@@ -231,6 +271,8 @@
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = macosx;
 				SUPPORTED_PLATFORMS = macosx;
+				SWIFT_OBJC_INTERFACE_HEADER_NAME = "RNFBHandleMapStorage-Swift.inc";
+				SWIFT_VERSION = 5.10;
 			};
 			name = Release;
 		};

package/ios/generated/RNFBDatabaseTurboModules/RNFBDatabaseTurboModules-generated.mm

@@ -141,6 +141,10 @@ namespace facebook::react {
       return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "once", @selector(once:dbURL:path:modifiers:eventType:resolve:reject:), args, count);
     }
 
+    static facebook::jsi::Value __hostFunction_NativeRNFBTurboDatabaseQuerySpecJSI_get(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "get", @selector(get:dbURL:path:modifiers:resolve:reject:), args, count);
+    }
+
     static facebook::jsi::Value __hostFunction_NativeRNFBTurboDatabaseQuerySpecJSI_on(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
       return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "on", @selector(on:dbURL:props:), args, count);
     }
@@ -159,6 +163,9 @@ namespace facebook::react {
         methodMap_["once"] = MethodMetadata {5, __hostFunction_NativeRNFBTurboDatabaseQuerySpecJSI_once};
         
         
+        methodMap_["get"] = MethodMetadata {4, __hostFunction_NativeRNFBTurboDatabaseQuerySpecJSI_get};
+        
+        
         methodMap_["on"] = MethodMetadata {3, __hostFunction_NativeRNFBTurboDatabaseQuerySpecJSI_on};
         
         

package/ios/generated/RNFBDatabaseTurboModules/RNFBDatabaseTurboModules.h

@@ -135,6 +135,12 @@ namespace facebook::react {
    eventType:(NSString *)eventType
      resolve:(RCTPromiseResolveBlock)resolve
       reject:(RCTPromiseRejectBlock)reject;
+- (void)get:(NSString *)app
+      dbURL:(NSString *)dbURL
+       path:(NSString *)path
+  modifiers:(NSArray *)modifiers
+    resolve:(RCTPromiseResolveBlock)resolve
+     reject:(RCTPromiseRejectBlock)reject;
 - (void)on:(NSString *)app
      dbURL:(NSString *)dbURL
      props:(NSDictionary *)props;

package/ios/generated/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/lib/DatabaseQuery.ts

@@ -18,6 +18,7 @@
 import {
   isBoolean,
   isFunction,
+  isIOS,
   isNull,
   isNumber,
   isObject,
@@ -45,6 +46,20 @@ const eventTypes = [
   'child_removed',
 ] as const;
 
+/** `.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: unknown): boolean {
+  const code = (error as { code?: string } | null | undefined)?.code;
+  return typeof code === 'string' && code.startsWith('database/') && code !== 'database/unknown';
+}
+
 type DatabaseReferenceConstructor = new (
   database: DatabaseInternal,
   path: string,
@@ -316,6 +331,47 @@ export default class DatabaseQuery extends ReferenceBase implements Query {
     return callback as (a: DataSnapshot | null, b?: string | null) => void;
   }
 
+  /**
+   * 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(): Promise<DataSnapshot> {
+    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: EventType,
     successCallBack?: (a: DataSnapshot, b?: string | null) => any,

package/lib/DatabaseSyncTree.ts

@@ -18,7 +18,7 @@
 import { isString } from '@react-native-firebase/app/dist/module/common';
 import NativeError from '@react-native-firebase/app/dist/module/internal/NativeFirebaseError';
 import SharedEventEmitter from '@react-native-firebase/app/dist/module/internal/SharedEventEmitter';
-import { getReactNativeModule } from '@react-native-firebase/app/dist/module/internal/nativeModule';
+import { getReactNativeModule } from '@react-native-firebase/app/dist/module/internal';
 import DatabaseDataSnapshot from './DatabaseDataSnapshot';
 import type {
   DatabaseChildSnapshotResultInternal,

package/lib/index.ts

@@ -25,9 +25,9 @@ import type { FirebaseApp } from '@react-native-firebase/app';
 import {
   FirebaseModule,
   getOrCreateModularInstance,
+  setReactNativeModule,
 } from '@react-native-firebase/app/dist/module/internal';
 import type { ModuleConfig } from '@react-native-firebase/app/dist/module/internal';
-import { setReactNativeModule } from '@react-native-firebase/app/dist/module/internal/nativeModule';
 import type { ReactNativeFirebase } from '@react-native-firebase/app';
 import type {
   DatabaseInternal,

package/lib/modular/query.ts

@@ -318,7 +318,7 @@ export function setWithPriority(
 }
 
 export function get(queryRef: Query): Promise<DataSnapshot> {
-  return (queryRef as QueryWithSubscriptionMethodsInternal).once('value');
+  return (queryRef as QueryWithSubscriptionMethodsInternal)._get();
 }
 
 export function off(