I'm trying to add a caching layer to my service (the url building/fetching/etc. is done with Squid). The obvious thing to do would be to use request URLs as cache keys, and return results from the cache before scheduling requests, however, the fact that all the URL logic is abstracted away (by HttpRoute, HttpQuery etc.) makes it hard. I tried to hack into the "prepare" function but couldn't really come up with a solution.

I was wondering if you had any ideas on how I could achieve such a goal? Any ideas/pointers would be appreciated!

So far I am really liking this library, well done!

However, there is one thing that is kind of bugging me: making the request structs gets tedious, and takes quite a lot of lines of code.

struct LoginTokenRequest: JsonRequest {
  private struct Payload: Encodable {
    let email: String
    let password: String
  }

  typealias Result = Token

  let email: String
  let password: String

  var method: HttpMethod = .post
  var routes: HttpRoute = ["auth", "tokens"]

  var body: HttpBody {
    HttpData.Json(Payload(email: email, password: password))
  }
}

Now imagine having tens of requests - this gets so long so fast.

A few observations.

It's a bit annoying that the HttpData.Json payload needs to be an Encodable thing. This causes the need for one-off payload structs, and repeated code to copy the properties over. On the other hand, HttpQuery can be created using a simple dictionary. Is it an idea to add an initializer that takes a dictionary instead of an Encodable struct/object? That way we could get rid of the Payload struct in my example. Turning a dict into Data is simple enough of course.

Or... could LoginTokenRequest itself be the payload? It has the email and password properties after all, so in theory it could be the payload? 🤔 Like, any properties on the request will be sent as body payload. Not sure if that's a terrible idea haha.

Another thing that could work to reduce the code is if JsonRequest wasn't a protocol but a Struct - that way you could simply create them using an initializer, have them in an enum, whatever.

I tried to implement something like that myself, but the typealias Result is making me hit roadblocks:

struct CoreRequest<Result: Decodable>: JsonRequest {
  var method: HttpMethod
  var routes: HttpRoute
  var body: HttpBody
}

enum Requests {
  case getLoginToken(email: String, password: String)

  var request: CoreRequest {
    switch self {
    case .getLoginToken(let email, let password):
      return CoreRequest<Token>(method: .post, routes: ["auth", "tokens"], body: HttpData.Json(payload))
    }
  }
}

As you can see, having 10 or 20 requests like this vs the "normal" method of one struct per request would save a LOT of repeating typing. But sadly this doesn't work since there's the generic type requirement. I would love to get this to work though. See also https://github.com/gonzalezreal/SimpleNetworking for inspiration.

Very curious about your thoughts and I'd be happy to brainstorm some ideas, test any of them, etc.

I'm using the sample code found in the "Basic" guide, however, as soon as I schedule the request, my app crashes in Concurrency.swift on line 60 with an EXC_BAD_INSTRUCTION:

I can paste my code, but it's literally just the sample code found in the documentation, in a new (empty) project.

Some context: I'm working with an API that requires a header field that is a hash computed with several elements of the http request (the POST body, the path, etc.).

I was able to do it by forking and making a couple of internal structs public (HttpRequest and the Network Scheduler), but it feels rather hack-ish, not quite sure what a good implementation would be, will try to think of a nicer implementation, but in the meantime, thought I'd let you know that this is a feature that some people might need. Loving the library so far BTW, nice work!

It would be nice to set a global error mapping. My API returns errors in a certain format, so I now have to add .mapError every time I make a request.

PasswordResetTokenRequest(email: email)
  .schedule(with: api)
  .receive(on: DispatchQueue.main)
  .mapError(CoreAPIError.fromError)
  .sink(
    // etc

CoreAPIError looks like this, in case you're wondering:

struct CoreAPIError: Decodable, Error, LocalizedError {
  let message: String?
  let errors: [String: [String]]?

  var errorDescription: String? {
    if let errors = errors {
      let values = errors.flatMap { $0.value }
      return values.joined(separator: "\n")
    }
    return message ?? "An error occured"
  }

  static func fromError(_ error: Squid.Error) -> CoreAPIError {
    if case .requestFailed(_, let data) = error, let coreError = try? JSONDecoder().decode(CoreAPIError.self, from: data) {
      return coreError
    }

    return CoreAPIError(message: error.localizedDescription, errors: nil)
  }
}

The problem is that I always have to remember to add this one line to every call site. It would be great if it would be possible to set this as a default, global thing that happens to all requests.

I love this library, it is awesome. Could you write some Paginator examples? I have parts of my app where I want to have an endless scroll while loading more data from the server, but not sure on how to use Paging properly in Squid!

Thanks again :)

import Squid
import Foundation

struct ListPlaylistsRequest: JsonRequest {
    typealias Result = [Playlist]

    var routes: HttpRoute {
        ["playlist", "v1"]
    }

    var method: HttpMethod {
        .get
    }
}

This request talks to my server and there are some headers that are returned from the request that I want to have access to. I tried using a ServiceHook but I don't think I get the response headers. Ideally I can still have it decoded automatically to JSON as well. I am not sure how to proceed. Love the library!

In my HTTPService I set a header:

var header: HttpHeader {
  HttpHeader([
    .accept: HttpMimeType.json.rawValue,
    .authorization: "Bearer \(token)",
  ])
}

