Use Codable to encode request parameters and decode response body

Author: kolyasev

Sources/SwiftJSONRPC/Client/RPCClient.swift

@@ -14,6 +14,8 @@ open class RPCClient {
 
     public var requestRetrier: RequestRetrier? = nil
 
+    public var coder = Coder()
+
     // MARK: - Private Properties
 
     private let requestExecutor: RequestExecutor
@@ -33,17 +35,17 @@ open class RPCClient {
 
     // MARK: - Public Functions
 
-    open func invoke<Result>(_ invocation: Invocation<Result>) async throws -> Result {
+    open func invoke<Params, Result>(_ invocation: Invocation<Params, Result>) async throws -> Result {
         // Init request
-        let request = makeRequest(invocation: invocation)
+        let request = try makeRequest(invocation: invocation)
 
         // Perform request
-        return try await execute(request: request, with: invocation.parser)
+        return try await execute(request: request)
     }
 
     // MARK: - Private Functions
 
-    private func makeRequest<Result>(invocation: Invocation<Result>) -> Request {
+    private func makeRequest<Params, Result>(invocation: Invocation<Params, Result>) throws -> Request {
         // TODO: Support notification type calls without identifiers
         // Generate request identifier
         let identifier = requestIdGenerator.next()
@@ -52,15 +54,15 @@ open class RPCClient {
         return Request(
             id: identifier,
             method: invocation.method,
-            params: invocation.params
+            params: try coder.encode(invocation.params)
         )
     }
 
-    private func execute<Result>(request: Request, with parser: AnyResultParser<Result>) async throws -> Result {
-        return try await withCheckedThrowingContinuation { continuation in
+    private func execute<Result: InvocationResult>(request: Request) async throws -> Result {
+        return try await withCheckedThrowingContinuation { [coder] continuation in
             execute(request: request) { result in
                 do {
-                    continuation.resume(returning: try result.result(with: parser))
+                    continuation.resume(returning: try result.result(with: coder))
                 } catch {
                     continuation.resume(throwing: error)
                 }
@@ -102,10 +104,10 @@ private extension RequestExecutorResult {
 
     // MARK: - Functions
 
-    func result<Result>(with parser: AnyResultParser<Result>) throws -> Result {
+    func result<Result: InvocationResult>(with coder: Coder) throws -> Result {
         switch self {
         case .response(let response):
-            return try result(for: response, with: parser)
+            return try result(for: response, with: coder)
         case .error(let error):
             throw InvocationError.applicationError(cause: error)
         case .cancel:
@@ -115,18 +117,18 @@ private extension RequestExecutorResult {
 
     // MARK: - Private Functions
 
-    private func result<Result>(for response: Response, with parser: AnyResultParser<Result>) throws -> Result {
+    private func result<Result: InvocationResult>(for response: Response, with coder: Coder) throws -> Result {
         switch response.body {
         case .success(let successBody):
-            return try resultForSuccessBody(successBody, with: parser)
+            return try resultForSuccessBody(successBody, with: coder)
         case .error(let error):
             throw InvocationError.rpcError(error: error)
         }
     }
 
-    private func resultForSuccessBody<Result>(_ body: AnyObject, with parser: AnyResultParser<Result>) throws -> Result {
+    private func resultForSuccessBody<Result: InvocationResult>(_ body: Any, with coder: Coder) throws -> Result {
         do {
-            return try parser.parse(body)
+            return try coder.decode(Result.self, from: body)
         } catch {
             throw InvocationError.applicationError(cause: error)
         }

Sources/SwiftJSONRPC/Coder/Coder.swift

@@ -0,0 +1,58 @@
+//
+//  Coder.swift
+//  
+//
+//  Created by Denis Kolyasev on 09.07.2022.
+//
+
+import Foundation
+
+public struct Coder {
+
+    // MARK: - Initialization
+
+    public init(paramsEncoder: JSONEncoder = JSONEncoder(),
+                resultDecoder: JSONDecoder = JSONDecoder()) {
+
+        self.paramsEncoder = paramsEncoder
+        self.resultDecoder = resultDecoder
+    }
+
+    // MARK: - Properties
+
+    public var paramsEncoder: JSONEncoder
+
+    public var resultDecoder: JSONDecoder
+
+    // MARK: - Functions
+
+    func encode<Params: InvocationParams>(_ params: Params) throws -> Request.Params? {
+        guard Params.self != VoidInvocationParams.self else {
+            return nil
+        }
+        do {
+            let data = try paramsEncoder.encode(params)
+            return try JSONSerialization.jsonObject(with: data, options: .allowFragments)
+        } catch {
+            throw ParamsEncodingError(cause: error)
+        }
+    }
+
+    func decode<Result: InvocationResult>(_ type: Result.Type, from result: Response.Result) throws -> Result {
+        guard Result.self != VoidInvocationResult.self else {
+            return VoidInvocationResult() as! Result
+        }
+        do {
+            let data = try JSONSerialization.data(withJSONObject: result, options: .fragmentsAllowed)
+            return try resultDecoder.decode(Result.self, from: data)
+        } catch {
+            throw ResultDecodingError(cause: error)
+        }
+    }
+
+    // MARK: - Inner Types
+
+    final class ParamsEncodingError: NestedError<Error> { }
+    final class ResultDecodingError: NestedError<Error> { }
+
+}

Sources/SwiftJSONRPC/Invocation/Invocation.swift

@@ -6,31 +6,25 @@
 //
 // ----------------------------------------------------------------------------
 
-public struct Invocation<Result>
-{
-// MARK: - Construction
-
-    init<Parser: ResultParser>(method: String, params: Params?, parser: Parser)
-        where Parser.Result == Result
-    {
-        // Init instance variables
+public struct Invocation<Params, Result> where Params: InvocationParams, Result: InvocationResult {
+
+    // MARK: - Initialization
+
+    init(method: String, params: Params, resultType: Result.Type) {
         self.method = method
         self.params = params
-        self.parser = AnyResultParser<Result>(parser)
     }
 
-// MARK: - Properties
+    // MARK: - Properties
 
     public let method: String
 
-    public let params: Params?
-
-    public let parser: AnyResultParser<Result>
-
-// MARK: - Inner Types
-
-    public typealias Params = [String: Any?]
+    public let params: Params
 
 }
 
-// ----------------------------------------------------------------------------
+public typealias InvocationParams = Encodable
+public typealias InvocationResult = Decodable
+
+public struct VoidInvocationParams: InvocationParams {}
+public struct VoidInvocationResult: InvocationResult {}

Sources/SwiftJSONRPC/RequestExecutor/Request.swift

@@ -14,46 +14,32 @@ public class Request {
 
     public let method: String
 
-    public let params: [String: Any]?
+    public let params: Params?
 
     // MARK: - Initialization
 
-    init(id: String? = nil, method: String, params: [String: Any?]?) {
+    init(id: String? = nil, method: String, params: Params?) {
         self.id = id
         self.method = method
-        self.params = params.map { Request.prepareParams($0) }
+        self.params = params
     }
 
     // MARK: - Functions
 
-    public func buildBody() -> [String: AnyObject] {
-        var body: [String: AnyObject] = [
-            JsonKeys.JsonRPC: RPCClient.Version as AnyObject,
-            JsonKeys.Method: method as AnyObject,
-            JsonKeys.Params: params as AnyObject,
+    public func buildBody() -> [String: Any] {
+        var body: [String: Any] = [
+            JsonKeys.JsonRPC: RPCClient.Version,
+            JsonKeys.Method: method
         ]
 
         if let id = id {
-            body[JsonKeys.Id] = id as AnyObject?
+            body[JsonKeys.Id] = id
         }
-        
-        return body
-    }
-
-    // MARK: - Private Functions
-
-    private static func prepareParams(_ params: [String: Any?]?) -> [String: Any] {
-        var result: [String: Any] = [:]
-
-        // Remove 'nil' values
-        for (key, value) in params ?? [:]
-        {
-            if let value = value {
-                result[key] = value
-            }
+        if let params = params {
+            body[JsonKeys.Params] = params
         }
 
-        return result
+        return body
     }
 
     // MARK: - Constants
@@ -69,4 +55,9 @@ public class Request {
         static let Data = "data"
         static let Id = "id"
     }
+
+    // MARK: - Inner Types
+
+    public typealias Params = Any
+
 }

Sources/SwiftJSONRPC/RequestExecutor/Response.swift

@@ -6,12 +6,17 @@
 //
 // ----------------------------------------------------------------------------
 
-public class Response
-{
-// MARK: Construction
+public class Response {
 
-    init(response: Any) throws
-    {
+    // MARK: - Properties
+
+    public let id: String
+
+    public let body: Body
+
+    // MARK: - Initialization
+
+    init(response: Any) throws {
         guard let json = (response as? [String: AnyObject]),
               let version = (json[JsonKeys.JsonRPC] as? String), (version == RPCClient.Version),
               let id = (json[JsonKeys.Id] as? String)
@@ -47,24 +52,9 @@ public class Response
         }
     }
 
-// MARK: - Properties
-
-    public let id: String
-
-    public let body: Body
-
-// MARK: - Inner Types
-
-    public enum Body
-    {
-        case success(result: AnyObject)
-        case error(error: RPCError)
-    }
-
-// MARK: Constants
+    // MARK: - Constants
 
-    fileprivate struct JsonKeys
-    {
+    private struct JsonKeys {
         static let JsonRPC = "jsonrpc"
         static let Method = "method"
         static let Params = "params"
@@ -76,13 +66,17 @@ public class Response
         static let Id = "id"
     }
 
-}
+    // MARK: - Inner Types
 
-// ----------------------------------------------------------------------------
+    public enum Body {
+        case success(result: Result)
+        case error(error: RPCError)
+    }
+
+    public typealias Result = Any
 
-enum ResponseError: Error
-{
-    case invalidFormat
 }
 
-// ----------------------------------------------------------------------------
+enum ResponseError: Error {
+    case invalidFormat
+}