@react-native-firebase/database 26.3.2 → 26.4.0

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

@@ -0,0 +1,199 @@
+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.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import io.invertase.firebase.common.RNFBHandleCollisionException;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import org.junit.Test;
+
+public class RNFBDatabaseTransactionRegistryTest {
+
+  private static final class FakeAbortable implements DatabaseAbortable {
+    int abortCount;
+
+    @Override
+    public void abort() {
+      abortCount++;
+    }
+  }
+
+  @Test
+  public void putGetTake_happyPath() throws Exception {
+    RNFBDatabaseTransactionRegistry registry = new RNFBDatabaseTransactionRegistry();
+    FakeAbortable handler = new FakeAbortable();
+    registry.put(1, handler);
+    assertSame(handler, registry.get(1));
+    assertSame(handler, registry.take(1));
+    assertNull(registry.get(1));
+    assertTrue(handler.abortCount == 0);
+  }
+
+  @Test
+  public void put_occupiedId_abortsIncomingAndLeavesExisting() throws Exception {
+    RNFBDatabaseTransactionRegistry registry = new RNFBDatabaseTransactionRegistry();
+    FakeAbortable first = new FakeAbortable();
+    FakeAbortable duplicate = new FakeAbortable();
+    registry.put(1, first);
+    try {
+      registry.put(1, duplicate);
+      fail("expected RNFBHandleCollisionException");
+    } catch (RNFBHandleCollisionException e) {
+      assertTrue(e.getMessage().contains("1"));
+      assertSame(first, registry.get(1));
+      assertTrue(first.abortCount == 0);
+      assertTrue(duplicate.abortCount == 1);
+    }
+  }
+
+  @Test
+  public void put_occupiedId_nullIncoming_doesNotAbort() throws Exception {
+    RNFBDatabaseTransactionRegistry registry = new RNFBDatabaseTransactionRegistry();
+    FakeAbortable first = new FakeAbortable();
+    registry.put(2, first);
+    try {
+      registry.put(2, null);
+      fail("expected RNFBHandleCollisionException");
+    } catch (RNFBHandleCollisionException e) {
+      assertSame(first, registry.get(2));
+      assertTrue(first.abortCount == 0);
+    }
+  }
+
+  @Test
+  public void registerReplacing_replacesLastWins() throws Exception {
+    RNFBDatabaseTransactionRegistry registry = new RNFBDatabaseTransactionRegistry();
+    FakeAbortable first = new FakeAbortable();
+    FakeAbortable second = new FakeAbortable();
+    registry.put(3, first);
+    registry.registerReplacing(3, second);
+    assertSame(second, registry.get(3));
+    assertTrue(first.abortCount == 0);
+    assertTrue(second.abortCount == 0);
+  }
+
+  @Test
+  public void registerReplacing_sameIdFromTwoThreads_lastWins() throws Exception {
+    RNFBDatabaseTransactionRegistry registry = new RNFBDatabaseTransactionRegistry();
+    FakeAbortable first = new FakeAbortable();
+    registry.put(5, first);
+
+    CountDownLatch start = new CountDownLatch(1);
+    CountDownLatch done = new CountDownLatch(2);
+    FakeAbortable second = new FakeAbortable();
+    FakeAbortable third = new FakeAbortable();
+
+    Thread t1 =
+        new Thread(
+            () -> {
+              try {
+                start.await();
+                registry.registerReplacing(5, second);
+              } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+              } finally {
+                done.countDown();
+              }
+            });
+    Thread t2 =
+        new Thread(
+            () -> {
+              try {
+                start.await();
+                registry.registerReplacing(5, third);
+              } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+              } finally {
+                done.countDown();
+              }
+            });
+
+    t1.start();
+    t2.start();
+    start.countDown();
+    assertTrue(done.await(5, TimeUnit.SECONDS));
+
+    DatabaseAbortable stored = registry.get(5);
+    assertTrue(stored == second || stored == third);
+    assertTrue(first.abortCount == 0);
+  }
+
+  @Test
+  public void takeAndAbort_abortsAfterTake() throws Exception {
+    RNFBDatabaseTransactionRegistry registry = new RNFBDatabaseTransactionRegistry();
+    FakeAbortable handler = new FakeAbortable();
+    registry.put(3, handler);
+    registry.takeAndAbort(3);
+    assertTrue(handler.abortCount == 1);
+    assertNull(registry.get(3));
+  }
+
+  @Test
+  public void takeAndAbort_missingKey_isNoOp() {
+    RNFBDatabaseTransactionRegistry registry = new RNFBDatabaseTransactionRegistry();
+    registry.takeAndAbort(99);
+    assertNull(registry.get(99));
+  }
+
+  @Test
+  public void takeAllAndAbort_abortsSnapshotAndLeavesEmpty() throws Exception {
+    RNFBDatabaseTransactionRegistry registry = new RNFBDatabaseTransactionRegistry();
+    FakeAbortable a = new FakeAbortable();
+    FakeAbortable b = new FakeAbortable();
+    registry.put(1, a);
+    registry.put(2, b);
+    registry.takeAllAndAbort();
+    assertTrue(a.abortCount == 1);
+    assertTrue(b.abortCount == 1);
+    assertNull(registry.get(1));
+    assertNull(registry.get(2));
+  }
+
+  @Test
+  public void takeAllAndAbort_empty_isNoOp() {
+    RNFBDatabaseTransactionRegistry registry = new RNFBDatabaseTransactionRegistry();
+    registry.takeAllAndAbort();
+    assertNull(registry.get(1));
+  }
+
+  @Test
+  public void takeAllAndAbort_nullHandler_isNoOp() throws Exception {
+    RNFBDatabaseTransactionRegistry registry = new RNFBDatabaseTransactionRegistry();
+    registry.put(4, null);
+    registry.takeAllAndAbort();
+    assertNull(registry.get(4));
+  }
+
+  @Test
+  public void put_afterTake_allowsReuse() throws Exception {
+    RNFBDatabaseTransactionRegistry registry = new RNFBDatabaseTransactionRegistry();
+    FakeAbortable first = new FakeAbortable();
+    FakeAbortable second = new FakeAbortable();
+    registry.put(1, first);
+    assertSame(first, registry.take(1));
+    registry.put(1, second);
+    assertSame(second, registry.get(1));
+    assertFalse(first.abortCount != 0);
+  }
+}

