Add support for transaction rollbacks

core/src/jsMain/kotlin/Database.kt

@@ -83,6 +83,7 @@ public class Database internal constructor(
             ensureDatabase().transaction(arrayOf(*store), "readonly", transactionOptions(durability)),
         )
         val result = transaction.action()
+        transaction.commit()
         transaction.awaitCompletion()
         result
     }
@@ -107,9 +108,16 @@ public class Database internal constructor(
                 .openKeyCursor(autoContinue = false)
                 .collect { it.close() }
         }
-        val result = transaction.action()
-        transaction.awaitCompletion()
-        result
+        try {
+            val result = transaction.action()
+            transaction.commit()
+            transaction.awaitCompletion()
+            result
+        } catch (e: Throwable) {
+            transaction.abort()
+            transaction.awaitFailure()
+            throw e
+        }
     }
 
     public fun close() {

core/src/jsMain/kotlin/Transaction.kt

@@ -8,6 +8,7 @@ import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.callbackFlow
 import org.w3c.dom.events.Event
+import kotlin.js.Json
 
 public open class Transaction internal constructor(
     internal val transaction: IDBTransaction,
@@ -23,6 +24,26 @@ public open class Transaction internal constructor(
         }
     }
 
+    internal suspend fun awaitFailure() {
+        transaction.onNextEvent("complete", "abort", "error") { event ->
+            when (event.type) {
+                "abort" -> Unit
+                "error" -> Unit
+                else -> Unit
+            }
+        }
+    }
+    internal fun abort() {
+        transaction.abort()
+    }
+
+    internal fun commit() {
+        // Check if function exists before calling it.
+        if (jsTypeOf(transaction.asDynamic().commit) === "function") {
+            transaction.commit()
+        }
+    }
+
     public fun objectStore(name: String): ObjectStore =
         ObjectStore(transaction.objectStore(name))
 
@@ -132,6 +153,7 @@ public open class Transaction internal constructor(
     ): Flow<T> = callbackFlow {
         var cursorStartAction = cursorStart
         val request = open(query, direction).request
+        var finished = false
         val onSuccess: (Event) -> Unit = { event ->
             @Suppress("UNCHECKED_CAST")
             val cursor = (event.target as IDBRequest<U?>).result
@@ -141,7 +163,7 @@ public open class Transaction internal constructor(
             } else if (cursor != null) {
                 val result = trySend(wrap(cursor, channel))
                 when {
-                    result.isSuccess -> if (autoContinue) cursor.`continue`()
+                    result.isSuccess -> if (autoContinue && !finished) cursor.`continue`()
                     result.isFailure -> channel.close(IllegalStateException("Send failed. Did you suspend illegally?"))
                     result.isClosed -> channel.close()
                 }
@@ -153,6 +175,7 @@ public open class Transaction internal constructor(
         request.addEventListener("success", onSuccess)
         request.addEventListener("error", onError)
         awaitClose {
+            finished = true
             request.removeEventListener("success", onSuccess)
             request.removeEventListener("error", onError)
         }

core/src/jsTest/kotlin/TransactionTest.kt

@@ -0,0 +1,68 @@
+package com.juul.indexeddb
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+
+class TransactionTest {
+    @Test
+    fun readWithinTransaction() = runTest {
+        val database = openDatabase("read-within-transaction", 1) { database, oldVersion, newVersion ->
+            if (oldVersion < 1) {
+                database.createObjectStore("users", KeyPath("id"))
+            }
+        }
+        onCleanup {
+            database.close()
+            deleteDatabase("read-within-transaction")
+        }
+
+        val user = database.writeTransaction("users") {
+            objectStore("users").add(
+                jso {
+                    id = "7740f7c4-f889-498a-bc6d-f88dabdcfb9a"
+                    username = "Username"
+                },
+            )
+            objectStore("users")
+                .get(Key("7740f7c4-f889-498a-bc6d-f88dabdcfb9a"))
+        }
+
+        assertEquals("Username", user.username)
+    }
+
+    @Test
+    fun whenExceptionIsThrowWithinTransaction_transactionIsAborted() = runTest {
+        val database = openDatabase("abort-transaction", 1) { database, oldVersion, newVersion ->
+            if (oldVersion < 1) {
+                database.createObjectStore("users", KeyPath("id"))
+            }
+        }
+        onCleanup {
+            database.close()
+            deleteDatabase("abort-transaction")
+        }
+
+        assertFailsWith<ExceptionToAbortTransaction> {
+            database.writeTransaction("users") {
+                objectStore("users").add(
+                    jso {
+                        id = "7740f7c4-f889-498a-bc6d-f88dabdcfb9a"
+                        username = "Username"
+                    },
+                )
+
+                // Abort transaction
+                throw ExceptionToAbortTransaction()
+            }
+        }
+
+        // because transaction is aborted, new values shouldn't be stored
+        val users = database.transaction("users") {
+            objectStore("users").getAll().toList()
+        }
+
+        assertEquals(listOf(), users)
+    }
+}
+private class ExceptionToAbortTransaction : Exception()