This is getting sent as Bearer%20DsNYO6w84ZaJBJyYWHEtStTBoRCquu3XAQc0tVH8ggq3orn7UAYGYvfrU8ZjYKQTHvKB2W28xZuUjMmZ, and the server really doesn't like this. Why is it getting encoded, and can I do something about that?

I have a very simple request:

struct LoginRequest: JsonRequest {
  typealias Result = LoginResponse

  let username: String
  let password: String

  let method: HttpMethod = .post
  let routes: HttpRoute = ["user", "login"]

  var body: HttpBody {
    HttpData.Json(["username": username, "password": password])
  }
}

LoginRequest(username: username, password: password)
        .schedule(with: apiService)

But I get this error:

[Squid] Scheduled request `LoginRequest` with identifier 3:
[Squid]     - Method:   POST
[Squid]     - Url:      https://example.com/api/user/login
[Squid]     - Headers:  * Content-Type => application/json
[Squid]     - Body:     {
[Squid]                   "username" : "s",
[Squid]                   "password" : "d"
[Squid]                 }
[Squid]  
[Squid @ 22:01:47.987] 
[Squid] Finished request `LoginRequest` with identifier 3:
[Squid]     - Status:   405
[Squid]     - Headers:  * Allow => POST, OPTIONS
[Squid]                 * Connection => keep-alive
[Squid]                 * Content-Length => 40
[Squid]                 * Content-Type => application/json
[Squid]                 * Date => Thu, 15 Oct 2020 20:01:47 GMT
[Squid]                 * Server => gunicorn/20.0.4
[Squid]                 * Strict-Transport-Security => max-age=60; includeSubDomains; preload
[Squid]                 * Via => 1.1 vegur
[Squid]                 * X-Content-Type-Options => nosniff
[Squid]                 * X-Frame-Options => DENY
[Squid]                 * X-Xss-Protection => 1; mode=block
[Squid]     - Body:     <40 bytes>
[Squid]                 {
[Squid]                   "detail" : "Method \"GET\" not allowed."
[Squid]                 }
[Squid]  

If I run it with the Charles proxy running, then yea it is actually doing a GET request. If I change LoginRequest.method to .put, the error I get back changes to "Method \"PUT\" not allowed.".

Why is .post not actually doing a POST but a GET? 🤔

I'm using a local development server, which doesn't work over http. Yet Squid always loads everything over https. I see there's a usesSecureProtocol property but that has to be specified per request, not on the HttpService level. Am I missing something? 🤔

Sink not working here, neither breakpoint nor printing users.

    func testNetworkAPI() {
        let service = MyApi()
        let request = UserRequest()
        let response = request.schedule(with: service)

        _ = response.sink(receiveCompletion: { completion in
            switch completion {
            case .failure(let error):
                print("Request failed due to: \(error)")
            case .finished:
                print("Request finished.")
            }
        }) { users in
            print("Received users: \(users)")
        }
    }

• [x] The onFailure callback now has the request paramater, useful for debugging/logging purposes
• [x] The Squid encoder is passed to requests rather than forcing camelCase
• [x] Improves description of Http Query/Route/Header ... (useful for logging purposes)

I get Swift access race in Squid.Locked.lock() -> () at 0x7b080002f4e0 when running Squid under Xcode thread sanitizer. My understanding is there's not currently an actual issue in the threading code due to the way that Swift is generating code, but the thread analyzer can't be sure, so generates the warning.

I think to fix warning you can replace:

internal class Locked<Value> {
    private var _lock = os_unfair_lock()
    ...

with:

internal class Locked<Value> {
    private var _lock: UnsafeMutablePointer<os_unfair_lock>

    init(_ value: Value) {
        _lock = UnsafeMutablePointer<os_unfair_lock>.allocate(capacity: 1)
        _lock.initialize(to: os_unfair_lock())
        self._value = value
    }

I found this solution and an explanation here:

http://www.russbishop.net/the-law

I'm trying to Mock endpoints with Squid and Mocker.

Here's the basic pattern of what I think I want to do:

import Mocker
import Squid

extension HttpService {
    func mock<R>(request: R, statusCode: Int = 200, data: [Mock.HTTPMethod : Data]) where R: Request {
        Mock(url: ..., dataType: .json, statusCode: statusCode, data: data)
    }
}

The problem I'm not sure how to generate a final URL from a Squid Request and Squid HttpService. I know it does this internally, but I can't figure how to to make it generate the URL myself. Is there some method that I'm overlooking? Or is this something that could be added?

For example I have an authenticated api, so I want to use an authentication retrier, but it also might have network errors, so I want exponential backoff. Is there a suggested way to combine the two?

Idea

Sometimes it is wise not to cache some requests that belong to the same HttpService. It's not possible right now, and as a result, you must create multiply HttpServices with cache hook and without. The idea is that let request decide if the response should be cached.

Solution

Add a new property for the Request protocol, which is then used by the cache hook to determine if the response should be cached. For example:

struct SomeRequest: JsonRequest {
    ...
    var shouldCacheResult: Bool {
        return false
    }
    ...
}

This property will be used in default CachingServiceHook, but you are also free to use this property in your cache-layer implementation