@react-native-firebase/database 25.1.0 → 26.1.0

package/android/src/reactnative/java/io/invertase/firebase/database/{ReactNativeFirebaseDatabaseQueryModule.java → NativeRNFBTurboDatabaseQuery.java}

@@ -21,6 +21,8 @@ import static io.invertase.firebase.common.RCTConvertFirebase.readableMapToWrita
 import static io.invertase.firebase.database.ReactNativeFirebaseDatabaseCommon.*;
 import static io.invertase.firebase.database.UniversalFirebaseDatabaseCommon.getDatabaseForApp;
 
+import androidx.annotation.CallSuper;
+import com.facebook.fbreact.specs.NativeRNFBTurboDatabaseQuerySpec;
 import com.facebook.react.bridge.*;
 import com.google.android.gms.tasks.Tasks;
 import com.google.firebase.database.*;
@@ -33,15 +35,17 @@ import java.util.Objects;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
-public class ReactNativeFirebaseDatabaseQueryModule extends ReactNativeFirebaseModule {
-  private static final String SERVICE_NAME = "DatabaseQuery";
+public class NativeRNFBTurboDatabaseQuery extends NativeRNFBTurboDatabaseQuerySpec {
+  private final DatabaseTurboModuleSupport turboSupport =
+      new DatabaseTurboModuleSupport("RNFBDatabaseQuery");
   private HashMap<String, ReactNativeFirebaseDatabaseQuery> queryMap = new HashMap<>();
 
-  ReactNativeFirebaseDatabaseQueryModule(ReactApplicationContext reactContext) {
-    super(reactContext, SERVICE_NAME);
+  public NativeRNFBTurboDatabaseQuery(ReactApplicationContext reactContext) {
+    super(reactContext);
   }
 
   @Override
+  @CallSuper
   public void invalidate() {
     Iterator refIterator = queryMap.entrySet().iterator();
     while (refIterator.hasNext()) {
@@ -49,31 +53,18 @@ public class ReactNativeFirebaseDatabaseQueryModule extends ReactNativeFirebaseM
       ReactNativeFirebaseDatabaseQuery databaseQuery =
           (ReactNativeFirebaseDatabaseQuery) pair.getValue();
       databaseQuery.removeAllEventListeners();
-      refIterator.remove(); // avoids a ConcurrentModificationException
+      refIterator.remove();
     }
 
+    turboSupport.invalidate();
     super.invalidate();
   }
 
-  /**
-   * Returns an uncached ReactNativeFirebaseDatabaseQuery instance, used when no cleanup is needed
-   * (e.g. once).
-   *
-   * @param reference
-   * @param modifiers
-   */
   private ReactNativeFirebaseDatabaseQuery getDatabaseQueryInstance(
       DatabaseReference reference, ReadableArray modifiers) {
     return new ReactNativeFirebaseDatabaseQuery(reference, modifiers);
   }
 
-  /**
-   * Caches a ReactNativeFirebaseDatabaseQuery instance from the query key and caches it for later
-   * use (e.g. on/off)
-   *
-   * @param reference
-   * @param modifiers
-   */
   private ReactNativeFirebaseDatabaseQuery getDatabaseQueryInstance(
       String key, DatabaseReference reference, ReadableArray modifiers) {
     ReactNativeFirebaseDatabaseQuery cachedDatabaseQuery = queryMap.get(key);
@@ -89,12 +80,6 @@ public class ReactNativeFirebaseDatabaseQueryModule extends ReactNativeFirebaseM
     return databaseQuery;
   }
 
-  /**
-   * ref().once('value')
-   *
-   * @param databaseQuery
-   * @param promise
-   */
   private void addOnceValueEventListener(
       ReactNativeFirebaseDatabaseQuery databaseQuery, Promise promise) {
     ValueEventListener onceValueEventListener =
@@ -102,17 +87,18 @@ public class ReactNativeFirebaseDatabaseQueryModule extends ReactNativeFirebaseM
           @Override
           public void onDataChange(@Nonnull DataSnapshot dataSnapshot) {
             try {
-              Tasks.call(getExecutor(), () -> snapshotToMap(dataSnapshot))
+              Tasks.call(turboSupport.getExecutor(), () -> snapshotToMap(dataSnapshot))
                   .addOnCompleteListener(
                       task -> {
                         if (task.isSuccessful()) {
                           promise.resolve(task.getResult());
                         } else {
-                          rejectPromiseWithExceptionMap(promise, task.getException());
+                          ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(
+                              promise, task.getException());
                         }
                       });
             } catch (java.util.concurrent.RejectedExecutionException e) {
-              rejectPromiseWithExceptionMap(promise, e);
+              ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(promise, e);
             }
           }
 
@@ -128,13 +114,6 @@ public class ReactNativeFirebaseDatabaseQueryModule extends ReactNativeFirebaseM
     databaseQuery.addSingleValueEventListener(onceValueEventListener);
   }
 
-  /**
-   * ref().once('child_*') handler
-   *
-   * @param eventType
-   * @param databaseQuery
-   * @param promise
-   */
   private void addChildOnceEventListener(
       String eventType, ReactNativeFirebaseDatabaseQuery databaseQuery, Promise promise) {
     ChildEventListener childEventListener =
@@ -145,18 +124,19 @@ public class ReactNativeFirebaseDatabaseQueryModule extends ReactNativeFirebaseM
               databaseQuery.removeEventListener(this);
               try {
                 Tasks.call(
-                        getExecutor(),
+                        turboSupport.getExecutor(),
                         () -> snapshotWithPreviousChildToMap(dataSnapshot, previousChildName))
                     .addOnCompleteListener(
                         task -> {
                           if (task.isSuccessful()) {
                             promise.resolve(task.getResult());
                           } else {
-                            rejectPromiseWithExceptionMap(promise, task.getException());
+                            ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(
+                                promise, task.getException());
                           }
                         });
               } catch (java.util.concurrent.RejectedExecutionException e) {
-                rejectPromiseWithExceptionMap(promise, e);
+                ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(promise, e);
               }
             }
           }
@@ -167,18 +147,19 @@ public class ReactNativeFirebaseDatabaseQueryModule extends ReactNativeFirebaseM
               databaseQuery.removeEventListener(this);
               try {
                 Tasks.call(
-                        getExecutor(),
+                        turboSupport.getExecutor(),
                         () -> snapshotWithPreviousChildToMap(dataSnapshot, previousChildName))
                     .addOnCompleteListener(
                         task -> {
                           if (task.isSuccessful()) {
                             promise.resolve(task.getResult());
                           } else {
-                            rejectPromiseWithExceptionMap(promise, task.getException());
+                            ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(
+                                promise, task.getException());
                           }
                         });
               } catch (java.util.concurrent.RejectedExecutionException e) {
-                rejectPromiseWithExceptionMap(promise, e);
+                ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(promise, e);
               }
             }
           }
