Get sqlite3mc running on macOS JVM

Author: simolus3

common/build.gradle.kts

@@ -137,6 +137,7 @@ kotlin {
                 optIn("kotlinx.cinterop.ExperimentalForeignApi")
                 optIn("kotlin.time.ExperimentalTime")
                 optIn("kotlin.experimental.ExperimentalObjCRefinement")
+                optIn("com.powersync.PowerSyncInternal")
             }
         }
 

common/src/commonMain/kotlin/com/powersync/PowerSyncInternal.kt

@@ -0,0 +1,12 @@
+package com.powersync
+
+@RequiresOptIn(message = "This API should not be used outside of PowerSync SDK packages")
+@Retention(AnnotationRetention.BINARY)
+@Target(
+    AnnotationTarget.CLASS,
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.CONSTRUCTOR,
+    AnnotationTarget.PROPERTY,
+    AnnotationTarget.VALUE_PARAMETER,
+)
+public annotation class PowerSyncInternal

common/src/jvmMain/kotlin/com/powersync/ConnectionFactory.jvm.kt

@@ -5,4 +5,4 @@ import com.powersync.db.runWrapped
 @Throws(PowerSyncException::class)
 public actual fun resolvePowerSyncLoadableExtensionPath(): String? = runWrapped { powersyncExtension }
 
-private val powersyncExtension: String by lazy { extractLib("powersync") }
+private val powersyncExtension: String by lazy { extractLib(BuildConfig::class,"powersync") }

common/src/jvmMain/kotlin/com/powersync/ExtractLib.kt

@@ -2,10 +2,10 @@ package com.powersync
 
 import java.io.File
 import java.util.UUID
+import kotlin.reflect.KClass
 
