Update serialization/deserialization related doc

kolyasev · kolyasev · commit a997ffa46000 · 2022-07-11T12:31:08.000+04:00
diff --git a/README.md b/README.md
@@ -17,7 +17,7 @@ class UserService: RPCService {
         return try await invoke("vote", params: ["rating": rating])
     }
 
-    func create(name: String) async throws -> UserModel {
+    func create(name: String) async throws -> User {
         return try await invoke("create", params: ["name": name])
     }
 
@@ -41,58 +41,55 @@ let service = MyService(client: client)
 try await service.vote(rating: 5)
 ```
 
-#### Result Serialization
+#### Result Decoding
 
-SwiftJSONRPC provides built-in result serialization for `Int`, `String`, `Bool` types.
-
-##### `Parcelable` Protocol
-
-To serialize your custom type result from JSON you can implement `Parcelable` protocol.
+SwiftJSONRPC uses Swift's `Decodable` protocol to decode response objects.
 
 ```swift
-protocol Parcelable {
-    init(params: [String: Any]) throws
+struct User: Decodable {
+    let id: String
+    let name: String
 }
+
+class UserService: RPCService {
+    func getCurrentUser() async throws -> User {
+        return try await invoke("getCurrentUser")
+    }
+}
+
+let user = try await userService.getCurrentUser()
+print("Current user ID = \(user.id), name = \(user.name)")
 ```
 
-For example:
+If you need to modify `JSONDecoder`'s behaviour, use `RPCClient.coder.resultDecoder` for that.
 
 ```swift
-struct UserModel: Parcelable {
-    let id: String
-    let name: String
-    
-    required init(params: [String: Any]) throws {
-        // Parse params to struct
-        // ...
-    }
-}
+client.coder.resultDecoder.dateDecodingStrategy = .iso8601
 ```
 
-> You can use libraries like [ObjectMapper](https://github.com/Hearst-DD/ObjectMapper), [MAPPER](https://github.com/LYFT/MAPPER) or other to adapt `Parcelable` protocol. Or you can adapt Swift 4 `Decodable`.
+#### Params Encoding
 
-After that use this struct as `RPCService.Result` generic parameter:
+SwiftJSONRPC uses Swift's `Encodable` protocol to encode request params.
 
 ```swift
-class UserService: RPCService {
-    func create(name: String) async throws -> UserModel {
-        return try await invoke("create", params: ["name": name])
+struct Message: Encodable {
+    let text: String
+}
+
+class MessageService: RPCService {
+    func send(message: Message) async throws {
+        return try await invoke("sendMessage", params: message)
     }
 }
-```
-```swift
-let user = try await service.create(name: "testuser")
-print("User created with ID = \(user.id)")
+
+let message = Message(text: "Hello World")
+try await messageService.send(message: message)
 ```
 
-Using array of `Parcelable` objects is also supported:
+If you need to modify `JSONEncoder`'s behaviour, use `RPCClient.coder.paramsEncoder` for that. 
 
 ```swift
-extension UserService {
-    func allUsers() async throws -> [UserModel] {
-        return try await invoke("all_users")
-    }
-}
+client.coder.paramsEncoder.dateDecodingStrategy = .iso8601
 ```
 
 ## Advanced Usage
@@ -129,7 +126,6 @@ dependencies: [
 ## ToDo
 
 - [ ] Add support for notification request object without an "id" member.
-- [ ] Remove `Parcelable` protocol and use `Decodable`.
 
 ## Author
 
