Fix Swift tests

Author: simolus3

core/src/appleMain/kotlin/com/powersync/DatabaseDriverFactory.apple.kt

@@ -1,6 +1,7 @@
 package com.powersync
 
 import kotlinx.cinterop.UnsafeNumber
+import kotlinx.io.files.FileSystem
 import platform.Foundation.NSApplicationSupportDirectory
 import platform.Foundation.NSBundle
 import platform.Foundation.NSFileManager
@@ -10,7 +11,7 @@ import kotlin.getValue
 
 @OptIn(UnsafeNumber::class)
 internal fun appleDefaultDatabasePath(dbFilename: String): String {
-// This needs to be compatible with https://github.com/touchlab/SQLiter/blob/a37bbe7e9c65e6a5a94c5bfcaccdaae55ad2bac9/sqliter-driver/src/appleMain/kotlin/co/touchlab/sqliter/DatabaseFileContext.kt#L36-L51
+    // This needs to be compatible with https://github.com/touchlab/SQLiter/blob/a37bbe7e9c65e6a5a94c5bfcaccdaae55ad2bac9/sqliter-driver/src/appleMain/kotlin/co/touchlab/sqliter/DatabaseFileContext.kt#L36-L51
     val paths = NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, true)
     val documentsDirectory = paths[0] as String
 
@@ -22,7 +23,7 @@ internal fun appleDefaultDatabasePath(dbFilename: String): String {
         fileManager.createDirectoryAtPath(databaseDirectory, true, null, null)
     }; // Create folder
 
