Malibu is a networking library built on promises

Morning All, Tried to install the library through cocoapods yesterday and the library won't compile. Seems there are references to updates in the When library which aren't there. Installing through cocoa-odds installs When version 2.1.1 when the changes are at least in the latest version 2.3.3. I updated the pod spec locally and installed When 2.3.3 which fixed the references, but the RequestConvertible isn't running the promise. Using the default promise works, i.e. "let promise = Malibu.request(Request.get("https://api.myjson.com/bins/1bgj27"))", but using the RequestConvertible method doesn't. Didn't want to troubleshoot much without you having a chance to update the dependencies. Hope this makes sense. Let me know if I'm just doing something stupid. Bruce

I noticed that my requests are being dispatched with the header If-None-Match: "Some ETag hash" even after calling Malibu.clearStorage()

I created a sample project demonstrating it: https://github.com/guilhermearaujo/malibu-etag Its README contains more details.

The weird thing is that at this line: https://github.com/hyperoslo/Malibu/blob/26657c5e46339749aa6cc178ed2a4111fe6841ce/Sources/Networking.swift#L200-L212 before the return, I added the code:

print(urlRequest.allHTTPHeaderFields!)

And the If-None-Match header is not present, but somehow it ends being sent anyway.

Looks like a bug to me. Tested on versions 6.2.0 and 6.4.1

