cleanup

Author: stevensJourney

Sources/PowerSync/Kotlin/KotlinPowerSyncDatabaseImpl.swift

@@ -25,7 +25,7 @@ final class KotlinPowerSyncDatabaseImpl: PowerSyncDatabaseProtocol {
     func waitForFirstSync() async throws {
         try await kotlinDatabase.waitForFirstSync()
     }
-    
+
     func waitForFirstSync(priority: Int32) async throws {
         try await kotlinDatabase.waitForFirstSync(priority: priority)
     }
@@ -173,58 +173,55 @@ final class KotlinPowerSyncDatabaseImpl: PowerSyncDatabaseProtocol {
         parameters: [Any]?,
         mapper: @escaping (SqlCursor) throws -> RowType
     ) throws -> AsyncThrowingStream<[RowType], Error> {
-       try watch(options: WatchOptions(sql: sql, parameters: parameters, mapper: mapper))
-    }
-        
-        func watch<RowType>(
-            options: WatchOptions<RowType>
-        ) throws -> AsyncThrowingStream<[RowType], Error> {
-            AsyncThrowingStream { continuation in
-                Task {
-                    do {
-                        var mapperError: Error?
-                        // HACK!
-                        // SKIEE doesn't support custom exceptions in Flows
-                        // Exceptions which occur in the Flow itself cause runtime crashes.
-                        // The most probable crash would be the internal EXPLAIN statement.
-                        // This attempts to EXPLAIN the query before passing it to Kotlin
-                        // We could introduce an onChange API in Kotlin which we use to implement watches here.
-                        // This would prevent most issues with exceptions.
-                        _ = try await self.kotlinDatabase.get(sql: "EXPLAIN \(options.sql)", parameters: options.parameters, mapper: {_ in ""})
-                        for try await values in try self.kotlinDatabase.watch(
-                            sql: options.sql,
-                            parameters: options.parameters,
-                            throttleMs: KotlinLong(value: options.throttleMs),
-                            mapper: { cursor in do {
-                                return try options.mapper(cursor)
-                            } catch {
-                                mapperError = error
-                                // The value here does not matter. We will throw the exception later
-                                // This is not ideal, this is only a workaround until we expose fine grained access to Kotlin SDK internals.
-                                return nil as RowType?
-                            } }
-                        ) {
-                            if mapperError != nil {
-                                throw mapperError!
-                            }
-                            try continuation.yield(safeCast(values, to: [RowType].self))
+        try watch(options: WatchOptions(sql: sql, parameters: parameters, mapper: mapper))
+    }
+
+    func watch<RowType>(
+        options: WatchOptions<RowType>
+    ) throws -> AsyncThrowingStream<[RowType], Error> {
+        AsyncThrowingStream { continuation in
+            Task {
+                do {
+                    var mapperError: Error?
+                    // HACK!
+                    // SKIEE doesn't support custom exceptions in Flows
+                    // Exceptions which occur in the Flow itself cause runtime crashes.
+                    // The most probable crash would be the internal EXPLAIN statement.
+                    // This attempts to EXPLAIN the query before passing it to Kotlin
+                    // We could introduce an onChange API in Kotlin which we use to implement watches here.
+                    // This would prevent most issues with exceptions.
+                    _ = try await self.kotlinDatabase.getAll(sql: "EXPLAIN \(options.sql)", parameters: options.parameters, mapper: { _ in "" })
+                    for try await values in try self.kotlinDatabase.watch(
+                        sql: options.sql,
+                        parameters: options.parameters,
+                        throttleMs: KotlinLong(value: options.throttleMs),
+                        mapper: { cursor in do {
+                            return try options.mapper(cursor)
+                        } catch {
+                            mapperError = error
+                            // The value here does not matter. We will throw the exception later
+                            // This is not ideal, this is only a workaround until we expose fine grained access to Kotlin SDK internals.
+                            return nil as RowType?
+                        } }
+                    ) {
+                        if mapperError != nil {
+                            throw mapperError!
                         }
-                        continuation.finish()
-                    } catch {
-                        continuation.finish(throwing: error)
+                        try continuation.yield(safeCast(values, to: [RowType].self))
                     }
+                    continuation.finish()
+                } catch {
+                    continuation.finish(throwing: error)
                 }
             }
         }
-        
-        
-        func writeTransaction<R>(callback: @escaping (any PowerSyncTransaction) throws -> R) async throws -> R {
-            return try safeCast(await kotlinDatabase.writeTransaction(callback: TransactionCallback(callback: callback)), to: R.self)
-        }
-        
-        func readTransaction<R>(callback: @escaping (any PowerSyncTransaction) throws -> R) async throws -> R {
-            return try safeCast(await kotlinDatabase.readTransaction(callback: TransactionCallback(callback: callback)), to: R.self)
-        }
-    
-}
+    }
 
+    func writeTransaction<R>(callback: @escaping (any PowerSyncTransaction) throws -> R) async throws -> R {
+        return try safeCast(await kotlinDatabase.writeTransaction(callback: TransactionCallback(callback: callback)), to: R.self)
+    }
+
+    func readTransaction<R>(callback: @escaping (any PowerSyncTransaction) throws -> R) async throws -> R {
+        return try safeCast(await kotlinDatabase.readTransaction(callback: TransactionCallback(callback: callback)), to: R.self)
+    }
+}

Sources/PowerSync/QueriesProtocol.swift

@@ -1,20 +1,20 @@
-import Foundation
 import Combine
+import Foundation
 import PowerSyncKotlin
 
-public let DEFAULT_WATCH_THROTTLE_MS = Int64(30);
+public let DEFAULT_WATCH_THROTTLE_MS = Int64(30)
 
 public struct WatchOptions<RowType> {
     public var sql: String
     public var parameters: [Any]
     public var throttleMs: Int64
     public var mapper: (SqlCursor) throws -> RowType
-    
+
     public init(sql: String, parameters: [Any]? = [], throttleMs: Int64? = DEFAULT_WATCH_THROTTLE_MS, mapper: @escaping (SqlCursor) throws -> RowType) {
         self.sql = sql
         self.parameters = parameters ?? [] // Default to empty array if nil
         self.throttleMs = throttleMs ?? DEFAULT_WATCH_THROTTLE_MS // Default to the constant if nil
-        self.mapper = mapper;
+        self.mapper = mapper
     }
 }
 
@@ -84,7 +84,7 @@ public protocol Queries {
         parameters: [Any]?,
         mapper: @escaping (SqlCursor) throws -> RowType
     ) throws -> AsyncThrowingStream<[RowType], Error>
-    
+
     func watch<RowType>(
         options: WatchOptions<RowType>
     ) throws -> AsyncThrowingStream<[RowType], Error>
@@ -96,59 +96,36 @@ public protocol Queries {
     func readTransaction<R>(callback: @escaping (any PowerSyncTransaction) throws -> R) async throws -> R
 }
 
-extension Queries {
-    public func execute(_ sql: String) async throws -> Int64 {
+public extension Queries {
+    func execute(_ sql: String) async throws -> Int64 {
         return try await execute(sql: sql, parameters: [])
     }
 
-    public func get<RowType>(
+    func get<RowType>(
         _ sql: String,
         mapper: @escaping (SqlCursor) -> RowType
     ) async throws -> RowType {
         return try await get(sql: sql, parameters: [], mapper: mapper)
     }
 
-    public func getAll<RowType>(
+    func getAll<RowType>(
         _ sql: String,
         mapper: @escaping (SqlCursor) -> RowType
     ) async throws -> [RowType] {
         return try await getAll(sql: sql, parameters: [], mapper: mapper)
     }
 
-    public func getOptional<RowType>(
+    func getOptional<RowType>(
         _ sql: String,
         mapper: @escaping (SqlCursor) -> RowType
     ) async throws -> RowType? {
         return try await getOptional(sql: sql, parameters: [], mapper: mapper)
     }
 
-    public func watch<RowType>(
-        _ sql: String,
-        mapper: @escaping (SqlCursor) -> RowType
-    ) throws -> AsyncThrowingStream<[RowType], Error> {
-        return try watch(sql: sql, parameters: [], mapper: mapper)
-    }
-    
-
-    /// Execute a read-only (SELECT) query every time the source tables are modified
-    /// and return the results as an array in a Publisher.
     func watch<RowType>(
-        sql: String,
-        parameters: [Any]?,
+        _ sql: String,
         mapper: @escaping (SqlCursor) -> RowType
     ) throws -> AsyncThrowingStream<[RowType], Error> {
         return try watch(sql: sql, parameters: [], mapper: mapper)
     }
-
-    /// Execute a read-only (SELECT) query every time the source tables are modified
-    /// and return the results as an array in a Publisher.
-    func watch<RowType>(
-        sql: String,
-        parameters: [Any]?,
-        mapper: @escaping (SqlCursor) throws -> RowType
-    ) throws -> AsyncThrowingStream<[RowType], Error> {
-        return try watch(sql: sql, parameters: [], mapper: mapper)
-    }
-    
-    
 }