Async HTTP API clients in Swift

Introducing SwiftHttp

An superior Swift HTTP library to quickly create communication layers with API endpoints. The library tries to separate the consumer request logic from the request constructing and response dealing with. That is the principle motive why it has a HttpClient protocol which can be utilized to carry out knowledge, obtain and add duties. You possibly can implement your individual HttpClient, however SwiftHttp comes with a built-in UrlSessionHttpClient primarily based on Foundation networking.

So the consumer is liable for executing the requests, however we nonetheless have to explain the request itself one way or the other. That is the place the HttpRawRequest object comes into play. You possibly can simply create a base HttpUrl and carry out a request utilizing the HttpRawRequest object. When working with a uncooked request you’ll be able to specify extra header fields and a uncooked physique knowledge object too. 💪

let url = HttpUrl(scheme: "https",
                  host: "jsonplaceholder.typicode.com",
                  port: 80,
                  path: ["todos"],
                  useful resource: nil,
                  question: [:],
                  fragment: nil)

let req = HttpRawRequest(url: url, methodology: .get, headers: [:], physique: nil)


let consumer = UrlSessionHttpClient(session: .shared, log: true)
let response = attempt await consumer.dataTask(req)


let todos = attempt JSONDecoder().decode([Todo].self, from: response.knowledge)

The HTTP consumer can carry out community calls utilizing the new async / await Swift concurrency API. It’s doable to cancel a community request by wrapping it right into a structured concurrency Activity.

let activity = Activity 
    let api = TodoApi()
    _ = attempt await api.listing()


DispatchQueue.international().asyncAfter(deadline: .now() + .milliseconds(10)) 
    activity.cancel()


do 
    let _ = attempt await activity.worth

catch 
    if (error as? URLError)?.code == .cancelled 
        print("cancelled")

It is a neat tick, you can even verify the explanation contained in the catch block, whether it is an URLError with a .cancelled code then the request was cancelled, in any other case it have to be some type of community error.

So that is how you should utilize the consumer to carry out or cancel a community activity, however often you do not need to work with uncooked knowledge, however encodable and decodable objects. While you work with such objects, you would possibly need to validate the response headers and ship extra headers to tell the server about the kind of the physique knowledge. Simply take into consideration the Content-Type / Accept header fields. 🤔

So we would need to ship extra headers alongside the request, plus it might be good to validate the standing code and response headers earlier than we attempt to parse the information. This looks as if a circulation of frequent operations, first we encode the information, set the extra header fields, and when the response arrives we validate the standing code and the header fields, lastly we attempt to decode the information object. It is a typical use case and SwiftHttp calls this workflow as a pipeline.

There are 4 forms of built-in HTTP pipelines:

Uncooked – Ship a uncooked knowledge request, return a uncooked knowledge response

Encodable – Ship an encodable object, return a uncooked knowledge response

Decodable – Ship a uncooked knowledge request, return a decodable object

Codable – Ship an encodable object, return a decodable object

We are able to use a HttpRawPipeline and execute our request utilizing a consumer as an executor.

let baseUrl = HttpUrl(host: "jsonplaceholder.typicode.com")
let consumer = UrlSessionHttpClient(session: .shared, log: true)

let pipeline = HttpRawPipeline(url: baseUrl.path("todos"), methodology: .get)

let response = attempt await pipeline.execute(consumer.dataTask)
let todos = attempt JSONDecoder().decode([Todo].self, from: response.knowledge)
print(response.statusCode)
print(todos.depend)

On this case we had been utilizing the dataTask perform, however in the event you anticipate the response to be an enormous file, you would possibly need to think about using a downloadTask, or in the event you’re importing a considerable amount of knowledge when sending the request, it is best to select the uploadTask perform. 💡

So on this case we needed to manually decode the Todo object from the uncooked HTTP response knowledge, however we are able to use the decodable pipeline to make issues much more easy.

let baseUrl = HttpUrl(host: "jsonplaceholder.typicode.com")
let consumer = UrlSessionHttpClient(session: .shared, log: true)


