Refactor decoding of heterogenous EntryDecodables collections

Author: JP Wright

Sources/Contentful/ArrayResponse.swift

@@ -154,41 +154,25 @@ internal struct MappedIncludes: Decodable {
     }
 
     init(from decoder: Decoder) throws {
-        let container   = try decoder.container(keyedBy: CodingKeys.self)
-
-        assets          = try container.decodeIfPresent([Asset].self, forKey: CodingKeys.assets)
+        let container       = try decoder.container(keyedBy: CodingKeys.self)
+        assets              = try container.decodeIfPresent([Asset].self, forKey: .assets)
+        entries             = try container.decodeHeterogeneousEntries(forKey: .entries,
+                                                                       contentTypes: decoder.contentTypes,
+                                                                       throwIfNotPresent: false)
         // Cache to enable link resolution.
         if let assets = assets {
             decoder.linkResolver.cache(assets: assets)
         }
-
-        // A copy as an array of dictionaries just to extract "sys.type" field.
-        guard let jsonItems = try container.decodeIfPresent(Swift.Array<Any>.self, forKey: .entries) as? [[String: Any]] else {
-            self.entries = nil
-            return
-        }
-        var entriesJSONContainer = try container.nestedUnkeyedContainer(forKey: .entries)
-        var entries: [EntryDecodable] = []
-        let contentTypes = decoder.userInfo[DecoderContext.contentTypesContextKey] as! [ContentTypeId: EntryDecodable.Type]
-
-        while entriesJSONContainer.isAtEnd == false {
-            let contentTypeInfo = try jsonItems.contentTypeInfo(at: entriesJSONContainer.currentIndex)
-
-            // For includes, if the type of this entry isn't defined by the user, we skip serialization.
-            if let type = contentTypes[contentTypeInfo.id] {
-                let entryModellable = try type.popEntryDecodable(from: &entriesJSONContainer)
-                entries.append(entryModellable)
-            }
-        }
-        self.entries = entries
-
         // Cache to enable link resolution.
-        if let entries = self.entries {
+        if let entries = entries {
             decoder.linkResolver.cache(entryDecodables: entries)
         }
     }
 }
 
