chore: merge main

Author: DominicGBauer

Demo/PowerSyncExample/PowerSync/SupabaseConnector.swift

@@ -2,7 +2,6 @@ import Auth
 import SwiftUI
 import Supabase
 import PowerSyncSwift
-import PowerSync
 import AnyCodable
 
 @Observable
@@ -16,7 +15,6 @@ class SupabaseConnector: PowerSyncBackendConnector {
 
     override init() {
         super.init()
-
         observeAuthStateChangesTask = Task { [weak self] in
             guard let self = self else { return }
 
@@ -49,7 +47,7 @@ class SupabaseConnector: PowerSyncBackendConnector {
         return PowerSyncCredentials(endpoint: self.powerSyncEndpoint, token: token, userId: currentUserID)
     }
 
-    override func uploadData(database: PowerSyncDatabase) async throws {
+    override func uploadData(database: PowerSyncDatabaseProtocol) async throws {
 
         guard let transaction = try await database.getNextCrudTransaction() else { return }
 
@@ -75,7 +73,7 @@ class SupabaseConnector: PowerSyncBackendConnector {
                 }
             }
 
-            try await transaction.complete.invoke(p1: nil)
+            _ = try await transaction.complete.invoke(p1: nil)
 
         } catch {
             print("Data upload error - retrying last entry: \(lastEntry!), \(error)")

Sources/PowerSyncSwift/Kotlin/KotlinPowerSyncDatabaseImpl.swift

@@ -2,110 +2,116 @@ import Foundation
 import PowerSync
 
 final class KotlinPowerSyncDatabaseImpl: PowerSyncDatabaseProtocol {
-    private let kmpDatabase: PowerSync.PowerSyncDatabase
-    
+    private let kotlinDatabase: PowerSync.PowerSyncDatabase
+
     var currentStatus: SyncStatus {
-        get { kmpDatabase.currentStatus }
+        get { kotlinDatabase.currentStatus }
     }
-    
+
     init(
         schema: Schema,
         dbFilename: String
     ) {
         let factory = PowerSync.DatabaseDriverFactory()
-        self.kmpDatabase = PowerSyncDatabase(
+        self.kotlinDatabase = PowerSyncDatabase(
             factory: factory,
             schema: KotlinAdapter.Schema.toKotlin(schema),
             dbFilename: dbFilename
         )
     }
 
+    init(kotlinDatabase: KotlinPowerSyncDatabase) {
+        self.kotlinDatabase = kotlinDatabase
+    }
+
     func waitForFirstSync() async throws {
-        try await kmpDatabase.waitForFirstSync()
+        try await kotlinDatabase.waitForFirstSync()
     }
-    
+
     func connect(
         connector: PowerSyncBackendConnector,
         crudThrottleMs: Int64 = 1000,
         retryDelayMs: Int64 = 5000,
         params: [String: JsonParam?] = [:]
     ) async throws {
-        try await kmpDatabase.connect(
-            connector: connector,
+        let connectorAdapter = PowerSyncBackendConnectorAdapter(swiftBackendConnector: connector)
+
+        try await kotlinDatabase.connect(
+            connector: connectorAdapter,
             crudThrottleMs: crudThrottleMs,
             retryDelayMs: retryDelayMs,
             params: params
         )
     }
-    
+
     func getCrudBatch(limit: Int32 = 100) async throws -> CrudBatch? {
-        try await kmpDatabase.getCrudBatch(limit: limit)
+        try await kotlinDatabase.getCrudBatch(limit: limit)
     }
-    
+
     func getNextCrudTransaction() async throws -> CrudTransaction? {
-        try await kmpDatabase.getNextCrudTransaction()
+        try await kotlinDatabase.getNextCrudTransaction()
     }
-    
+
     func getPowerSyncVersion() async throws -> String {
-        try await kmpDatabase.getPowerSyncVersion()
+        try await kotlinDatabase.getPowerSyncVersion()
     }
-    
+
     func disconnect() async throws {
-        try await kmpDatabase.disconnect()
+        try await kotlinDatabase.disconnect()
     }
-    
+
     func disconnectAndClear(clearLocal: Bool = true) async throws {
-        try await kmpDatabase.disconnectAndClear(clearLocal: clearLocal)
+        try await kotlinDatabase.disconnectAndClear(clearLocal: clearLocal)
     }
-    
+
     func execute(sql: String, parameters: [Any]?) async throws -> Int64 {
-        Int64(truncating: try await kmpDatabase.execute(sql: sql, parameters: parameters))
+        Int64(truncating: try await kotlinDatabase.execute(sql: sql, parameters: parameters))
     }
-    
+
     func get<RowType>(
         sql: String,
         parameters: [Any]?,
         mapper: @escaping (SqlCursor) -> RowType
     ) async throws -> RowType {
-        try await kmpDatabase.get(
+        try await kotlinDatabase.get(
             sql: sql,
             parameters: parameters,
             mapper: mapper
         ) as! RowType
     }
-    
+
     func getAll<RowType>(
         sql: String,
         parameters: [Any]?,
         mapper: @escaping (SqlCursor) -> RowType
     ) async throws -> [RowType] {
-        try await kmpDatabase.getAll(
+        try await kotlinDatabase.getAll(
             sql: sql,
             parameters: parameters,
             mapper: mapper
         ) as! [RowType]
     }
-    
+
     func getOptional<RowType>(
         sql: String,
         parameters: [Any]?,
         mapper: @escaping (SqlCursor) -> RowType
     ) async throws -> RowType? {
-        try await kmpDatabase.getOptional(
+        try await kotlinDatabase.getOptional(
             sql: sql,
             parameters: parameters,
             mapper: mapper
         ) as! RowType?
     }
-    
+
     func watch<RowType>(
         sql: String,
         parameters: [Any]?,
         mapper: @escaping (SqlCursor) -> RowType
     ) -> AsyncStream<[RowType]> {
         AsyncStream { continuation in
             Task {
-                for await values in self.kmpDatabase.watch(
+                for await values in self.kotlinDatabase.watch(
                     sql: sql,
                     parameters: parameters,
                     mapper: mapper
@@ -116,15 +122,15 @@ final class KotlinPowerSyncDatabaseImpl: PowerSyncDatabaseProtocol {
             }
         }
     }
-    
+
     public func writeTransaction<R>(callback: @escaping (any PowerSyncTransaction) async throws -> R) async throws -> R {
-        return try await kmpDatabase.writeTransaction(callback: SuspendTaskWrapper { transaction in
+        return try await kotlinDatabase.writeTransaction(callback: SuspendTaskWrapper { transaction in
             return try await callback(transaction)
         }) as! R
     }
-    
+
     public func readTransaction<R>(callback: @escaping (any PowerSyncTransaction) async throws -> R) async throws -> R {
-        return try await kmpDatabase.writeTransaction(callback: SuspendTaskWrapper { transaction in
+        return try await kotlinDatabase.writeTransaction(callback: SuspendTaskWrapper { transaction in
             return try await callback(transaction)
         }) as! R
     }
@@ -152,4 +158,3 @@ class SuspendTaskWrapper: KotlinSuspendFunction1 {
         }
     }
 }
-

Sources/PowerSyncSwift/Kotlin/KotlinTypes.swift

@@ -1,11 +1,12 @@
 import PowerSync
 
-public typealias PowerSyncBackendConnector = PowerSync.PowerSyncBackendConnector
+public typealias KotlinPowerSyncBackendConnector = PowerSync.PowerSyncBackendConnector
 public typealias CrudEntry = PowerSync.CrudEntry
 public typealias CrudBatch = PowerSync.CrudBatch
 public typealias SyncStatus = PowerSync.SyncStatus
 public typealias SqlCursor = PowerSync.RuntimeSqlCursor
 public typealias JsonParam = PowerSync.JsonParam
 public typealias CrudTransaction = PowerSync.CrudTransaction
-public typealias PowerSyncCredentials = PowerSync.PowerSyncCredentials
+public typealias KotlinPowerSyncCredentials = PowerSync.PowerSyncCredentials
+public typealias KotlinPowerSyncDatabase = PowerSync.PowerSyncDatabase
 

Sources/PowerSyncSwift/PowerSyncBackendConnector.swift

@@ -0,0 +1,16 @@
+public protocol PowerSyncBackendConnectorProtocol {
+    func uploadData(database: PowerSyncDatabaseProtocol) async throws
+
+    func fetchCredentials() async throws -> PowerSyncCredentials?
+}
+
+open class PowerSyncBackendConnector: PowerSyncBackendConnectorProtocol {
+    public init() {}
+    
+    open func uploadData(database: PowerSyncDatabaseProtocol) async throws {}
+
+    open func fetchCredentials() async throws -> PowerSyncCredentials? {
+        return nil
+    }
+}
+

Sources/PowerSyncSwift/PowerSyncBackendConnectorAdapter.swift

@@ -0,0 +1,18 @@
+class PowerSyncBackendConnectorAdapter: KotlinPowerSyncBackendConnector {
+    let swiftBackendConnector: PowerSyncBackendConnector
+
+    init(
+        swiftBackendConnector: PowerSyncBackendConnector
+    ) {
+        self.swiftBackendConnector = swiftBackendConnector
+    }
+
+    override func __fetchCredentials() async throws -> KotlinPowerSyncCredentials? {
+        try await swiftBackendConnector.fetchCredentials()?.kotlinCredentials
+    }
+
+    override func __uploadData(database: KotlinPowerSyncDatabase) async throws {
+        let swiftDatabase = KotlinPowerSyncDatabaseImpl(kotlinDatabase: database)
+        try await swiftBackendConnector.uploadData(database: swiftDatabase)
+    }
+}

Sources/PowerSyncSwift/PowerSyncCredentials.swift

@@ -0,0 +1,38 @@
+import Foundation
+
+public struct PowerSyncCredentials: Codable {
+    /// PowerSync endpoint, e.g. "https://myinstance.powersync.co".
+    public let endpoint: String
+
+    /// Temporary token to authenticate against the service.
+    public let token: String
+
+    /// User ID.
+    public let userId: String?
+
+    public init(endpoint: String, token: String, userId: String?) {
+        self.endpoint = endpoint
+        self.token = token
+        self.userId = userId
+    }
+
+    internal init(kotlin: KotlinPowerSyncCredentials) {
+        self.endpoint = kotlin.endpoint
+        self.token = kotlin.token
+        self.userId = kotlin.userId
+    }
+
+    internal var kotlinCredentials: KotlinPowerSyncCredentials {
+        return KotlinPowerSyncCredentials(endpoint: endpoint, token: token, userId: userId)
+    }
+
+    public func endpointUri(path: String) -> String {
+        return "\(endpoint)/\(path)"
+    }
+}
+
+extension PowerSyncCredentials: CustomStringConvertible {
+    public var description: String {
+        return "PowerSyncCredentials<endpoint: \(endpoint) userId: \(userId ?? "nil")>"
+    }
+}