let pipeline = HttpDecodablePipeline<[Todo]>(url: baseUrl.path("todos"),
                                             methodology: .get,
                                             decoder: .json(JSONDecoder(), validators: [
                                                HttpStatusCodeValidator(.ok),
                                                HttpHeaderValidator(.key(.contentType)) 
                                                    $0.contains("application/json")
                                                ,
                                             ]))

let todos = attempt await pipeline.execute(consumer.dataTask)
print(todos.depend)

As you’ll be able to see, on this case the as a substitute of returning the response, the pipeline can carry out extra validation and the decoding utilizing the offered decoder and validators. You possibly can create your individual validators, there’s a HttpResponseValidator protocol for this goal.

The encodable pipeline works like the identical, you’ll be able to specify the encoder, you’ll be able to present the encodable object and you will get again a HttpResponse occasion.

let consumer = UrlSessionHttpClient(session: .shared, log: true)
        
let todo = Todo(id: 1, title: "lorem ipsum", accomplished: false)

let pipeline = HttpEncodablePipeline(url: baseUrl.path("todos"),
                                     methodology: .put up,
                                     physique: todo,
                                     encoder: .json())

let response = attempt await pipeline.execute(consumer.dataTask)

print(response.statusCode == .created)

The codable pipeline is a mix of the encodable and decodable pipeline. 🙃

let baseUrl = HttpUrl(host: "jsonplaceholder.typicode.com")
let consumer = UrlSessionHttpClient(session: .shared, log: true)

let todo = Todo(id: 1, title: "lorem ipsum", accomplished: false)

let pipeline = HttpCodablePipeline<Todo, Todo>(url: baseUrl.path("todos", String(1)),
                                               methodology: .put,
                                               physique: todo,
                                               encoder: .json(),
                                               decoder: .json())

let todo = attempt await pipeline.execute(consumer.dataTask)
print(todo.title)

As you’ll be able to see that is fairly a typical sample, and once we’re speaking with a REST API, we will carry out kind of the very same community calls for each single endpoint. SwiftHttp has a pipeline assortment protocol that you should utilize to carry out requests with out the necessity of explicitly establishing these pipelines. Here is an instance:

import SwiftHttp

struct Todo: Codable 
    let id: Int
    let title: String
    let accomplished: Bool


struct TodoApi: HttpCodablePipelineCollection 

    let consumer: HttpClient = UrlSessionHttpClient(log: true)
    let apiBaseUrl = HttpUrl(host: "jsonplaceholder.typicode.com")

    
    func listing() async throws -> [Todo] 
        attempt await decodableRequest(executor: consumer.dataTask,
                                   url: apiBaseUrl.path("todos"),
                                   methodology: .get)
        


let todos = attempt await api.listing()

When utilizing a HttpCodablePipelineCollection you’ll be able to carry out an encodable, decodable or codable request utilizing an executor object. This may scale back the boilerplate code wanted to carry out a request and the whole lot goes to be kind secure because of the generic protocol oriented networking layer. You possibly can setup as many pipeline collections as you want, it’s doable to make use of a shared consumer or you’ll be able to create a devoted consumer for every.

By the best way, if one thing goes mistaken with the request, or one of many validators fail, you’ll be able to at all times verify for the errors utilizing a do-try-catch block. 😅

do 
    _ = attempt await api.listing()

catch HttpError.invalidStatusCode(let res) 
    
    let decoder = HttpResponseDecoder<CustomError>(decoder: JSONDecoder())
    do 
        let error = attempt decoder.decode(res.knowledge)
        print(res.statusCode, error)
    
    catch 
        print(error.localizedDescription)
    

catch 
    print(error.localizedDescription)

That is how SwiftHttp works in a nutshell, after all you’ll be able to setup customized encoders and decoders, however that is one other subject. In case you are within the challenge, be at liberty to present it a star on GitHub. We will use it sooner or later rather a lot each on the consumer and server facet. ⭐️⭐️⭐️

Source link