Merge remote-tracking branch 'origin/main' into api-ref

Author: stevensJourney

.github/workflows/test.yml

@@ -16,9 +16,9 @@ jobs:
       matrix:
         include:
           - os: macos-latest
-            targets: iosSimulatorArm64Test jvmTest lintKotlin
+            targets: iosSimulatorArm64Test macosArm64Test jvmTest
           - os: ubuntu-latest
-            targets: testDebugUnitTest testReleaseUnitTest jvmTest
+            targets: testDebugUnitTest testReleaseUnitTest jvmTest lintKotlin
           - os: windows-latest
             targets: jvmTest
     runs-on: ${{ matrix.os }}
@@ -44,4 +44,14 @@ jobs:
         ./gradlew \
           -PGITHUB_PUBLISH_TOKEN=${{ secrets.GITHUB_TOKEN }} \
           ${{ matrix.targets }}
-      shell: bash
+      shell: bash
+
+    # Credit: https://github.com/gradle/actions/issues/76#issuecomment-2007584323
+    - name: Upload reports on failure
+      if: failure()
+      uses: actions/upload-artifact@v4
+      with:
+        name: report-for-${{ matrix.os }}
+        path: |
+          **/build/reports/
+          **/build/test-results/

CHANGELOG.md

@@ -1,8 +1,19 @@
 # Changelog
 
-## 1.0.0-BETA29 (unreleased)
+## 1.0.0-BETA30
+
+* Fix a deadlock when calling `connect()` immediately after opening a database.
+  The issue has been introduced in version `1.0.0-BETA29`.
+
+## 1.0.0-BETA29
 
 * Fix potential race condition between jobs in `connect()` and `disconnect()`.
+* [JVM Windows] Fixed PowerSync Extension temporary file deletion error on process shutdown.
+* [iOS] Fixed issue where automatic driver migrations would fail with the error:
+```
+Sqlite operation failure database is locked attempted to run migration and failed. closing connection
+```
+* Fix race condition causing data received during uploads not to be applied.
 
 ## 1.0.0-BETA28
 

PowerSyncKotlin/build.gradle.kts

