@sriinnu/runic 1.2.0 → 2.0.0

package/Sources/RunicCore/Sync/SyncConflictResolver.swift

@@ -11,7 +11,6 @@ import Foundation
 /// - Highest version: Keep record with highest version number
 /// - Merge: Attempt to merge both versions (custom logic required)
 public actor SyncConflictResolver: SyncConflictResolverProtocol {
-
     // MARK: - Properties
 
     /// Statistics about resolved conflicts
@@ -38,38 +37,35 @@ public actor SyncConflictResolver: SyncConflictResolverProtocol {
     public func resolve(
         local: SyncableRecord,
         remote: SyncableRecord,
-        strategy: ConflictResolutionStrategy
-    ) async -> SyncableRecord {
+        strategy: ConflictResolutionStrategy) async -> SyncableRecord
+    {
         // Validate that records are the same type
         guard local.recordID == remote.recordID else {
             return local // Fallback to local if IDs don't match
         }
 
-        let resolved: SyncableRecord
-
-        switch strategy {
+        let resolved: SyncableRecord = switch strategy {
         case .lastWriteWins:
-            resolved = resolveLastWriteWins(local: local, remote: remote)
+            self.resolveLastWriteWins(local: local, remote: remote)
 
         case .preferLocal:
-            resolved = local
+            local
 
         case .preferRemote:
-            resolved = remote
+            remote
 
         case .highestVersion:
-            resolved = resolveHighestVersion(local: local, remote: remote)
+            self.resolveHighestVersion(local: local, remote: remote)
 
         case .merge:
-            resolved = resolveMerge(local: local, remote: remote)
+            self.resolveMerge(local: local, remote: remote)
         }
 
         // Update statistics
-        conflictStats.recordConflict(
+        self.conflictStats.recordConflict(
             recordType: local.recordType,
             strategy: strategy,
-            winner: resolved.recordID == local.recordID ? .local : .remote
-        )
+            winner: resolved.recordID == local.recordID ? .local : .remote)
 
         return resolved
     }
@@ -81,14 +77,14 @@ public actor SyncConflictResolver: SyncConflictResolverProtocol {
     ///   - handler: Closure that merges two records of this type
     public func registerMergeHandler(
         for recordType: String,
-        handler: @escaping MergeHandler
-    ) {
-        mergeHandlers[recordType] = handler
+        handler: @escaping MergeHandler)
+    {
+        self.mergeHandlers[recordType] = handler
     }
 
     /// Resets conflict statistics
     public func resetStatistics() {
-        conflictStats = ConflictStatistics()
+        self.conflictStats = ConflictStatistics()
     }
 
     // MARK: - Private Resolution Methods
@@ -96,45 +92,45 @@ public actor SyncConflictResolver: SyncConflictResolverProtocol {
     /// Resolves conflict by keeping the most recently modified record
     private func resolveLastWriteWins(
         local: SyncableRecord,
-        remote: SyncableRecord
-    ) -> SyncableRecord {
+        remote: SyncableRecord) -> SyncableRecord
+    {
         if local.modifiedAt > remote.modifiedAt {
-            return local
+            local
         } else if remote.modifiedAt > local.modifiedAt {
-            return remote
+            remote
         } else {
             // Same timestamp, use version as tiebreaker
-            return local.version >= remote.version ? local : remote
+            local.version >= remote.version ? local : remote
         }
     }
 
     /// Resolves conflict by keeping the record with highest version number
     private func resolveHighestVersion(
         local: SyncableRecord,
-        remote: SyncableRecord
-    ) -> SyncableRecord {
+        remote: SyncableRecord) -> SyncableRecord
+    {
         if local.version > remote.version {
-            return local
+            local
         } else if remote.version > local.version {
-            return remote
+            remote
         } else {
             // Same version, use timestamp as tiebreaker
-            return local.modifiedAt >= remote.modifiedAt ? local : remote
+            local.modifiedAt >= remote.modifiedAt ? local : remote
         }
     }
 
     /// Attempts to merge both versions using custom merge logic
     private func resolveMerge(
         local: SyncableRecord,
-        remote: SyncableRecord
-    ) -> SyncableRecord {
+        remote: SyncableRecord) -> SyncableRecord
+    {
         // Check for registered merge handler
         if let handler = mergeHandlers[local.recordType] {
             return handler(local, remote)
         }
 
         // No custom merge handler, fall back to last-write-wins
-        return resolveLastWriteWins(local: local, remote: remote)
+        return self.resolveLastWriteWins(local: local, remote: remote)
     }
 }
 
@@ -173,32 +169,32 @@ public struct ConflictStatistics: Sendable {
     mutating func recordConflict(
         recordType: String,
         strategy: ConflictResolutionStrategy,
-        winner: ConflictWinner
-    ) {
-        totalConflicts += 1
-        conflictsByType[recordType, default: 0] += 1
-        conflictsByStrategy[strategy.rawValue, default: 0] += 1
+        winner: ConflictWinner)
+    {
+        self.totalConflicts += 1
+        self.conflictsByType[recordType, default: 0] += 1
+        self.conflictsByStrategy[strategy.rawValue, default: 0] += 1
 
         switch winner {
         case .local:
-            localWins += 1
+            self.localWins += 1
         case .remote:
-            remoteWins += 1
+            self.remoteWins += 1
         }
 
-        lastConflictAt = Date()
+        self.lastConflictAt = Date()
     }
 
     /// Percentage of conflicts won by local version
     public var localWinRate: Double {
-        guard totalConflicts > 0 else { return 0 }
-        return Double(localWins) / Double(totalConflicts)
+        guard self.totalConflicts > 0 else { return 0 }
+        return Double(self.localWins) / Double(self.totalConflicts)
     }
 
     /// Percentage of conflicts won by remote version
     public var remoteWinRate: Double {
-        guard totalConflicts > 0 else { return 0 }
-        return Double(remoteWins) / Double(totalConflicts)
+        guard self.totalConflicts > 0 else { return 0 }
+        return Double(self.remoteWins) / Double(self.totalConflicts)
     }
 
     /// Human-readable summary of conflict statistics
@@ -207,19 +203,19 @@ public struct ConflictStatistics: Sendable {
             "Conflict Resolution Statistics:",
             "  Total conflicts: \(totalConflicts)",
             "  Local wins: \(localWins) (\(String(format: "%.1f%%", localWinRate * 100)))",
-            "  Remote wins: \(remoteWins) (\(String(format: "%.1f%%", remoteWinRate * 100)))"
+            "  Remote wins: \(remoteWins) (\(String(format: "%.1f%%", remoteWinRate * 100)))",
         ]
 
-        if !conflictsByType.isEmpty {
+        if !self.conflictsByType.isEmpty {
             lines.append("  By record type:")
-            for (type, count) in conflictsByType.sorted(by: { $0.value > $1.value }) {
+            for (type, count) in self.conflictsByType.sorted(by: { $0.value > $1.value }) {
                 lines.append("    \(type): \(count)")
             }
         }
 
-        if !conflictsByStrategy.isEmpty {
+        if !self.conflictsByStrategy.isEmpty {
             lines.append("  By strategy:")
-            for (strategy, count) in conflictsByStrategy.sorted(by: { $0.value > $1.value }) {
+            for (strategy, count) in self.conflictsByStrategy.sorted(by: { $0.value > $1.value }) {
                 lines.append("    \(strategy): \(count)")
             }
         }
@@ -240,9 +236,10 @@ extension SyncConflictResolver {
     /// Registers default merge handlers for Runic record types
     public func registerDefaultMergeHandlers() {
         // Usage Snapshot merge: prefer record with most recent data
-        registerMergeHandler(for: CloudKitRecordType.usageSnapshot) { local, remote in
+        self.registerMergeHandler(for: CloudKitRecordType.usageSnapshot) { local, remote in
             guard let localUsage = local as? UsageSnapshotSyncRecord,
-                  let remoteUsage = remote as? UsageSnapshotSyncRecord else {
+                  let remoteUsage = remote as? UsageSnapshotSyncRecord
+            else {
                 return local
             }
 
@@ -251,9 +248,10 @@ extension SyncConflictResolver {
         }
 
         // User Preferences merge: combine enabled providers
-        registerMergeHandler(for: CloudKitRecordType.userPreferences) { local, remote in
+        self.registerMergeHandler(for: CloudKitRecordType.userPreferences) { local, remote in
             guard let localPrefs = local as? UserPreferencesSyncRecord,
-                  let remotePrefs = remote as? UserPreferencesSyncRecord else {
+                  let remotePrefs = remote as? UserPreferencesSyncRecord
+            else {
                 return local
             }
 
@@ -273,14 +271,14 @@ extension SyncConflictResolver {
                 notificationsEnabled: source.notificationsEnabled,
                 autoRefreshEnabled: source.autoRefreshEnabled,
                 theme: source.theme,
-                displayFormat: source.displayFormat
-            )
+                displayFormat: source.displayFormat)
         }
 
         // Alert Configuration merge: prefer most restrictive thresholds
-        registerMergeHandler(for: CloudKitRecordType.alertConfiguration) { local, remote in
+        self.registerMergeHandler(for: CloudKitRecordType.alertConfiguration) { local, remote in
             guard let localAlert = local as? AlertConfigurationSyncRecord,
-                  let remoteAlert = remote as? AlertConfigurationSyncRecord else {
+                  let remoteAlert = remote as? AlertConfigurationSyncRecord
+            else {
                 return local
             }
 
@@ -303,8 +301,7 @@ extension SyncConflictResolver {
                 warningThreshold: warningThreshold,
                 criticalThreshold: criticalThreshold,
                 notificationChannels: mergedChannels,
-                enabled: enabled
-            )
+                enabled: enabled)
         }
     }
 }

package/Sources/RunicCore/Sync/SyncProtocol.swift

@@ -1,5 +1,5 @@
-import Foundation
 import CloudKit
+import Foundation
 
 // MARK: - Sync Protocol Definitions
 
@@ -90,8 +90,7 @@ public protocol SyncConflictResolverProtocol: Sendable {
     func resolve(
         local: SyncableRecord,
         remote: SyncableRecord,
-        strategy: ConflictResolutionStrategy
-    ) async -> SyncableRecord
+        strategy: ConflictResolutionStrategy) async -> SyncableRecord
 }
 
 // MARK: - Sync Observer Protocol
@@ -150,8 +149,8 @@ public struct SyncOptions: Sendable {
         conflictStrategy: ConflictResolutionStrategy = .lastWriteWins,
         backgroundMode: Bool = false,
         timeout: TimeInterval = 60.0,
-        encryptSensitiveData: Bool = true
-    ) {
+        encryptSensitiveData: Bool = true)
+    {
         self.forceFullSync = forceFullSync
         self.batchSize = batchSize
         self.conflictStrategy = conflictStrategy
@@ -191,8 +190,8 @@ public struct SyncResult: Sendable {
         deletedCount: Int = 0,
         completedAt: Date = Date(),
         duration: TimeInterval = 0,
-        warnings: [String] = []
-    ) {
+        warnings: [String] = [])
+    {
         self.pushedCount = pushedCount
         self.fetchedCount = fetchedCount
         self.conflictsResolved = conflictsResolved
@@ -256,25 +255,25 @@ public enum SyncError: Error, Sendable {
     public var localizedDescription: String {
         switch self {
         case .iCloudAccountUnavailable:
-            return "iCloud account is not available. Please sign in to iCloud in Settings."
+            "iCloud account is not available. Please sign in to iCloud in Settings."
         case .networkUnavailable:
-            return "Network connection is not available. Sync will retry when online."
+            "Network connection is not available. Sync will retry when online."
         case .quotaExceeded:
-            return "iCloud storage quota exceeded. Please free up space or upgrade your plan."
-        case .invalidRecordFormat(let details):
-            return "Invalid record format: \(details)"
+            "iCloud storage quota exceeded. Please free up space or upgrade your plan."
+        case let .invalidRecordFormat(details):
+            "Invalid record format: \(details)"
         case .timeout:
-            return "Sync operation timed out. Please try again."
+            "Sync operation timed out. Please try again."
         case .authenticationFailed:
-            return "Authentication failed. Please sign in again."
-        case .conflictResolutionFailed(let details):
-            return "Failed to resolve conflict: \(details)"
-        case .cloudKitError(let error):
-            return "CloudKit error: \(error.localizedDescription)"
-        case .encryptionFailed(let details):
-            return "Encryption failed: \(details)"
-        case .unknown(let error):
-            return "Unknown error: \(error.localizedDescription)"
+            "Authentication failed. Please sign in again."
+        case let .conflictResolutionFailed(details):
+            "Failed to resolve conflict: \(details)"
+        case let .cloudKitError(error):
+            "CloudKit error: \(error.localizedDescription)"
+        case let .encryptionFailed(details):
+            "Encryption failed: \(details)"
+        case let .unknown(error):
+            "Unknown error: \(error.localizedDescription)"
         }
     }
 }

package/Sources/RunicCore/Sync/SyncRecord.swift

@@ -1,6 +1,6 @@
-import Foundation
 import CloudKit
 import CryptoKit
+import Foundation
 import LocalAuthentication
 
 // MARK: - CloudKit Record Type Constants
@@ -54,8 +54,8 @@ public struct UsageSnapshotSyncRecord: SyncableRecord {
         accountEmail: String? = nil,
         updatedAt: Date = Date(),
         deviceName: String,
-        platform: String
-    ) {
+        platform: String)
+    {
         self.recordID = recordID
         self.version = version
         self.modifiedAt = modifiedAt
@@ -73,20 +73,20 @@ public struct UsageSnapshotSyncRecord: SyncableRecord {
     }
 
     public func toCKRecord() throws -> CKRecord {
-        let record = CKRecord(recordType: recordType, recordID: CKRecord.ID(recordName: recordID))
-
-        record["version"] = version as CKRecordValue
-        record["modifiedAt"] = modifiedAt as CKRecordValue
-        record["lastModifiedDeviceID"] = lastModifiedDeviceID as? CKRecordValue
-        record["providerID"] = providerID as CKRecordValue
-        record["primaryUsed"] = primaryUsed as CKRecordValue
-        record["primaryLimit"] = primaryLimit as? CKRecordValue
-        record["secondaryUsed"] = secondaryUsed as? CKRecordValue
-        record["secondaryLimit"] = secondaryLimit as? CKRecordValue
-        record["costUSD"] = costUSD as? CKRecordValue
-        record["updatedAt"] = updatedAt as CKRecordValue
-        record["deviceName"] = deviceName as CKRecordValue
-        record["platform"] = platform as CKRecordValue
+        let record = CKRecord(recordType: recordType, recordID: CKRecord.ID(recordName: self.recordID))
+
+        record["version"] = self.version as CKRecordValue
+        record["modifiedAt"] = self.modifiedAt as CKRecordValue
+        record["lastModifiedDeviceID"] = self.lastModifiedDeviceID as? CKRecordValue
+        record["providerID"] = self.providerID as CKRecordValue
+        record["primaryUsed"] = self.primaryUsed as CKRecordValue
+        record["primaryLimit"] = self.primaryLimit as? CKRecordValue
+        record["secondaryUsed"] = self.secondaryUsed as? CKRecordValue
+        record["secondaryLimit"] = self.secondaryLimit as? CKRecordValue
+        record["costUSD"] = self.costUSD as? CKRecordValue
+        record["updatedAt"] = self.updatedAt as CKRecordValue
+        record["deviceName"] = self.deviceName as CKRecordValue
+        record["platform"] = self.platform as CKRecordValue
 
         // Encrypt sensitive data
         if let email = accountEmail {
@@ -128,8 +128,7 @@ public struct UsageSnapshotSyncRecord: SyncableRecord {
             accountEmail: accountEmail,
             updatedAt: updatedAt,
             deviceName: deviceName,
-            platform: platform
-        )
+            platform: platform)
     }
 }
 
@@ -164,8 +163,8 @@ public struct UserPreferencesSyncRecord: SyncableRecord {
         notificationsEnabled: Bool = true,
         autoRefreshEnabled: Bool = true,
         theme: String = "system",
-        displayFormat: String = "compact"
-    ) {
+        displayFormat: String = "compact")
+    {
         self.recordID = recordID
         self.version = version
         self.modifiedAt = modifiedAt
@@ -179,17 +178,17 @@ public struct UserPreferencesSyncRecord: SyncableRecord {
     }
 
     public func toCKRecord() throws -> CKRecord {
-        let record = CKRecord(recordType: recordType, recordID: CKRecord.ID(recordName: recordID))
-
-        record["version"] = version as CKRecordValue
-        record["modifiedAt"] = modifiedAt as CKRecordValue
-        record["lastModifiedDeviceID"] = lastModifiedDeviceID as? CKRecordValue
-        record["refreshInterval"] = refreshInterval as CKRecordValue
-        record["enabledProviders"] = enabledProviders as CKRecordValue
-        record["notificationsEnabled"] = (notificationsEnabled ? 1 : 0) as CKRecordValue
-        record["autoRefreshEnabled"] = (autoRefreshEnabled ? 1 : 0) as CKRecordValue
-        record["theme"] = theme as CKRecordValue
-        record["displayFormat"] = displayFormat as CKRecordValue
+        let record = CKRecord(recordType: recordType, recordID: CKRecord.ID(recordName: self.recordID))
+
+        record["version"] = self.version as CKRecordValue
+        record["modifiedAt"] = self.modifiedAt as CKRecordValue
+        record["lastModifiedDeviceID"] = self.lastModifiedDeviceID as? CKRecordValue
+        record["refreshInterval"] = self.refreshInterval as CKRecordValue
+        record["enabledProviders"] = self.enabledProviders as CKRecordValue
+        record["notificationsEnabled"] = (self.notificationsEnabled ? 1 : 0) as CKRecordValue
+        record["autoRefreshEnabled"] = (self.autoRefreshEnabled ? 1 : 0) as CKRecordValue
+        record["theme"] = self.theme as CKRecordValue
+        record["displayFormat"] = self.displayFormat as CKRecordValue
 
         return record
     }
@@ -217,8 +216,7 @@ public struct UserPreferencesSyncRecord: SyncableRecord {
             notificationsEnabled: notificationsEnabled == 1,
             autoRefreshEnabled: autoRefreshEnabled == 1,
             theme: theme,
-            displayFormat: displayFormat
-        )
+            displayFormat: displayFormat)
     }
 }
 
@@ -251,8 +249,8 @@ public struct AlertConfigurationSyncRecord: SyncableRecord {
         warningThreshold: Double = 0.75,
         criticalThreshold: Double = 0.90,
         notificationChannels: [String] = ["system"],
-        enabled: Bool = true
-    ) {
+        enabled: Bool = true)
+    {
         self.recordID = recordID
         self.version = version
         self.modifiedAt = modifiedAt
@@ -265,16 +263,16 @@ public struct AlertConfigurationSyncRecord: SyncableRecord {
     }
 
     public func toCKRecord() throws -> CKRecord {
-        let record = CKRecord(recordType: recordType, recordID: CKRecord.ID(recordName: recordID))
+        let record = CKRecord(recordType: recordType, recordID: CKRecord.ID(recordName: self.recordID))
 
-        record["version"] = version as CKRecordValue
-        record["modifiedAt"] = modifiedAt as CKRecordValue
-        record["lastModifiedDeviceID"] = lastModifiedDeviceID as? CKRecordValue
-        record["providerID"] = providerID as CKRecordValue
-        record["warningThreshold"] = warningThreshold as CKRecordValue
-        record["criticalThreshold"] = criticalThreshold as CKRecordValue
-        record["notificationChannels"] = notificationChannels as CKRecordValue
-        record["enabled"] = (enabled ? 1 : 0) as CKRecordValue
+        record["version"] = self.version as CKRecordValue
+        record["modifiedAt"] = self.modifiedAt as CKRecordValue
+        record["lastModifiedDeviceID"] = self.lastModifiedDeviceID as? CKRecordValue
+        record["providerID"] = self.providerID as CKRecordValue
+        record["warningThreshold"] = self.warningThreshold as CKRecordValue
+        record["criticalThreshold"] = self.criticalThreshold as CKRecordValue
+        record["notificationChannels"] = self.notificationChannels as CKRecordValue
+        record["enabled"] = (self.enabled ? 1 : 0) as CKRecordValue
 
         return record
     }
@@ -300,8 +298,7 @@ public struct AlertConfigurationSyncRecord: SyncableRecord {
             warningThreshold: warningThreshold,
             criticalThreshold: criticalThreshold,
             notificationChannels: notificationChannels,
-            enabled: enabled == 1
-        )
+            enabled: enabled == 1)
     }
 }
 
@@ -378,7 +375,7 @@ private func saveToKeychain(key: String, data: Data) {
         kSecAttrAccount as String: key,
         kSecUseDataProtectionKeychain as String: true,
         kSecValueData as String: data,
-        kSecAttrAccessible as String: kSecAttrAccessibleAfterFirstUnlock
+        kSecAttrAccessible as String: kSecAttrAccessibleAfterFirstUnlock,
     ]
     SecItemDelete(query as CFDictionary)
     SecItemAdd(query as CFDictionary, nil)
@@ -391,7 +388,7 @@ private func loadFromKeychain(key: String) -> Data? {
         kSecAttrAccount as String: key,
         kSecUseDataProtectionKeychain as String: true,
         kSecUseAuthenticationUI as String: "kSecUseAuthenticationUIFail" as CFString,
-        kSecReturnData as String: true
+        kSecReturnData as String: true,
     ]
     let authContext = LAContext()
     authContext.interactionNotAllowed = true