Get basic sqlite working with updates

Author: jkmassel

.buildkite/swift-test.sh

@@ -18,7 +18,7 @@ function build_for_real_device() {
     echo "--- :swift: Building for $platform device"
     export NSUnbufferedIO=YES
     xcodebuild -destination "generic/platform=$platform" \
-        -scheme WordPressAPI \
+        -scheme WordPressAPI-Package \
         -derivedDataPath DerivedData \
         -skipPackagePluginValidation \
         build | xcbeautify

.gitignore

@@ -6,6 +6,10 @@
 /docs
 /docs.tar.gz
 
+# Test DB Files
+kotlin.db
+swift.db
+
 # Ignore Gradle project-specific cache directory
 .gradle
 
@@ -33,7 +37,6 @@ fastlane/report.xml
 libwordPressFFI.xcframework*
 /swift-docs.tar.gz
 
-
 # Auto-generated Swift Files
 native/swift/Sources/wordpress-api-wrapper/*.swift
 

Cargo.lock

@@ -102,7 +102,7 @@ _build-apple-%-tvos _build-apple-%-tvos-sim _build-apple-%-watchos _build-apple-
 
 # Build the library for a specific target
 _build-apple-%:
-	cargo $(CARGO_OPTS) $(cargo_config_library) build --target $* --package wp_api --profile $(CARGO_PROFILE)
+	cargo $(CARGO_OPTS) $(cargo_config_library) build --target $* --package wp_api --profile $(CARGO_PROFILE) --no-default-features
 	./scripts/swift-bindings.sh target/$*/$(CARGO_PROFILE_DIRNAME)/libwp_api.a
 
 # Build the library for one single platform, including real device and simulator.

Makefile

@@ -26,6 +26,10 @@ var package = Package(
         .library(
             name: "WordPressAPI",
             targets: ["WordPressAPI"]
+        ),
+        .library(
+            name: "WordPressApiCache",
+            targets: ["WordPressApiCache"]
         )
     ],
     dependencies: [
@@ -56,6 +60,13 @@ var package = Package(
                 .swiftLanguageMode(.v5)
             ]
         ),
+        .target(
+            name: "WordPressApiCache",
+            dependencies: [
+                .target(name: "WordPressAPIInternal")
+            ],
+            path: "native/swift/Sources/wordpress-api-cache"
+        ),
         libwordpressFFI,
         .testTarget(
             name: "WordPressAPITests",
@@ -68,6 +79,14 @@ var package = Package(
             swiftSettings: [
                 .define("PROGRESS_REPORTING_ENABLED", .when(platforms: [.iOS, .macOS, .tvOS, .watchOS]))
             ]
+        ),
+        .testTarget(
+            name: "WordPressApiCacheTests",
+            dependencies: [
+                .target(name: "WordPressApiCache"),
+                .target(name: "WordPressAPIInternal")
+            ],
+            path: "native/swift/Tests/wordpress-api-cache"
         )
     ].addingIntegrationTests()
 )

Package.resolved

@@ -1,3 +1,6 @@
+import org.jetbrains.kotlin.konan.target.linker
+import kotlin.system.exitProcess
+
 plugins {
     id("com.android.library")
     id("org.jetbrains.kotlin.android")

Package.swift

@@ -0,0 +1,15 @@
+package rs.wordpress.api.cache.kotlin
+
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.parallel.Execution
+import org.junit.jupiter.api.parallel.ExecutionMode
+import kotlin.test.assertEquals
+
+@Execution(ExecutionMode.CONCURRENT)
+class WordPressApiCache {
+
+    @Test
+    fun testThatMigrationsWork() {
+        assertEquals(2, WordPressApiCache().performMigrations())
+    }
+}

native/kotlin/api/android/build.gradle.kts

@@ -0,0 +1,47 @@
+package rs.wordpress.cache.kotlin
+
+import kotlinx.coroutines.asCoroutineDispatcher
+import uniffi.wp_api.DatabaseDelegate
+import uniffi.wp_api.UpdateHook
+import uniffi.wp_api.WpApiCache
+import uniffi.wp_api.setGlobalDelegate
+import java.nio.file.Path
+import java.util.concurrent.Executors
+
+class WordPressApiCacheDelegate : DatabaseDelegate {
+    override fun didUpdate(updateHook: UpdateHook) {
+        println("Received update: $updateHook")
+    }
+}
+
+class WordPressApiCache {
+    private val cache: WpApiCache
+    private val internalDispatcher = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
+    private val delegate: DatabaseDelegate = WordPressApiCacheDelegate()
+
+    // Creates a new in-memory cache
+    constructor() : this(":memory:")
+
+    // Creates a new cache at the specified file system URL
+    constructor(path: Path) : this(path.toString())
+
+    // Creates a new cache at the specified path
+    constructor(string: String) {
+        this.cache = WpApiCache(string)
+    }
+
+    fun performMigrations(): Int {
+        internalDispatcher.run {
+            return this@WordPressApiCache.cache.performMigrations().toInt()
+        }
+    }
+
+    fun startListeningForUpdates() {
+        setGlobalDelegate(delegate)
+        this.cache.startListeningForUpdates()
+    }
+
+    fun stopListeningForUpdates() {
+        this.cache.stopListeningForUpdates()
+    }
+}

native/kotlin/api/kotlin/src/integrationTest/kotlin/WordPressApiCache.kt

@@ -0,0 +1,58 @@
+import Foundation
+import WordPressAPIInternal
+
+public actor WordPressApiCache {
+
+    private let cache: WpApiCache
+    private let delegate: any DatabaseDelegate
+
+    public struct Notifications {
+        public static let cacheDidUpdate = Notification.Name("WordPressApiCache.cacheDidUpdate")
+
+        public static func name(for table: String) -> Notification.Name {
+            Notification.Name(rawValue: "WordPressApiCachce.cacheDidUpdate.\(table)")
+        }
+    }
+
+    final public class ApiCacheDelegate: DatabaseDelegate {
+        public init() {}
+
+        public func didUpdate(updateHook: WordPressAPIInternal.UpdateHook) {
+            let name = Notifications.name(for: updateHook.tableName)
+            NotificationCenter.default.post(name: name, object: updateHook)
+        }
+    }
+
+    /// Creates a new in-memory cache
+    public init(delegate: DatabaseDelegate = ApiCacheDelegate()) throws {
+        try self.init(path: ":memory:", delegate: delegate)
+    }
+
+    /// Creates a new cache at the specified file system URL
+    public init(url: URL, delegate: DatabaseDelegate = ApiCacheDelegate()) throws {
+        try self.init(path: url.absoluteString, delegate: delegate)
+    }
+
+    /// Creates a new cache at the specified path
+    public init(path: String, delegate: DatabaseDelegate = ApiCacheDelegate()) throws {
+        self.cache = try WpApiCache(path: path)
+        self.delegate = delegate
+    }
+
+    public func performMigrations() async throws -> Int {
+        return Int(try self.cache.performMigrations())
+    }
+
+    public func startListeningForUpdates() {
+        setGlobalDelegate(delegate: delegate)
+        self.cache.startListeningForUpdates()
+    }
+
+    public func stopListeningForUpdates() {
+        self.cache.stopListeningForUpdates()
+    }
+
+    deinit {
+        self.cache.stopListeningForUpdates()
+    }
+}