update time durations from ms to TimeInterval

Author: stevensJourney

CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-# 1.0.0-Beta.14
+# 1.0.0
 
 - Improved the stability of watched queries. Watched queries were previously susceptible to runtime crashes if an exception was thrown in the update stream. Errors are now gracefully handled.
 
@@ -86,6 +86,35 @@ try await database.connect(
 + let time: Date? = db.currentStatus.lastSyncedAt
 ```
 
+- `crudThrottleMs` and `retryDelayMs` in the `connect` method have been updated to `crudThrottle` and `retryDelay` which are now of type `TimeInterval`. Previously the parameters were specified in milliseconds, the `TimeInterval` typing now requires values to be specified in seconds.
+
+```diff
+try await database.connect(
+            connector: PowerSyncBackendConnector(),
+-           crudThrottleMs: 1000,
+-           retryDelayMs: 5000,
++           crudThrottle: 1,
++           retryDelay: 5,
+            params: [
+                "foo": .string("bar"),
+            ]
+        )
+```
+
+- `throttleMs` in the watched query `WatchOptions` has been updated to `throttle` which is now of type `TimeInterval`. Previously the parameters were specified in milliseconds, the `TimeInterval` typing now requires values to be specified in seconds.
+
+```diff
+let stream = try database.watch(
+            options: WatchOptions(
+                sql: "SELECT name FROM users ORDER BY id",
+-               throttleMs: 1000,
++               throttle: 1,
+                mapper: { cursor in
+                    try cursor.getString(index: 0)
+                }
+            ))
+```
+
 # 1.0.0-Beta.13
 
 - Update `powersync-kotlin` dependency to version `1.0.0-BETA32`, which includes:

Sources/PowerSync/Kotlin/KotlinPowerSyncDatabaseImpl.swift

@@ -55,8 +55,8 @@ final class KotlinPowerSyncDatabaseImpl: PowerSyncDatabaseProtocol {
 
         try await kotlinDatabase.connect(
             connector: connectorAdapter,
-            crudThrottleMs: resolvedOptions.crudThrottleMs,
-            retryDelayMs: resolvedOptions.retryDelayMs,
+            crudThrottleMs: Int64(resolvedOptions.crudThrottle * 1000),
+            retryDelayMs: Int64(resolvedOptions.retryDelay * 1000),
             params: resolvedOptions.params.mapValues { $0.toKotlinMap() }
         )
     }
@@ -230,7 +230,7 @@ final class KotlinPowerSyncDatabaseImpl: PowerSyncDatabaseProtocol {
                     // Watching for changes in the database
                     for try await _ in try self.kotlinDatabase.onChange(
                         tables: Set(watchedTables),
-                        throttleMs: options.throttleMs,
+                        throttleMs: Int64(options.throttle * 1000),
                         triggerImmediately: true // Allows emitting the first result even if there aren't changes
                     ) {
                         // Check if the outer task is cancelled

Sources/PowerSync/Protocol/PowerSyncDatabaseProtocol.swift

@@ -4,17 +4,23 @@ import Foundation
 ///
 /// Provides optional parameters to customize sync behavior such as throttling and retry policies.
 public struct ConnectOptions {
-    /// Time in milliseconds between CRUD (Create, Read, Update, Delete) operations.
+    /// Defaults to 1 second
+    public static let DefaultCrudThrottle: TimeInterval = 1
+    
+    /// Defaults to 5 seconds
+    public static let DefaultRetryDelay: TimeInterval = 5
+    
+    /// TimeInterval (in seconds) between CRUD (Create, Read, Update, Delete) operations.
     ///
-    /// Default is `1000` ms (1 second).
+    /// Default is ``ConnectOptions/DefaultCrudThrottle``.
     /// Increase this value to reduce load on the backend server.
-    public var crudThrottleMs: Int64
+    public var crudThrottle: TimeInterval
 
-    /// Delay in milliseconds before retrying after a connection failure.
+    /// Delay TimeInterval (in seconds) before retrying after a connection failure.
     ///
-    /// Default is `5000` ms (5 seconds).
+    /// Default is ``ConnectOptions/DefaultRetryDelay``.
     /// Increase this value to wait longer before retrying connections in case of persistent failures.
-    public var retryDelayMs: Int64
+    public var retryDelay: TimeInterval
 
     /// Additional sync parameters passed to the server during connection.
     ///
@@ -32,16 +38,16 @@ public struct ConnectOptions {
     /// Initializes a `ConnectOptions` instance with optional values.
     ///
     /// - Parameters:
-    ///   - crudThrottleMs: Time between CRUD operations in milliseconds. Defaults to `1000`.
-    ///   - retryDelayMs: Delay between retry attempts in milliseconds. Defaults to `5000`.
+    ///   - crudThrottle: TimeInterval between CRUD operations in milliseconds. Defaults to `1` second.
+    ///   - retryDelay: Delay TimeInterval between retry attempts in milliseconds. Defaults to `5` seconds.
     ///   - params: Custom sync parameters to send to the server. Defaults to an empty dictionary.
     public init(
-        crudThrottleMs: Int64 = 1000,
-        retryDelayMs: Int64 = 5000,
+        crudThrottle: TimeInterval = 1,
+        retryDelay: TimeInterval = 5,
         params: JsonParam = [:]
     ) {
-        self.crudThrottleMs = crudThrottleMs
-        self.retryDelayMs = retryDelayMs
+        self.crudThrottle = crudThrottle
+        self.retryDelay = retryDelay
         self.params = params
     }
 }
@@ -168,8 +174,8 @@ public extension PowerSyncDatabaseProtocol {
     ///
     /// - Parameters:
     ///   - connector: The PowerSyncBackendConnector to use
-    ///   - crudThrottleMs: Time between CRUD operations. Defaults to 1000ms.
-    ///   - retryDelayMs: Delay between retries after failure. Defaults to 5000ms.
+    ///   - crudThrottle: TimeInterval between CRUD operations. Defaults to ``ConnectOptions/DefaultCrudThrottle``.
+    ///   - retryDelay: Delay TimeInterval between retries after failure. Defaults to ``ConnectOptions/DefaultRetryDelay``.
     ///   - params: Sync parameters from the client
     ///
     /// Example usage:
@@ -188,15 +194,15 @@ public extension PowerSyncDatabaseProtocol {
     /// )
     func connect(
         connector: PowerSyncBackendConnector,
-        crudThrottleMs: Int64 = 1000,
-        retryDelayMs: Int64 = 5000,
+        crudThrottle: TimeInterval = 1,
+        retryDelay: TimeInterval = 5,
         params: JsonParam = [:]
     ) async throws {
         try await connect(
             connector: connector,
             options: ConnectOptions(
-                crudThrottleMs: crudThrottleMs,
-                retryDelayMs: retryDelayMs,
+                crudThrottle: crudThrottle,
+                retryDelay: retryDelay,
                 params: params
             )
         )

Sources/PowerSync/Protocol/QueriesProtocol.swift

@@ -1,22 +1,22 @@
 import Combine
 import Foundation
 
-public let DEFAULT_WATCH_THROTTLE_MS = Int64(30)
+public let DEFAULT_WATCH_THROTTLE: TimeInterval = 0.03 // 30ms
 
 public struct WatchOptions<RowType> {
     public var sql: String
     public var parameters: [Any?]
-    public var throttleMs: Int64
+    public var throttle: TimeInterval
     public var mapper: (SqlCursor) throws -> RowType
 
     public init(
         sql: String, parameters: [Any?]? = [],
-        throttleMs: Int64? = DEFAULT_WATCH_THROTTLE_MS,
+        throttle: TimeInterval? = DEFAULT_WATCH_THROTTLE,
         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.parameters = parameters ?? []
+        self.throttle = throttle ?? DEFAULT_WATCH_THROTTLE
         self.mapper = mapper
     }
 }