Database transactions

firebase-app/src/androidMain/kotlin/dev/gitlive/firebase/firebase.kt

@@ -34,6 +34,8 @@ actual class FirebaseApp internal constructor(val android: com.google.firebase.F
         get() = android.name
     actual val options: FirebaseOptions
         get() = android.options.run { FirebaseOptions(applicationId, apiKey, databaseUrl, gaTrackingId, storageBucket, projectId) }
+
+    actual fun delete() = android.delete()
 }
 
 actual fun Firebase.apps(context: Any?) = com.google.firebase.FirebaseApp.getApps(context as Context)

firebase-app/src/commonMain/kotlin/dev/gitlive/firebase/firebase.kt

@@ -19,6 +19,7 @@ object Firebase
 expect class FirebaseApp {
     val name: String
     val options: FirebaseOptions
+    fun delete()
 }
 
 /** Returns the default firebase app instance. */

firebase-app/src/iosMain/kotlin/dev/gitlive/firebase/firebase.kt

@@ -5,6 +5,7 @@
 package dev.gitlive.firebase
 
 import cocoapods.FirebaseCore.*
+import kotlinx.coroutines.CompletableDeferred
 
 actual open class FirebaseException(message: String) : Exception(message)
 actual open class FirebaseNetworkException(message: String) : FirebaseException(message)
@@ -31,6 +32,8 @@ actual class FirebaseApp internal constructor(val ios: FIRApp) {
         get() = ios.name
     actual val options: FirebaseOptions
         get() = ios.options.run { FirebaseOptions(bundleID, APIKey!!, databaseURL!!, trackingID, storageBucket, projectID) }
+
+    actual fun delete() { }
 }
 
 actual fun Firebase.apps(context: Any?) = FIRApp.allApps()

firebase-app/src/jsMain/kotlin/dev/gitlive/firebase/firebase.kt

@@ -28,6 +28,8 @@ actual class FirebaseApp internal constructor(val js: firebase.App) {
         get() = js.options.run {
             FirebaseOptions(applicationId, apiKey, databaseUrl, gaTrackingId, storageBucket, projectId, messagingSenderId, authDomain)
         }
+
+    actual fun delete() = js.delete()
 }
 
 actual fun Firebase.apps(context: Any?) = firebase.apps.map { FirebaseApp(it) }

firebase-common/src/jsMain/kotlin/dev/gitlive/firebase/externals.kt

