Add Room web support

Author: simolus3

integrations/room/build.gradle.kts

@@ -18,7 +18,8 @@ kotlin {
         android = {
             namespace = "com.powersync.integrations.room"
         },
-        legacyJavaSupport = false
+        legacyJavaSupport = false,
+        web = true
     )
 
     explicitApi()
@@ -34,23 +35,43 @@ kotlin {
         commonMain.dependencies {
             api(projects.common)
             api(libs.androidx.room.runtime)
-            api(libs.androidx.sqlite.bundled)
 
+            implementation(libs.androidx.sqlite.async)
             implementation(libs.kotlinx.serialization.json)
         }
 
+        val commonNonWeb by creating {
+            dependsOn(commonMain.get())
+
+            dependencies {
+                api(libs.androidx.sqlite.bundled)
+            }
+        }
+
+        jvmMain {
+            dependsOn(commonNonWeb)
+        }
+        nativeMain {
+            dependsOn(commonNonWeb)
+        }
+        androidMain {
+            dependsOn(commonNonWeb)
+        }
+
         commonTest.dependencies {
             implementation(libs.kotlin.test)
             implementation(libs.kotlinx.io)
             implementation(libs.test.kotest.assertions)
             implementation(libs.test.coroutines)
             implementation(libs.test.turbine)
-
-            implementation(libs.androidx.sqlite.bundled)
         }
 
         val commonIntegrationTest by creating {
             dependsOn(commonTest.get())
+
+            dependencies {
+                implementation(libs.androidx.sqlite.bundled)
+            }
         }
 
         // We're putting the native libraries into our JAR, so integration tests for the JVM can run as part of the unit

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

@@ -7,15 +7,13 @@ import androidx.room3.useReaderConnection
 import androidx.room3.useWriterConnection
 import androidx.sqlite.SQLiteException
 import androidx.sqlite.SQLiteStatement
+import androidx.sqlite.async.step
 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 kotlin.coroutines.CoroutineContext
 
 /**
  * A [SQLiteConnectionPool] implementation for the PowerSync SDK that is backed by a [RoomDatabase].
@@ -52,7 +50,7 @@ public class RoomConnectionPool(
 
     override suspend fun <T> read(callback: suspend (SQLiteConnectionLease) -> T): T =
         db.useReaderConnection {
-            callback(RoomTransactionLease(it, currentCoroutineContext()))
+            callback(it.asConnectionLease())
         }
 
     /**
@@ -97,7 +95,7 @@ public class RoomConnectionPool(
             }
 
             try {
-                callback(RoomTransactionLease(it, currentCoroutineContext()))
+                callback(it.asConnectionLease())
             } finally {
                 // List changed tables, excluding virtual and shadow tables for e.g. fts5
                 val statement =
@@ -138,36 +136,15 @@ public class RoomConnectionPool(
     }
 }
 
-private class RoomTransactionLease(
-    private val transactor: Transactor,
-    /**
-     * The context to use for [runBlocking] calls to avoid the "Attempted to use connection on a
-     * different coroutine" error.
-     */
-    private val context: CoroutineContext,
+internal expect suspend fun Transactor.asConnectionLease(): SQLiteConnectionLease
+
+internal abstract class RoomTransactionLease(
+    protected val transactor: Transactor,
 ) : SQLiteConnectionLease {
     override suspend fun isInTransaction(): Boolean = transactor.inTransaction()
 
-    override suspend fun <R> usePrepared(
-        sql: String,
-        block: (SQLiteStatement) -> R,
-    ): R = transactor.usePrepared(sql, block)
-
     override suspend fun <R> usePreparedAsync(
         sql: String,
         block: suspend (SQLiteStatement) -> R,
     ): R = transactor.usePrepared(sql, block)
-
-    override fun isInTransactionSync(): Boolean =
-        runBlocking(context) {
-            isInTransaction()
-        }
-
-    override fun <R> usePreparedSync(
-        sql: String,
-        block: (SQLiteStatement) -> R,
-    ): R =
-        runBlocking(context) {
-            usePrepared(sql, block)
-        }
 }

…/integrations/room/PowerSyncExtension.kt …/integrations/room/PowerSyncExtension.ktintegrations/room/src/commonMain/kotlin/com/powersync/integrations/room/PowerSyncExtension.kt renamed to integrations/room/src/commonNonWeb/kotlin/com/powersync/integrations/room/PowerSyncExtension.kt integrations/room/src/commonMain/kotlin/com/powersync/integrations/room/PowerSyncExtension.kt renamed to integrations/room/src/commonNonWeb/kotlin/com/powersync/integrations/room/PowerSyncExtension.kt

@@ -0,0 +1,34 @@
+package com.powersync.integrations.room
+
+import androidx.room3.Transactor
+import androidx.sqlite.SQLiteStatement
+import com.powersync.db.driver.SQLiteConnectionLease
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.runBlocking
+import kotlin.coroutines.CoroutineContext
+
+internal actual suspend fun Transactor.asConnectionLease(): SQLiteConnectionLease =
+    SyncRoomTransactionLease(this, currentCoroutineContext())
+
+private class SyncRoomTransactionLease(
+    transactor: Transactor,
+    private val context: CoroutineContext,
+) : RoomTransactionLease(transactor) {
+    override suspend fun <R> usePrepared(
+        sql: String,
+        block: (SQLiteStatement) -> R,
+    ): R = transactor.usePrepared(sql, block)
+
+    override fun isInTransactionSync(): Boolean =
+        runBlocking(context) {
+            isInTransaction()
+        }
+
+    override fun <R> usePreparedSync(
+        sql: String,
+        block: (SQLiteStatement) -> R,
+    ): R =
+        runBlocking(context) {
+            usePrepared(sql, block)
+        }
+}

integrations/room/src/commonNonWeb/kotlin/com/powersync/integrations/room/SyncRoomTransactionLease.kt

@@ -0,0 +1,10 @@
+package com.powersync.integrations.room
+
+import androidx.room3.Transactor
+import com.powersync.db.driver.SQLiteConnectionLease
+
+internal actual suspend fun Transactor.asConnectionLease(): SQLiteConnectionLease = WebRoomTransactionLease(this)
+
+private class WebRoomTransactionLease(
+    transactor: Transactor,
+) : RoomTransactionLease(transactor)