@@ -188,17 +169,20 @@ public class ReactNativeFirebaseDatabaseQueryModule extends ReactNativeFirebaseM
             if ("child_removed".equals(eventType)) {
               databaseQuery.removeEventListener(this);
               try {
-                Tasks.call(getExecutor(), () -> snapshotWithPreviousChildToMap(dataSnapshot, null))
+                Tasks.call(
+                        turboSupport.getExecutor(),
+                        () -> snapshotWithPreviousChildToMap(dataSnapshot, null))
                     .addOnCompleteListener(
                         task -> {
                           if (task.isSuccessful()) {
                             promise.resolve(task.getResult());
                           } else {
-                            rejectPromiseWithExceptionMap(promise, task.getException());
+                            ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(
+                                promise, task.getException());
                           }
                         });
               } catch (java.util.concurrent.RejectedExecutionException e) {
-                rejectPromiseWithExceptionMap(promise, e);
+                ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(promise, e);
               }
             }
           }
@@ -209,18 +193,19 @@ public class ReactNativeFirebaseDatabaseQueryModule extends ReactNativeFirebaseM
               databaseQuery.removeEventListener(this);
               try {
                 Tasks.call(
-                        getExecutor(),
+                        turboSupport.getExecutor(),
                         () -> snapshotWithPreviousChildToMap(dataSnapshot, previousChildName))
                     .addOnCompleteListener(
                         task -> {
                           if (task.isSuccessful()) {
                             promise.resolve(task.getResult());
                           } else {
-                            rejectPromiseWithExceptionMap(promise, task.getException());
+                            ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(
+                                promise, task.getException());
                           }
                         });
               } catch (java.util.concurrent.RejectedExecutionException e) {
-                rejectPromiseWithExceptionMap(promise, e);
+                ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(promise, e);
               }
             }
           }
