{"id":9735,"date":"2025-06-30T16:35:00","date_gmt":"2025-06-30T13:35:00","guid":{"rendered":"https:\/\/handoli.com\/index.php\/2025\/06\/30\/decoding-swift-types-that-require-additional-data\/"},"modified":"2025-06-30T16:35:00","modified_gmt":"2025-06-30T13:35:00","slug":"decoding-swift-types-that-require-additional-data","status":"publish","type":"post","link":"https:\/\/handoli.com\/index.php\/2025\/06\/30\/decoding-swift-types-that-require-additional-data\/","title":{"rendered":"Decoding Swift types that require additional data"},"content":{"rendered":"

Swift\u2019s Codable<\/code> API \u2014 which consists of the Encodable<\/code> protocol for encoding, and Decodable<\/code> for decoding \u2014 offers a powerful, built-in mechanism for converting native Swift types to and from a serialized format, such as JSON. Thanks to its integration with the Swift compiler, we often don\u2019t have to do any additional work to enable one of our types to become Codable<\/code>, such as this Movie<\/code> type:<\/p>\n

struct<\/span> Movie: Identifiable<\/span>, Codable<\/span> {\n    let<\/span> id: UUID<\/span>\n    var<\/span> title: String<\/span>\n    var<\/span> releaseDate: Date<\/span>\n    var<\/span> genre: Genre<\/span>\n    var<\/span> directorName: String<\/span>\n}<\/code><\/pre>\n
\n
Just by adding that Codable<\/code> conformance (which is a type alias for both Encodable<\/code> and Decodable<\/code>), our above Movie<\/code> type can now be serialized and deserialized automatically, as long as the data format (such as JSON) that we\u2019re working with follows the same structure as our Swift type declaration.<\/p>\n<\/blockquote>\n
However, sometimes we might be working with a type that requires some additional<\/em> data that\u2019s not present in the JSON (or whichever data format we\u2019re decoding from) in order to be initialized. For example, the following User<\/code> type includes a favorites<\/code> property \u2014 which is a Favorites<\/code> value that contains the user\u2019s favorites, such as their favorite director and movie genre:<\/p>\n
struct<\/span> User: Identifiable<\/span> {\n    let<\/span> id: UUID<\/span>\n    var<\/span> name: String<\/span>\n    var<\/span> membershipPoints: Int<\/span>\n    var<\/span> favorites: Favorites<\/span>\n}\n\nstruct<\/span> Favorites: Codable<\/span> {\n    var<\/span> genre: Genre<\/span>\n    var<\/span> directorName: String<\/span>\n    var<\/span> movieIDs: [Movie<\/span>.ID<\/span>]\n}<\/code><\/pre>\n
However, the JSON response that our app receives from the server when loading the data for a user doesn\u2019t include the Favorites<\/code> data, which instead need to be loaded from a separate server endpoint:<\/p>\n
\/\/ User server response:\n{\n    \"id\": \"7CBE0CC1-7779-42E9-AAF1-C4B145F3CAE9\",\n    \"name\": \"John Appleseed\",\n    \"membershipPoints\": 192\n}\n\n\/\/ Favorites server response:\n{\n    \"genre\": \"action\",\n    \"directorName\": \"Christopher Nolan\",\n    \"movieIDs\": [\n        \"F028CAB5-74D7-4B86-8450-D0046C32DFA0\",\n        \"D2657C95-1A35-446C-97D4-FAAA4783F2AA\",\n        \"5159AF60-DF61-4A0C-A6BA-AE0E027E2BC2\"\n    ]\n}<\/code><\/pre>\n
Now the question is, how do we make User<\/code> conform to Codable<\/code> (or more specifically, Decodable<\/code>) without being able to decode the required Favorites<\/code> data from the server\u2019s JSON response?<\/p>\n
One option would be to simply make the favorites<\/code> property optional \u2014 but that would have several downsides. First, it would make our data model more fragile, as we could easily miss to populate that property when loading User<\/code> values within various contexts (and the compiler wouldn\u2019t be able to warn us about it). Second, and arguably more important, is that we\u2019d constantly have to unwrap that optional favorites<\/code> value every time we access it, leading to either extra boilerplate code (and potentially ambiguous states), or dangerous force unwrapping.<\/p>\n
Another, more robust option would be to use a secondary, partial<\/em> model when decoding our User<\/code> data, which we would then combine with a Favorites<\/code> value in order to form our final model \u2014 like this:<\/p>\n
extension<\/span> User<\/span> {\n    struct<\/span> Partial: Decodable<\/span> {\n        let<\/span> id: UUID<\/span>\n        var<\/span> name: String<\/span>\n        var<\/span> membershipPoints: Int<\/span>\n    }\n}\n\nstruct<\/span> Networking {\n    var<\/span> session = URLSession<\/span>.shared<\/span>\n    ...\n\n    func<\/span> loadUser(withID id: User<\/span>.ID<\/span>) async throws<\/span> -> User<\/span> {\n        let<\/span> favoritesURL = favoritesURLForUser<\/span>(withID: id)\n        let<\/span> userURL = urlForUser<\/span>(withID: id)\n\n        \/\/ Load the user's favorites and the partial user data\n        \/\/ that our server responds with:<\/span>\n        async let<\/span> favorites = request<\/span>(favoritesURL) as<\/span> Favorites<\/span>\n        async let<\/span> partialUser = request<\/span>(userURL) as<\/span> User<\/span>.Partial<\/span>\n\n        \/\/ Form our final user model by combining the partial\n        \/\/ model with the favorites that were loaded:<\/span>\n        return try await<\/span> User<\/span>(\n            id: partialUser.id<\/span>,\n            name: partialUser.name<\/span>,\n            membershipPoints: partialUser.membershipPoints<\/span>,\n            favorites: favorites\n        )\n    }\n    \n    ...\n\n    private func<\/span> request<T: Decodable<\/span>>(_<\/span> url: URL<\/span>) async throws<\/span> -> T<\/span> {\n        let<\/span> (data, _<\/span>) = try await<\/span> session.data<\/span>(from: url)\n        return try<\/span> JSONDecoder<\/span>().decode<\/span>(T<\/span>.self<\/span>, from: data)\n    }\n}<\/code><\/pre>\n
While the above works perfectly fine, it would be really nice to find a solution that doesn\u2019t require us to duplicate all of our User<\/code> model\u2019s properties by declaring a separate, decoding-specific Partial<\/code> model. Thankfully, the Swift Codable system* does actually include such a solution \u2014 the somewhat lesser known CodableWithConfiguration<\/code> API.<\/p>\n
\n
* CodableWithConfiguration is not technically a direct part of Codable, which is defined within Swift\u2019s standard library, but is instead an extension defined within Foundation. That doesn\u2019t make much of a difference when targeting any of Apple\u2019s platforms, though.<\/p>\n<\/blockquote>\n
When a type conforms to either EncodableWithConfiguration<\/code> or DecodableWithConfiguration<\/code>, it requires an additional configuration value to be passed when either encoding or decoding it (and the compiler will enforce that requirement). That\u2019s incredibly useful in situations such as when decoding our User<\/code> type, since we can define that Favorites<\/code> is the required DecodingConfiguration<\/code> for our type \u2014 meaning that we can ensure that such a value will always be present during decoding, without having to declare any additional partial types.<\/p>\n
So let\u2019s go ahead and update our User<\/code> type to conform to DecodableWithConfiguration<\/code>, which does require a manual decoding implementation, unfortunately:<\/p>\n
extension<\/span> User<\/span>: Encodable<\/span>, DecodableWithConfiguration<\/span> {\n    enum<\/span> CodingKeys: CodingKey<\/span> {\n        case<\/span> id\n        case<\/span> name\n        case<\/span> membershipPoints\n    }\n\n    init<\/span>(from decoder: Decoder<\/span>, configuration: Favorites<\/span>) throws<\/span> {\n        let<\/span> container = try<\/span> decoder.container<\/span>(keyedBy: CodingKeys<\/span>.self<\/span>)\n\n        id = try<\/span> container.decode<\/span>(UUID<\/span>.self<\/span>, forKey: .id<\/span>)\n        name = try<\/span> container.decode<\/span>(String<\/span>.self<\/span>, forKey: .name<\/span>)\n        membershipPoints = try<\/span> container.decode<\/span>(\n            Int<\/span>.self<\/span>,\n            forKey: .membershipPoints<\/span>\n        )\n        favorites = configuration\n    }\n}<\/code><\/pre>\n
So we still have to write a bit of boilerplate in order to enable our new decoding setup, but the advantage is that we can now make our networking code a lot simpler \u2014 all that we need is another overload of our private request<\/code> method, which works with types conforming to DecodableWithConfiguration<\/code>, and we\u2019ll now be able to leverage type inference to make our decoding call site a lot simpler:<\/p>\n
struct<\/span> Networking {\n    ...\n\n    func<\/span> loadUser(withID id: User<\/span>.ID<\/span>) async throws<\/span> -> User<\/span> {\n        let<\/span> favoritesURL = favoritesURLForUser<\/span>(withID: id)\n        let<\/span> userURL = urlForUser<\/span>(withID: id)\n\n        return try await<\/span> request<\/span>(userURL, with: request<\/span>(favoritesURL))\n    }\n    \n    ...\n\n    private func<\/span> request<T: Decodable<\/span>>(_<\/span> url: URL<\/span>) async throws<\/span> -> T<\/span> {\n        ...\n    }\n\n    private func<\/span> request<T: DecodableWithConfiguration<\/span>>(\n        _<\/span> url: URL<\/span>,\n        with config: T<\/span>.DecodingConfiguration<\/span>\n    ) async throws<\/span> -> T<\/span> {\n        let<\/span> (data, _<\/span>) = try await<\/span> session.data<\/span>(from: url)\n\n        return try<\/span> JSONDecoder<\/span>().decode<\/span>(\n            T<\/span>.self<\/span>,\n            from: data,\n            configuration: config\n        )\n    }\n}<\/code><\/pre>\n
However, one thing that\u2019s a bit puzzling about the Codable WithConfiguration<\/code> API is that even though the protocol itself, as well as the KeyedCodingContainer<\/code> methods that enable us to perform nested decoding of such types, are all available from iOS 15, the top-level configuration-compatible JSONDecoder<\/code> API wasn\u2019t added until iOS 17.<\/p>\n
Thankfully, that\u2019s something that we can quite easily work around if working on a project that needs to support iOS 16 and earlier \u2014 by introducing our own implementation of that API, which uses Codable\u2019s userInfo<\/code> mechanism to store the configuration of the value that we\u2019re currently decoding:<\/p>\n
extension<\/span> JSONDecoder<\/span> {\n    \/\/ First, we define a wrapper type which we'll use to decode\n    \/\/ values that require a configuration type:<\/span>\n    private struct<\/span> ConfigurationDecodingWrapper<\n        Wrapped: DecodableWithConfiguration<\/span>\n    >: Decodable<\/span> {\n        var<\/span> wrapped: Wrapped<\/span>\n\n        init<\/span>(from decoder: Decoder<\/span>) throws<\/span> {\n            let<\/span> configuration = decoder.userInfo<\/span>[configurationUserInfoKey]\n\n            wrapped = try<\/span> Wrapped<\/span>(\n                from: decoder,\n                configuration: configuration as<\/span>! Wrapped<\/span>.DecodingConfiguration<\/span>\n            )\n        }\n    }\n\n    private static let<\/span> configurationUserInfoKey = CodingUserInfoKey<\/span>(\n        rawValue: \"configuration\"<\/span>\n    )!\n\n    \/\/ Then, we declare our own decode method (which omits the\n    \/\/ type parameter in order to not conflict with the built-in\n    \/\/ API), which will work on iOS 15 and above:<\/span>\n    func<\/span> decode<T: DecodableWithConfiguration<\/span>>(\n        from data: Data<\/span>,\n        configuration: T<\/span>.DecodingConfiguration<\/span>\n    ) throws<\/span> -> T<\/span> {\n        let<\/span> decoder = JSONDecoder<\/span>()\n        decoder.userInfo<\/span>[Self<\/span>.configurationUserInfoKey<\/span>] = configuration\n\n        let<\/span> wrapper = try<\/span> decoder.decode<\/span>(\n            ConfigurationDecodingWrapper<\/span><T<\/span>>.self<\/span>,\n            from: data\n        )\n\n        return<\/span> wrapper.wrapped<\/span>\n    }\n}<\/code><\/pre>\n
CodableWithConfiguration<\/code> is really quite useful when using Swift\u2019s built-in serialization API to encode and decode types that require additional data in order to be initialized, without having to resort to modeling required data as optional, or having to define additional types that are only ever used for decoding purposes.<\/p>\n
I hope that you found this article useful. Feel free to reach out via either either Mastodon<\/a> or Bluesky<\/a> if you have any questions or feedback.<\/p>\n
Thanks for reading!<\/p>","protected":false},"excerpt":{"rendered":"
Swift\u2019s Codable API \u2014 which consists of the Encodable protocol for encoding, and Decodable for decoding \u2014 offers a powerful, built-in mechanism for converting native Swift types to and from a serialized format, such as JSON. Thanks to its integration with the Swift compiler, we often don\u2019t have to do any additional work to enable […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"rop_custom_images_group":[],"rop_custom_messages_group":[],"rop_publish_now":"initial","rop_publish_now_accounts":[],"rop_publish_now_history":[],"rop_publish_now_status":"pending","footnotes":""},"categories":[1,15],"tags":[],"class_list":["post-9735","post","type-post","status-publish","format-standard","hentry","category-explore","category-world"],"_links":{"self":[{"href":"https:\/\/handoli.com\/index.php\/wp-json\/wp\/v2\/posts\/9735","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/handoli.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/handoli.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/handoli.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/handoli.com\/index.php\/wp-json\/wp\/v2\/comments?post=9735"}],"version-history":[{"count":0,"href":"https:\/\/handoli.com\/index.php\/wp-json\/wp\/v2\/posts\/9735\/revisions"}],"wp:attachment":[{"href":"https:\/\/handoli.com\/index.php\/wp-json\/wp\/v2\/media?parent=9735"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/handoli.com\/index.php\/wp-json\/wp\/v2\/categories?post=9735"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/handoli.com\/index.php\/wp-json\/wp\/v2\/tags?post=9735"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}