Unstable error message from the API in Xcode?

Question

while i am trying to decode some json data using Alamofire and PromiseKit, I am encountering some unstable error message.. why I am saying " unstable error message is that sometimes when I hit the API .GET request, i am getting the response in full format, without any error, but after a couple of times running the application Xcode throwing an Alamofire Response Serialization Error which is so confusing.. . I have implemented Coding keys too, data and json response formats are also in right format.. can anyone please help me decode this error message .?

here is the response i got from the API in one of random application run:

and after the next run, here is the error message from the xcode console:

Alamofire.AFError.ResponseSerializationFailureReason.decodingFailed(error: Swift.DecodingError.typeMismatch(Swift.Array<Any>, Swift.DecodingError.Context(codingPath: [], debugDescription: "Expected to decode Array<Any> but found a dictionary instead.", underlyingError: nil))))

if any part of the code is required for more analysis, please let me know so that I will update the question contents with those required pieces of code.. .

here is my json response model structs:

// MARK: - TickerByPair
struct TickerByPair {
    var price, ask: Double
    var askVolume: Double
    var bid: Double
    var bidVolume, volume: Double
    var time: String
    
}

extension TickerByPair: Decodable{
    
    enum TrackCodingKeys: String, CodingKey {
        case price = "price"
        case ask = "ask"
        case askVolume = "askVolume"
        case bid = "bid"
        case bidVolume = "bidVolume"
        case volume = "volume"
        case time = "time"
    }
    
    
    
    init(from decoder: Decoder) throws {
        let trackContainer = try decoder.container(keyedBy: TrackCodingKeys.self)
        if trackContainer.contains(.price){
            price = try trackContainer.decode(Double.self, forKey: .price)
        }else{
            price = 0
        }
        if trackContainer.contains(.ask) {
            ask = try trackContainer.decode(Double.self, forKey: .ask)
        } else {
            ask = 0
        }
        if trackContainer.contains(.askVolume) {
            askVolume = try trackContainer.decode(Double.self, forKey: .askVolume)
        } else {
            askVolume = 0
        }
        if trackContainer.contains(.bid) {
            bid = try trackContainer.decode(Double.self, forKey: .bid)
        } else {
            bid = 0
        }
        if trackContainer.contains(.bidVolume) {
            bidVolume = try trackContainer.decode(Double.self, forKey: .bidVolume)
        } else {
            bidVolume = 0
        }
        if trackContainer.contains(.volume) {
            volume = try trackContainer.decode(Double.self, forKey: .volume)
        } else {
            volume = 0
        }
        if trackContainer.contains(.time) {
            time = try trackContainer.decode(String.self, forKey: .time)
        }
        else {
            time = ""
        }
    }
    
    
}


// MARK: - TradingPairElement
struct TradingPair {
    var id: Int
    var name: String
    var quoteAsset: String
    var baseAsset: String
}

extension TradingPair: Decodable {
    
    enum TrackCodingKeys: String, CodingKey {
        case id = "id"
        case name = "name"
        case quoteAsset = "quoteAsset"
        case baseAsset = "baseAsset"
       
    }
    init(from decoder: Decoder) throws {
        let trackContainer = try decoder.container(keyedBy: TrackCodingKeys.self)
        if trackContainer.contains(.id){
            id = try trackContainer.decode(Int.self, forKey: .id)
        }else{
            id = 0
        }
        if trackContainer.contains(.name) {
            name = try trackContainer.decode(String.self, forKey: .name)
        } else {
            name = ""
        }
        if trackContainer.contains(.quoteAsset) {
            quoteAsset = try trackContainer.decode(String.self, forKey: .quoteAsset)
        } else {
            quoteAsset = ""
        }
        if trackContainer.contains(.baseAsset) {
            baseAsset = try trackContainer.decode(String.self, forKey: .baseAsset)
        } else {
            baseAsset = ""
        }
    }
}

and the API .GET request using Alamofire :

class ServerCommunicator {
    
    static func getAssets() -> Promise<[Assets]> {
        let decoder = JSONDecoder()
        return Promise { seal in
            AF.request(API.assets, method: .get, parameters: .none, headers: .none).responseDecodable(of: [Assets].self, decoder: decoder) { response in
                switch response.result {
                    case .success(let assets):
                        return seal.fulfill(assets)
                    case .failure(let error):
                        return seal.reject(error)
                }
            }
        }
    }
    
    static func getPairs() -> Promise<[TradingPair]> {
        let decoder = JSONDecoder()
        decoder.keyDecodingStrategy = .useDefaultKeys
        return Promise { seal in
            AF.request(API.tradingPairs, method: .get, parameters: .none, headers: .none).responseDecodable(of: [TradingPair].self, decoder: decoder) { response in
                switch response.result {
                    case .success(let pairs):
                        return seal.fulfill(pairs)
                    case .failure(let error):
                        return seal.reject(error)
                }
            }
        }
    }
    