-    return databaseDirectory
+    return "$databaseDirectory/$dbFilename"
 }
 
 internal val powerSyncExtensionPath: String by lazy {

core/src/appleNonWatchOsMain/kotlin/com/powersync/DatabaseDriverFactory.appleNonWatchOs.kt

@@ -2,7 +2,6 @@ package com.powersync
 
 import androidx.sqlite.SQLiteConnection
 import com.powersync.sqlite.Database
-import com.powersync.sqlite.SqliteException
 
 @Suppress(names = ["EXPECT_ACTUAL_CLASSIFIERS_ARE_IN_BETA_WARNING"])
 public actual class DatabaseDriverFactory {
@@ -15,7 +14,7 @@ public actual class DatabaseDriverFactory {
         val db = Database.open(path, openFlags)
         try {
             db.loadExtension(powerSyncExtensionPath, "sqlite3_powersync_init")
-        } catch (e: SqliteException) {
+        } catch (e: PowerSyncException) {
             db.close()
             throw e
         }

core/src/appleTest/kotlin/com/powersync/sqlite/DatabaseTest.kt

@@ -2,6 +2,7 @@ package com.powersync.sqlite
 
 import androidx.sqlite.SQLiteConnection
 import androidx.sqlite.execSQL
+import com.powersync.PowerSyncException
 import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.matchers.shouldBe
 import kotlin.test.Test
@@ -22,9 +23,9 @@ class DatabaseTest {
     @Test
     fun syntaxError() =
         inMemoryDatabase().use {
-            val exception = shouldThrow<SqliteException> { it.execSQL("bad syntax") }
+            val exception = shouldThrow<PowerSyncException> { it.execSQL("bad syntax") }
 
-            exception.toString() shouldBe "SqliteException(1): SQL logic error at offset 0, near \"bad\": syntax error for SQL: bad syntax"
+            exception.message shouldBe "SqliteException(1): SQL logic error at offset 0, near \"bad\": syntax error for SQL: bad syntax"
             Unit
         }
 

core/src/appleTest/kotlin/com/powersync/sqlite/StatementTest.kt

@@ -1,6 +1,7 @@
 package com.powersync.sqlite
 
 import androidx.sqlite.SQLiteConnection
+import com.powersync.PowerSyncException
 import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.matchers.shouldBe
 import kotlin.test.Test
@@ -28,16 +29,16 @@ class StatementTest {
     fun testBindOutOfBounds() =
         inMemoryDatabase().use { db ->
             db.prepare("SELECT ?").use { stmt ->
-                shouldThrow<SqliteException> {
+                shouldThrow<PowerSyncException> {
                     stmt.bindText(-1, "foo")
                 }
-                shouldThrow<SqliteException> {
+                shouldThrow<PowerSyncException> {
                     stmt.bindText(0, "foo")
                 }
 
                 stmt.bindText(1, "foo")
 
-                shouldThrow<SqliteException> {
+                shouldThrow<PowerSyncException> {
                     stmt.bindText(2, "foo")
                 }
             }

core/src/commonMain/kotlin/com/powersync/PowerSyncDatabaseFactory.kt

@@ -5,6 +5,7 @@ import co.touchlab.skie.configuration.annotations.DefaultArgumentInterop
 import com.powersync.db.ActiveDatabaseGroup
 import com.powersync.db.PowerSyncDatabaseImpl
 import com.powersync.db.driver.InternalConnectionPool
+import com.powersync.db.driver.LazyPool
 import com.powersync.db.schema.Schema
 import com.powersync.utils.generateLogger
 import kotlinx.coroutines.CoroutineScope
@@ -55,13 +56,15 @@ internal fun createPowerSyncDatabaseImpl(
     val activeDatabaseGroup = ActiveDatabaseGroup.referenceDatabase(logger, identifier)
 
     val pool =
-        InternalConnectionPool(
-            factory,
-            scope,
-            dbFilename,
-            dbDirectory,
-            activeDatabaseGroup.first.group.writeLockMutex,
-        )
+        LazyPool {
+            InternalConnectionPool(
+                factory,
+                scope,
+                dbFilename,
+                dbDirectory,
+                activeDatabaseGroup.first.group.writeLockMutex,
+            )
+        }
 
     return PowerSyncDatabase.opened(
         pool,

core/src/commonMain/kotlin/com/powersync/db/driver/LazyPool.kt

@@ -0,0 +1,30 @@
+package com.powersync.db.driver
+
+import com.powersync.ExperimentalPowerSyncAPI
+import kotlinx.coroutines.flow.SharedFlow
+
+/**
+ * A [SQLiteConnectionPool] implemented by constructing an inner pool on first access.
+ *
+ * This allows [InternalConnectionPool] to construct connections immediately (which potentially
+ * throws an exception that we want to report when the SDK is actually used instead of when it's
+ * first constructed).
+ */
+@OptIn(ExperimentalPowerSyncAPI::class)
+internal class LazyPool(
+    openInner: () -> SQLiteConnectionPool,
+) : SQLiteConnectionPool {
+    private val pool by lazy(openInner)
+
+    override suspend fun <T> read(callback: suspend (SQLiteConnectionLease) -> T): T = pool.read(callback)
+
+    override suspend fun <T> write(callback: suspend (SQLiteConnectionLease) -> T): T = pool.write(callback)
+
+    override suspend fun <R> withAllConnections(action: suspend (SQLiteConnectionLease, List<SQLiteConnectionLease>) -> R) =
+        pool.withAllConnections(action)
+
+    override val updates: SharedFlow<Set<String>>
+        get() = pool.updates
+
+    override suspend fun close() = pool.close()
+}

core/src/commonMain/kotlin/com/powersync/db/internal/InternalDatabaseImpl.kt

@@ -210,17 +210,6 @@ internal class InternalDatabaseImpl(
     // Register callback for table updates on a specific table
     override fun updatesOnTables(): SharedFlow<Set<String>> = pool.updates
 
-    // Unfortunately Errors can't be thrown from Swift SDK callbacks.
-    // These are currently returned and should be thrown here.
-    private inline fun <R> catchSwiftExceptions(action: () -> R): R {
-        val result = action()
-
-        if (result is PowerSyncException) {
-            throw result
-        }
-        return result
-    }
-
     private suspend fun getSourceTables(
         sql: String,
         parameters: List<Any?>?,

core/src/commonMain/kotlin/com/powersync/db/internal/PowerSyncTransaction.kt

@@ -59,16 +59,14 @@ internal class PowerSyncTransactionImpl(
 @ExperimentalPowerSyncAPI
 internal suspend fun <T> SQLiteConnectionLease.runTransaction(cb: suspend (PowerSyncTransaction) -> T): T {
     execSQL("BEGIN")
-    var didComplete = false
     return try {
         val result = cb(PowerSyncTransactionImpl(this))
-        didComplete = true
 
         check(isInTransaction())
         execSQL("COMMIT")
         result
     } catch (e: Throwable) {
-        if (!didComplete && isInTransaction()) {
+        if (isInTransaction()) {
             execSQL("ROLLBACK")
         }
 

core/src/nativeMain/interop/sqlite3.h

@@ -32,6 +32,7 @@ int sqlite3_load_extension(
         const char *zProc,    /* Entry point.  Derived from zFile if 0 */
         char **pzErrMsg       /* Put error message here if not 0 */
 );
+int sqlite3_extended_result_codes(sqlite3*, int onoff);
 
 // Statements
 int sqlite3_prepare16_v3(

core/src/nativeMain/kotlin/com/powersync/sqlite/Database.kt

@@ -4,8 +4,10 @@ import androidx.sqlite.SQLiteConnection
 import androidx.sqlite.SQLiteStatement
 import cnames.structs.sqlite3
 import cnames.structs.sqlite3_stmt
+import com.powersync.PowerSyncException
 import com.powersync.internal.sqlite3.sqlite3_close_v2
 import com.powersync.internal.sqlite3.sqlite3_db_config
+import com.powersync.internal.sqlite3.sqlite3_extended_result_codes
 import com.powersync.internal.sqlite3.sqlite3_free
 import com.powersync.internal.sqlite3.sqlite3_get_autocommit
 import com.powersync.internal.sqlite3.sqlite3_initialize
@@ -24,6 +26,14 @@ import kotlinx.cinterop.toKStringFromUtf8
 import kotlinx.cinterop.utf16
 import kotlinx.cinterop.value
 
+/**
+ * A simple implementation of the [SQLiteConnection] interface backed by a synchronous `sqlite3*`
+ * database pointer and the SQLite C APIs called via cinterop.
+ *
+ * Multiple instances of this class are bundled into an
+ * [com.powersync.db.driver.InternalConnectionPool] and called from [kotlinx.coroutines.Dispatchers.IO]
+ * to make these APIs asynchronous.
+ */
 internal class Database(
     private val ptr: CPointer<sqlite3>,
 ) : SQLiteConnection {
@@ -55,7 +65,7 @@ internal class Database(
                 sqlite3_free(errorMessagePointer.value)
             }
 
-            throw SqliteException(resultCode, errorMessage ?: "unknown error")
+            throw PowerSyncException("Could not load extension ($resultCode): ${errorMessage ?: "unknown error"}", null)
         }
     }
 
@@ -65,7 +75,7 @@ internal class Database(
 
     private fun Int.checkResult(stmt: String? = null) {
         if (this != 0) {
-            throw SqliteException.createExceptionInDatabase(this, ptr, stmt)
+            throw createExceptionInDatabase(ptr, stmt)
         }
     }
 
@@ -77,17 +87,21 @@ internal class Database(
             memScoped {
                 var rc = sqlite3_initialize()
                 if (rc != 0) {
-                    throw SqliteException.createExceptionOutsideOfDatabase(rc)
+                    throw PowerSyncException("sqlite3_initialize() failed", null)
                 }
 
                 val encodedPath = path.cstr.getPointer(this)
                 val ptr = allocPointerTo<sqlite3>()
                 rc = sqlite3_open_v2(encodedPath, ptr.ptr, flags, null)
                 if (rc != 0) {
-                    throw SqliteException.createExceptionOutsideOfDatabase(rc)
+                    throw PowerSyncException("Could not open database $path with $flags", null)
                 }
 
                 val db = ptr.value!!
+
+                // Enable extended error codes.
+                sqlite3_extended_result_codes(db, 1)
+
                 // Enable extensions via the C API
                 sqlite3_db_config(db, DBCONFIG_ENABLE_LOAD_EXTENSION, 1, 0)