Swift Decodable - How to decode nested JSON that has been base64 encoded

Question

I am attempting to decode a JSON response from a third-party API which contains nested/child JSON that has been base64 encoded.

Contrived Example JSON

{
   "id": 1234,
   "attributes": "eyAibmFtZSI6ICJzb21lLXZhbHVlIiB9",  
}

PS "eyAibmFtZSI6ICJzb21lLXZhbHVlIiB9" is { 'name': 'some-value' } base64 encoded.

I have some code that is able to decode this at present but unfortunately I have to reinstanciate an additional JSONDecoder() inside of the init in order to do so, and this is not cool...

Contrived Example Code


struct Attributes: Decodable {
    let name: String
}

struct Model: Decodable {

    let id: Int64
    let attributes: Attributes

    private enum CodingKeys: String, CodingKey {
        case id
        case attributes
    }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)

        self.id = try container.decode(Int64.self, forKey: .id)

        let encodedAttributesString = try container.decode(String.self, forKey: .attributes)

        guard let attributesData = Data(base64Encoded: encodedAttributesString) else {
            fatalError()
        }

        // HERE IS WHERE I NEED HELP
        self.attributes = try JSONDecoder().decode(Attributes.self, from: attributesData)
    }
}

Is there anyway to achieve the decoding without instanciating the additional JSONDecoder?

PS: I have no control over the response format and it cannot be changed.

Out of curiosity, what's the downside with using an additional `JSONDecoder`? (and I don't think you can avoid it) — New Dev, Sep 28 '20 at 22:32
Some reasons I can think of... because the new decoder will potentially have different options to the original (e.g. `convertFromSnakeCase` or `dateDecodingStrategy`), because the data format might not be JSON at all, someone might be trying to decode the same model in an XML format. — Oliver Pearmain, Sep 29 '20 at 07:48
You can put a custom decoder (could be one with the same options), in the `userInfo` of the "main" Decoder. — Larme, Sep 29 '20 at 13:01
what @Larme said, ... and, the fact that it could be a different data format from the decoder of the parent object (e.g. XML inside a JSON) is a reason I was thinking why it ought to be an additional (or different) decoder — New Dev, Sep 29 '20 at 13:16

vadian · Answer 1 · 2020-09-29T12:05:39.857

If attributes contains only one key value pair this is the simple solution.

It decodes the base64 encoded string directly as Data – this is possible with the .base64 data decoding strategy – and deserializes it with traditional JSONSerialization. The value is assigned to a member name in the Model struct.

If the base64 encoded string cannot be decoded a DecodingError will be thrown

let jsonString = """
{
   "id": 1234,
   "attributes": "eyAibmFtZSI6ICJzb21lLXZhbHVlIiB9",
}
"""

struct Model: Decodable {
    
    let id: Int64
    let name: String
    
    private enum CodingKeys: String, CodingKey {
        case id, attributes
    }
    
    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.id = try container.decode(Int64.self, forKey: .id)
        let attributeData = try container.decode(Data.self, forKey: .attributes)
        guard let attributes = try JSONSerialization.jsonObject(with: attributeData) as? [String:String],
            let attributeName = attributes["name"] else { throw DecodingError.dataCorruptedError(forKey: .attributes, in: container, debugDescription: "Attributes isn't eiter a dicionary or has no key name") }
        self.name = attributeName
    }
}

let data = Data(jsonString.utf8)

do {
    let decoder = JSONDecoder()
    decoder.dataDecodingStrategy = .base64
    let result = try decoder.decode(Model.self, from: data)
    print(result)
} catch {
    print(error)
}

"If attributes contains only one key value pair this is the simple solution." Unfortunately it does not, the example in the OP is contrived and simplified. — Oliver Pearmain, Sep 29 '20 at 14:57
The suggested solution simply swaps `JSONDecoder` for `JSONSerialization` which isn't really solving the code smell. — Oliver Pearmain, Sep 29 '20 at 14:58
You cannot avoid the *smell* since it's necessary to decode two different levels. — vadian, Sep 29 '20 at 15:01

score 2 · Accepted Answer · answered Sep 29 '20 at 13:30

I find the question interesting, so here is a possible solution which would be to give the main decoder an additional one in its userInfo:

extension CodingUserInfoKey {
    static let additionalDecoder = CodingUserInfoKey(rawValue: "AdditionalDecoder")!
}

var decoder = JSONDecoder()
let additionalDecoder = JSONDecoder() //here you can put the same one, you can add different options, same ones, etc.
decoder.userInfo = [CodingUserInfoKey.additionalDecoder: additionalDecoder]

Because the main method we use from JSONDecoder() is func decode<T>(_ type: T.Type, from data: Data) throws -> T where T : Decodable and I wanted to keep it as such, I created a protocol:

protocol BasicDecoder {
    func decode<T>(_ type: T.Type, from data: Data) throws -> T where T : Decodable
}

extension JSONDecoder: BasicDecoder {}

