URLSession and the Mix framework

That is going to be a very quick, however hopefully very helpful tutorial about how I began to make the most of the Mix framework to slowly change my Promise library. 🤫

API & information construction

To start with we’ll want some type of API to attach, as common I’ll use my favourite JSONPlaceholder service with the next information fashions:

enum HTTPError: LocalizedError {
    case statusCode
    case put up
}

struct Put up: Codable {

    let id: Int
    let title: String
    let physique: String
    let userId: Int
}

struct Todo: Codable {

    let id: Int
    let title: String
    let accomplished: Bool
    let userId: Int
}

Nothing particular to this point, just a few fundamental Codable components, and a easy error, as a result of hell yeah, we wish to present some error if one thing fails. ❌

The normal manner

Doing an HTTP request in Swift is fairly simple, you should use the built-in shared URLSession with a easy information job, and voilá there’s your response. In fact you may wish to test for legitimate standing code and if the whole lot is ok, you’ll be able to parse your response JSON by utilizing the JSONDecoder object from Basis.

let url = URL(string: "https://jsonplaceholder.typicode.com/posts")!

let job = URLSession.shared.dataTask(with: url) { information, response, error in
    if let error = error {
        fatalError("Error: (error.localizedDescription)")
    }
    guard let response = response as? HTTPURLResponse, response.statusCode == 200 else {
        fatalError("Error: invalid HTTP response code")
    }
    guard let information = information else {
        fatalError("Error: lacking response information")
    }

    do {
        let decoder = JSONDecoder()
        let posts = attempt decoder.decode([Post].self, from: information)
        print(posts.map { $0.title })
    }
    catch {
        print("Error: (error.localizedDescription)")
    }
}
job.resume()

Do not forget to renew your information job or the request will not hearth in any respect. 🔥

Knowledge duties and the Mix framework

Now as you’ll be able to see the standard “block-based” method is sweet, however can we do perhaps one thing higher right here? , like describing the entire thing as a series, like we used to do that with Guarantees? Starting from iOS13 with the assistance of the superb Mix framework you really can go far past! 😃

My favourite a part of Mix is reminiscence administration & cancellation.

Knowledge job with Mix

So the most typical instance is normally the next one:

non-public var cancellable: AnyCancellable?

self.cancellable = URLSession.shared.dataTaskPublisher(for: url)
.map { $0.information }
.decode(sort: [Post].self, decoder: JSONDecoder())
.replaceError(with: [])
.eraseToAnyPublisher()
.sink(receiveValue: { posts in
    print(posts.rely)
})

self.cancellable?.cancel()

I like how the code “explains itself”:

• First we make a cancellable storage to your Writer
• Then we create a model new information job writer object
• Map the response, we solely care in regards to the information half (ignore errors)
• Decode the content material of the information utilizing a JSONDecoder
• If something goes mistaken, simply go together with an empty array
• Erase the underlying complexity to a easy AnyPublisher
• Use sink to show some data in regards to the closing worth
• Elective: you’ll be able to cancel your community request any time

Error dealing with

Let’s introduce some error dealing with, as a result of I do not like the concept of hiding errors. It is so significantly better to current an alert with the precise error message, is not it? 🤔

enum HTTPError: LocalizedError {
    case statusCode
}

self.cancellable = URLSession.shared.dataTaskPublisher(for: url)
.tryMap { output in
    guard let response = output.response as? HTTPURLResponse, response.statusCode == 200 else {
        throw HTTPError.statusCode
    }
    return output.information
}
.decode(sort: [Post].self, decoder: JSONDecoder())
.eraseToAnyPublisher()
.sink(receiveCompletion: { completion in
    change completion {
    case .completed:
        break
    case .failure(let error):
        fatalError(error.localizedDescription)
    }
}, receiveValue: { posts in
    print(posts.rely)
})

In a nutshell, this time we test the response code and if one thing goes mistaken we throw an error. Now as a result of the writer can lead to an error state, sink has one other variant, the place you’ll be able to test the end result of your entire operation so you are able to do your personal error thingy there, like displaying an alert. 🚨