-private class R
-
-internal fun extractLib(fileName: String): String {
+@PowerSyncInternal
+public fun extractLib(reference: KClass<*>, fileName: String): String {
     val os = System.getProperty("os.name").lowercase()
     val (prefix, extension) =
         when {
@@ -34,7 +34,7 @@ internal fun extractLib(fileName: String): String {
 
     val resourcePath = "/$prefix${fileName}_$arch.$extension"
 
-    (R::class.java.getResourceAsStream(resourcePath) ?: error("Resource $resourcePath not found")).use { input ->
+    (reference.java.getResourceAsStream(resourcePath) ?: error("Resource $resourcePath not found")).use { input ->
         file.outputStream().use { output -> input.copyTo(output) }
     }
 

sqlite3multipleciphers/build.gradle.kts

@@ -89,6 +89,7 @@ kotlin {
                 optIn("kotlin.experimental.ExperimentalNativeApi")
                 optIn("kotlinx.cinterop.ExperimentalForeignApi")
                 optIn("kotlinx.cinterop.BetaInteropApi")
+                optIn("com.powersync.PowerSyncInternal")
             }
         }
 
@@ -159,27 +160,34 @@ tasks.withType<ExternalNativeBuildTask> {
     dependsOn(unzipSQLiteSources)
 }
 
+tasks.named<ProcessResources>(kotlin.jvm().compilations["main"].processResourcesTaskName) {
+    from("build/jni-build/")
+}
+
 val xCodeInstallation = ClangCompile.resolveXcode(providers)
 
 // Tasks to build the JNI shared library for multiple operating systems.
 // Since the JNI sources rarely change, we don't run these tasks on every build. Instead,
 // we'll publish these sources as one-off releases when needed, and then reference that URL.
-fun registerCompileMacOsHostTask(architecture: String): TaskProvider<Exec> {
-    return tasks.register<Exec>("jniCompileMacos$architecture") {
+fun registerCompileMacOsHostTask(arm: Boolean): TaskProvider<Exec> {
+    val architectureName = if (arm) { "aarch64" } else { "x64" }
+
+    return tasks.register<Exec>("jniCompileMacos$architectureName") {
         val xcode = Path(xCodeInstallation.get())
         val toolchain =
             xcode.resolve("Toolchains/XcodeDefault.xctoolchain/usr/bin").absolutePathString()
 
-        val outputDirectory = layout.buildDirectory.dir("jni-build/macos")
-        val outputFile = outputDirectory.map { it.file("libsqlite3mc_jni.$architecture.dylib") }
+        val outputDirectory = layout.buildDirectory.dir("jni-build")
+        val outputFile = outputDirectory.map {
+            it.file("libsqlite3mc_jni_$architectureName.macos.dylib")
+        }
         outputs.file(outputFile)
 
         dependsOn(unzipSQLiteSources)
         val sqlite3McSources = unzipSQLiteSources.map { it.destinationDir }
         inputs.dir(sqlite3McSources)
 
-        val headers = layout.projectDirectory.dir("src/jni/headers/inc_mac")
-        inputs.dir(headers)
+        inputs.dir(layout.projectDirectory.dir("src/jni/"))
 
         doFirst {
             outputDirectory.get().asFile.mkdirs()
@@ -190,23 +198,23 @@ fun registerCompileMacOsHostTask(architecture: String): TaskProvider<Exec> {
             "-B$toolchain",
             "-dynamiclib",
             "-fPIC",
-            "--target=${architecture}-apple-macos",
+            if (arm) "--target=aarch64-apple-macos" else "--target=x86_64-apple-macos",
             "-o",
             outputFile.get().asFile.path,
             "src/jni/sqlite_bindings.cpp",
             File(sqlite3McSources.get(), "sqlite3mc_amalgamation.c").path,
             "-I",
             sqlite3McSources.get().path,
             "-I",
-            headers.asFile.path,
+            "src/jni/headers/inc_mac",
             "-O3",
             *ClangCompile.sqlite3ClangOptions,
         )
     }
 }
 
-val macosArm64 = registerCompileMacOsHostTask("aarch64")
-val macosX64 = registerCompileMacOsHostTask("x86_64")
+val macosArm64 = registerCompileMacOsHostTask(true)
+val macosX64 = registerCompileMacOsHostTask(false)
 
 tasks.register("jniCompile") {
     dependsOn(macosArm64)

sqlite3multipleciphers/src/jni/sqlite_bindings.cpp

@@ -421,17 +421,17 @@ jint JNI_OnLoad(JavaVM *vm, void * /* reserved */) {
     }
 
     const int driverMethodCount = sizeof(sDriverMethods) / sizeof(sDriverMethods[0]);
-    if (register_methods(env, "androidx/sqlite/driver/bundled/BundledSQLiteDriverKt",
+    if (register_methods(env, "com/powersync/encryption/BundledSQLiteDriverKt",
                          sDriverMethods, driverMethodCount) != JNI_OK) {
         return JNI_ERR;
     }
     const int connectionMethodCount = sizeof(sConnectionMethods) / sizeof(sConnectionMethods[0]);
-    if (register_methods(env, "androidx/sqlite/driver/bundled/BundledSQLiteConnectionKt",
+    if (register_methods(env, "com/powersync/encryption/BundledSQLiteConnectionKt",
                          sConnectionMethods, connectionMethodCount) != JNI_OK) {
         return JNI_ERR;
     }
     const int statementMethodCount = sizeof(sStatementMethods) / sizeof(sStatementMethods[0]);
-    if (register_methods(env, "androidx/sqlite/driver/bundled/BundledSQLiteStatementKt",
+    if (register_methods(env, "com/powersync/encryption/BundledSQLiteStatementKt",
                          sStatementMethods, statementMethodCount) != JNI_OK) {
         return JNI_ERR;
     }

sqlite3multipleciphers/src/jvmAndroidMain/kotlin/com/powersync/encryption/BundledSQLiteDriver.kt

@@ -20,7 +20,7 @@ import androidx.sqlite.SQLiteConnection
 import com.powersync.PersistentConnectionFactory
 import com.powersync.resolvePowerSyncLoadableExtensionPath
 
-internal abstract class BundledSQLiteDriver(private val key: Key): PersistentConnectionFactory {
+public abstract class BundledSQLiteDriver internal constructor(private val key: Key): PersistentConnectionFactory {
     private fun open(fileName: String, flags: Int): SQLiteConnection {
         ensureJniLibraryLoaded()
 

sqlite3multipleciphers/src/jvmMain/kotlin/com/powersync/encryption/BundledSQLiteDriver.jvm.kt

@@ -1,5 +1,18 @@
 package com.powersync.encryption
 
-internal actual fun ensureJniLibraryLoaded() {
+import com.powersync.extractLib
+
+public class JavaEncryptedDatabaseFactory(key: Key): BundledSQLiteDriver(key) {
+    override fun resolveDefaultDatabasePath(dbFilename: String): String {
+        return dbFilename
+    }
+}
 
+private val didLoadLibrary by lazy {
+    val path = extractLib(JavaEncryptedDatabaseFactory::class, "sqlite3mc_jni")
+    System.load(path)
+}
+
+internal actual fun ensureJniLibraryLoaded() {
+    didLoadLibrary
 }

sqlite3multipleciphers/src/jvmTest/kotlin/com/powersync/JvmSmokeTest.kt

@@ -0,0 +1,23 @@
+package com.powersync
+
+import com.powersync.encryption.JavaEncryptedDatabaseFactory
+import com.powersync.encryption.Key
+import io.kotest.matchers.shouldBe
+import kotlin.test.Test
+import kotlin.use
+
+class JvmSmokeTest {
+    @Test
+    fun linksSqlite3MultipleCiphers() {
+        JavaEncryptedDatabaseFactory(key).openInMemoryConnection().use { db ->
+            db.prepare("PRAGMA cipher").use { stmt ->
+                stmt.step() shouldBe true
+                stmt.getText(0) shouldBe "chacha20"
+            }
+        }
+    }
+
+    private companion object Companion {
+        val key = Key.Passphrase("test")
+    }
+}