Best approach for handing Response JSON data structures? - ios

Question

I have built a backend and am working on a front end client, currently, a login response from my client returns:
{
"user": {
"email": "fdsa#fdsafsdfa.com",
"token": "eyJhbGciOiJIUzI"
}
}
This is presenting me an issue where I cant simply decode to a user object, Im having to do the following 2 layers for everything:
struct User: Codable {
let email: String
let token: String
}
struct UserResponseData: Codable {
let user: User
}
Is there a more effective way to directly access the values and constrict the object? Perhaps my editing the user json parent to something more generic like data then sit the user inside that? I am unsure...
My client looks like the below, if that helps inform an improved architecture:
class APIClient {
static func signup(request: SignupRequestData, completion: #escaping (Result<UserResponseData>) -> Void) {
performRequest(route: APIRouter.signup(request), completion: completion)
}
#discardableResult
private static func performRequest<T:Decodable>(route: APIRouter,
decoder: JSONDecoder = JSONDecoder(),
completion:#escaping (Result<T>)->Void) -> DataRequest {
return AF.request(route).responseDecodable (decoder: decoder){ (response: DataResponse<T>) in
completion(response.result)
}
}
}
Appreciate some assistance in a better suited structure moving forward so I dont have to keep unwrapping a parent to get to the values needed for the client

Answer 1

One fairly simple approach is to wrap this up into a general-purpose Response type that assumes the first key is always the right one.
struct AnyStringKey: CodingKey {
var stringValue: String
init?(stringValue: String) { self.stringValue = stringValue }
var intValue: Int?
init?(intValue: Int) { return nil }
}
struct Response<Payload: Decodable>: Decodable {
let payload: Payload
init(from decoder: Decoder) throws {
let container = try decoder.container(keyedBy: AnyStringKey.self)
guard let key = container.allKeys.first else {
throw DecodingError.dataCorrupted(.init(codingPath: decoder.codingPath,
debugDescription: "Missing payload key"))
}
self.payload = try container.decode(Payload.self, forKey: key)
}
}
let user = try JSONDecoder().decode(Response<User>.self, from: json).payload
It's possible to make this more advanced, and check that the key matches your expectation, but this is probably sufficient for your situation.
This approach moves some work into the caller (calling .payload). You can get rid of that at the cost of moving some of the work into the decoded type with a protocol that handles extracting sub-keys.
protocol LayerDecodable: Decodable {
associatedtype CodingKeys: CodingKey
init(from container: KeyedDecodingContainer<CodingKeys>) throws
}
extension LayerDecodable {
init(from decoder: Decoder) throws {
let container = try decoder.container(keyedBy: AnyStringKey.self)
guard let key = container.allKeys.first else {
throw DecodingError.dataCorrupted(.init(codingPath: decoder.codingPath,
debugDescription: "Missing payload key"))
}
try self.init(from: container.nestedContainer(keyedBy: CodingKeys.self, forKey: key))
}
}
But with this, you need to implement the decoding by hand.
struct User: LayerDecodable {
let email: String
let token: String
enum CodingKeys: CodingKey {
case email, token
}
init(from container: KeyedDecodingContainer<CodingKeys>) throws {
self.email = try container.decode(String.self, forKey: .email)
self.token = try container.decode(String.self, forKey: .token)
}
}
The benefit is that the caller is now clean:
let user = try JSONDecoder().decode(User.self, from: json)