Assign outcome to property

One other frequent sample is to retailer the response in an inside variable someplace within the view controller. You’ll be able to merely do that by utilizing the assign perform.

class ViewController: UIViewController {

    non-public var cancellable: AnyCancellable?

    non-public var posts: [Post] = [] {
        didSet {
            print("posts --> (self.posts.rely)")
        }
    }

    override func viewDidLoad() {
        tremendous.viewDidLoad()

        let url = URL(string: "https://jsonplaceholder.typicode.com/posts")!

        self.cancellable = URLSession.shared.dataTaskPublisher(for: url)
        .map { $0.information }
        .decode(sort: [Post].self, decoder: JSONDecoder())
        .replaceError(with: [])
        .eraseToAnyPublisher()
        .assign(to: .posts, on: self)
    }
}

Very simple, you can too use the didSet property observer to get notified about modifications.

Group a number of requests

Sending a number of requests was a painful course of previously. Now we now have Compose and this job is simply ridiculously simple with Publishers.Zip. You’ll be able to actually mix a number of requests togeter and wait till each of them are completed. 🤐

let url1 = URL(string: "https://jsonplaceholder.typicode.com/posts")!
let url2 = URL(string: "https://jsonplaceholder.typicode.com/todos")!

let publisher1 = URLSession.shared.dataTaskPublisher(for: url1)
.map { $0.information }
.decode(sort: [Post].self, decoder: JSONDecoder())

let publisher2 = URLSession.shared.dataTaskPublisher(for: url2)
.map { $0.information }
.decode(sort: [Todo].self, decoder: JSONDecoder())

self.cancellable = Publishers.Zip(publisher1, publisher2)
.eraseToAnyPublisher()
.catch { _ in
    Simply(([], []))
}
.sink(receiveValue: { posts, todos in
    print(posts.rely)
    print(todos.rely)
})

Identical sample as earlier than, we’re simply zipping collectively two publishers.

Request dependency

Generally it’s important to load a useful resource from a given URL, after which use one other one to increase the item with one thing else. I am speaking about request dependency, which was fairly problematic with out Mix, however now you’ll be able to chain two HTTP calls along with just some traces of Swift code. Let me present you:

override func viewDidLoad() {
    tremendous.viewDidLoad()

    let url1 = URL(string: "https://jsonplaceholder.typicode.com/posts")!

    self.cancellable = URLSession.shared.dataTaskPublisher(for: url1)
    .map { $0.information }
    .decode(sort: [Post].self, decoder: JSONDecoder())
    .tryMap { posts in
        guard let id = posts.first?.id else {
            throw HTTPError.put up
        }
        return id
    }
    .flatMap { id in
        return self.particulars(for: id)
    }
    .sink(receiveCompletion: { completion in

    }) { put up in
        print(put up.title)
    }
}

func particulars(for id: Int) -> AnyPublisher<Put up, Error> {
    let url = URL(string: "https://jsonplaceholder.typicode.com/posts/(id)")!
    return URLSession.shared.dataTaskPublisher(for: url)
        .mapError { $0 as Error }
        .map { $0.information }
        .decode(sort: Put up.self, decoder: JSONDecoder())
        .eraseToAnyPublisher()
}

The trick right here is which you can flatMap a writer into one other.

Conclusion

Mix is an incredible framework, it may do lots, nevertheless it undoubtedly has some studying curve. Sadly you’ll be able to solely use it in case you are focusing on iOS13 or above (which means that you will have one entire yr to study each single little bit of the framework) so assume twice earlier than adopting this new know-how.

You must also observe that at present there isn’t a add and obtain job writer, however you may make your very personal resolution till Apple formally releases one thing. Fingers crossed. 🤞

I actually love how Apple applied some ideas of reactive programming, I am unable to await Mix to reach as an open supply package deal with linux help as effectively. ❤️