@@ -17,6 +17,8 @@ kotlin {
         iosX64(),
         iosArm64(),
         iosSimulatorArm64(),
+        macosArm64(),
+        macosX64(),
     ).forEach {
         it.binaries.framework {
             export(project(":core"))
@@ -41,6 +43,26 @@ kotlin {
     }
 }
 
+repositories {
+    maven {
+        name = "PowerSyncSQLiterFork"
+        url = uri("https://powersync-ja.github.io/SQLiter")
+        content {
+            includeModuleByRegex("co.touchlab", "sqliter-driver.*")
+        }
+    }
+}
+
+configurations.all {
+    resolutionStrategy {
+        // This version has not been released yet (https://github.com/touchlab/SQLiter/pull/124), so we're pointing this
+        // towards our fork with the repositories block above.
+        // The API is identical, but we have to make sure this particular project builds the xcframework with the
+        // patched SQLiter version to avoid linker errors on macOS.
+        force("co.touchlab:sqliter-driver:1.3.2-powersync")
+    }
+}
+
 kmmbridge {
     artifactManager.set(SonatypePortalPublishArtifactManager(project, repositoryName = null))
     artifactManager.finalizeValue()

…/src/iosMain/kotlin/com/powersync/SDK.kt …rc/appleMain/kotlin/com/powersync/SDK.ktPowerSyncKotlin/src/iosMain/kotlin/com/powersync/SDK.kt renamed to PowerSyncKotlin/src/appleMain/kotlin/com/powersync/SDK.kt PowerSyncKotlin/src/iosMain/kotlin/com/powersync/SDK.kt renamed to PowerSyncKotlin/src/appleMain/kotlin/com/powersync/SDK.kt

@@ -1,4 +1,5 @@
 import com.powersync.plugins.sonatype.setupGithubRepository
+import com.powersync.plugins.utils.powersyncTargets
 
 plugins {
     alias(libs.plugins.kotlinMultiplatform)
@@ -10,15 +11,7 @@ plugins {
 }
 
 kotlin {
-    androidTarget {
-        publishLibraryVariants("release", "debug")
-    }
-
-    jvm()
-
-    iosX64()
-    iosArm64()
-    iosSimulatorArm64()
+    powersyncTargets(includeTargetsWithoutComposeSupport = false)
 
     explicitApi()
 

compose/build.gradle.kts

@@ -1,4 +1,5 @@
 import com.powersync.plugins.sonatype.setupGithubRepository
+import com.powersync.plugins.utils.powersyncTargets
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
 
 plugins {
@@ -10,12 +11,7 @@ plugins {
 }
 
 kotlin {
-    androidTarget {
-        publishLibraryVariants("release", "debug")
-    }
-
-    jvm()
-
+    powersyncTargets()
     targets.withType<KotlinNativeTarget> {
         compilations.named("main") {
             compileTaskProvider {
@@ -24,10 +20,6 @@ kotlin {
         }
     }
 
-    iosX64()
-    iosArm64()
-    iosSimulatorArm64()
-
     explicitApi()
 
     sourceSets {

connectors/supabase/build.gradle.kts

@@ -1,9 +1,8 @@
 import com.powersync.plugins.sonatype.setupGithubRepository
+import com.powersync.plugins.utils.powersyncTargets
 import de.undercouch.gradle.tasks.download.Download
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat
 import org.gradle.internal.os.OperatingSystem
-import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
 import org.jetbrains.kotlin.gradle.plugin.mpp.TestExecutable
 import org.jetbrains.kotlin.gradle.targets.jvm.tasks.KotlinJvmTest
@@ -85,15 +84,22 @@ val downloadPowersyncFramework by tasks.registering(Download::class) {
     onlyIfModified(true)
 }
 
-val unzipPowersyncFramework by tasks.registering(Copy::class) {
+val unzipPowersyncFramework by tasks.registering(Exec::class) {
     dependsOn(downloadPowersyncFramework)
 
-    from(
-        zipTree(downloadPowersyncFramework.get().dest).matching {
-            include("powersync-sqlite-core.xcframework/**")
-        },
-    )
-    into(binariesFolder.map { it.dir("framework") })
+    val zipfile = downloadPowersyncFramework.get().dest
+    inputs.file(zipfile)
+    val destination = File(zipfile.parentFile, "extracted")
+    doFirst {
+        destination.deleteRecursively()
+        destination.mkdir()
+    }
+
+    // We're using unzip here because the Gradle copy task doesn't support symlinks.
+    executable = "unzip"
+    args(zipfile.absolutePath)
+    workingDir(destination)
+    outputs.dir(destination)
 }
 
 val sqliteJDBCFolder =
@@ -151,26 +157,7 @@ val moveJDBCJNIFiles by tasks.registering(Copy::class) {
 }
 
 kotlin {
-    androidTarget {
-        publishLibraryVariants("release", "debug")
-
-        @OptIn(ExperimentalKotlinGradlePluginApi::class)
-        compilerOptions {
-            jvmTarget.set(JvmTarget.JVM_17)
-        }
-    }
-    jvm {
-        @OptIn(ExperimentalKotlinGradlePluginApi::class)
-        compilerOptions {
-            jvmTarget.set(JvmTarget.JVM_1_8)
-            // https://jakewharton.com/kotlins-jdk-release-compatibility-flag/
-            freeCompilerArgs.add("-Xjdk-release=8")
-        }
-    }
-
-    iosX64()
-    iosArm64()
-    iosSimulatorArm64()
+    powersyncTargets()
 
     targets.withType<KotlinNativeTarget> {
         compilations.named("main") {
@@ -185,7 +172,20 @@ kotlin {
                 linkerOpts("-framework", "powersync-sqlite-core")
                 val frameworkRoot =
                     binariesFolder
-                        .map { it.dir("framework/powersync-sqlite-core.xcframework/ios-arm64_x86_64-simulator") }
+                        .map { it.dir("framework/extracted/powersync-sqlite-core.xcframework/ios-arm64_x86_64-simulator") }
+                        .get()
+                        .asFile.path
+
+                linkerOpts("-F", frameworkRoot)
+                linkerOpts("-rpath", frameworkRoot)
+            }
+        } else if (konanTarget.family == Family.OSX) {
+            binaries.withType<TestExecutable>().configureEach {
+                linkTaskProvider.configure { dependsOn(unzipPowersyncFramework) }
+                linkerOpts("-framework", "powersync-sqlite-core")
+                var frameworkRoot =
+                    binariesFolder
+                        .map { it.dir("framework/extracted/powersync-sqlite-core.xcframework/macos-arm64_x86_64") }
                         .get()
                         .asFile.path
 
@@ -254,14 +254,15 @@ kotlin {
             }
         }
 
-        iosMain.dependencies {
-            implementation(libs.ktor.client.ios)
+        appleMain.dependencies {
+            implementation(libs.ktor.client.darwin)
         }
 
         commonTest.dependencies {
             implementation(libs.kotlin.test)
             implementation(libs.test.coroutines)
             implementation(libs.test.turbine)
+            implementation(libs.test.kotest.assertions)
             implementation(libs.kermit.test)
             implementation(libs.ktor.client.mock)
             implementation(libs.test.turbine)
@@ -271,8 +272,9 @@ kotlin {
         // tests.
         jvmTest.get().dependsOn(commonIntegrationTest)
 
-        // We're linking the xcframework for the simulator tests, so they can use integration tests too
-        iosSimulatorArm64Test.orNull?.dependsOn(commonIntegrationTest)
+        // We have special setup in this build configuration to make these tests link the PowerSync extension, so they
+        // can run integration tests along with the executable for unit testing.
+        appleTest.orNull?.dependsOn(commonIntegrationTest)
     }
 }
 
@@ -346,6 +348,7 @@ tasks.withType<KotlinTest> {
     testLogging {
         events("PASSED", "FAILED", "SKIPPED")
         exceptionFormat = TestExceptionFormat.FULL
+        showCauses = true
         showStandardStreams = true
         showStackTraces = true
     }

core/build.gradle.kts

@@ -1,8 +1,10 @@
 package com.powersync
 
+import app.cash.sqldelight.db.QueryResult
 import co.touchlab.sqliter.DatabaseConfiguration
 import co.touchlab.sqliter.DatabaseConfiguration.Logging
 import co.touchlab.sqliter.DatabaseConnection
+import co.touchlab.sqliter.NO_VERSION_CHECK
 import co.touchlab.sqliter.interop.Logger
 import co.touchlab.sqliter.interop.SqliteErrorType
 import co.touchlab.sqliter.sqlite3.sqlite3_commit_hook
@@ -68,7 +70,13 @@ public actual class DatabaseDriverFactory {
                         configuration =
                             DatabaseConfiguration(
                                 name = dbFilename,
-                                version = schema.version.toInt(),
+                                version =
+                                    if (!readOnly) {
+                                        schema.version.toInt()
+                                    } else {
+                                        // Don't do migrations on read only connections
+                                        NO_VERSION_CHECK
+                                    },
                                 create = { connection ->
                                     wrapConnection(connection) {
                                         schema.create(
@@ -106,6 +114,15 @@ public actual class DatabaseDriverFactory {
             driver.execute("PRAGMA query_only=true")
         }
 
+        // Ensure internal read pool has created a connection at this point. This makes connection
+        // initialization a bit more deterministic.
+        driver.executeQuery(
+            identifier = null,
+            sql = "SELECT 1",
+            mapper = { QueryResult.Value(it.getLong(0)) },
+            parameters = 0,
+        )
+
         deferredDriver.setDriver(driver)
 
         return driver