    static func getPair(with pairName: String?) -> Promise<TickerByPair> {
        let decoder = JSONDecoder()
        decoder.keyDecodingStrategy = .useDefaultKeys
        return Promise { seal in
            AF.request(API.getPairByTicker(pairName: pairName!), method: .get, parameters: .none, headers: .none).responseDecodable(of: TickerByPair.self, decoder: decoder) { response in
                switch response.result {
                    case .success(let ticker):
                        return seal.fulfill(ticker)
                    case .failure(let error):
                        return seal.reject(error)
                }
            }
        }
    }
}

and my json response format is also as follows:

[
  {
    "name": "ETH-KRW",
    "baseAsset": "ETH",
    "quoteAsset": "KRW"
  }, {
    "name": "BTC-KRW",
    "baseAsset": "BTC",
    "quoteAsset": "KRW"
  }, {
    "name": "BCH-KRW",
    "baseAsset": "BCH",
    "quoteAsset": "KRW"
  }
]

-------------

{
  "price": 10194500,
  "ask": 10195000,
  "bid": 10184500,
  "volume": 1752.05558316,
  "time": "2018-03-14T03:50:41.184Z"
}

Answer 1

If there are cases where your API that supposed to return array, returns dictionary instead, you can try re-implementing the convenient responseDecodable(of:decoder:) function of Alamofire.

Use the responseData(queue:completionHandler:) and try to decode your response data to array and if that fails try again to an object type.

Your getPairs() function for example could be something like this:

static func getPairs() -> Promise<[TradingPair]> {
    let decoder = JSONDecoder()
    decoder.keyDecodingStrategy = .useDefaultKeys
    return Promise { seal in
        AF.request(API.tradingPairs, method: .get, parameters: .none, headers: .none).responseData { response in
            switch response.result {
            case .success(let data):
                do {
                    let pairs = try decoder.decode([TradingPair].self, from: data)
                    return seal.fulfill(pairs)
                } catch DecodingError.typeMismatch {
                    do {
                        let pair = try decoder.decode(TradingPair.self, from: data)
                        return seal.fulfill([pair])
                    } catch {
                        return seal.reject(error)
                    }
                } catch {
                    return seal.reject(error)
                }
            case .failure(let error):
                return seal.reject(error)
            }
        }
    }
}

Or more generally, make an extension of DataRequest like this:

extension DataRequest {
    @discardableResult func responseArray<T: Decodable>(
        of type: T.Type,
        decoder: DataDecoder,
        completionHandler: @escaping (AFDataResponse<[T]>) -> Void
    ) -> Self {
        responseData { response in
            switch response.result {
            case .success(let data):
                do {
                    let array = try decoder.decode([T].self, from: data)
                    let dataResponse = self.dataResponse(from: response, result: .success(array))
                    completionHandler(dataResponse)
                } catch DecodingError.typeMismatch {
                    do {
                        let object = try decoder.decode(T.self, from: data)
                        let dataResponse = self.dataResponse(from: response, result: .success([object]))
                        completionHandler(dataResponse)
                    } catch {
                        let dataResponse: AFDataResponse<[T]> = self.dataResponse(
                            from: response,
                            result: .failure(.responseSerializationFailed(reason: .decodingFailed(error: error)))
                        )
                        completionHandler(dataResponse)
                    }
                } catch {
                    let dataResponse: AFDataResponse<[T]> = self.dataResponse(
                        from: response,
                        result: .failure(.responseSerializationFailed(reason: .decodingFailed(error: error)))
                    )
                    completionHandler(dataResponse)
                }
            case .failure(let error):
                let dataResponse: AFDataResponse<[T]> = self.dataResponse(from: response, result: .failure(error))
                completionHandler(dataResponse)
            }
        }
    }
    
    private func dataResponse<T: Decodable>(from response: AFDataResponse<Data>, result: Result<[T], AFError>) -> AFDataResponse<[T]> {
        return .init(
            request: response.request,
            response: response.response,
            data: response.data,
            metrics: response.metrics,
            serializationDuration: response.serializationDuration,
            result: result
        )
    }
}

and then your getPairs() function will be much simpler:

static func getPairs() -> Promise<[TradingPair]> {
    let decoder = JSONDecoder()
    decoder.keyDecodingStrategy = .useDefaultKeys
    return Promise { seal in
        AF.request(API.tradingPairs, method: .get, parameters: .none, headers: .none).responseArray(of: TradingPair.self, decoder: decoder) { response in
            switch response.result {
            case .success(let pairs):
                return seal.fulfill(pairs)
            case .failure(let error):
                return seal.reject(error)
            }
        }
    }
}