@@ -238,13 +223,6 @@ public class ReactNativeFirebaseDatabaseQueryModule extends ReactNativeFirebaseM
     databaseQuery.addSingleChildEventListener(childEventListener);
   }
 
-  /**
-   * ref().on('value') handler
-   *
-   * @param key
-   * @param databaseQuery
-   * @param registration
-   */
   private void addValueEventListener(
       String key, ReactNativeFirebaseDatabaseQuery databaseQuery, ReadableMap registration) {
     final String eventRegistrationKey = registration.getString("eventRegistrationKey");
@@ -321,13 +299,6 @@ public class ReactNativeFirebaseDatabaseQueryModule extends ReactNativeFirebaseM
     }
   }
 
-  /**
-   * Handles value/child update events.
-   *
-   * @param eventType
-   * @param dataSnapshot
-   * @param previousChildName
-   */
   private void handleDatabaseEvent(
       final String key,
       final String eventType,
@@ -337,7 +308,7 @@ public class ReactNativeFirebaseDatabaseQueryModule extends ReactNativeFirebaseM
     final String eventRegistrationKey = registration.getString("eventRegistrationKey");
     try {
       Tasks.call(
-              getTransactionalExecutor(eventRegistrationKey),
+              turboSupport.getTransactionalExecutor(eventRegistrationKey),
               () -> {
                 if (eventType.equals("value")) {
                   return snapshotToMap(dataSnapshot);
@@ -346,7 +317,7 @@ public class ReactNativeFirebaseDatabaseQueryModule extends ReactNativeFirebaseM
                 }
               })
           .addOnCompleteListener(
-              getExecutor(),
+              turboSupport.getExecutor(),
               task -> {
                 if (task.isSuccessful()) {
                   WritableMap data = task.getResult();
@@ -366,16 +337,9 @@ public class ReactNativeFirebaseDatabaseQueryModule extends ReactNativeFirebaseM
               });
     } catch (java.util.concurrent.RejectedExecutionException e) {
       // Event arrived after module invalidation shut down an executor.
-      // Safe to drop when tearing down; no JS listener will consume the event.
     }
   }
 
-  /**
-   * Handles a database listener cancellation error.
-   *
-   * @param registration
-   * @param error
-   */
   private void handleDatabaseEventError(String key, ReadableMap registration, DatabaseError error) {
     WritableMap event = Arguments.createMap();
     UniversalDatabaseException databaseException =
@@ -395,17 +359,7 @@ public class ReactNativeFirebaseDatabaseQueryModule extends ReactNativeFirebaseM
         new ReactNativeFirebaseDatabaseEvent(ReactNativeFirebaseDatabaseEvent.EVENT_SYNC, event));
   }
 
-  /**
-   * ref().once('*')
-   *
-   * @param app
-   * @param dbURL
-   * @param path
-   * @param modifiers
-   * @param eventType
-   * @param promise
-   */
-  @ReactMethod
+  @Override
   public void once(
       String app,
       String dbURL,
@@ -422,14 +376,7 @@ public class ReactNativeFirebaseDatabaseQueryModule extends ReactNativeFirebaseM
     }
   }
 