package/dist/module/version.js

@@ -1,5 +1,5 @@
 "use strict";
 
 // Generated by genversion.
-export const version = '26.3.2';
+export const version = '26.4.0';
 //# sourceMappingURL=version.js.map

package/dist/typescript/lib/index.d.ts

@@ -1,7 +1,7 @@
 import type { FirebaseApp } from '@react-native-firebase/app';
 import './types/internal';
 import type { Database, DatabaseReference, EmulatorMockTokenOptions } from './types/database';
-export declare const SDK_VERSION = "26.3.2";
+export declare const SDK_VERSION = "26.4.0";
 export declare function getDatabase(app?: FirebaseApp, url?: string): Database;
 export declare function connectDatabaseEmulator(db: Database, host: string, port: number, options?: {
     mockUserToken?: EmulatorMockTokenOptions | string;

package/dist/typescript/lib/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "26.3.2";
+export declare const version = "26.4.0";
 //# sourceMappingURL=version.d.ts.map

package/ios/RNFBDatabase/RNFBDatabaseListenerRegistry.h

@@ -0,0 +1,37 @@
+/**
+ * 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 <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Per-query listener handle map. Unique `put`; callers `take` or `takeAll` then remove the SDK
+ * observer outside the HandleMap lock. Values are typically NSNumber observer handles.
+ */
+@interface RNFBDatabaseListenerRegistry : NSObject
+
+- (BOOL)put:(id)key value:(id)value error:(NSError *_Nullable *_Nullable)error;
+- (nullable id)get:(id)key;
+- (nullable id)take:(id)key;
+- (NSArray *)takeAll;
+- (BOOL)hasEventListener:(id)key;
+- (BOOL)hasListeners;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RNFBDatabase/RNFBDatabaseListenerRegistry.m

@@ -0,0 +1,84 @@
+/**
+ * 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 "RNFBDatabaseListenerRegistry.h"
+
+#if __has_include("RNFBHandleMap.h")
+#import "RNFBHandleMap.h"
+#else
+#import "RNFBApp/RNFBHandleMap.h"
+#endif
+
+@interface RNFBDatabaseListenerRegistry ()
+@property(nonatomic, strong) RNFBHandleMap *map;
+@property(nonatomic, assign) NSInteger occupancy;
+@end
+
+@implementation RNFBDatabaseListenerRegistry
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _map = [[RNFBHandleMap alloc] init];
+    _occupancy = 0;
+  }
+  return self;
+}
+
+- (BOOL)put:(id)key value:(id)value error:(NSError **)error {
+  @synchronized(self) {
+    if ([self.map put:key value:value error:error]) {
+      _occupancy += 1;
+      return YES;
+    }
+    return NO;
+  }
+}
+
+- (id)get:(id)key {
+  return [self.map get:key];
+}
+
+- (id)take:(id)key {
+  @synchronized(self) {
+    id value = [self.map take:key];
+    if (value != nil) {
+      _occupancy -= 1;
+    }
+    return value;
+  }
+}
+
+- (NSArray *)takeAll {
+  @synchronized(self) {
+    NSArray *remaining = [self.map takeAll];
+    _occupancy -= (NSInteger)remaining.count;
+    return remaining;
+  }
+}
+
+- (BOOL)hasEventListener:(id)key {
+  return [self.map get:key] != nil;
+}
+
+- (BOOL)hasListeners {
+  @synchronized(self) {
+    return _occupancy > 0;
+  }
+}
+
+@end

package/ios/RNFBDatabase/RNFBDatabaseQuery.h

@@ -28,10 +28,11 @@
 @import FirebaseDatabaseInternal;
 #endif
 #import <React/RCTBridgeModule.h>
+#import "RNFBDatabaseListenerRegistry.h"
 
 @interface RNFBDatabaseQuery : NSObject
 @property FIRDatabaseQuery *query;
-@property NSMutableDictionary *listeners;
+@property(nonatomic, strong, readonly) RNFBDatabaseListenerRegistry *listeners;
 
 - (RNFBDatabaseQuery *)initWithReferenceAndModifiers:(FIRDatabaseReference *)reference
                                            modifiers:(NSArray *)modifiers;
@@ -40,7 +41,7 @@
 
 - (BOOL)hasListeners;
 
-- (void)addEventListener:(NSString *)eventRegistrationKey handle:(FIRDatabaseHandle)handle;
+- (BOOL)addEventListener:(NSString *)eventRegistrationKey handle:(FIRDatabaseHandle)handle;
 
 - (void)removeEventListener:(NSString *)eventRegistrationKey;
 

package/ios/RNFBDatabase/RNFBDatabaseQuery.m

@@ -17,6 +17,7 @@
  */
 
 #import "RNFBDatabaseQuery.h"
+#import "RNFBDatabaseListenerRegistry.h"
 
 @implementation RNFBDatabaseQuery
 
@@ -26,7 +27,7 @@
 
   if (self) {
     _query = [self buildQueryWithModifiers:reference modifiers:modifiers];
-    _listeners = [NSMutableDictionary dictionary];
+    _listeners = [[RNFBDatabaseListenerRegistry alloc] init];
   }
 
   return self;
@@ -112,32 +113,32 @@
   }
 }
 
