Add CmixWaitForMessageDelivery functor

Sources/ElixxirDAppsSDK/Cmix.swift

@@ -12,6 +12,7 @@ public struct Cmix {
   public var waitForNetwork: CmixWaitForNetwork
   public var registerClientErrorCallback: CmixRegisterClientErrorCallback
   public var addHealthCallback: CmixAddHealthCallback
+  public var waitForMessageDelivery: CmixWaitForMessageDelivery
 }
 
 extension Cmix {
@@ -27,7 +28,8 @@ extension Cmix {
       stopNetworkFollower: .live(bindingsCmix),
       waitForNetwork: .live(bindingsCmix),
       registerClientErrorCallback: .live(bindingsCmix),
-      addHealthCallback: .live(bindingsCmix)
+      addHealthCallback: .live(bindingsCmix),
+      waitForMessageDelivery: .live(bindingsCmix)
     )
   }
 }
@@ -44,6 +46,7 @@ extension Cmix {
     stopNetworkFollower: .unimplemented,
     waitForNetwork: .unimplemented,
     registerClientErrorCallback: .unimplemented,
-    addHealthCallback: .unimplemented
+    addHealthCallback: .unimplemented,
+    waitForMessageDelivery: .unimplemented
   )
 }

Sources/ElixxirDAppsSDK/CmixWaitForMessageDelivery.swift

+import Bindings
+import XCTestDynamicOverlay
+
+public struct CmixWaitForMessageDelivery {
+  public var run: (MessageSendReport, Int, MessageDeliveryCallback) throws -> Void
+
+  public func callAsFunction(
+    report: MessageSendReport,
+    timeoutMS: Int,
+    callback: MessageDeliveryCallback
+  ) throws {
+    try run(report, timeoutMS, callback)
+  }
+}
+
+extension CmixWaitForMessageDelivery {
+  public static func live(_ bindingsCmix: BindingsCmix) -> CmixWaitForMessageDelivery {
+    CmixWaitForMessageDelivery { report, timeoutMS, callback in
+      try bindingsCmix.wait(
+        forMessageDelivery: try report.encode(),
+        mdc: callback.makeBindingsMessageDeliveryCallback(),
+        timeoutMS: timeoutMS
+      )
+    }
+  }
+}
+
+extension CmixWaitForMessageDelivery {
+  public static let unimplemented = CmixWaitForMessageDelivery(
+    run: XCTUnimplemented("\(Self.self)")
+  )
+}

Sources/ElixxirDAppsSDK/Legacy/MessageDeliveryWaiter.swift

-import Bindings
-
-public struct MessageDeliveryWaiter {
-  public enum Result: Equatable {
-    case delivered(roundResults: [Int])
-    case notDelivered(timedOut: Bool)
-  }
-
-  public var wait: (MessageSendReport, Int, @escaping (Result) -> Void) throws -> Void
-
-  public func callAsFunction(
-    report: MessageSendReport,
-    timeoutMS: Int,
-    callback: @escaping (Result) -> Void
-  ) throws {
-    try wait(report, timeoutMS, callback)
-  }
-}
-
-extension MessageDeliveryWaiter {
-  public static func live(bindingsClient: BindingsCmix) -> MessageDeliveryWaiter {
-    MessageDeliveryWaiter { report, timeoutMS, callback in
-      let encoder = JSONEncoder()
-      let reportData = try encoder.encode(report)
-      try bindingsClient.wait(
-        forMessageDelivery: reportData,
-        mdc: Callback(onCallback: callback),
-        timeoutMS: timeoutMS
-      )
-    }
-  }
-}
-
-private final class Callback: NSObject, BindingsMessageDeliveryCallbackProtocol {
-  init(onCallback: @escaping (MessageDeliveryWaiter.Result) -> Void) {
-    self.onCallback = onCallback
-    super.init()
-  }
-
-  let onCallback: (MessageDeliveryWaiter.Result) -> Void
-
-  func eventCallback(_ delivered: Bool, timedOut: Bool, roundResults: Data?) {
-    if delivered, !timedOut, let roundResultsData = roundResults {
-      let decoder = JSONDecoder()
-      do {
-        let roundResults = try decoder.decode([Int].self, from: roundResultsData)
-        return onCallback(.delivered(roundResults: roundResults))
-      } catch {
-        return onCallback(.delivered(roundResults: [Int]()))
-      }
-    }
-    if !delivered, roundResults == nil {
-      return onCallback(.notDelivered(timedOut: timedOut))
-    }
-    fatalError("""
-      BindingsMessageDeliveryCallback received invalid parameters:
-      - delivered → \(delivered)
-      - timedOut → \(timedOut)
-      - roundResults == nil → \(roundResults == nil)
-      """)
-  }
-}
-
-#if DEBUG
-extension MessageDeliveryWaiter {
-  public static let failing = MessageDeliveryWaiter { _, _, _ in
-    struct NotImplemented: Error {}
-    throw NotImplemented()
-  }
-}
-#endif

Sources/ElixxirDAppsSDK/MessageDeliveryCallback.swift

+import Bindings
+import XCTestDynamicOverlay
+
+public struct MessageDeliveryCallback {
+  public enum Result: Equatable {
+    case delivered(roundResults: [Int])
+    case notDelivered(timedOut: Bool)
+  }
+
+  public init(handle: @escaping (Result) -> Void) {
+    self.handle = handle
+  }
+
+  public var handle: (Result) -> Void
+}
+
+extension MessageDeliveryCallback {
+  public static let unimplemented = MessageDeliveryCallback(
+    handle: XCTUnimplemented("\(Self.self)")
+  )
+}
+
+extension MessageDeliveryCallback {
+  func makeBindingsMessageDeliveryCallback() -> BindingsMessageDeliveryCallbackProtocol {
+    class Callback: NSObject, BindingsMessageDeliveryCallbackProtocol {
+      init(_ callback: MessageDeliveryCallback) {
+        self.callback = callback
+      }
+
+      let callback: MessageDeliveryCallback
+
+      func eventCallback(_ delivered: Bool, timedOut: Bool, roundResults: Data?) {
+        if delivered,
+           !timedOut,
+           let roundResultsData = roundResults,
+           let roundResults = try? JSONDecoder().decode([Int].self, from: roundResultsData)
+        {
+          callback.handle(.delivered(roundResults: roundResults))
+          return
+        }
+
+        if !delivered {
+          callback.handle(.notDelivered(timedOut: timedOut))
+          return
+        }
+
+        fatalError("""
+          BindingsMessageDeliveryCallback received invalid parameters:
+          - delivered → \(delivered)
+          - timedOut → \(timedOut)
+          - roundResults → \(roundResults.map { String(data: $0, encoding: .utf8) ?? "" } ?? "")
+          """)
+      }
+    }
+
+    return Callback(self)
+  }
+}

Sources/ElixxirDAppsSDK/Legacy/MessageSendReport.swift → Sources/ElixxirDAppsSDK/MessageSendReport.swift

@@ -22,4 +22,12 @@ extension MessageSendReport: Codable {
     case messageId = "MessageID"
     case timestamp = "Timestamp"
   }
+
+  static func decode(_ data: Data) throws -> MessageSendReport {
+    try JSONDecoder().decode(Self.self, from: data)
+  }
+
+  func encode() throws -> Data {
+    try JSONEncoder().encode(self)
+  }
 }