-  /**
-   * ref().on('*')
-   *
-   * @param app
-   * @param dbURL
-   * @param props
-   */
-  @ReactMethod
+  @Override
   public void on(String app, String dbURL, ReadableMap props) {
     String key = props.getString("key");
     ReadableArray modifiers = props.getArray("modifiers");
@@ -447,14 +394,13 @@ public class ReactNativeFirebaseDatabaseQueryModule extends ReactNativeFirebaseM
     }
   }
 
-  /** ref().off('*') */
-  @ReactMethod
+  @Override
   public void off(String queryKey, String eventRegistrationKey) {
     ReactNativeFirebaseDatabaseQuery databaseQuery = queryMap.get(queryKey);
 
     if (databaseQuery != null) {
       databaseQuery.removeEventListener(eventRegistrationKey);
-      removeEventListeningExecutor(eventRegistrationKey);
+      turboSupport.removeEventListeningExecutor(eventRegistrationKey);
 
       if (!databaseQuery.hasListeners()) {
         queryMap.remove(queryKey);
@@ -462,27 +408,17 @@ public class ReactNativeFirebaseDatabaseQueryModule extends ReactNativeFirebaseM
     }
   }
 
-  /**
-   * ref().keepSynced('*')
-   *
-   * @param app
-   * @param dbURL
-   * @param path
-   * @param modifiers
-   * @param bool
-   * @param promise
-   */
-  @ReactMethod
+  @Override
   public void keepSynced(
       String app,
       String dbURL,
       String key,
       String path,
       ReadableArray modifiers,
-      Boolean bool,
+      boolean enabled,
       Promise promise) {
     DatabaseReference reference = getDatabaseForApp(app, dbURL).getReference(path);
-    getDatabaseQueryInstance(key, reference, modifiers).query.keepSynced(bool);
+    getDatabaseQueryInstance(key, reference, modifiers).query.keepSynced(enabled);
     promise.resolve(null);
   }
 }

package/android/src/reactnative/java/io/invertase/firebase/database/{ReactNativeFirebaseDatabaseReferenceModule.java → NativeRNFBTurboDatabaseReference.java}

@@ -20,29 +20,38 @@ package io.invertase.firebase.database;
 import static io.invertase.firebase.common.RCTConvertFirebase.toHashMap;
 import static io.invertase.firebase.database.ReactNativeFirebaseDatabaseCommon.rejectPromiseDatabaseException;
 
+import androidx.annotation.CallSuper;
+import com.facebook.fbreact.specs.NativeRNFBTurboDatabaseReferenceSpec;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
 import com.google.android.gms.tasks.Tasks;
-import io.invertase.firebase.common.ReactNativeFirebaseModule;
 import java.util.Map;
 
