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

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))

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
    }
}

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.

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)
}