+// Empty type so that we can continue to the end of a UnkeyedContainer
+internal struct EmptyDecodable: Decodable {}
+
 extension MappedArrayResponse: Decodable {
 
     public init(from decoder: Decoder) throws {
@@ -282,25 +266,9 @@ extension MixedMappedArrayResponse: Decodable {
 
         // All items and includes.
         includes        = try container.decodeIfPresent(MappedIncludes.self, forKey: .includes)
-
-        // A copy as an array of dictionaries just to extract "sys.type" field.
-        guard let jsonItems = try container.decode(Swift.Array<Any>.self, forKey: .items) as? [[String: Any]] else {
-            throw SDKError.unparseableJSON(data: nil, errorMessage: "SDK was unable to serialize returned resources")
-        }
-        var entriesJSONContainer = try container.nestedUnkeyedContainer(forKey: .items)
-        var entries: [EntryDecodable] = []
-        let contentTypes = decoder.userInfo[DecoderContext.contentTypesContextKey] as! [ContentTypeId: EntryDecodable.Type]
-
-        while entriesJSONContainer.isAtEnd == false {
-            let contentTypeInfo = try jsonItems.contentTypeInfo(at: entriesJSONContainer.currentIndex)
-
-            // After implementing handling of the errors array, we can append an SDKError when the type isn't found.
-            if let entryDecodableType = contentTypes[contentTypeInfo.id] {
-                let entryDecodable = try entryDecodableType.popEntryDecodable(from: &entriesJSONContainer)
-                entries.append(entryDecodable)
-            }
-        }
-        self.items = entries
+        items           = try container.decodeHeterogeneousEntries(forKey: .items,
+                                                                   contentTypes: decoder.contentTypes,
+                                                                   throwIfNotPresent: true) ?? []
 
         // Cache to enable link resolution.
         decoder.linkResolver.cache(entryDecodables: self.items)
@@ -321,3 +289,37 @@ internal extension Swift.Array where Element == Dictionary<String, Any> {
         return contentTypeInfo
     }
 }
+
+extension KeyedDecodingContainer {
+
+    internal func decodeHeterogeneousEntries(forKey key: K,
+                                             contentTypes: [ContentTypeId: EntryDecodable.Type],
+                                             throwIfNotPresent: Bool) throws -> [EntryDecodable]? {
+
+
+        guard let itemsAsDictionaries = try self.decodeIfPresent(Swift.Array<Any>.self, forKey: key) as? [[String: Any]] else {
+            if throwIfNotPresent {
+                throw SDKError.unparseableJSON(data: nil, errorMessage: "SDK was unable to serialize returned resources")
+            } else {
+                return nil
+            }
+        }
+        var entriesJSONContainer = try self.nestedUnkeyedContainer(forKey: key)
+
+        var entries: [EntryDecodable] = []
+        while entriesJSONContainer.isAtEnd == false {
+            let contentTypeInfo = try itemsAsDictionaries.contentTypeInfo(at: entriesJSONContainer.currentIndex)
+
+            // For includes, if the type of this entry isn't defined by the user, we skip serialization.
+            if let type = contentTypes[contentTypeInfo.id] {
+                let entryModellable = try type.popEntryDecodable(from: &entriesJSONContainer)
+                entries.append(entryModellable)
+            } else {
+                // Another annoying workaround: there is no mechanism for incrementing the `currentIndex` of an
+                // UnkeyedCodingContainer other than actually decoding an item
+                _ = try? entriesJSONContainer.decode(EmptyDecodable.self)
+            }
+        }
+        return entries
+    }
+}

Sources/Contentful/Decodable.swift

@@ -32,6 +32,10 @@ public extension Decoder {
         return userInfo[DecoderContext.linkResolverContextKey] as! LinkResolver
     }
 
+    internal var contentTypes: [ContentTypeId: EntryDecodable.Type] {
+        return userInfo[DecoderContext.contentTypesContextKey] as! [ContentTypeId: EntryDecodable.Type]
+    }
+
     /// Helper method to extract the sys property of a Contentful resource.
     public func sys() throws -> Sys {
         let container = try self.container(keyedBy: LocalizableResource.CodingKeys.self)
@@ -178,7 +182,7 @@ internal class LinkResolver {
                 let onlyKeysString = linkKey[firstKeyIndex ..< linkKey.endIndex]
                 // Split creates a [Substring] array, but we need [String] to index the cache
                 let keys = onlyKeysString.split(separator: ",").map { String($0) }
-                let items: [Any] = keys.map { dataCache.item(for: $0) as Any }
+                let items: [Any] = keys.flatMap { dataCache.item(for: $0) }
                 for callback in callbacksList {
                     callback(items as Any)
                 }

Tests/ContentfulTests/QueryTests.swift

@@ -93,42 +93,13 @@ final class Dog: EntryDecodable, ResourceQueryable {
     }
 }
 
-class Human: EntryDecodable, ResourceQueryable {
-
-    static let contentTypeId = "human"
-
-    let sys: Sys
-    let name: String?
-    let description: String?
-    let likes: [String]?
-
-    var image: Asset?
-
-    public required init(from decoder: Decoder) throws {
-        sys             = try decoder.sys()
-        let fields      = try decoder.contentfulFieldsContainer(keyedBy: Human.Fields.self)
-        name            = try fields.decode(String.self, forKey: .name)
-        description     = try fields.decode(String.self, forKey: .description)
-        likes           = try fields.decode(Array<String>.self, forKey: .likes)
-
-        try fields.resolveLink(forKey: .image, decoder: decoder) { [weak self] linkedImage in
-            self?.image = linkedImage as? Asset
-        }
-    }
-
-    enum Fields: String, CodingKey {
-        case name, description, likes, image
-    }
-}
-
 class QueryTests: XCTestCase {
 
     static let client: Client = {
         let contentTypeClasses: [EntryDecodable.Type] = [
             Cat.self,
             Dog.self,
-            City.self,
-            Human.self
+            City.self
         ]
         return TestClientFactory.testClient(withCassetteNamed: "QueryTests", contentTypeClasses: contentTypeClasses)
     }()
@@ -193,7 +164,8 @@ class QueryTests: XCTestCase {
             switch result {
             case .success(let response):
                 let entries = response.items
-                expect(entries.count).to(equal(10))
+                // We didn't decode the "human" content type so only 9 decoded entries should be returned instead of 10
+                expect(entries.count).to(equal(9))
 
                 if let cat = entries.first as? Cat, let bestFriend = cat.bestFriend {
                     expect(bestFriend.name).to(equal("Nyan Cat"))