Refactor SQLite compilation tasks

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

@@ -10,10 +10,11 @@ import com.powersync.bucket.OplogEntry
 import com.powersync.testutils.ActiveDatabaseTest
 import com.powersync.testutils.databaseTest
 import com.powersync.testutils.waitFor
+import io.kotest.assertions.withClue
+import io.kotest.matchers.properties.shouldHaveValue
 import kotlinx.coroutines.channels.Channel
 import kotlin.test.BeforeTest
 import kotlin.test.Test
-import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertNull
 import kotlin.test.assertTrue
@@ -75,6 +76,16 @@ class SyncProgressTest {
         }
     }
 
+    private fun ProgressWithOperations.shouldBe(
+        downloaded: Int,
+        total: Int,
+    ) {
+        withClue("progress $downloadedOperations/$totalOperations should be $downloaded/$total") {
+            this::downloadedOperations shouldHaveValue downloaded
+            this::totalOperations shouldHaveValue total
+        }
+    }
+
     private suspend fun ReceiveTurbine<SyncStatusData>.expectProgress(
         total: Pair<Int, Int>,
         priorities: Map<BucketPriority, Pair<Int, Int>> = emptyMap(),
@@ -83,14 +94,12 @@ class SyncProgressTest {
         val progress = item.downloadProgress ?: error("Expected download progress on $item")
 
         assertTrue { item.downloading }
-        assertEquals(total.first, progress.downloadedOperations)
-        assertEquals(total.second, progress.totalOperations)
+        progress.shouldBe(total.first, total.second)
 
         priorities.forEach { (priority, expected) ->
             val (expectedDownloaded, expectedTotal) = expected
-            val progress = progress.untilPriority(priority)
-            assertEquals(expectedDownloaded, progress.downloadedOperations)
-            assertEquals(expectedTotal, progress.totalOperations)
+            val actualProgress = progress.untilPriority(priority)
+            actualProgress.shouldBe(expectedDownloaded, expectedTotal)
         }
     }
 

core/src/commonMain/kotlin/com/powersync/sync/SyncStream.kt

@@ -436,8 +436,8 @@ internal class SyncStream(
         state: SyncStreamState,
     ): SyncStreamState {
         val batch = SyncDataBatch(listOf(data))
-        status.update { copy(downloading = true, downloadProgress = downloadProgress?.incrementDownloaded(batch)) }
         bucketStorage.saveSyncData(batch)
+        status.update { copy(downloading = true, downloadProgress = downloadProgress?.incrementDownloaded(batch)) }
         return state
     }
 

demos/supabase-todolist/gradle.properties

@@ -1,6 +1,7 @@
 kotlin.code.style=official
 xcodeproj=./iosApp
 android.useAndroidX=true
+org.gradle.caching=true
 org.gradle.jvmargs=-Xmx3g
 org.jetbrains.compose.experimental.jscanvas.enabled=true
 org.jetbrains.compose.experimental.macos.enabled=true

gradle.properties

@@ -1,6 +1,7 @@
 kotlin.code.style=official
 # Gradle
 org.gradle.jvmargs=-Xmx2048M -Dfile.encoding=UTF-8 -Dkotlin.daemon.jvm.options\="-Xmx2048M"
+org.gradle.caching=true
 # Compose
 org.jetbrains.compose.experimental.uikit.enabled=true
 # Android

plugins/build-plugin/src/main/kotlin/com/powersync/compile/ClangCompile.kt

@@ -0,0 +1,92 @@
+package com.powersync.compile
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.provider.ProviderFactory
+import org.gradle.api.tasks.CacheableTask
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.InputDirectory
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.PathSensitive
+import org.gradle.api.tasks.PathSensitivity
+import org.gradle.api.tasks.TaskAction
+import org.jetbrains.kotlin.konan.target.KonanTarget
+import javax.inject.Inject
+import kotlin.io.path.name
+
+@CacheableTask
+abstract class ClangCompile: DefaultTask() {
+    @get:InputFile
+    @get:PathSensitive(PathSensitivity.NONE)
+    abstract val inputFile: RegularFileProperty
+
+    @get:Input
+    abstract val konanTarget: Property<String>
+
+    @get:InputDirectory
+    @get:PathSensitive(PathSensitivity.NONE)
+    abstract val include: DirectoryProperty
+
+    @get:OutputFile
+    abstract val objectFile: RegularFileProperty
+
+    @get:Inject
+    protected abstract val providers: ProviderFactory
+
+    @TaskAction
+    fun run() {
+        val target = requireNotNull(KonanTarget.predefinedTargets[konanTarget.get()])
+
+        val (llvmTarget, sysRoot) = when (target) {
+            KonanTarget.IOS_X64 -> "x86_64-apple-ios12.0-simulator" to IOS_SIMULATOR_SDK
+            KonanTarget.IOS_ARM64 -> "arm64-apple-ios12.0" to IOS_SDK
+            KonanTarget.IOS_SIMULATOR_ARM64 -> "arm64-apple-ios14.0-simulator" to IOS_SIMULATOR_SDK
+            KonanTarget.MACOS_ARM64 -> "aarch64-apple-macos" to MACOS_SDK
+            KonanTarget.MACOS_X64 -> "x86_64-apple-macos" to MACOS_SDK
+            KonanTarget.WATCHOS_DEVICE_ARM64 -> "aarch64-apple-watchos" to WATCHOS_SDK
+            KonanTarget.WATCHOS_ARM32 -> "armv7k-apple-watchos" to WATCHOS_SDK
+            KonanTarget.WATCHOS_ARM64 -> "arm64_32-apple-watchos" to WATCHOS_SDK
+            KonanTarget.WATCHOS_SIMULATOR_ARM64 -> "aarch64-apple-watchos-simulator" to WATCHOS_SIMULATOR_SDK
+            KonanTarget.WATCHOS_X64 -> "x86_64-apple-watchos-simulator" to WATCHOS_SIMULATOR_SDK
+            else -> error("Unexpected target $target")
+        }
+
+        val output = objectFile.get()
+
+        providers.exec {
+            executable = "clang"
+            args(
+                "-B/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin",
+                "-fno-stack-protector",
+                "-target",
+                llvmTarget,
+                "-isysroot",
+                sysRoot,
+                "-fPIC",
+                "--compile",
+                "-I${include.get().asFile.absolutePath}",
+                inputFile.get().asFile.absolutePath,
+                "-DHAVE_GETHOSTUUID=0",
+                "-DSQLITE_ENABLE_DBSTAT_VTAB",
+                "-DSQLITE_ENABLE_FTS5",
+                "-DSQLITE_ENABLE_RTREE",
+                "-O3",
+                "-o",
+                output.asFile.toPath().name,
+            )
+
+            workingDir = output.asFile.parentFile
+        }.result.get()
+    }
+
+    companion object {
+        const val WATCHOS_SDK = "/Applications/Xcode.app/Contents/Developer/Platforms/WatchOS.platform/Developer/SDKs/WatchOS.sdk"
+        const val WATCHOS_SIMULATOR_SDK = "/Applications/Xcode.app/Contents/Developer/Platforms/WatchSimulator.platform/Developer/SDKs/WatchSimulator.sdk/"
+        const val IOS_SDK = "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk"
+        const val IOS_SIMULATOR_SDK = "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk"
+        const val MACOS_SDK = "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/"
+    }
+}

plugins/build-plugin/src/main/kotlin/com/powersync/compile/CreateSqliteCInterop.kt

@@ -0,0 +1,33 @@
+package com.powersync.compile
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.TaskAction
+import org.gradle.work.DisableCachingByDefault
+
+@DisableCachingByDefault(because = "not worth caching")
+abstract class CreateSqliteCInterop: DefaultTask() {
+    @get:InputFile
+    abstract val archiveFile: RegularFileProperty
+
+    @get:OutputFile
+    abstract val definitionFile: RegularFileProperty
+
+    @TaskAction
+    fun run() {
+        val archive = archiveFile.get().asFile
+        val parent = archive.parentFile
+
+        definitionFile.get().asFile.writeText("""
+            package = com.powersync.sqlite3
+
+            linkerOpts.linux_x64 = -lpthread -ldl
+            linkerOpts.macos_x64 = -lpthread -ldl
+            staticLibraries=${archive.name}
+            libraryPaths=${parent.relativeTo(project.layout.projectDirectory.asFile.canonicalFile)}
+            """.trimIndent(),
+        )
+    }
+}

plugins/build-plugin/src/main/kotlin/com/powersync/compile/CreateStaticLibrary.kt

@@ -0,0 +1,37 @@
+package com.powersync.compile
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.ProviderFactory
+import org.gradle.api.tasks.CacheableTask
+import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.PathSensitive
+import org.gradle.api.tasks.PathSensitivity
+import org.gradle.api.tasks.TaskAction
+import javax.inject.Inject
+
+@CacheableTask
+abstract class CreateStaticLibrary: DefaultTask() {
+    @get:InputFiles
+    @get:PathSensitive(PathSensitivity.RELATIVE)
+    abstract val objects: ConfigurableFileCollection
+
+    @get:OutputFile
+    abstract val staticLibrary: RegularFileProperty
+
+    @get:Inject
+    abstract val providers: ProviderFactory
+
+    @TaskAction
+    fun run() {
+        providers.exec {
+            executable = "ar"
+            args("rc", staticLibrary.get().asFile.absolutePath)
+            for (file in objects.files) {
+                args(file.absolutePath)
+            }
+        }.result.get()
+    }
+}

plugins/build-plugin/src/main/kotlin/com/powersync/compile/UnzipSqlite.kt

@@ -0,0 +1,35 @@
+package com.powersync.compile
+
+import org.gradle.api.file.Directory
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.FileTree
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.CacheableTask
+import org.gradle.api.tasks.Copy
+import org.gradle.api.tasks.OutputDirectory
+
+/**
+ * A cacheable [Copy] task providing a typed provider for the output directory.
+ */
+@CacheableTask
+abstract class UnzipSqlite: Copy() {
+    @get:OutputDirectory
+    abstract val destination: DirectoryProperty
+
+    fun unzipSqlite(src: FileTree, dir: Provider<Directory>) {
+        from(
+            src.matching {
+                include("*/sqlite3.*")
+                exclude {
+                    it.isDirectory
+                }
+                eachFile {
+                    this.path = this.name
+                }
+            },
+        )
+
+        into(dir)
+        destination.set(dir)
+    }
+}