how do you set nil to codable enum when unexpected value in swift iOS

Question

I'm using Codable for my WebRequest response which is returning some predefined string or number. So, I'm using Enums for those. But when some unexpected value arrive to Response at that my Codable fails to decode.

Here some code for better understanding.

class WebUser: Codable, Equatable {
    static func == (lhs: WebUser, rhs: WebUser) -> Bool {
        return lhs.id == rhs.id
    }
    ...
    var mobileNumberPrivacy: CommonPrivacyOption?
    var emailPrivacy: CommonPrivacyOption?
    var dobPrivacy: CommonPrivacyOption?
    ...
}

enum CommonPrivacyOption: Int, CaseIterable, Codable {
    case privacyOnlyMe = 1, privacyPublic, privacyFriends, privacyFriendsOfFriends

    //Does not help this optional init function
    /*init?(rawValue: Int) {
        switch rawValue {
            case 1: self = .privacyOnlyMe
            case 2: self = .privacyPublic
            case 3: self = .privacyFriends
            case 4: self = .privacyFriendsOfFriends
            default: return nil
        }
    }*/

}

but sometimes from WebServer I'm getting, 0 for dobPrivacy at that time I'm getting DecodingError.dataCorrupted exception with context Cannot initialize CommonPrivacyOption from invalid Int value 0

As I expect to dobPrivacy nil when I get other values then 1/2/3/4.

EDIT:

let dict1 = [
    "id": 2,
    "mobileNumberPrivacy": 3,
    "emailPrivacy": 4,
    "dobPrivacy": 0 // Works perfectly with 1
]
do {
    let data1 = try JSONSerialization.data(withJSONObject: dict1, options: .prettyPrinted)
    let user1 = try JSONDecoder().decode(WebUser.self, from: data1)
    print("User1 created")
}
catch DecodingError.dataCorrupted(let context) {
    print(context.codingPath)
    print(context.debugDescription)
}
catch {
    print(error.localizedDescription)
}

I'm using this same Codable WebUser object for Profile detail, search users and many more. so may be some times one more key will not present in WebRequest's response.

Answer 1

I recommend writing a property wrapper that handles this problem for you.

Specifically, let's write a property wrapper named NilOnDecodingError that turns any DecodingError into nil.

Here's the declaration of NilOnDecodingError:

@propertyWrapper
public struct NilOnDecodingError<Wrapped> {
    public init(wrappedValue: Wrapped?) {
        self.wrappedValue = wrappedValue
    }

    public var wrappedValue: Wrapped?
}

We've defined it to wrap any type, storing an Optional.

Now we can conform it to Decodable when the Wrapped type is Decodable:

extension NilOnDecodingError: Decodable where Wrapped: Decodable {
    public init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        do {
            wrappedValue = .some(try container.decode(Wrapped.self))
        } catch is DecodingError {
            wrappedValue = nil
        }
    }
}

We probably also want it to be Encodable when the Wrapped type is Encodable:

extension NilOnDecodingError: Encodable where Wrapped: Encodable {
    public func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        if let value = wrappedValue {
            try container.encode(value)
        } else {
            try container.encodeNil()
        }
    }
}

Now we can wrap the appropriate fields of WebUser:

class WebUser: Codable {
    let id: String

    @NilOnDecodingError
    var mobileNumberPrivacy: CommonPrivacyOption?

    @NilOnDecodingError
    var emailPrivacy: CommonPrivacyOption?

    @NilOnDecodingError
    var dobPrivacy: CommonPrivacyOption?
}

For testing, we'll want to print the fields of the decoded user:

extension WebUser: CustomStringConvertible {
    var description: String {
        return """
        WebUser(
            id: \(id),
            mobileNumberPrivacy: \(mobileNumberPrivacy.map { "\($0)" } ?? "nil"),
            emailPrivacy: \(emailPrivacy.map { "\($0)" } ?? "nil")),
            dobPrivacy: \(dobPrivacy.map { "\($0)" } ?? "nil")))
        """
    }
}

Now we can try it out:

let json = """
{
    "id": "mrugesh",
    "mobileNumberPrivacy": 1,
    "emailPrivacy": 2,
    "dobPrivacy": 1000
}
"""

let user = try! JSONDecoder().decode(WebUser.self, from: json.data(using: .utf8)!)
print(user)

Output:

WebUser(
    id: mrugesh,
    mobileNumberPrivacy: privacyOnlyMe,
    emailPrivacy: privacyPublic),
    dobPrivacy: nil))

Answer 2

You need to create a custom Decodable initializer inside WebUser:

class WebUser: Codable {
    var dobPrivacy: CommonPrivacyOption?
    // Rest of your properties here.

    enum CodingKeys: String, CodingKey {
        case dobPrivacy
        // Add a case for each property you want to decode here.
    }

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

        // Use optional try to decode your enum so that when the
        // decode fails because of wrong Int value, it will assign nil.
        dobPrivacy = try? container.decode(CommonPrivacyOption.self, forKey: .dobPrivacy)
    }
}

Alternatively, you can implement the Decodable initializer inside CommonPrivacyOption and add an additional case unknown like so:

enum CommonPrivacyOption: Int, Codable {
    case privacyOnlyMe = 1
    case privacyPublic, privacyFriends, privacyFriendsOfFriends
    case unknown

    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        let value = try container.decode(Int.self)

        // Try to initialize Self from value, if 
        // value is not 1, 2, 3, or 4, initialize Self to 
        // the unknown case.
        self = .init(rawValue: value) ?? .unknown
    }
}

Answer 3

It looks to me like the compiler selects the wrong init for the enum types, instead of init(rawValue) it uses init(from:) that is the one for decoding (which in a way makes sense)

Here is a solution where we override this behaviour by using a custom init(from) in WebUser that decodes the raw values and then creates an enum item

required init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    if let value = try container.decodeIfPresent(CommonPrivacyOption.RawValue.self, forKey: .mobileNumberPrivacy), let mobileNumberPrivacy = CommonPrivacyOption(rawValue: value) {
        self.mobileNumberPrivacy = mobileNumberPrivacy
    }
    if let value = try container.decodeIfPresent(CommonPrivacyOption.RawValue.self, forKey: .emailPrivacy), let emailPrivacy = CommonPrivacyOption(rawValue: value) {
        self.emailPrivacy = emailPrivacy
    }
    if let value = try container.decodeIfPresent(CommonPrivacyOption.RawValue.self, forKey: .dobPrivacy), let dobPrivacy = CommonPrivacyOption(rawValue: value) {
        self.dobPrivacy = dobPrivacy
    }
}

Below is a small example

extension WebUser: CustomStringConvertible {
    var description: String {
        "Mobile: \(mobileNumberPrivacy?.rawValue), email: \(emailPrivacy?.rawValue), dob: \(dobPrivacy?.rawValue)"
    }
}

let data = """
{
    "mobileNumberPrivacy": 1,
    "dobPrivacy": 0
}
""".data(using: .utf8)!

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

Mobile: Optional(1), email: nil, dob: nil

---

Of course if you can change your mind about 0 being translated to nil then I would suggest you extend the enum to support the 0 value

enum CommonPrivacyOption: Int, CaseIterable, Codable {
    case none = 0
    case privacyOnlyMe = 1, privacyPublic, privacyFriends, privacyFriendsOfFriends
}

Then it should work out of the box and you don't need to write any custom code.

Answer 4

I liked @alobaili's answer since it's simple and provided a good solution. One thing I wanted to improve is to make it more generic, so that any Decodable (and Codable) could do it with less code to write.

extension Decodable where Self: RawRepresentable, RawValue: Decodable {
    
    static func initializedOptionalWith(decoder: Decoder, defaultValue: Self) throws -> Self {
        
        let container = try decoder.singleValueContainer()
        let value = try container.decode(RawValue.self)
        
        return .init(rawValue: value) ?? defaultValue
    }
}

Usage:

init(from decoder: Decoder) throws {
    self = try .initializedOptionalWith(decoder: decoder, defaultValue: .unknown)
}