If the validation fails (let's say the server returns 400> status code) there is no way to get the data that the server returns.

Would be very helpful if there is a way to get the data so you can display server sided exceptions.

This is a super breaking change, so the next version should be Malibu 3.

We used structs to describe requests for a while and it worked, but it wasn't the most elegant solution. I see libraries like https://github.com/Moya/Moya and https://github.com/kickstarter/ios-ksapi/blob/master/KsApi/lib/Route.swift use enum for this and I think it looks really nice. Based on this idea I've made the following API changes:

1. Endpoint

Additional headers, base url and request description are moved to Endpoint. There are no Requestable protocols anymore, they are replaced by Request struct with helper get, post, patch, put, delete and head methods:

enum SharkywatersService: Endpoint {
  // Describe requests
  case fetchBoards
  case showBoard(id: Int)
  case createBoard(type: Int, title: String)
  case updateBoard(id: Int, type: Int, title: String)
  case deleteBoard(id: Int)

  // Every request will be scoped by the base url
  static var baseUrl: URLStringConvertible = "http://sharkywaters.com/api/"

  // Additional headers for every request
  static var headers: [String: String] = [
    "Accept" : "application/json"
  ]

  // Build requests
  var request: Request {
    switch self {
    case .fetchBoards:
      return Request.get("boards")
    case .showBoard(let id):
      // Let's use JSON dictionary as a mock data
      return Request.get("boards:\(id)", mock: Mock(json: ["type": 1, "title": "Classic"]))
    case .createBoard(let type, let title):
      return Request.post("boards", parameters: ["type": type, "title": title])
    case .updateBoard(let id, let title):
      return Request.patch("boards\(id)", parameters: ["title": title])
    case .deleteBoard(let id):
      return Request.delete("boards\(id)")
    }
  }
}

let networking = Networking<SharkywatersService>()
networking.request(.fetchBoards)

2. Networking is endpoint-specific:

let networking = Networking<SharkywatersService>(
  // `OperationQueue` Mode
  mode: .async,
  // Mock behavior (never, delayed)
  mockBehavior: .delayed(0.5),
  // `default`, `ephemeral`, `background` or `custom`
  sessionConfiguration: .default,
  // Custom `URLSessionDelegate` could set if needed
  sessionDelegate: self
)

3. There is no networking container anymore, it's up to developer to create and keep Networking instances.

4. Mocks are created directly on a request:

let request = Request.get(
  "boards",
  mock: Mock(fileName: "boards.json")
)

I think it simplifies the way requests are described and used, plus it's gonna remove a lot of boilerplate code from our projects.

I'm doing authentication in middleware and when authentication fails I want to reject the promise with a custom error object. Where do I catch this error object? I have added validate(), done(), fail() and always handlers but none of them seem to be called. Have I misunderstood how reject works?

Recently I released two updates of my app with no updates (concerning networking or the requests the app makes, or how and when they are made), but I did update Malibu from 6.2.0 to 6.3.0, and 6.4.0 in the second update.

Since 6.3.0, several customers have been complaining that some contents cannot be load in the app, and send screenshots displaying the error messages I programmed to be displayed when a network request fails for any reason other than 2 cases: Reachability says the device is offline; or the request returns with a 401 status code.

In my tests, I could never reproduce an error, and the worst case I could recreate was to enable the network conditioner with a very poor condition to force a request to time out.

.fail { error in
  switch error {
  case is UnreachableError: Alert.warn(R.string.alert.unreachable()) // Reachability
  case is Unauthorized: AppNotification.loggedOut.post() // 401
  default:
    Alert.warn("some 'could not load' message")
    if !(error is ApiError) { // ApiError is base for UnreachableError, Unauthorized and some other erros like 404, 500, 503, etc.
      Crashlytics.sharedInstance().recordError(error)
    }
  }
}

So I started logging the errors to Crashlytics, but the only data I get from them is:

NSERROR-DOMAIN: Malibu.NetworkError NSERROR-CODE: 8

Is there any important change since 6.2.0? What case of NetworkError is this one whose code is 8?? How can I debug it better and get more data to understand what's really happening?

This is how the UnreachableError is thrown:

networking.middleware = { promise in
  if let connection = Reachability()?.connection, connection != .none {
    promise.resolve(Void())
  } else {
    promise.reject(UnreachableError())
  }
}

@zenangst @RamonGilabert @onmyway133 This feature introduces operations instead of tasks in Malibu meaning that NSOperationQueue is used to execute/cancel requests. That makes it easier to manage request lifetime and concurrency.

1. When you create a new networking instance there is an optional argument to specify operationKind which could be Sync, Async or Limited:

let networking = Networking(operationKind: .Sync) // requests will be executed one after another

2. Small addition to Mock, now it's possible to specify a delay in the init.

@zenangst @RamonGilabert @onmyway133

New level names

public enum LogLevel {
  case None, Error, Info, Verbose
}

Request logging

• Method + URL when the level is Info or Verbose;
• Headers and parameters when the level is Verbose;

Response logging

• Status code

The following snippet shows a reproducible case in which neither success nor failure on the promise's part is called.

This seems to be in part due to the Networking instance being deallocated (the weak self check) returns since it is nil.

How can I work around this?

final class MockProviderSpec: QuickSpec {
    override func spec() {
        describe("Test") {
            it("Passes") {
                let fetcher = APIFetcher()
                waitUntil { done in
                    fetcher.request(request: CustomEndpoint.test).then({ _ in
                        done()
                    }).fail({ error in
                        done()
                    })
                }
            }
        }
    }
}

class APIFetcher {
    var mockClosure: ((RequestConvertible) -> Mock?)?

    func defaultClosure(_ request: RequestConvertible) -> Mock?{
        return Mock(json: [:])
    }

    func request(request: CustomEndpoint) -> NetworkPromise {

        let networking = Networking<CustomEndpoint>(mode: .sync, 
                                                    mockProvider: MockProvider<CustomEndpoint>(defaultClosure)
        )
        return networking.request(request)
    }
}

enum CustomEndpoint: RequestConvertible {
    static var baseUrl: URLStringConvertible?

    static var headers: [String : String] = [:]

    var request: Request {
        return Request.post("mock://derp")
    }

    case test
}

Right now, the default .validate() fails when receiving a HTTP 204 NO CONTENT response trough Express, as Express strips away those fields when not needed.

If the maintainers agree, I'd like to remove 204 from the standard .validate() method in ResponseValidation.swift.

Edit: A more detailed explanation of why it doesn't work: If you set application/json as Accept and receive a 204, Express strips the Content-Type field making NSURLRequest do its best to guess the Content-Type itself, and as Express does chunk = '' on a 204, it assumes its text/plain. That obviously fails content type validation.

• We have accept language, so I think that should be in the default headers, too 😄
• Make Header public, as when we have our own login networking, we can reuse these default headers

Super simpel test.

import Malibu

enum Endpoint: RequestConvertible {
  case fetchUsers

  static let baseUrl: URLStringConvertible? = "https://jsonplaceholder.typicode.com/"

  static var headers: [String : String] {
    return ["Accept" : "application/json"]
  }

  var request: Request {
    switch self {
    case .fetchUsers:
      return Request.get("users")
    }
  }
}

class ViewController: UIViewController {
  let networking = Networking<Endpoint>()

  override func viewDidLoad() {
    super.viewDidLoad()

    let promise = networking.request(.fetchUsers)

    promise.validate().done({ data in
      print("Success")
    }).fail({ error in
      print(error)
    })

    promise.cancel()
  }
}

With the method above, where I cancel a single network promise, the request is not made and neither the success or an error is printed. Great!

However, when I change that last line to networking.cancelAllRequests(), I do get "Success" printed out, and I can confirm that the request is indeed made.

I've been playing around with the CodyFire network library recently and while it has some flaws (and doesn't use promises), it uses Codable throughout in nifty ways. For example, it uses strongly typed structs for both request parameters and the response, like this:

