transaction processing fixed

As there was probably improper handling of the callback type. Also exec() is now used instead run().

Author: wojta

src/jsMain/kotlin/cz/sazel/sqldelight/node/sqlite3/SQLite3Driver.kt

@@ -24,27 +24,32 @@ internal suspend fun SQLite3Driver.withSchema(schema: SqlSchema? = null) = this.
 class SQLite3Driver internal constructor(private val db: Sqlite3.Database) : SqlDriver {
     private val listeners = mutableMapOf<String, MutableSet<Query.Listener>>()
     private val statements = mutableMapOf<Int, Sqlite3.Statement>()
-    private var transaction: Transacter.Transaction? = null
+    private var transaction: Transaction? = null
 
-    private inner class Transaction(
+    internal inner class Transaction(
         override val enclosingTransaction: Transacter.Transaction?,
     ) : Transacter.Transaction() {
         override fun endTransaction(successful: Boolean): QueryResult<Unit> = QueryResult.AsyncValue {
             if (enclosingTransaction == null) {
                 val sql = if (successful) "END TRANSACTION" else "ROLLBACK TRANSACTION"
                 suspendCoroutine { cont ->
-                    val callback: (Any) -> Unit = { self ->
+                    val callback: (Any?) -> Unit = { self ->
                         if (self !is Throwable) {
                             cont.resume(self as Sqlite3.Statement)
                         } else {
                             cont.resumeWithException(SQLite3Exception(self))
                         }
                     }
-                    db.run(sql, callback)
+                    db.exec(sql, callback)
                 }
             }
-            transaction = enclosingTransaction
+            transaction = this
         }
+
+        /**
+         * Use for tests only.
+         */
+        internal fun _endTransactionForTests(successful: Boolean) = endTransaction(successful)
     }
 
     private fun createOrGetStatement(identifier: Int?, sql: String): Sqlite3.Statement {
@@ -104,14 +109,14 @@ class SQLite3Driver internal constructor(private val db: Sqlite3.Database) : Sql
         this.transaction = transaction
         if (enclosing == null) {
             suspendCoroutine { cont ->
-                val callback: (Any) -> Unit = { self ->
-                    if (self !is Throwable) {
-                        cont.resume(self as Sqlite3.Statement)
+                val callback: (Any?) -> Unit = {
+                    if (it == null || it !is Throwable) {
+                        cont.resume(it)
                     } else {
-                        cont.resumeWithException(SQLite3Exception(self))
+                        cont.resumeWithException(SQLite3Exception(it))
                     }
                 }
-                db.run("BEGIN TRANSACTION", callback)
+                db.exec("BEGIN TRANSACTION", callback)
             }
         }
 
@@ -120,6 +125,9 @@ class SQLite3Driver internal constructor(private val db: Sqlite3.Database) : Sql
 
     override fun currentTransaction(): Transacter.Transaction? = transaction
 
+    internal fun _endTransactionForTests(successful: Boolean) = transaction?._endTransactionForTests(successful)
+
+
     override fun addListener(listener: Query.Listener, queryKeys: Array<String>) {
         queryKeys.forEach {
             listeners.getOrPut(it) { mutableSetOf() }.add(listener)
@@ -153,10 +161,11 @@ class SQLite3Driver internal constructor(private val db: Sqlite3.Database) : Sql
             binders(bound)
             suspendCoroutine { cont ->
                 val callback: (Any?) -> Unit = {
-                    if (it is Throwable)
-                        cont.resumeWithException(it)
-                    else
+                    if (it == null || it !is Throwable) {
                         cont.resume(it)
+                    } else {
+                        cont.resumeWithException(it)
+                    }
                 }
                 bind(bound.parameters.toTypedArray(), callback)
             }

src/jsMain/kotlin/node/sqlite3/sqlite3.module_sqlite3.kt

@@ -159,10 +159,10 @@ external object Sqlite3 {
         constructor(filename: String, mode: Number = definedExternally)
 
         open fun close(callback: (err: Error?) -> Unit = definedExternally)
-        open fun run(sql: String, callback: (self: Any?) -> Unit): Database /* this */
+        open fun run(sql: String, callback: (self: Any?) -> Unit = definedExternally): Database /* this */
 
-        //        open fun run(sql: String): Database /* this */
-        open fun run(sql: String, params: Any, callback: (self: Any?) -> Unit = definedExternally): Database /* this */
+        open fun run(sql: String): Database
+        open fun run(sql: String, params: Any?, callback: (self: Any?) -> Unit = definedExternally): Database /* this */
 
         //        open fun run(sql: String, params: Any): Database /* this */
         open fun get(sql: String, callback: (self: Statement, err: Error?, row: Any) -> Unit = definedExternally): Database /* this */
@@ -190,7 +190,7 @@ external object Sqlite3 {
 
         open fun each(sql: String, params: Any): Database /* this */
         open fun each(sql: String, params: Any, callback: (self: Statement, err: Error?, row: Any) -> Unit = definedExternally): Database /* this */
-        open fun exec(sql: String, callback: (self: Statement, err: Error?) -> Unit = definedExternally): Database /* this */
+        open fun exec(sql: String, callback: (self: Any?) -> Unit = definedExternally): Database /* this */
 
         //open fun prepare(sql: String, callback: (self: Statement, err: Error?) -> Unit = definedExternally): Statement
         open fun prepare(sql: String, callback: (self: Any) -> Unit): Statement

src/jsTest/kotlin/cz/sazel/sqldelight/node/sqlite3/SQLite3DriverTest.kt

@@ -230,6 +230,54 @@ class SQLite3DriverTest {
         driver.awaitQuery(8, "SELECT * FROM nullability_test", mapper, 0)
     }
 
+    @Test
+    fun test_transaction_commit() = runTest { driver ->
+        val insert: InsertFunction = { binders: SqlPreparedStatement.() -> Unit ->
+            driver.await(12, "INSERT INTO test VALUES (?, ?);", 2, binders)
+        }
+
+        driver.newTransaction().await()
+        val success = try {
+            insert {
+                bindLong(0, 3)
+                bindString(1, "Hello")
+            }
+            true
+        } catch (e: SQLite3Exception) {
+            false
+        }
+
+        try {
+            assertTrue(success)
+        } finally {
+            (driver as SQLite3Driver)._endTransactionForTests(success)
+        }
+    }
+
+    @Test
+    fun test_transaction_rollback() = runTest { driver ->
+        val insert: InsertFunction = { binders: SqlPreparedStatement.() -> Unit ->
+            driver.await(13, "INSERT INTO nonexisting_test VALUES (?, ?);", 2, binders)
+        }
+
+        driver.newTransaction().await()
+        val success = try {
+            insert {
+                bindLong(0, 3)
+                bindString(1, "Hello")
+            }
+            true
+        } catch (e: SQLite3Exception) {
+            false
+        }
+
+        try {
+            assertFalse(success)
+        } finally {
+            (driver as SQLite3Driver)._endTransactionForTests(success)
+        }
+    }
+
     @Test
     fun worker_exceptions_are_handled_correctly() = runTest { driver ->
         println("IS_LEGACY: $IS_LEGACY")