SQLite persistent normalized cache

Apollo/JSONStandardTypeConversions.swift

@@ -117,14 +117,13 @@ extension Dictionary: JSONEncodable {
   public var jsonObject: JSONObject {
     var jsonObject = JSONObject(minimumCapacity: count)
     for (key, value) in self {
+      print("key: \(key), \(type(of: key))")
+      print("value: \(value), \(type(of: value))")
       if case let (key as String, value as JSONEncodable) = (key, value) {
         if !isNil(value) {
           jsonObject[key] = value.jsonValue
         }
-      }
-      else {
-        print("key: \(type(of: key))")
-        print("value: \(type(of: value))")
+      } else {
         fatalError("Dictionary is only JSONEncodable if Value is (and if Key is String)")
       }
     }

Apollo/Record.swift

@@ -4,14 +4,17 @@ public typealias CacheKey = String
 /// A cache record.
 public struct Record {
   public let key: CacheKey
-  public private(set) var fields: JSONObject
 
-  public init(key: CacheKey, _ fields: JSONObject = [:]) {
+  public typealias Value = Any
+  public typealias Fields = [CacheKey: Value]
+  public private(set) var fields: Fields
+
+  public init(key: CacheKey, _ fields: Fields = [:]) {
     self.key = key
     self.fields = fields
   }
 
-  public subscript(key: CacheKey) -> JSONValue? {
+  public subscript(key: CacheKey) -> Value? {
     get {
       return fields[key]
     }

Apollo/RecordSet.swift

@@ -59,7 +59,7 @@ public struct RecordSet {
 }
 
 extension RecordSet: ExpressibleByDictionaryLiteral {
-  public init(dictionaryLiteral elements: (CacheKey, JSONObject)...) {
+  public init(dictionaryLiteral elements: (CacheKey, Record.Fields)...) {
     self.init(records: elements.map { Record(key: $0.0, $0.1) })
   }
 }

ApolloSQLite/SQLiteNormalizedCache.swift

@@ -83,60 +83,56 @@ public final class SQLiteNormalizedCache: NormalizedCache {
       throw SQLiteNormalizedCacheError.invalidRecordEncoding(record: record)
     }
 
-    let recordJSON = try SQLiteSerialization.deserialize(data: recordData)
-    return Record(key: row[key], recordJSON)
+    let fields = try SQLiteSerialization.deserialize(data: recordData)
+    return Record(key: row[key], fields)
   }
 }
 
 private let serializedReferenceKey = "reference"
 
 final class SQLiteSerialization {
-  static func serialize(fields: JSONObject) throws -> Data {
+  static func serialize(fields: Record.Fields) throws -> Data {
     var objectToSerialize = JSONObject()
     for (key, value) in fields {
       objectToSerialize[key] = try serialize(value: value)
     }
-    return try JSONSerializationFormat.serialize(value: objectToSerialize)
+    return try JSONSerialization.data(withJSONObject: objectToSerialize, options: [])
+  }
+
+  private static func serialize(value: Record.Value) throws -> JSONValue {
+    switch value {
+    case let reference as Reference:
+      return [serializedReferenceKey: reference.key]
+    case let array as [Record.Value]:
+      return try array.map { try serialize(value: $0) }
+    default:
+      return value
+    }
   }
 
-  static func deserialize(data: Data) throws -> JSONObject {
-    let object = try JSONSerializationFormat.deserialize(data: data)
+  static func deserialize(data: Data) throws -> Record.Fields {
+    let object = try JSONSerialization.jsonObject(with: data, options: [])
     guard let jsonObject = object as? JSONObject else {
       throw SQLiteNormalizedCacheError.invalidRecordShape(object: object)
     }
-    var deserializedObject = JSONObject()
+    var fields = Record.Fields()
     for (key, value) in jsonObject {
-      deserializedObject[key] = try deserialize(valueJSON: value)
+      fields[key] = try deserialize(jsonValue: value)
     }
-    return deserializedObject
+    return fields
   }
 
-  private static func deserialize(valueJSON: Any) throws -> Any {
-    switch valueJSON {
+  private static func deserialize(jsonValue: JSONValue) throws -> Record.Value {
+    switch jsonValue {
     case let dictionary as JSONObject:
       guard let reference = dictionary[serializedReferenceKey] as? String else {
-        throw SQLiteNormalizedCacheError.invalidRecordValue(value: valueJSON)
+        throw SQLiteNormalizedCacheError.invalidRecordValue(value: jsonValue)
       }
       return Reference(key: reference)
-    case let array as NSArray:
-      return try array.map { try deserialize(valueJSON: $0) }
+    case let array as [JSONValue]:
+      return try array.map { try deserialize(jsonValue: $0) }
     default:
-      return valueJSON
-    }
-  }
-
-  private static func serialize(value: Any) throws -> Any {
-    switch value {
-    case let reference as Reference:
-      return [serializedReferenceKey: reference.key]
-    case let array as NSArray:
-      return try array.map { try serialize(value: $0) }
-    case let string as NSString:
-      return string as String
-    case let number as NSNumber:
-      return number.doubleValue
-    default:
-      return value
+      return jsonValue
     }
   }
 }