Review feedback

Author: simolus3

core/src/androidMain/kotlin/com/powersync/DatabaseDriverFactory.android.kt

@@ -3,6 +3,7 @@ package com.powersync
 import android.content.Context
 import androidx.sqlite.SQLiteConnection
 import androidx.sqlite.driver.bundled.BundledSQLiteDriver
+import kotlin.Throws
 
 @Suppress("EXPECT_ACTUAL_CLASSIFIERS_ARE_IN_BETA_WARNING")
 public actual class DatabaseDriverFactory(
@@ -23,4 +24,5 @@ public fun BundledSQLiteDriver.addPowerSyncExtension() {
 }
 
 @ExperimentalPowerSyncAPI
+@Throws(PowerSyncException::class)
 public actual fun resolvePowerSyncLoadableExtensionPath(): String? = "libpowersync.so"

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

@@ -23,4 +23,5 @@ public actual class DatabaseDriverFactory {
 }
 
 @ExperimentalPowerSyncAPI
+@Throws(PowerSyncException::class)
 public actual fun resolvePowerSyncLoadableExtensionPath(): String? = powerSyncExtensionPath

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

@@ -28,6 +28,7 @@ public expect class DatabaseDriverFactory {
  * SDK.
  */
 @ExperimentalPowerSyncAPI
+@Throws(PowerSyncException::class)
 public expect fun resolvePowerSyncLoadableExtensionPath(): String?
 
 @OptIn(ExperimentalPowerSyncAPI::class)

core/src/watchosMain/kotlin/com/powersync/DatabaseDriverFactory.watchos.kt

@@ -33,6 +33,7 @@ private val didLoadExtension by lazy {
 }
 
 @ExperimentalPowerSyncAPI
+@Throws(PowerSyncException::class)
 public actual fun resolvePowerSyncLoadableExtensionPath(): String? {
     didLoadExtension
     return null

integrations/room/README.md

@@ -28,18 +28,21 @@ been loaded. To do that:
 3. Configure raw tables for your Room databases.
 
 After these steps, you can open your Room database like you normally would. Then, you can use the
-following method to obtain  a `PowerSyncDatabase` instance that is backed by Room:
+following method to obtain  a `PowerSyncDatabase` instance which is backed by Room:
 
 ```Kotlin
-val pool = RoomConnectionPool(yourRoomDatabase)
+// With Room, you need to use raw tables (https://docs.powersync.com/usage/use-case-examples/raw-tables).
+// This is because Room verifies your schema at runtime, and PowerSync-managed views will not
+// pass those checks.
+val schema = Schema(...)
+val pool = RoomConnectionPool(yourRoomDatabase, schema)
 val powersync = PowerSyncDatabase.opened(
     pool = pool,
     scope = this,
-    schema = Schema(...), // With Room, you need to use raw tables
+    schema = schema,
     identifier = "databaseName", // Prefer to use the same path/name as your Room database
     logger = Logger,
 )
-
 powersync.connect(...)
 ```
 

integrations/room/src/commonIntegrationTest/kotlin/com/powersync/integrations/room/PowerSyncRoomTest.kt

@@ -39,7 +39,7 @@ class PowerSyncRoomTest {
 
             val powersync =
                 PowerSyncDatabase.opened(
-                    pool = RoomConnectionPool(database),
+                    pool = RoomConnectionPool(database, TestDatabase.schema),
                     scope = this,
                     schema = TestDatabase.schema,
                     identifier = "test",
@@ -62,7 +62,7 @@ class PowerSyncRoomTest {
     fun roomWritePowerSyncWatch() =
         runTest {
             val logger = Logger(loggerConfigInit())
-            val pool = RoomConnectionPool(database)
+            val pool = RoomConnectionPool(database, TestDatabase.schema)
 
             val powersync =
                 PowerSyncDatabase.opened(
@@ -85,7 +85,6 @@ class PowerSyncRoomTest {
 
                 turbine.awaitItem() shouldHaveSize 0
                 database.userDao().create(User("id", "name"))
-                pool.transferRoomUpdatesToPowerSync() // TODO: Would be cool if this wasn't necessary
                 turbine.awaitItem() shouldHaveSize 1
                 turbine.cancel()
             }
@@ -95,7 +94,7 @@ class PowerSyncRoomTest {
     fun powersyncWriteRoomRead() =
         runTest {
             val logger = Logger(loggerConfigInit())
-            val pool = RoomConnectionPool(database)
+            val pool = RoomConnectionPool(database, TestDatabase.schema)
 
             val powersync =
                 PowerSyncDatabase.opened(
@@ -115,7 +114,7 @@ class PowerSyncRoomTest {
     fun powersyncWriteRoomWatch() =
         runTest {
             val logger = Logger(loggerConfigInit())
-            val pool = RoomConnectionPool(database)
+            val pool = RoomConnectionPool(database, TestDatabase.schema)
 
             val powersync =
                 PowerSyncDatabase.opened(

integrations/room/src/commonIntegrationTest/kotlin/com/powersync/integrations/room/TestDatabase.kt

@@ -10,6 +10,9 @@ import androidx.room.PrimaryKey
 import androidx.room.Query
 import androidx.room.RoomDatabase
 import androidx.room.RoomDatabaseConstructor
+import com.powersync.db.schema.PendingStatement
+import com.powersync.db.schema.PendingStatementParameter
+import com.powersync.db.schema.RawTable
 import com.powersync.db.schema.Schema
 import kotlinx.coroutines.flow.Flow
 
@@ -40,7 +43,25 @@ abstract class TestDatabase : RoomDatabase() {
     abstract fun userDao(): UserDao
 
     companion object {
-        val schema = Schema()
+        val schema =
+            Schema(
+                RawTable(
+                    name = "user",
+                    put =
+                        PendingStatement(
+                            "INSERT INTO user (id, name) VALUES (?, ?)",
+                            listOf(
+                                PendingStatementParameter.Id,
+                                PendingStatementParameter.Column("name"),
+                            ),
+                        ),
+                    delete =
+                        PendingStatement(
+                            "DELETE FROM user WHERE id = ?",
+                            listOf(PendingStatementParameter.Id),
+                        ),
+                ),
+            )
     }
 }
 

integrations/room/src/commonMain/kotlin/com/powersync/integrations/room/RoomConnectionPool.kt

@@ -8,9 +8,11 @@ import androidx.room.useWriterConnection
 import androidx.sqlite.SQLiteStatement
 import com.powersync.db.driver.SQLiteConnectionLease
 import com.powersync.db.driver.SQLiteConnectionPool
+import com.powersync.db.schema.Schema
 import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import kotlinx.serialization.json.Json
 import kotlin.coroutines.CoroutineContext
@@ -23,16 +25,23 @@ import kotlin.coroutines.CoroutineContext
  *
  * Writes made from the wrapped PowerSync database, including writes made for the sync process, are
  * forwarded to Room and will update your flows automatically.
- * On the other hand, the PowerSync SDK needs to be notified about updates in Room. For that, use
- * the [transferRoomUpdatesToPowerSync] method as a collector of a Room flow listening on all your
- * tables.
+ *
+ * On the other hand, the PowerSync SDK needs to be notified about updates in Room. For that, a
+ * schema parameter can be used in the constructor. It will call [syncRoomUpdatesToPowerSync] to
+ * collect a Room flow on all tables. Alternatively, [transferPendingRoomUpdatesToPowerSync] can be
+ * called after issuing writes in Room to transfer them to PowerSync.
  */
 public class RoomConnectionPool(
     private val db: RoomDatabase,
+    schema: Schema? = null,
 ) : SQLiteConnectionPool {
     private val _updates = MutableSharedFlow<Set<String>>()
     private var hasInstalledUpdateHook = false
 
+    init {
+        schema?.let { syncRoomUpdatesToPowerSync(it) }
+    }
+
     override suspend fun <R> withAllConnections(action: suspend (SQLiteConnectionLease, List<SQLiteConnectionLease>) -> R) {
         // We can't obtain a list of all connections on Room. That's fine though, we expect this to
         // be used with raw tables, and withAllConnections is only used to apply a PowerSync schema.
@@ -50,12 +59,25 @@ public class RoomConnectionPool(
      * Makes pending updates tracked by Room's invalidation tracker available to the PowerSync
      * database, updating flows and triggering CRUD uploads.
      */
-    public suspend fun transferRoomUpdatesToPowerSync() {
+    public suspend fun transferPendingRoomUpdatesToPowerSync() {
         write {
             // The end of the write callback invokes powersync_update_hooks('get') for this
         }
     }
 
+    /**
+     * Registers a Room listener on all tables mentioned in the [schema] and invokes
+     * [transferPendingRoomUpdatesToPowerSync] when they change.
+     */
+    public fun syncRoomUpdatesToPowerSync(schema: Schema) {
+        db.getCoroutineScope().launch {
+            val tables = schema.rawTables.map { it.name }.toTypedArray()
+            db.invalidationTracker.createFlow(*tables, emitInitialState = false).collect {
+                transferPendingRoomUpdatesToPowerSync()
+            }
+        }
+    }
+
     override suspend fun <T> write(callback: suspend (SQLiteConnectionLease) -> T): T =
         db.useWriterConnection {
             if (!hasInstalledUpdateHook) {