-public class ReactNativeFirebaseDatabaseReferenceModule extends ReactNativeFirebaseModule {
+public class NativeRNFBTurboDatabaseReference extends NativeRNFBTurboDatabaseReferenceSpec {
   private static final String SERVICE_NAME = "DatabaseReference";
   private final UniversalFirebaseDatabaseReferenceModule module;
+  private final DatabaseTurboModuleSupport turboSupport =
+      new DatabaseTurboModuleSupport("RNFBDatabaseReference");
 
-  ReactNativeFirebaseDatabaseReferenceModule(ReactApplicationContext reactContext) {
-    super(reactContext, SERVICE_NAME);
+  public NativeRNFBTurboDatabaseReference(ReactApplicationContext reactContext) {
+    super(reactContext);
     module = new UniversalFirebaseDatabaseReferenceModule(reactContext, SERVICE_NAME);
   }
 
-  @ReactMethod
+  @Override
+  @CallSuper
+  public void invalidate() {
+    turboSupport.invalidate();
+    super.invalidate();
+  }
+
+  @Override
   public void set(String app, String dbURL, String path, ReadableMap props, Promise promise) {
-    Tasks.call(getTransactionalExecutor(), () -> toHashMap(props).get("value"))
+    Tasks.call(turboSupport.getTransactionalExecutor(), () -> toHashMap(props).get("value"))
         .onSuccessTask(aValue -> module.set(app, dbURL, path, aValue))
         .addOnCompleteListener(
-            getTransactionalExecutor(),
+            turboSupport.getTransactionalExecutor(),
             task -> {
               if (task.isSuccessful()) {
                 promise.resolve(task.getResult());
@@ -53,12 +62,12 @@ public class ReactNativeFirebaseDatabaseReferenceModule extends ReactNativeFireb
   }
 
   @SuppressWarnings("unchecked")
-  @ReactMethod
+  @Override
   public void update(String app, String dbURL, String path, ReadableMap props, Promise promise) {
-    Tasks.call(getTransactionalExecutor(), () -> toHashMap(props).get("values"))
+    Tasks.call(turboSupport.getTransactionalExecutor(), () -> toHashMap(props).get("values"))
         .onSuccessTask(aMap -> module.update(app, dbURL, path, (Map<String, Object>) aMap))
         .addOnCompleteListener(
-            getTransactionalExecutor(),
+            turboSupport.getTransactionalExecutor(),
             task -> {
               if (task.isSuccessful()) {
                 promise.resolve(task.getResult());
@@ -68,15 +77,15 @@ public class ReactNativeFirebaseDatabaseReferenceModule extends ReactNativeFireb
             });
   }
 
-  @ReactMethod
+  @Override
   public void setWithPriority(
       String app, String dbURL, String path, ReadableMap props, Promise promise) {
-    Tasks.call(getTransactionalExecutor(), () -> toHashMap(props))
+    Tasks.call(turboSupport.getTransactionalExecutor(), () -> toHashMap(props))
         .onSuccessTask(
             aMap ->
                 module.setWithPriority(app, dbURL, path, aMap.get("value"), aMap.get("priority")))
         .addOnCompleteListener(
-            getTransactionalExecutor(),
+            turboSupport.getTransactionalExecutor(),
             task -> {
               if (task.isSuccessful()) {
                 promise.resolve(task.getResult());
@@ -86,13 +95,12 @@ public class ReactNativeFirebaseDatabaseReferenceModule extends ReactNativeFireb
             });
   }
 
-  @ReactMethod
+  @Override
   public void remove(String app, String dbURL, String path, Promise promise) {
-    // continuation tasks not needed for this as no data
     module
         .remove(app, dbURL, path)
         .addOnCompleteListener(
-            getTransactionalExecutor(),
+            turboSupport.getTransactionalExecutor(),
             task -> {
               if (task.isSuccessful()) {
                 promise.resolve(task.getResult());
@@ -102,14 +110,13 @@ public class ReactNativeFirebaseDatabaseReferenceModule extends ReactNativeFireb
             });
   }
 
-  @ReactMethod
+  @Override
   public void setPriority(
       String app, String dbURL, String path, ReadableMap props, Promise promise) {
-    // continuation tasks not needed for this as minimal data
     module
         .setPriority(app, dbURL, path, toHashMap(props).get("priority"))
         .addOnCompleteListener(
-            getTransactionalExecutor(),
+            turboSupport.getTransactionalExecutor(),
             task -> {
               if (task.isSuccessful()) {
                 promise.resolve(task.getResult());

package/android/src/reactnative/java/io/invertase/firebase/database/{ReactNativeFirebaseDatabaseTransactionModule.java → NativeRNFBTurboDatabaseTransaction.java}

@@ -21,27 +21,44 @@ import static io.invertase.firebase.database.UniversalFirebaseDatabaseCommon.get
 
 import android.os.AsyncTask;
 import android.util.SparseArray;
+import com.facebook.fbreact.specs.NativeRNFBTurboDatabaseTransactionSpec;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
 import com.google.firebase.database.*;
 import io.invertase.firebase.common.ReactNativeFirebaseEventEmitter;
-import io.invertase.firebase.common.ReactNativeFirebaseModule;
 import javax.annotation.Nonnull;
 
-public class ReactNativeFirebaseDatabaseTransactionModule extends ReactNativeFirebaseModule {
+public class NativeRNFBTurboDatabaseTransaction extends NativeRNFBTurboDatabaseTransactionSpec {
   private static final String SERVICE_NAME = "DatabaseTransaction";
   private static SparseArray<ReactNativeFirebaseDatabaseTransactionHandler> transactionHandlers =
       new SparseArray<>();
+  private final DatabaseTurboModuleSupport turboSupport =
+      new DatabaseTurboModuleSupport("RNFBDatabaseTransaction");
 
-  ReactNativeFirebaseDatabaseTransactionModule(ReactApplicationContext reactContext) {
-    super(reactContext, SERVICE_NAME);
+  public NativeRNFBTurboDatabaseTransaction(ReactApplicationContext reactContext) {
+    super(reactContext);
   }
 
-  @ReactMethod
+  @Override
+  public void invalidate() {
+    for (int i = 0, size = transactionHandlers.size(); i < size; i++) {
+      int key = transactionHandlers.keyAt(i);
+      ReactNativeFirebaseDatabaseTransactionHandler transactionHandler =
+          transactionHandlers.get(key);
+
+      if (transactionHandler != null) {
+        transactionHandler.abort();
+      }
+    }
+
+    transactionHandlers.clear();
+    turboSupport.invalidate();
+  }
+
+  @Override
   public void transactionStart(
-      String app, String dbURL, String path, int transactionId, Boolean applyLocally) {
+      String app, String dbURL, String path, double transactionId, boolean applyLocally) {
     AsyncTask.execute(
         () -> {
           DatabaseReference reference = getDatabaseForApp(app, dbURL).getReference(path);
@@ -52,12 +69,11 @@ public class ReactNativeFirebaseDatabaseTransactionModule extends ReactNativeFir
                 @Override
                 public Transaction.Result doTransaction(@Nonnull MutableData mutableData) {
                   final ReactNativeFirebaseDatabaseTransactionHandler transactionHandler =
-                      new ReactNativeFirebaseDatabaseTransactionHandler(transactionId, app, dbURL);
-                  transactionHandlers.put(transactionId, transactionHandler);
+                      new ReactNativeFirebaseDatabaseTransactionHandler(
+                          (int) transactionId, app, dbURL);
+                  transactionHandlers.put((int) transactionId, transactionHandler);
                   final WritableMap updatesMap = transactionHandler.createUpdateMap(mutableData);
 
-                  // emit the updates to js using an async task
-                  // otherwise it gets blocked by the lock await
                   AsyncTask.execute(
                       () -> {
                         ReactNativeFirebaseEventEmitter emitter =
@@ -68,10 +84,9 @@ public class ReactNativeFirebaseDatabaseTransactionModule extends ReactNativeFir
                                 ReactNativeFirebaseTransactionEvent.EVENT_TRANSACTION,
                                 updatesMap,
                                 app,
-                                transactionId));
+                                (int) transactionId));
                       });
 
-                  // wait for js to return the updates (js calls transactionTryCommit)
                   try {
                     transactionHandler.await();
                   } catch (InterruptedException e) {
@@ -95,7 +110,13 @@ public class ReactNativeFirebaseDatabaseTransactionModule extends ReactNativeFir
                 public void onComplete(
                     DatabaseError error, boolean committed, DataSnapshot snapshot) {
                   ReactNativeFirebaseDatabaseTransactionHandler transactionHandler =
-                      transactionHandlers.get(transactionId);
+                      transactionHandlers.get((int) transactionId);
+
+                  if (transactionHandler == null) {
+                    transactionHandlers.delete((int) transactionId);
+                    return;
+                  }
+
                   WritableMap resultMap =
                       transactionHandler.createResultMap(error, committed, snapshot);
 
@@ -107,19 +128,20 @@ public class ReactNativeFirebaseDatabaseTransactionModule extends ReactNativeFir
                           ReactNativeFirebaseTransactionEvent.EVENT_TRANSACTION,
                           resultMap,
                           app,
-                          transactionId));
+                          (int) transactionId));
 
-                  transactionHandlers.delete(transactionId);
+                  transactionHandlers.delete((int) transactionId);
                 }
               },
               applyLocally);
         });
   }
 
-  @ReactMethod
+  @Override
   public void transactionTryCommit(
-      String app, String dbURL, int transactionId, ReadableMap updates) {
-    ReactNativeFirebaseDatabaseTransactionHandler handler = transactionHandlers.get(transactionId);
+      String app, String dbURL, double transactionId, ReadableMap updates) {
+    ReactNativeFirebaseDatabaseTransactionHandler handler =
+        transactionHandlers.get((int) transactionId);
 
     if (handler != null) {
       handler.signalUpdateReceived(updates);

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

@@ -30,11 +30,11 @@ public class ReactNativeFirebaseDatabasePackage implements ReactPackage {
   @Override
   public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
     List<NativeModule> modules = new ArrayList<>();
-    modules.add(new ReactNativeFirebaseDatabaseModule(reactContext));
-    modules.add(new ReactNativeFirebaseDatabaseReferenceModule(reactContext));
-    modules.add(new ReactNativeFirebaseDatabaseQueryModule(reactContext));
-    modules.add(new ReactNativeFirebaseDatabaseOnDisconnectModule(reactContext));
-    modules.add(new ReactNativeFirebaseDatabaseTransactionModule(reactContext));
+    modules.add(new NativeRNFBTurboDatabase(reactContext));
+    modules.add(new NativeRNFBTurboDatabaseReference(reactContext));
+    modules.add(new NativeRNFBTurboDatabaseQuery(reactContext));
+    modules.add(new NativeRNFBTurboDatabaseOnDisconnect(reactContext));
+    modules.add(new NativeRNFBTurboDatabaseTransaction(reactContext));
     return modules;
   }
 

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

@@ -81,6 +81,17 @@ public class ReactNativeFirebaseDatabaseTransactionHandler {
     }
   }
 
+  /** Abort the currently in progress transaction if any. */
+  void abort() {
+    lock.lock();
+    try {
+      abort = true;
+      condition.signalAll();
+    } finally {
+      lock.unlock();
+    }
+  }
+
   /** Wait for signalUpdateReceived to signal condition */
   void await() throws InterruptedException {
     lock.lock();

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

@@ -0,0 +1,55 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJavaSpec.js
+ *
+ * @nolint
+ */
+
+package com.facebook.fbreact.specs;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import javax.annotation.Nonnull;
+
+public abstract class NativeRNFBTurboDatabaseOnDisconnectSpec extends ReactContextBaseJavaModule implements TurboModule {
+  public static final String NAME = "NativeRNFBTurboDatabaseOnDisconnect";
+
+  public NativeRNFBTurboDatabaseOnDisconnectSpec(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public @Nonnull String getName() {
+    return NAME;
+  }
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void onDisconnectCancel(String app, String dbURL, String path, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void onDisconnectRemove(String app, String dbURL, String path, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void onDisconnectSet(String app, String dbURL, String path, ReadableMap props, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void onDisconnectSetWithPriority(String app, String dbURL, String path, ReadableMap props, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void onDisconnectUpdate(String app, String dbURL, String path, ReadableMap props, Promise promise);
+}