class API {
  func register(_ request: RegisterData) -> APIRequest<LoginResponse> {
    return APIRequest("user/register/", payload: request).method(.post).desiredStatusCode(.created)
  }

  func login(_ request: LoginRequest) -> APIRequest<LoginResponse> {
    return APIRequest("user/login/", payload: request).method(.post)
  }

  func logout() -> APIRequest<Nothing> {
    return APIRequest("user/logout/").method(.post).desiredStatusCode(.noContent)
  }
}

struct RegisterData: JSONPayload {
  let username: String
  let name: String
  let password: String
  let email: String
  let gender: String
}

struct LoginRequest: JSONPayload {
  let username: String
  let password: String
}

struct LoginResponse: Codable {
  var token: String
}

As you can see, the parameters are strongly typed, this works for query params, form params, multi-part upload, etc etc. And the response is also automatically decoded. I know that you can do that in Malibu 8.1.0 as well, but there you have to do it when you make the request, instead of declaring it upfront on the Request itself.

Another thing that would be great is to have Decodable support for errors as well, something that CodyFire also lacks sadly.

Hi Vadym!

We have an Auth SDK at work that exposes a simple function:

public func addAuthentication(to request: Request, completion: (TypedResult<Request, TokenStorageError>) -> Void) 

(since we don't want clients to have access to the access tokens directly)

Since this API works asynchronously, we can't add this to preProcessRequest (which is synchronous) or to middleware (since that doesn't have access to the request). Is there a "right" way to do this?

Hi!

I'm trying to test a flow where access tokens are refreshed(similar to #42 ), and I'm using a MockProvider instead of making actual network requests (imagine making a MockProvider where if a request is made with the old token, it'll return a "failed" json and if the request is made with a new token, you get the "success" json). However, since the request in the MockProvider closure doesn't contain any information about the middleware, authentication etc, I can't check what token the request is made with.

Any suggestions on how I can write a test for this? 🤔

Playground complains: "No such module 'Malibu'". After I've updated Carthage dependencies I'm getting:

error: Couldn't lookup symbols: _T06Malibu10NetworkingCACyxGAA0B4ModeO4mode_AA12MockProviderCyxGSg04mockF0AA20SessionConfigurationO07sessionI0So18URLSessionDelegate_pSg0jL0tcfcfA _T06Malibu10NetworkingCACyxGAA0B4ModeO4mode_AA12MockProviderCyxGSg04mockF0AA20SessionConfigurationO07sessionI0So18URLSessionDelegate_pSg0jL0tcfcfA0 __T06Malibu7RequestV3getAcA20URLStringConvertible_p_s10DictionaryVySSypG10parametersAGyS2SG7headersAA10EtagPolicyO04etagJ0AA05StoreJ0O05storeJ0So12NSURLRequestC05CacheJ0O05cacheJ0tFZ __T04When7PromiseC6MalibuAD8ResponseCRbzlE8validateACyAFGyF .....