Add SQLDelight driver

CHANGELOG.md

@@ -1,9 +1,12 @@
 # Changelog
 
-## 1.3.1 (unreleased)
+## 1.4.0 (unreleased)
 
 * Update SQLite to 3.50.3.
+* Remove internal SQLDelight and SQLiter dependencies.
 * Android: Ensure JNI libraries are 16KB-aligned.
+* Add `rawConnection` getter to `ConnectionContext`, which is a `SQLiteConnection` instance from
+  `androidx.sqlite` that can be used to step through statements in a custom way.
 
 ## 1.3.0
 

README.md

@@ -32,6 +32,10 @@ and API documentation [here](https://powersync-ja.github.io/powersync-kotlin/).
         1. Retrieve a token to connect to the PowerSync service.
         2. Apply local changes on your backend application server (and from there, to your backend database).
 
+- [integrations](./integrations/)
+    - [sqldelight](./integrations/sqldelight/): An experimental SQLDelight driver backed by PowerSync databases.
+      Changes to the PowerSync database, including those from the server, update SQLDelight queries.
+
 ## Demo Apps / Example Projects
 
 The easiest way to test the PowerSync KMP SDK is to run one of our demo applications.

build.gradle.kts

@@ -13,13 +13,12 @@ plugins {
     alias(libs.plugins.skie) apply false
     alias(libs.plugins.kotlin.jvm) apply false
     alias(libs.plugins.kotlin.android) apply false
-    alias(libs.plugins.sqldelight) apply false
-    alias(libs.plugins.grammarKitComposer) apply false
     alias(libs.plugins.mavenPublishPlugin) apply false
     alias(libs.plugins.downloadPlugin) apply false
     alias(libs.plugins.kotlinter) apply false
     alias(libs.plugins.keeper) apply false
     alias(libs.plugins.kotlin.atomicfu) apply false
+    alias(libs.plugins.sqldelight) apply false
     id("org.jetbrains.dokka") version libs.versions.dokkaBase
     id("dokka-convention")
 }

compose/build.gradle.kts

@@ -19,7 +19,6 @@ kotlin {
     sourceSets {
         commonMain.dependencies {
             api(project(":core"))
-            implementation(project(":persistence"))
             implementation(compose.runtime)
         }
         androidMain.dependencies {

core/build.gradle.kts

@@ -181,6 +181,7 @@ kotlin {
         all {
             languageSettings {
                 optIn("kotlinx.cinterop.ExperimentalForeignApi")
+                optIn("kotlin.experimental.ExperimentalObjCRefinement")
             }
         }
 
@@ -201,6 +202,9 @@ kotlin {
             }
 
             dependencies {
+                api(libs.kermit)
+                api(libs.androidx.sqlite)
+
                 implementation(libs.uuid)
                 implementation(libs.kotlin.stdlib)
                 implementation(libs.ktor.client.core)
@@ -213,8 +217,7 @@ kotlin {
                 implementation(libs.kotlinx.datetime)
                 implementation(libs.stately.concurrency)
                 implementation(libs.configuration.annotations)
-                api(projects.persistence)
-                api(libs.kermit)
+                implementation(projects.drivers.common)
             }
         }
 
@@ -233,6 +236,7 @@ kotlin {
 
         appleMain.dependencies {
             implementation(libs.ktor.client.darwin)
+            implementation(projects.staticSqliteDriver)
         }
 
         commonTest.dependencies {

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

@@ -1,79 +1,35 @@
 package com.powersync
 
 import android.content.Context
-import com.powersync.db.JdbcSqliteDriver
-import com.powersync.db.buildDefaultWalProperties
-import com.powersync.db.internal.InternalSchema
-import com.powersync.db.migrateDriver
-import kotlinx.coroutines.CoroutineScope
-import org.sqlite.SQLiteCommitListener
-import java.util.concurrent.atomic.AtomicBoolean
+import androidx.sqlite.SQLiteConnection
+import com.powersync.db.loadExtensions
+import com.powersync.internal.driver.AndroidDriver
+import com.powersync.internal.driver.ConnectionListener
+import com.powersync.internal.driver.JdbcConnection
 
 @Suppress("EXPECT_ACTUAL_CLASSIFIERS_ARE_IN_BETA_WARNING")
 public actual class DatabaseDriverFactory(
     private val context: Context,
 ) {
-    internal actual fun createDriver(
-        scope: CoroutineScope,
+    internal actual fun openDatabase(
         dbFilename: String,
         dbDirectory: String?,
         readOnly: Boolean,
-    ): PsSqlDriver {
-        val schema = InternalSchema
-
+        listener: ConnectionListener?,
+    ): SQLiteConnection {
         val dbPath =
             if (dbDirectory != null) {
                 "$dbDirectory/$dbFilename"
             } else {
-                context.getDatabasePath(dbFilename)
+                "${context.getDatabasePath(dbFilename)}"
             }
 
-        val properties = buildDefaultWalProperties(readOnly = readOnly)
-        val isFirst = IS_FIRST_CONNECTION.getAndSet(false)
-        if (isFirst) {
-            // Make sure the temp_store_directory points towards a temporary directory we actually
-            // have access to. Due to sandboxing, the default /tmp/ is inaccessible.
-            // The temp_store_directory pragma is deprecated and not thread-safe, so we only set it
-            // on the first connection (it sets a global field and will affect every connection
-            // opened).
-            val escapedPath = context.cacheDir.absolutePath.replace("\"", "\"\"")
-            properties.setProperty("temp_store_directory", "\"$escapedPath\"")
-        }
-
-        val driver =
-            JdbcSqliteDriver(
-                url = "jdbc:sqlite:$dbPath",
-                properties = properties,
-            )
-
-        migrateDriver(driver, schema)
-
-        driver.loadExtensions(
+        val driver = AndroidDriver(context)
+        val connection = driver.openDatabase(dbPath, readOnly, listener) as JdbcConnection
+        connection.loadExtensions(
             "libpowersync.so" to "sqlite3_powersync_init",
         )
 
-        val mappedDriver = PsSqlDriver(driver = driver)
-
-        driver.connection.database.addUpdateListener { _, _, table, _ ->
-            mappedDriver.updateTable(table)
-        }
-
-        driver.connection.database.addCommitListener(
-            object : SQLiteCommitListener {
-                override fun onCommit() {
-                    // We track transactions manually
-                }
-
-                override fun onRollback() {
-                    mappedDriver.clearTableUpdates()
-                }
-            },
-        )
-
-        return mappedDriver
-    }
-
-    private companion object {
-        val IS_FIRST_CONNECTION = AtomicBoolean(true)
+        return connection
     }
 }