Make some types Codable and change visibility.

Author: paulofaria

.swift-version

@@ -1 +1 @@
-5.0
+5.1

Package.resolved

@@ -4,8 +4,8 @@
  * it also includes information about the locations in a
  * GraphQL document and/or execution result that correspond to the error.
  */
-public struct GraphQLError : Error, Encodable {
-    private enum CodingKeys : String, CodingKey {
+public struct GraphQLError : Error, Codable {
+    enum CodingKeys : String, CodingKey {
         case message
         case locations
         case path
@@ -41,23 +41,23 @@ public struct GraphQLError : Error, Encodable {
     /**
      * An array of GraphQL AST Nodes corresponding to this error.
      */
-    public let nodes: [Node]
+    public private(set) var nodes: [Node] = []
 
     /**
      * The source GraphQL document corresponding to this error.
      */
-    public let source: Source?
+    public private(set) var source: Source? = nil
 
     /**
      * An array of character offsets within the source GraphQL document
      * which correspond to this error.
      */
-    public let positions: [Int]
+    public private(set) var positions: [Int] = []
 
     /**
      * The original error thrown from a field resolver during execution.
      */
-    public let originalError: Error?
+    public private(set) var originalError: Error? = nil
 
     public init(
         message: String,
@@ -134,7 +134,7 @@ extension GraphQLError : Hashable {
 
 // MARK: IndexPath
 
-public struct IndexPath : Encodable {
+public struct IndexPath : Codable {
     public let elements: [IndexPathValue]
 
     public init(_ elements: [IndexPathElement] = []) {
@@ -152,10 +152,22 @@ extension IndexPath : ExpressibleByArrayLiteral {
     }
 }
 
-public enum IndexPathValue : Encodable {
+public enum IndexPathValue : Codable {
     case index(Int)
     case key(String)
 
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        
+        if let index = try? container.decode(Int.self) {
+            self = .index(index)
+        } else if let key = try? container.decode(String.self) {
+            self = .key(key)
+        } else {
+            throw DecodingError.dataCorruptedError(in: container, debugDescription: "Invalid type.")
+        }
+    }
+    
     public func encode(to encoder: Encoder) throws {
         var container = encoder.singleValueContainer()
 

Sources/GraphQL/Error/GraphQLError.swift

@@ -1,7 +1,7 @@
 import Foundation
 import NIO
 
-public struct GraphQLResult : Equatable, Encodable, CustomStringConvertible {
+public struct GraphQLResult : Equatable, Codable, CustomStringConvertible {
     public var data: Map?
     public var errors: [GraphQLError]
 
@@ -14,6 +14,12 @@ public struct GraphQLResult : Equatable, Encodable, CustomStringConvertible {
         case data
         case errors
     }
+    
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.data = try container.decodeIfPresent(Map.self, forKey: .data)
+        self.errors = try container.decodeIfPresent([GraphQLError].self, forKey: .errors) ?? []
+    }
 
     public func encode(to encoder: Encoder) throws {
         var container = encoder.container(keyedBy: CodingKeys.self)

Sources/GraphQL/GraphQL.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-public struct SourceLocation : Encodable {
+public struct SourceLocation : Codable {
     public let line: Int
     public let column: Int
 

Sources/GraphQL/Language/Location.swift

@@ -738,37 +738,65 @@ extension Map:CustomDebugStringConvertible {
 extension Map {
     public func description(debug: Bool) -> String {
         var indentLevel = 0
-        
+
+        let escapeMapping: [Character: String] = [
+            "\r": "\\r",
+            "\n": "\\n",
+            "\t": "\\t",
+            "\\": "\\\\",
+            "\"": "\\\"",
+
+            "\u{2028}": "\\u2028",
+            "\u{2029}": "\\u2029",
+
+            "\r\n": "\\r\\n"
+        ]
+
+        func escape(_ source: String) -> String {
+            var string = "\""
+
+            for character in source {
+                if let escapedSymbol = escapeMapping[character] {
+                    string.append(escapedSymbol)
+                } else {
+                    string.append(character)
+                }
+            }
+
+            string.append("\"")
+            return string
+        }
+
         func serialize(map: Map) -> String {
             switch map {
             case .null:
                 return "null"
             case let .number(number):
                 return number.description
-            case .string(let string):
-                return string
-            case .array(let array):
+            case let .string(string):
+                return escape(string)
+            case let .array(array):
                 return serialize(array: array)
-            case .dictionary(let dictionary):
+            case let .dictionary(dictionary):
                 return serialize(dictionary: dictionary)
             }
         }
-        
+
         func serialize(array: [Map]) -> String {
             var string = "["
-            
+
             if debug {
                 indentLevel += 1
             }
-            
+
             for index in 0 ..< array.count {
                 if debug {
                     string += "\n"
                     string += indent()
                 }
-                
+
                 string += serialize(map: array[index])
-                
+
                 if index != array.count - 1 {
                     if debug {
                         string += ", "
@@ -777,43 +805,43 @@ extension Map {
                     }
                 }
             }
-            
+
             if debug {
                 indentLevel -= 1
                 return string + "\n" + indent() + "]"
             } else {
                 return string + "]"
             }
         }
-        
+
         func serialize(dictionary: [String: Map]) -> String {
             var string = "{"
             var index = 0
-            
+
             if debug {
                 indentLevel += 1
             }
-            
+
             for (key, value) in dictionary.sorted(by: {$0.0 < $1.0}) {
                 if debug {
                     string += "\n"
                     string += indent()
-                    string += key + ": " + serialize(map: value)
+                    string += escape(key) + ": " + serialize(map: value)
                 } else {
-                    string += key + ":" + serialize(map: value)
+                    string += escape(key) + ":" + serialize(map: value)
                 }
-                
+
                 if index != dictionary.count - 1 {
                     if debug {
                         string += ", "
                     } else {
                         string += ","
                     }
                 }
-                
+
                 index += 1
             }
-            
+
             if debug {
                 indentLevel -= 1
                 return string + "\n" + indent() + "}"