fixing error handling

Author: wojta

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

@@ -33,11 +33,11 @@ class SQLite3Driver internal constructor(private val db: Sqlite3.Database) : Sql
             if (enclosingTransaction == null) {
                 val sql = if (successful) "END TRANSACTION" else "ROLLBACK TRANSACTION"
                 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(SQLite3JsException(it))
                         }
                     }
                     db.exec(sql, callback)
@@ -60,9 +60,6 @@ class SQLite3Driver internal constructor(private val db: Sqlite3.Database) : Sql
                 val res2 = db.prepare(sql)
                 return@getOrPut res2
             }
-//                .apply {
-//                reset()
-//            }
         }
         return res
     }
@@ -75,7 +72,7 @@ class SQLite3Driver internal constructor(private val db: Sqlite3.Database) : Sql
             val rows = suspendCoroutine { cont ->
                 statement.all { error, rows ->
                     if (error is Throwable) {
-                        cont.resumeWithException(error)
+                        cont.resumeWithException(SQLite3JsException(error))
                     } else {
                         cont.resume(rows)
                     }
@@ -88,19 +85,24 @@ class SQLite3Driver internal constructor(private val db: Sqlite3.Database) : Sql
         }
 
     override fun execute(identifier: Int?, sql: String, parameters: Int, binders: (SqlPreparedStatement.() -> Unit)?): QueryResult<Long> = QueryResult.AsyncValue {
-        val statement = createOrGetStatement(identifier, sql)
-        statement.bind(parameters, binders)
-        suspendCoroutine { cont ->
-            val callback: (Any) -> Unit = { self ->
-                if (self is Throwable) {
-                    cont.resumeWithException(SQLite3Exception(self))
-                } else {
-                    cont.resume(Unit)
+        try {
+            val statement = createOrGetStatement(identifier, sql)
+            statement.bind(parameters, binders)
+            suspendCoroutine { cont ->
+                val callback: (Any) -> Unit = {
+                    if (it is Throwable) {
+                        cont.resumeWithException(SQLite3JsException(it))
+                    } else {
+                        cont.resume(Unit)
+                    }
                 }
+                statement.run(callback)
             }
-            statement.run(callback)
+            return@AsyncValue 0
+        } catch (e: Throwable) {
+            println("exception $e")
+            return@AsyncValue 0
         }
-        return@AsyncValue 0
     }
 
     override fun newTransaction(): QueryResult<Transacter.Transaction> = QueryResult.AsyncValue {
@@ -113,7 +115,7 @@ class SQLite3Driver internal constructor(private val db: Sqlite3.Database) : Sql
                     if (it == null || it !is Throwable) {
                         cont.resume(it)
                     } else {
-                        cont.resumeWithException(SQLite3Exception(it))
+                        cont.resumeWithException(SQLite3JsException(it))
                     }
                 }
                 db.exec("BEGIN TRANSACTION", callback)
@@ -159,16 +161,22 @@ class SQLite3Driver internal constructor(private val db: Sqlite3.Database) : Sql
         if (parameters > 0) {
             val bound = SQLite3PreparedStatement(parameters)
             binders(bound)
+            println("binders")
             suspendCoroutine { cont ->
                 val callback: (Any?) -> Unit = {
                     if (it == null || it !is Throwable) {
+                        println("bind resume")
                         cont.resume(it)
                     } else {
-                        cont.resumeWithException(it)
+                        println("bind resume exception")
+                        cont.resumeWithException(SQLite3JsException(it))
                     }
                 }
-                bind(bound.parameters.toTypedArray(), callback)
+                println("bind")
+                bind(bound.parameters.toTypedArray(), callback = callback)
+                println("bind end")
             }
+            println("bind after susp")
         }
     }
 }

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

@@ -1,3 +1,20 @@
 package cz.sazel.sqldelight.node.sqlite3
 
-class SQLite3Exception(val error: Any?) : Exception()
+
+/**
+ * Exception of [SQLite3Driver].
+ * Usually this class is directly returned in case of error within driver itself.
+ */
+open class SQLite3Exception(message: String) : Exception(message)
+
+/**
+ * Exception that occurs from within SQLite 3 Node.js module.
+ */
+class SQLite3JsException(private val err: Throwable?) : SQLite3Exception(err.nullable?.message ?: "unknown error") {
+    /**
+     * SQLite error number
+     */
+    val errorNumber: Int
+        get() = err?.asDynamic().errno as? Int ?: -1
+}
+

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

@@ -24,3 +24,11 @@ suspend fun <T : Any> Query<T>.executeSuspendingAsList(): List<T> {
         return (query as QueryResult.AsyncValue<List<T>>).await()
     } else throw IllegalArgumentException("Can be used only with async SQLite3 driver")
 }
+
+
+internal val <T> T?.nullable: T?
+    get() = when (this) {
+        null -> null
+        undefined -> null
+        else -> this
+    }

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

@@ -257,10 +257,10 @@ class SQLite3DriverTest {
     @Test
     fun test_transaction_rollback() = runTest { driver ->
         val insert: InsertFunction = { binders: SqlPreparedStatement.() -> Unit ->
-            driver.await(13, "INSERT INTO nonexisting_test VALUES (?, ?);", 2, binders)
+            driver.await(13, "INSERT INTO nonexisting_table VALUES (?, ?);", 2, binders)
         }
 
-        driver.newTransaction().await()
+//        driver.newTransaction().await()
         val success = try {
             insert {
                 bindLong(0, 3)
@@ -274,28 +274,16 @@ class SQLite3DriverTest {
         try {
             assertFalse(success)
         } finally {
-            (driver as SQLite3Driver)._endTransactionForTests(success)
+//            (driver as SQLite3Driver)._endTransactionForTests(success)
         }
     }
 
     @Test
-    fun worker_exceptions_are_handled_correctly() = runTest { driver ->
-        println("IS_LEGACY: $IS_LEGACY")
-        // Despite the exception being thrown correctly in LEGACY builds, this test fails for some reason
-        if (IS_LEGACY) return@runTest
-
-        val error = assertFailsWith<Exception> { //TODO change exception
+    fun exceptions_are_handled_correctly() = runTest { driver ->
+        val error = assertFailsWith<SQLite3JsException> {
             schema.awaitCreate(driver)
         }
         assertContains(error.toString(), "table test already exists")
-    }
-
-    // TODO: Remove this once LEGACY builds are dropped
-    companion object {
-        private data class Obj(val entry: String)
-
-        private val prototype = js("Object").getPrototypeOf(Obj("test"))
-        private val prototypeProps: Array<String> = js("Object").getOwnPropertyNames(prototype).unsafeCast<Array<String>>()
-        private val IS_LEGACY = prototypeProps.firstOrNull { it.contains("_get_") } == null
+        assertEquals(error.errorNumber, 1)
     }
 }