And I made JSONDecoder respects it (and since it already does...)

Now, to play a little and check what could be done, I created a custom one, in the idea of having like you said a XML Decoder, it's basic, and it's just for the fun (ie: do no replicate this at home ^^):

struct CustomWithJSONSerialization: BasicDecoder {
    func decode<T>(_ type: T.Type, from data: Data) throws -> T where T : Decodable {
        guard let dict = try JSONSerialization.jsonObject(with: data) as? [String: Any] else { fatalError() }
        return Attributes(name: dict["name"] as! String) as! T
    }
}

So, init(from:):

guard let attributesData = Data(base64Encoded: encodedAttributesString) else { fatalError() }
guard let additionalDecoder = decoder.userInfo[.additionalDecoder] as? BasicDecoder else { fatalError() }
self.attributes = try additionalDecoder.decode(Attributes.self, from: attributesData)

Let's try it now!

var decoder = JSONDecoder()
let additionalDecoder = JSONDecoder()
decoder.userInfo = [CodingUserInfoKey.additionalDecoder: additionalDecoder]


var decoder2 = JSONDecoder()
let additionalDecoder2 = CustomWithJSONSerialization()
decoder2.userInfo = [CodingUserInfoKey.additionalDecoder: additionalDecoder]


let jsonStr = """
{
"id": 1234,
"attributes": "eyAibmFtZSI6ICJzb21lLXZhbHVlIiB9",
}
"""

let jsonData = jsonStr.data(using: .utf8)!

do {
    let value = try decoder.decode(Model.self, from: jsonData)
    print("1: \(value)")
    let value2 = try decoder2.decode(Model.self, from: jsonData)
    print("2: \(value2)")
}
catch {
    print("Error: \(error)")
}

Output:

$> 1: Model(id: 1234, attributes: Quick.Attributes(name: "some-value"))
$> 2: Model(id: 1234, attributes: Quick.Attributes(name: "some-value"))

I have implemented this approach. Thanks for a great answer and write up, I have accepted! — Oliver Pearmain, Sep 30 '20 at 15:30

gcharita · Answer 3 · 2020-09-29T12:52:24.350

After reading this interesting post, I came up with a reusable solution.

You can create a new NestedJSONDecodable protocol which gets also the JSONDecoder in it's initializer:

protocol NestedJSONDecodable: Decodable {
    init(from decoder: Decoder, using nestedDecoder: JSONDecoder) throws
}

Implement the decoder extraction technique (from the aforementioned post) together with a new decode(_:from:) function for decoding NestedJSONDecodable types:

protocol DecoderExtractable {
    func decoder(for data: Data) throws -> Decoder
}

extension JSONDecoder: DecoderExtractable {
    struct DecoderExtractor: Decodable {
        let decoder: Decoder
        
        init(from decoder: Decoder) throws {
            self.decoder = decoder
        }
    }
    
    func decoder(for data: Data) throws -> Decoder {
        return try decode(DecoderExtractor.self, from: data).decoder
    }
    
    func decode<T: NestedJSONDecodable>(_ type: T.Type, from data: Data) throws -> T {
        return try T(from: try decoder(for: data), using: self)
    }
}

And change your Model struct to conform to NestedJSONDecodable protocol instead of Decodable:

struct Model: NestedJSONDecodable {

    let id: Int64
    let attributes: Attributes

    private enum CodingKeys: String, CodingKey {
        case id
        case attributes
    }

    init(from decoder: Decoder, using nestedDecoder: JSONDecoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)

        self.id = try container.decode(Int64.self, forKey: .id)
        let attributesData = try container.decode(Data.self, forKey: .attributes)
        
        self.attributes = try nestedDecoder.decode(Attributes.self, from: attributesData)
    }
}

The rest of your code will remain the same.

Thank you, this is defintely a good answer (I have upvoted) however I see one drawback in that its not possible to have `Model` as a sub/nested/child entity of another model. — Oliver Pearmain, Sep 29 '20 at 15:04
@OliverPearmain yes, that's definitely something that I did thought of. I like Larme's answer better to be honest :) — gcharita, Sep 29 '20 at 15:20

score 0 · Answer 4 · answered Sep 29 '20 at 00:16

You could create a single decoder as a static property of Model, configure it once, and use it for all your Model decoding needs, both externally and internally.

Unsolicited thought: Honestly, I would only recommend doing that if you're seeing a measurable loss of CPU time or crazy heap growth from the allocation of additional JSONDecoders… they're not heavyweight objects, less than 128 bytes unless there's some trickery I don't understand (which is pretty common though tbh):

let decoder = JSONDecoder()
malloc_size(Unmanaged.passRetained(decoder).toOpaque()) // 128

Thanks for the suggestion but this is replacing one problem for another really. I've already considered using a singleton. — Oliver Pearmain, Sep 29 '20 at 07:52

Swift Decodable - How to decode nested JSON that has been base64 encoded

4 Answers4