throwing save

Author: stephencelis

Sources/Sharing/Internal/Reference.swift

@@ -350,11 +350,14 @@ extension _PersistentReference: MutableReference, Equatable where Key: SharedKey
     try withMutation(keyPath: \.value) {
       saveError = nil
       defer {
-        do {
-          try key.save(value, immediately: false)
-          loadError = nil
-        } catch {
-          saveError = error
+        key.save(value, immediately: false) { [weak self] result in
+          guard let self else { return }
+          switch result {
+          case .success:
+            loadError = nil
+          case let .failure(error):
+            saveError = error
+          }
         }
       }
       return try lock.withLock {
@@ -363,10 +366,10 @@ extension _PersistentReference: MutableReference, Equatable where Key: SharedKey
     }
   }
 
-  func save() throws {
+  func save() async throws {
     saveError = nil
     do {
-      try key.save(lock.withLock { value }, immediately: true)
+      try await key.save(lock.withLock { value }, immediately: true)
     } catch {
       saveError = error
       throw error
@@ -445,8 +448,8 @@ extension _ManagedReference: MutableReference, Equatable where Key: SharedKey {
     try base.withLock(body)
   }
 
-  func save() throws {
-    try base.save()
+  func save() async throws {
+    try await base.save()
   }
 
   static func == (lhs: _ManagedReference, rhs: _ManagedReference) -> Bool {

Sources/Sharing/SharedKey.swift

@@ -18,7 +18,21 @@ public protocol SharedKey<Value>: SharedReaderKey {
   ///     by default to delay writing to an external source in some way, for example throttling or
   ///     debouncing, if `immediately` is `false`. If `immediately` is `true` it should bypass these
   ///     delays.
-  func save(_ value: Value, immediately: Bool) throws
+  func save(
+    _ value: Value,
+    immediately: Bool,
+    didComplete callback: @escaping @Sendable (Result<Void, any Error>) -> Void
+  )
+}
+
+extension SharedKey {
+  public func save(_ value: Value, immediately: Bool = false) async throws {
+    try await withUnsafeThrowingContinuation { continuation in
+      save(value, immediately: immediately) { result in
+        continuation.resume(with: result)
+      }
+    }
+  }
 }
 
 extension Shared {

Sources/Sharing/SharedKeys/AppStorageKey.swift

@@ -485,8 +485,12 @@
       }
     }
 
-    public func save(_ value: Value, immediately: Bool) {
-      lookup.saveValue(value, to: store.wrappedValue, at: key)
+    public func save(
+      _ value: Value,
+      immediately: Bool,
+      didComplete callback: @escaping (Result<Void, any Error>) -> Void
+    ) {
+      callback(.success(lookup.saveValue(value, to: store.wrappedValue, at: key)))
     }
 
     private final class Observer: NSObject, Sendable {

Sources/Sharing/SharedKeys/DefaultKey.swift

@@ -61,8 +61,12 @@ public struct _SharedKeyDefault<Base: SharedReaderKey>: SharedReaderKey {
 }
 
 extension _SharedKeyDefault: SharedKey where Base: SharedKey {
-  public func save(_ value: Value, immediately: Bool) throws {
-    try base.save(value, immediately: immediately)
+  public func save(
+    _ value: Base.Value,
+    immediately: Bool,
+    didComplete callback: @escaping @Sendable (Result<Void, any Error>) -> Void
+  ) {
+    base.save(value, immediately: immediately, didComplete: callback)
   }
 }
 

Sources/Sharing/SharedKeys/FileStorageKey.swift

@@ -99,13 +99,19 @@
 
     public func load(
       initialValue: Value?,
-      didReceive callback: @escaping (Result<Value?, any Error>) -> Void
+      didReceive callback: @escaping @Sendable (Result<Value?, any Error>) -> Void
     ) {
       do {
         if let initialValue, !storage.fileExists(url) {
           try storage.createDirectory(url.deletingLastPathComponent(), true)
-          try save(initialValue, immediately: true)
-          callback(.success(nil))
+          save(initialValue, immediately: true) { result in
+            switch result {
+            case let .failure(error):
+              callback(.failure(error))
+            case .success:
+              callback(.success(nil))
+            }
+          }
           return
         }
         try callback(.success(decode(storage.load(url))))
@@ -117,44 +123,61 @@
     private func save(data: Data, url: URL, modificationDates: inout [Date]) throws {
       try self.storage.save(data, url)
       if let modificationDate = try storage.attributesOfItemAtPath(url.path)[.modificationDate]
-          as? Date
+        as? Date
       {
         modificationDates.append(modificationDate)
       }
     }
 
-    public func save(_ value: Value, immediately: Bool) throws {
-      try state.withValue { state in
-        let data = try self.encode(value)
-        if immediately {
-          state.value = nil
-          state.workItem?.cancel()
-          state.workItem = nil
-          try self.storage.save(data, url)
-          return
-        }
-        if state.workItem == nil {
-          try save(data: data, url: url, modificationDates: &state.modificationDates)
-
-          let workItem = DispatchWorkItem { [weak self] in
-            guard let self else { return }
-            self.state.withValue { state in
-              defer {
-                state.value = nil
-                state.workItem = nil
+    public func save(
+      _ value: Value,
+      immediately: Bool,
+      didComplete callback: @escaping @Sendable (Result<Void, any Error>) -> Void
+    ) {
+      do {
+        try state.withValue { state in
+          let data = try self.encode(value)
+          if immediately {
+            state.value = nil
+            state.workItem?.cancel()
+            state.workItem = nil
+            try self.storage.save(data, url)
+            callback(.success(()))
+            return
+          }
+          if state.workItem == nil {
+            try save(data: data, url: url, modificationDates: &state.modificationDates)
+            callback(.success(()))
+            let workItem = DispatchWorkItem { [weak self] in
+              guard let self else { return }
+              self.state.withValue { state in
+                defer {
+                  state.value = nil
+                  state.workItem = nil
+                }
+                guard
+                  let value = state.value,
+                  let data = try? self.encode(value)
+                else { return }
+                callback(
+                  Result {
+                    try self.save(
+                      data: data,
+                      url: self.url,
+                      modificationDates: &state.modificationDates
+                    )
+                  }
+                )
               }
-              guard
-                let value = state.value,
-                let data = try? self.encode(value)
-              else { return }
-              try? self.save(data: data, url: self.url, modificationDates: &state.modificationDates)
             }
+            state.workItem = workItem
+            storage.asyncAfter(.seconds(1), workItem)
+          } else {
+            state.value = value
           }
-          state.workItem = workItem
-          storage.asyncAfter(.seconds(1), workItem)
-        } else {
-          state.value = value
         }
+      } catch {
+        callback(.failure(error))
       }
     }
 

Sources/Sharing/SharedKeys/InMemoryKey.swift

@@ -52,8 +52,13 @@ public struct InMemoryKey<Value: Sendable>: SharedKey {
   ) -> SharedSubscription {
     SharedSubscription {}
   }
-  public func save(_ value: Value, immediately: Bool) {
+  public func save(
+    _ value: Value,
+    immediately: Bool,
+    didComplete callback: @escaping (Result<Void, any Error>) -> Void
+  ) {
     store.values[key] = value
+    callback(.success(()))
   }
 }
 

Tests/SharingTests/SharedTests.swift

@@ -90,8 +90,12 @@ import Testing
         ) -> SharedSubscription {
           SharedSubscription {}
         }
-        func save(_ value: Int, immediately: Bool) throws {
-          if value < 0 { throw SaveError() }
+        func save(
+          _ value: Int,
+          immediately: Bool,
+          didComplete callback: @escaping (Result<Void, any Error>) -> Void
+        ) {
+          callback(value < 0 ? .failure(SaveError()) : .success(()))
         }
         struct SaveError: Error {}
       }
@@ -125,8 +129,12 @@ import Testing
           self.callback = callback
           return SharedSubscription {}
         }
-        func save(_ value: Int, immediately: Bool) throws {
-          if value < 0 { throw SaveError() }
+        func save(
+          _ value: Int,
+          immediately: Bool,
+          didComplete callback: @escaping (Result<Void, any Error>) -> Void
+        ) {
+          callback(value < 0 ? .failure(SaveError()) : .success(()))
         }
         struct LoadError: Error {}
         struct SaveError: Error {}