Really handy library, thanks for making it.

I'm wondering if you think the responseDecodableObject[keyPath: ...] is a good call. There's going to be performance hit deserializing to json then serializing back to data then deserializing to codable object.

Users might not look under the hood and see this. Isn't better they just make a container object or writing a customer coder method? Also asking for myself really.

Best,

    var id:        String
    var owner_id:  String
    var name:      String
    var active:    Bool?
    var share:     Bool?
    var date:      Int?
    var duration:  Int
    
    typealias DownloadComplete = () -> ()
}

extension ActiveChannelHangouts {
    static func from(json: String, using encoding: String.Encoding = .utf8) -> ActiveChannelHangouts? {
        guard let data = json.data(using: encoding) else { return nil }
        return ActiveChannelHangouts.from(data: data)
    }
    
    static func from(data: Data) -> ActiveChannelHangouts? {
        let decoder = JSONDecoder()
        do {
            return try decoder.decode(ActiveChannelHangouts.self, from: data)
        } catch  {
            print(error.localizedDescription)
            return nil
        }
    }
    
    var jsonData: Data? {
        let encoder = JSONEncoder()
        do {
            return try encoder.encode(self)
        } catch {
            print(error.localizedDescription)
            return nil
        }
    }
    
    var jsonString: String? {
        guard let data = self.jsonData else { return nil }
        return String(data: data, encoding: .utf8)
    }
    
}

extension ActiveChannelHangouts {
    enum CodingKeys: String, CodingKey {
        case id       = "id"
        case ownerId  = "ownerId"
        case name     = "name"
        case active   = "active"
        case share    = "share"
        case date     = "date"
        case duration = "duration"
    }
}

// from my APIClient struct trying to call this method 
func responseDecodableObject<T: Decodable>(url: String, queue: DispatchQueue? = nil,
                                               keyPath: String? = nil,
                                               decoder: JSONDecoder = JSONDecoder(),
                                               completionHandler: @escaping (DataResponse<T>) -> Void) {
        if !PerfectLocalAuth.sessionid.isEmpty {
            Alamofire.request(url).responseDecodableObject(queue: PerfectLocalAuth.setHeaders(), keyPath: keyPath, decoder: decoder) {
                (response: DataResponse<[T]>) in
                let repo = response.result.value
                print(repo)
            }
            
        }
    }

i am trying to create one func that can be handle for all my fetch request but i go this error Cannot convert value of type 'HTTPHeaders' (aka 'Dictionary<String, String>') to expected argument type 'DispatchQueue?

Swift 4 & Xcode 9.0 on mac OS High Sierra

Where the issue accurs:

...alamofireRequest.responseDecodableObject(
    queue: nil, 
    keyPath: nil, 
    decoder: JSONDecoder()) { 
        (resp: DataResponse<GenralResponse<FlexibleValue>>) in
        logger.verbose(resp)
}

Related Types

// FlexibleValue is for decoding the flexible part of response JSON.

struct FlexibleValue: Decodable {
    var role: [String]
}

// GeneralResponse<T> is the designed to decode general response from back-end, with a hosted type T, which is decodable too.

struct GeneralResponse<T: Decodable>: Decodable  {
    struct Head: Decodable {
        let version: String
        let msgtype: String
        let interface: String
        let remark: String
    }
    struct Body: Decodable {
        let ret: String
        let retcode: String
        let retinfo: String
        let data: T?
    }
    let head: Head
    let body: Body
}

The Alamofire dependency is specified in such a manner that users of this pod are locked to a specific minor version. As Alamofire follows sematic versioning (see Alamofire/Changelog), locking this dependency to a major version is all that should be required.

Is it possible for

s.dependency 'Alamofire', '~> 5.0.0-rc.3'

to be replaced with

s.dependency 'Alamofire', '~> 5.0'

Hello,

First of all thanks for such useful library.

It seems Alamofire 5.0.0-rc.3 is API stable now. Is there a way/branch to use that with CodableAlamofire? without forking?

Best

This PR updates the Package.swift tool version and adds platform information.

This makes it possible to use CodableAlamofire with Alamofire 4.9 using Swift Package Manager.

Hi,

I have a special case, I have a JSON response which sometimes returns a numeric value and sometimes a string value for the same key. Is there any way to handle such a JSON response.

I know, that this isn't a good idea in general, but I don't have access to the server backend 😉.

Moving to Alamofire 5.x isn't possible for us at the moment but we would like to be one RxSwift 6.2 for other reasons.

This is branched off the last Alamofire 4.x release as far as I can tell but github won't accept a pr against it for some reason.

I'll appreciate if this is no longer part of this repo and maintain my own fork until we can get Alamofire upgraded.

When using this DateFormatter separately, I can successfully deserialize date string with it:

extension DateFormatter {
    static let apiDateFormatter: DateFormatter = {
        let formatter = DateFormatter()
        //2019-08-05T08:41:06.590Z
        formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSZ"
        return formatter
    }()
}

If I use the same formatter when calling .responeDecodableObject(decoder: decoder), model properties (of Date type) are set to nil.

let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .formatted(.apiDateFormatter)

Alamofire.request(url, method: method, parameters: parameters, encoding: encoding, headers: headers)
    .responseDecodableObject(decoder: decoder) { (response: DataResponse<T>) in
        let data = response.data
}

Is there any more setup that I am not aware of? Thanks