Decodable returning object

Question

I have a decodable class:

struct AuthenticationResponse : Decodable {
var status: String
var error: Error
var access_token: String? = ""
var expires_in: Double? = 0
var token_type: String? = ""
var scope: String? = ""
var refresh_token: String? = " 
}

struct Error : Decodable {
var desc: String
var code: String
}

In the Error class I have:

And to decode to this class, I have:

 URLSession.shared.dataTask(with: request) { (data:Data?, response:URLResponse?, error:Error?) in
            if let jsonData = data{
                let decoder = JSONDecoder()
                print("hey")
                print("response: \(String(data:jsonData, encoding:.utf8))")
                completion(try! decoder.decode(AuthenticationResponse.self, from: jsonData))
            }
    }.resume()

As some of the responses I receive are (Success response):

{
“status”: “SUCCESS”  “error”: null,  "access_token":
"MWVmOWQxMDYwMjQyNDQ4NzQyNTdkZjQ3NmI4YmVjMGZjZGM5N2IyZmNkOTA1 N2M0NDUzODEwYjM5ZWQyNGNkZg",
"expires_in": 3600, "token_type": "bearer", "scope": null, 
"refresh_token":
"ZGEwOGZiOWZhMzhhYjBmMzAyOGRmZTA5NjJhMjY2MTk3YzMyMmE1ZDlkNWI2N mJjYmIxMjNkMjE1NWFhNWY0Mg"
}

And then a failed response just contains an error object with desc and code in it.

What i am trying to achieve is a decodable class suitable for both scenarios (When a response is successful and failed) however im not sure how to achieve this. I'm aware i can make 2 separate decodable classes but this would make things messier as i'd have to determine if the response is an error and populate to return different classes.

Does anyone know how i should acheive this>

Answer 1

I will give it a try, but first we need to sort out what I consider a somewhat shoddy question. Since Error is the name of a (famous and widely used) protocol it should be renamed and since you want to be able to leave it empty in your AuthenticationResponse it must obviously be an optional there (bearing the question why it is in the Response at all, but I will leave this aside). This leaves us with the following:

struct AuthError : Decodable {
    var desc: String
    var code: String
}

struct AuthenticationResponse : Decodable {
    var status: String
    var error: AuthError?
    var access_token: String? = ""
    var expires_in: Double? = 0
    var token_type: String? = ""
    var scope: String? = ""
    var refresh_token: String? = ""
}

Then we need some example data for the two relevant cases in question, I used:

let okData = """
    {
    "status": "SUCCESS",
    "error": null,
    "access_token":
    "MWVmOWQxMDYwMjQyNDQ4NzQyNTdkZjQ3NmI4YmVjMGZjZGM5N2IyZmNkOTA1N2M0NDUzODEwYjM5ZWQyNGNkZg",
    "expires_in": 3600,
    "token_type": "bearer",
    "scope": null,
    "refresh_token":
    "ZGEwOGZiOWZhMzhhYjBmMzAyOGRmZTA5NjJhMjY2MTk3YzMyMmE1ZDlkNWI2NmJjYmIxMjNkMjE1NWFhNWY0Mg"
    }
    """.data(using: .utf8)!

let errData = """
    {
        "desc": "username or password incorrect",
        "code": "404"
    }
    """.data(using: .utf8)!

Now we can define a single enum return type which allows for all our cases:

enum AuthResult {
    case ok(response: AuthenticationResponse)
    case authError(error: AuthError)
    case parseError(description: String)
    case fatal
}

which finally allows us to write our parse function for the received authentication data:

func parse(_ jsonData:Data) -> AuthResult {
   let decoder = JSONDecoder()
    do {
        let authRes = try decoder.decode(AuthenticationResponse.self, from: jsonData)
        return .ok(response: authRes)
    } catch {
        do {
            let errRes = try decoder.decode(AuthError.self, from: jsonData)
            return .authError(error: errRes)
        } catch let errDecode {
            return .parseError(description: errDecode.localizedDescription)
        }
    }
}

All this in a Playground will permit usage as in

switch parse(okData) {
case let .ok(response):
    print(response)
case let .authError(error):
    print(error)
case let .parseError(description):
    print("You threw some garbage at me and I was only able to \(description)")
default:
    print("don't know what to do here")
}

That is still elegant compared to the mess you would make in most other languages, but the call is still out on wether it would not make more sense to just define AuthenticationResponse as the (regular) return type of the parse function and provide the rest by throwing some enum (conforming to Error) and some suitable payload.

Coming (mainly) from Java I still shun from using exceptions as "somewhat" regular control flow (as in a "regular" login failure), but given Swifts much more reasonable approach to exceptions this might have to be reconsidered.

Anyways, this leaves you with a function to parse either case of your services replies and a decent way to handle them in a "uniform" manner. As you might not be able to modify the behaviour of the service handling your request this might be the only viable option. However, if you are able to modify the service you should strive for a "uniform" reply that would be parseable by a single call to JSONDecoder.decode. You would still have to interpret the optionals (as you should in the above example, since they are still a pain to work with, even given Swifts brilliant compiler support forcing you to "do the right thing"), but it would make your parsing less error prone.