Add sync implementation from core extension

CHANGELOG.md

@@ -1,7 +1,30 @@
 # Changelog
 
-## 1.1.2 (pending)
-
+## 1.2.0 (pending)
+
+* Add a new sync client implementation written in Rust instead of Kotlin. While this client is still
+  experimental, we intend to make it the default in the future. The main benefit of this client is
+  faster sync performance, but upcoming features will also require this client. We encourage 
+  interested users to try it out by opting in to `ExperimentalPowerSyncAPI` and passing options when
+  connecting:
+  ```Kotlin
+  //@file:OptIn(ExperimentalPowerSyncAPI::class)
+  database.connect(MyConnector(), options = SyncOptions(
+    newClientImplementation = true,
+  ))
+  ```
+  Switching between the clients can be done at any time without compatibility issues. If you run
+  into issues with the new client, please reach out to us!
+* In addition to HTTP streams, the Kotlin SDK also supports fetching sync instructions from the
+  PowerSync service in a binary format. This requires the new sync client, and can then be enabled
+  on the sync options:
+  ```Kotlin
+  //@file:OptIn(ExperimentalPowerSyncAPI::class)
+  database.connect(MyConnector(), options = SyncOptions(
+    newClientImplementation = true,
+    method = ConnectionMethod.WebSocket()
+  ))
+  ```
 * [Android, JVM] Use version `0.4.0` of `powersync-sqlite-core`.
 
 ## 1.1.1

PowerSyncKotlin/src/appleMain/kotlin/com/powersync/SDK.kt

@@ -2,6 +2,9 @@
 
 package com.powersync
 
+import com.powersync.sync.ConnectionMethod
+import com.powersync.sync.SyncOptions
+
 /**
  * Helper class designed to bridge SKIEE methods and allow them to throw
  * `PowerSyncException`. This is necessary because these exceptions cannot
@@ -13,3 +16,25 @@ package com.powersync
  */
 @Throws(PowerSyncException::class)
 public fun throwPowerSyncException(exception: PowerSyncException): Unit = throw exception
+
+/**
+ * Creates a [ConnectionMethod] based on simple booleans, because creating the actual instance with
+ * the default constructor is not possible from Swift due to an optional argument with an internal
+ * default value.
+ */
+@OptIn(ExperimentalPowerSyncAPI::class)
+public fun createSyncOptions(
+    newClient: Boolean,
+    webSocket: Boolean,
+    userAgent: String,
+): SyncOptions =
+    SyncOptions(
+        newClientImplementation = newClient,
+        method =
+            if (webSocket) {
+                ConnectionMethod.WebSocket()
+            } else {
+                ConnectionMethod.Http
+            },
+        userAgent = userAgent,
+    )

core/build.gradle.kts

@@ -175,6 +175,8 @@ kotlin {
             implementation(libs.ktor.client.contentnegotiation)
             implementation(libs.ktor.serialization.json)
             implementation(libs.kotlinx.io)
+            implementation(libs.rsocket.core)
+            implementation(libs.rsocket.transport.websocket)
             implementation(libs.kotlinx.coroutines.core)
             implementation(libs.kotlinx.datetime)
             implementation(libs.stately.concurrency)

core/src/androidMain/kotlin/com/powersync/sync/UserAgent.android.kt

@@ -0,0 +1,5 @@
+package com.powersync.sync
+
+import android.os.Build
+
+internal actual fun userAgent(): String = "PowerSync Kotlin SDK (Android ${Build.VERSION.SDK_INT})"

core/src/commonIntegrationTest/kotlin/com/powersync/sync/AbstractSyncTest.kt

@@ -0,0 +1,16 @@
+package com.powersync.sync
+
+import com.powersync.ExperimentalPowerSyncAPI
+
+/**
+ * Small utility to run tests both with the legacy Kotlin sync implementation and the new
+ * implementation from the core extension.
+ */
+abstract class AbstractSyncTest(
+    private val useNewSyncImplementation: Boolean,
+) {
+    @OptIn(ExperimentalPowerSyncAPI::class)
+    val options: SyncOptions get() {
+        return SyncOptions(useNewSyncImplementation)
+    }
+}