@@ -15,6 +15,7 @@ external object firebase {
     open class App {
         val name: String
         val options: Options
+        fun delete()
         fun functions(region: String? = definedExternally): functions.Functions
         fun database(url: String? = definedExternally): database.Database
         fun firestore(): firestore.Firestore
@@ -320,6 +321,11 @@ external object firebase {
             fun update(value: Any?): Promise<Unit>
             fun set(value: Any?): Promise<Unit>
             fun push(): ThenableReference
+            fun <T> transaction(
+                transactionUpdate: (currentData: T) -> T,
+                onComplete: (error: Error?, committed: Boolean, snapshot: DataSnapshot?) -> Unit,
+                applyLocally: Boolean?
+            ): Promise<T>
         }
 
         open class DataSnapshot {

firebase-database/build.gradle.kts

@@ -23,17 +23,11 @@ android {
     defaultConfig {
         minSdk = property("minSdkVersion") as Int
         targetSdk = property("targetSdkVersion") as Int
-        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
-        multiDexEnabled = true
     }
     sourceSets {
         getByName("main") {
             manifest.srcFile("src/androidMain/AndroidManifest.xml")
         }
-        getByName("androidTest"){
-            java.srcDir(file("src/androidAndroidTest/kotlin"))
-            manifest.srcFile("src/androidAndroidTest/AndroidManifest.xml")
-        }
     }
     testOptions {
         unitTests.apply {
@@ -135,9 +129,9 @@ kotlin {
                 apiVersion = "1.6"
                 languageVersion = "1.6"
                 progressiveMode = true
-                optIn("kotlinx.coroutines.ExperimentalCoroutinesApi")
-                optIn("kotlinx.coroutines.FlowPreview")
-                optIn("kotlinx.serialization.InternalSerializationApi")
+//                optIn("kotlinx.coroutines.ExperimentalCoroutinesApi")
+//                optIn("kotlinx.coroutines.FlowPreview")
+//                optIn("kotlinx.serialization.InternalSerializationApi")
             }
         }
 

firebase-database/src/androidMain/kotlin/dev/gitlive/firebase/database/database.kt

@@ -5,10 +5,8 @@
 package dev.gitlive.firebase.database
 
 import com.google.android.gms.tasks.Task
-import com.google.firebase.database.ChildEventListener
-import com.google.firebase.database.Logger
+import com.google.firebase.database.*
 import com.google.firebase.database.ServerValue
-import com.google.firebase.database.ValueEventListener
 import dev.gitlive.firebase.Firebase
 import dev.gitlive.firebase.FirebaseApp
 import dev.gitlive.firebase.database.ChildEvent.Type
@@ -22,7 +20,9 @@ import kotlinx.coroutines.flow.produceIn
 import kotlinx.coroutines.selects.select
 import kotlinx.coroutines.tasks.asDeferred
 import kotlinx.coroutines.tasks.await
+import kotlinx.coroutines.CompletableDeferred
 import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.KSerializer
 import kotlinx.serialization.SerializationStrategy
 
 @PublishedApi
@@ -189,8 +189,34 @@ actual class DatabaseReference internal constructor(
     actual suspend fun removeValue() = android.removeValue()
         .run { if(persistenceEnabled) await() else awaitWhileOnline() }
         .run { Unit }
-}
 
+    actual suspend fun <T> runTransaction(strategy: KSerializer<T>, transactionUpdate: (currentData: T) -> T): DataSnapshot {
+        val deferred = CompletableDeferred<DataSnapshot>()
+        android.runTransaction(object : Transaction.Handler {
+
+            override fun doTransaction(currentData: MutableData): Transaction.Result {
+                currentData.value = currentData.value?.let {
+                    transactionUpdate(decode(strategy, it))
+                }
+                return Transaction.success(currentData)
+            }
+
+            override fun onComplete(
+                error: DatabaseError?,
+                committed: Boolean,
+                snapshot: com.google.firebase.database.DataSnapshot?
+            ) {
+                if (error != null) {
+                    deferred.completeExceptionally(error.toException())
+                } else {
+                    deferred.complete(DataSnapshot(snapshot!!))
+                }
+            }
+
+        })
+        return deferred.await()
+    }
+}
 @Suppress("UNCHECKED_CAST")
 actual class DataSnapshot internal constructor(val android: com.google.firebase.database.DataSnapshot) {
 

firebase-database/src/commonMain/kotlin/dev/gitlive/firebase/database/database.kt

@@ -9,6 +9,7 @@ import dev.gitlive.firebase.FirebaseApp
 import dev.gitlive.firebase.database.ChildEvent.Type.*
 import kotlinx.coroutines.flow.Flow
 import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.KSerializer
 import kotlinx.serialization.SerializationStrategy
 
 /** Returns the [FirebaseDatabase] instance of the default [FirebaseApp]. */
@@ -72,6 +73,8 @@ expect class DatabaseReference : Query {
     suspend fun <T> setValue(strategy: SerializationStrategy<T>, value: T, encodeDefaults: Boolean = true)
     suspend fun updateChildren(update: Map<String, Any?>, encodeDefaults: Boolean = true)
     suspend fun removeValue()
+
+    suspend fun <T> runTransaction(strategy: KSerializer<T>, transactionUpdate: (currentData: T) -> T): DataSnapshot
 }
 
 expect class DataSnapshot {

firebase-database/src/commonTest/kotlin/dev.gitlive.firebase.database/database.kt → firebase-database/src/commonTest/kotlin/dev/gitlive/firebase/database/database.kt

@@ -1,7 +1,3 @@
-/*
- * Copyright (c) 2020 GitLive Ltd.  Use of this source code is governed by the Apache 2.0 license.
- */
-
 package dev.gitlive.firebase.database
 
 import dev.gitlive.firebase.*
@@ -18,6 +14,9 @@ class FirebaseDatabaseTest {
     @Serializable
     data class FirebaseDatabaseChildTest(val prop1: String? = null, val time: Double = 0.0)
 
+    @Serializable
+    data class DatabaseTest(val title: String, val likes: Int = 0)
+
     @BeforeTest
     fun initializeFirebase() {
         Firebase
@@ -28,7 +27,7 @@ class FirebaseDatabaseTest {
                     FirebaseOptions(
                         applicationId = "1:846484016111:ios:dd1f6688bad7af768c841a",
                         apiKey = "AIzaSyCK87dcMFhzCz_kJVs2cT2AVlqOTLuyWV0",
-                        databaseUrl = "https://fir-kotlin-sdk.firebaseio.com",
+                        databaseUrl = "http://fir-kotlin-sdk.firebaseio.com",
                         storageBucket = "fir-kotlin-sdk.appspot.com",
                         projectId = "fir-kotlin-sdk",
                         gcmSenderId = "846484016111"
@@ -52,7 +51,7 @@ class FirebaseDatabaseTest {
 
         assertEquals(testValue, testReferenceValue)
     }
-    
+
     @Test
     fun testChildCount() = runTest {
         setupRealtimeData()
@@ -65,6 +64,52 @@ class FirebaseDatabaseTest {
         assertEquals(3, firebaseDatabaseChildCount)
     }
 
+    @Test
+    fun testBasicIncrementTransaction() = runTest {
+        val data = DatabaseTest("PostOne", 2)
+        val userRef = Firebase.database.reference("users/user_1/post_id_1")
+        setupDatabase(userRef, data, DatabaseTest.serializer())
+
+        // Check database before transaction
+        val userDocBefore = userRef.valueEvents.first().value(DatabaseTest.serializer())
+        assertEquals(data.title, userDocBefore.title)
+        assertEquals(data.likes, userDocBefore.likes)
+
+        // Run transaction
+        val transactionSnapshot = userRef.runTransaction(DatabaseTest.serializer()) { DatabaseTest(data.title, it.likes + 1) }
+        val userDocAfter = transactionSnapshot.value(DatabaseTest.serializer())
+
+        // Check the database after transaction
+        assertEquals(data.title, userDocAfter.title)
+        assertEquals(data.likes + 1, userDocAfter.likes)
+
+        // cleanUp Firebase
+        cleanUp()
+    }
+
+    @Test
+    fun testBasicDecrementTransaction() = runTest {
+        val data = DatabaseTest("PostTwo", 2)
+        val userRef = Firebase.database.reference("users/user_1/post_id_2")
+        setupDatabase(userRef, data, DatabaseTest.serializer())
+
+        // Check database before transaction
+        val userDocBefore = userRef.valueEvents.first().value(DatabaseTest.serializer())
+        assertEquals(data.title, userDocBefore.title)
+        assertEquals(data.likes, userDocBefore.likes)
+
+        // Run transaction
+        val transactionSnapshot = userRef.runTransaction(DatabaseTest.serializer()) { DatabaseTest(data.title, it.likes - 1) }
+        val userDocAfter = transactionSnapshot.value(DatabaseTest.serializer())
+
+        // Check the database after transaction
+        assertEquals(data.title, userDocAfter.title)
+        assertEquals(data.likes - 1, userDocAfter.likes)
+
+        // cleanUp Firebase
+        cleanUp()
+    }
+
     private suspend fun setupRealtimeData() {
         val firebaseDatabaseTestReference = Firebase.database
             .reference("FirebaseRealtimeDatabaseTest")
@@ -77,4 +122,19 @@ class FirebaseDatabaseTest {
         firebaseDatabaseTestReference.child("2").setValue(firebaseDatabaseChildTest2)
         firebaseDatabaseTestReference.child("3").setValue(firebaseDatabaseChildTest3)
     }
+
+    private fun cleanUp() {
+        Firebase
+            .takeIf { Firebase.apps(context).isNotEmpty() }
+            ?.apply { app.delete() }
+    }
+
+    private suspend fun <T> setupDatabase(ref: DatabaseReference, data: T, strategy: SerializationStrategy<T>) {
+        try {
+            ref.setValue(strategy, data)
+        } catch (err: DatabaseException) {
+            println(err)
+        }
+    }
+
 }

firebase-database/src/iosMain/kotlin/dev/gitlive/firebase/database/database.kt

@@ -13,14 +13,14 @@ import dev.gitlive.firebase.database.ChildEvent.Type.*
 import dev.gitlive.firebase.decode
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.FlowPreview
-import kotlinx.coroutines.channels.ClosedSendChannelException
 import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.flow.callbackFlow
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.produceIn
 import kotlinx.coroutines.selects.select
 import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.KSerializer
 import kotlinx.serialization.SerializationStrategy
 import platform.Foundation.*
 import kotlin.collections.component1
@@ -158,6 +158,27 @@ actual class DatabaseReference internal constructor(
     actual suspend fun removeValue() {
         ios.await(persistenceEnabled) { removeValueWithCompletionBlock(it) }
     }
+
+    actual suspend fun <T> runTransaction(strategy: KSerializer<T>, transactionUpdate: (currentData: T) -> T): DataSnapshot {
+        val deferred = CompletableDeferred<DataSnapshot>()
+        ios.runTransactionBlock(
+            block = { firMutableData ->
+                firMutableData?.value = firMutableData?.value?.let {
+                    transactionUpdate(decode(strategy, firMutableData.value))
+                }
+                FIRTransactionResult.successWithValue(firMutableData!!)
+            },
+            andCompletionBlock = { error, _, snapshot ->
+                if (error != null) {
+                    deferred.completeExceptionally(DatabaseException(error.toString(), null))
+                } else {
+                    deferred.complete(DataSnapshot(snapshot!!))
+                }
+            },
+            withLocalEvents = false
+        )
+        return deferred.await()
+    }
 }
 
 @Suppress("UNCHECKED_CAST")

firebase-database/src/jsMain/kotlin/dev/gitlive/firebase/database/database.kt

@@ -12,6 +12,7 @@ import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.produceIn
 import kotlinx.coroutines.selects.select
 import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.KSerializer
 import kotlinx.serialization.SerializationStrategy
 import kotlin.js.Promise
 
@@ -128,6 +129,23 @@ actual class DatabaseReference internal constructor(override val js: firebase.da
 
     actual suspend fun <T> setValue(strategy: SerializationStrategy<T>, value: T, encodeDefaults: Boolean) =
         rethrow { js.set(encode(strategy, value, encodeDefaults)).awaitWhileOnline() }
+
+    actual suspend fun <T> runTransaction(strategy: KSerializer<T>, transactionUpdate: (currentData: T) -> T): DataSnapshot {
+        val deferred = CompletableDeferred<DataSnapshot>()
+        js.transaction(
+            transactionUpdate,
+            { error, _, snapshot ->
+                if (error != null) {
+                    deferred.completeExceptionally(error)
+                } else {
+                    deferred.complete(DataSnapshot(snapshot!!))
+                }
+            },
+            applyLocally = false
+        )
+        return deferred.await()
+    }
+
 }
 
 actual class DataSnapshot internal constructor(val js: firebase.database.DataSnapshot) {
@@ -186,7 +204,9 @@ suspend fun <T> Promise<T>.awaitWhileOnline(): T = coroutineScope {
     val notConnected = Firebase.database
         .reference(".info/connected")
         .valueEvents
-        .filter { !it.value<Boolean>() }
+        .filter {
+            !it.value<Boolean>()
+        }
         .produceIn(this)
 
     select<T> {

firebase-database/src/jsTest/kotlin/dev/gitlive/firebase/database/database.kt

@@ -0,0 +1,26 @@
+package dev.gitlive.firebase.database
+
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.promise
+
+actual val emulatorHost: String = "localhost"
+
+actual val context: Any = Unit
+
+actual fun runTest(test: suspend () -> Unit) = GlobalScope
+    .promise {
+        try {
+            test()
+        } catch (e: Throwable) {
+            e.log()
+            throw e
+        }
+    }.asDynamic()
+
+internal fun Throwable.log() {
+    console.error(this)
+    cause?.let {
+        console.error("Caused by:")
+        it.log()
+    }
+}