-- (void)addEventListener:(NSString *)eventRegistrationKey handle:(FIRDatabaseHandle)handle {
-  _listeners[eventRegistrationKey] = @(handle);
+- (BOOL)addEventListener:(NSString *)eventRegistrationKey handle:(FIRDatabaseHandle)handle {
+  NSError *error = nil;
+  return [_listeners put:eventRegistrationKey value:@(handle) error:&error];
 }
 
 - (void)removeEventListener:(NSString *)eventRegistrationKey {
-  FIRDatabaseHandle handle = (FIRDatabaseHandle)[_listeners[eventRegistrationKey] integerValue];
-  if (handle) {
-    [_query removeObserverWithHandle:handle];
-    [_listeners removeObjectForKey:eventRegistrationKey];
+  NSNumber *handleNumber = [_listeners take:eventRegistrationKey];
+  if (handleNumber != nil) {
+    [_query removeObserverWithHandle:(FIRDatabaseHandle)[handleNumber integerValue]];
   }
 }
 
 - (void)removeAllEventListeners {
-  NSArray *eventRegistrationKeys = [_listeners allKeys];
-
-  for (NSString *eventRegistrationKey in eventRegistrationKeys) {
-    [self removeEventListener:eventRegistrationKey];
+  NSArray *handles = [_listeners takeAll];
+  for (NSNumber *handleNumber in handles) {
+    FIRDatabaseHandle handle = (FIRDatabaseHandle)[handleNumber integerValue];
+    [_query removeObserverWithHandle:handle];
   }
 }
 
 - (BOOL)hasEventListener:(NSString *)eventRegistrationKey {
-  return _listeners[eventRegistrationKey] != nil;
+  return [_listeners hasEventListener:eventRegistrationKey];
 }
 
 - (BOOL)hasListeners {
-  return [[_listeners allKeys] count] > 0;
+  return [_listeners hasListeners];
 }
 
 @end

package/ios/RNFBDatabase/RNFBDatabaseQueryHelper.m

@@ -26,29 +26,24 @@
 #import "RNFBDatabaseCommon.h"
 #import "RNFBDatabaseQuery.h"
 #import "RNFBDatabaseQueryHelper.h"
+#import "RNFBDatabaseQueryRegistry.h"
 #import "RNFBRCTEventEmitter.h"
 
-static __strong NSMutableDictionary *queryDictionary;
+static RNFBDatabaseQueryRegistry *queryRegistry;
 static NSString *const RNFB_DATABASE_SYNC = @"database_sync_event";
 
 @implementation RNFBDatabaseQueryHelper
 
-+ (NSMutableDictionary *)queryDictionary {
++ (RNFBDatabaseQueryRegistry *)queryRegistry {
   static dispatch_once_t onceToken;
   dispatch_once(&onceToken, ^{
-    queryDictionary = [[NSMutableDictionary alloc] init];
+    queryRegistry = [[RNFBDatabaseQueryRegistry alloc] init];
   });
-  return queryDictionary;
+  return queryRegistry;
 }
 
 + (void)invalidate {
-  NSMutableDictionary *queries = [self queryDictionary];
-  NSArray *queryKeys = [queries allKeys];
-  for (NSString *key in queryKeys) {
-    RNFBDatabaseQuery *query = queries[key];
-    [query removeAllEventListeners];
-    [queries removeObjectForKey:key];
-  }
+  [[self queryRegistry] removeAll];
 }
 
 + (RNFBDatabaseQuery *)getDatabaseQueryInstance:(FIRDatabaseReference *)reference
@@ -59,17 +54,23 @@ static NSString *const RNFB_DATABASE_SYNC = @"database_sync_event";
 + (RNFBDatabaseQuery *)getDatabaseQueryInstance:(NSString *)key
                                       reference:(FIRDatabaseReference *)reference
                                       modifiers:(NSArray *)modifiers {
-  NSMutableDictionary *queries = [self queryDictionary];
-  RNFBDatabaseQuery *cachedQuery = queries[key];
+  RNFBDatabaseQueryRegistry *queries = [self queryRegistry];
+  id cachedQuery = [queries get:key];
 
-  if (cachedQuery != nil) {
+  if ([cachedQuery isKindOfClass:[RNFBDatabaseQuery class]]) {
     return cachedQuery;
   }
 
   RNFBDatabaseQuery *query = [[RNFBDatabaseQuery alloc] initWithReferenceAndModifiers:reference
                                                                             modifiers:modifiers];
 
-  queries[key] = query;
+  NSError *error = nil;
+  if (![queries put:key value:query error:&error]) {
+    id winner = [queries get:key];
+    if ([winner isKindOfClass:[RNFBDatabaseQuery class]]) {
+      return winner;
+    }
+  }
   return query;
 }
 
@@ -167,7 +168,9 @@ static NSString *const RNFB_DATABASE_SYNC = @"database_sync_event";
     FIRDatabaseHandle handle = [databaseQuery.query observeEventType:firDataEventType
                                       andPreviousSiblingKeyWithBlock:andPreviousSiblingKeyWithBlock
                                                      withCancelBlock:errorBlock];
-    [databaseQuery addEventListener:eventRegistrationKey handle:handle];
+    if (![databaseQuery addEventListener:eventRegistrationKey handle:handle]) {
+      [databaseQuery.query removeObserverWithHandle:handle];
+    }
   }
 }
 
@@ -206,14 +209,14 @@ static NSString *const RNFB_DATABASE_SYNC = @"database_sync_event";
 }
 
 + (void)off:(NSString *)queryKey eventRegistrationKey:(NSString *)eventRegistrationKey {
-  NSMutableDictionary *queries = [self queryDictionary];
-  RNFBDatabaseQuery *databaseQuery = queries[queryKey];
+  RNFBDatabaseQueryRegistry *queries = [self queryRegistry];
+  id cached = [queries get:queryKey];
 
-  if (databaseQuery != nil) {
+  if ([cached isKindOfClass:[RNFBDatabaseQuery class]]) {
+    RNFBDatabaseQuery *databaseQuery = cached;
     [databaseQuery removeEventListener:eventRegistrationKey];
 
-    if (![databaseQuery hasListeners]) {
-      [queries removeObjectForKey:queryKey];
+    if ([queries takeIfIdle:queryKey] != nil) {
       [RNFBDatabaseCommon removeReferenceByKey:queryKey];
     }
   }

package/ios/RNFBDatabase/RNFBDatabaseQueryRegistry.h

@@ -0,0 +1,37 @@
+/**
+ * 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 <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Cached query map. Unique `put`; callers `take`, `takeIfIdle`, or `removeAll` then
+ * `removeAllEventListeners` outside the HandleMap lock. Stored values are expected to respond to
+ * `removeAllEventListeners` and `hasListeners`.
+ */
+@interface RNFBDatabaseQueryRegistry : NSObject
+
+- (BOOL)put:(id)key value:(id)value error:(NSError *_Nullable *_Nullable)error;
+- (nullable id)get:(id)key;
+- (nullable id)take:(id)key;
+- (nullable id)takeIfIdle:(id)key;
+- (void)removeAll;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RNFBDatabase/RNFBDatabaseQueryRegistry.m

@@ -0,0 +1,105 @@
+/**
+ * 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 "RNFBDatabaseQueryRegistry.h"
+
+#if __has_include("RNFBHandleMap.h")
+#import "RNFBHandleMap.h"
+#else
+#import "RNFBApp/RNFBHandleMap.h"
+#endif
+
+@protocol RNFBDatabaseHasListeners
+- (BOOL)hasListeners;
+@end
+
+@interface RNFBDatabaseQueryRegistry ()
+@property(nonatomic, strong) RNFBHandleMap *map;
+@end
+
+@implementation RNFBDatabaseQueryRegistry
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _map = [[RNFBHandleMap alloc] init];
+  }
+  return self;
+}
+
+- (void)rnfb_removeAllListeners:(id)query {
+  if (query && [query respondsToSelector:@selector(removeAllEventListeners)]) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+    [query performSelector:@selector(removeAllEventListeners)];
+#pragma clang diagnostic pop
+  }
+}
+
+- (BOOL)put:(id)key value:(id)value error:(NSError **)error {
+  return [self.map put:key value:value error:error];
+}
+
+- (id)get:(id)key {
+  return [self.map get:key];
+}
+
+- (id)take:(id)key {
+  return [self.map take:key];
+}
+
+- (id)takeIfIdle:(id)key {
+  // Read hasListeners outside the HandleMap lock (avoids nesting listener occupancy), then
+  // identity-take and put-back if listeners appeared.
+  id query = [self.map get:key];
+  if (query == nil) {
+    return nil;
+  }
+  if (![query respondsToSelector:@selector(hasListeners)]) {
+    return nil;
+  }
+  if ([(id<RNFBDatabaseHasListeners>)query hasListeners]) {
+    return nil;
+  }
+  id taken = [self.map takeIf:key
+                         when:^BOOL(id value) {
+                           return value == query;
+                         }];
+  if (taken == nil) {
+    return nil;
+  }
+  if ([taken respondsToSelector:@selector(hasListeners)] &&
+      [(id<RNFBDatabaseHasListeners>)taken hasListeners]) {
+    // 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 (![self.map putIfAbsent:key value:taken]) {
+      [self rnfb_removeAllListeners:taken];
+    }
+    return nil;
+  }
+  return taken;
+}
+
+- (void)removeAll {
+  NSArray *queries = [self.map takeAll];
+  for (id query in queries) {
+    [self rnfb_removeAllListeners:query];
+  }
+}
+
+@end