Replace Combine with async/await on paginated feed loading

Author: caiozullo

EssentialApp/EssentialApp/CombineHelpers.swift

@@ -6,32 +6,6 @@ import Foundation
 import Combine
 import EssentialFeed
 
-public extension Paginated {
-	init(items: [Item], loadMorePublisher: (() -> AnyPublisher<Self, Error>)?) {
-		self.init(items: items, loadMore: loadMorePublisher.map { publisher in
-			return { completion in
-				publisher().subscribe(Subscribers.Sink(receiveCompletion: { result in
-					if case let .failure(error) = result {
-						completion(.failure(error))
-					}
-				}, receiveValue: { result in
-					completion(.success(result))
-				}))
-			}
-		})
-	}
-	
-	var loadMorePublisher: (() -> AnyPublisher<Self, Error>)? {
-		guard let loadMore = loadMore else { return nil }
-		
-		return {
-			Deferred {
-				Future(loadMore)
-			}.eraseToAnyPublisher()
-		}
-	}
-}
-
 @MainActor
 public extension HTTPClient {
 	typealias Publisher = AnyPublisher<(Data, HTTPURLResponse), Error>

EssentialApp/EssentialApp/FeedUIComposer.swift

@@ -3,18 +3,17 @@
 //
 
 import UIKit
-import Combine
 import EssentialFeed
 import EssentialFeediOS
 
 @MainActor
 public final class FeedUIComposer {
 	private init() {}
 
-	private typealias FeedPresentationAdapter = LoadResourcePresentationAdapter<Paginated<FeedImage>, FeedViewAdapter>
+	private typealias FeedPresentationAdapter = AsyncLoadResourcePresentationAdapter<Paginated<FeedImage>, FeedViewAdapter>
 
 	public static func feedComposedWith(
-		feedLoader: @MainActor @escaping () -> AnyPublisher<Paginated<FeedImage>, Error>,
+		feedLoader: @MainActor @escaping () async throws -> Paginated<FeedImage>,
 		imageLoader: @MainActor @escaping (URL) async throws -> Data,
 		selection: @MainActor @escaping (FeedImage) -> Void = { _ in }
 	) -> ListViewController {

EssentialApp/EssentialApp/FeedViewAdapter.swift

@@ -14,7 +14,7 @@ final class FeedViewAdapter: ResourceView {
 	private let currentFeed: [FeedImage: CellController]
 
 	private typealias ImageDataPresentationAdapter = AsyncLoadResourcePresentationAdapter<Data, WeakRefVirtualProxy<FeedImageCellController>>
-	private typealias LoadMorePresentationAdapter = LoadResourcePresentationAdapter<Paginated<FeedImage>, FeedViewAdapter>
+	private typealias LoadMorePresentationAdapter = AsyncLoadResourcePresentationAdapter<Paginated<FeedImage>, FeedViewAdapter>
 
 	init(currentFeed: [FeedImage: CellController] = [:], controller: ListViewController, imageLoader: @escaping (URL) async throws -> Data, selection: @escaping (FeedImage) -> Void) {
 		self.currentFeed = currentFeed
@@ -54,12 +54,12 @@ final class FeedViewAdapter: ResourceView {
 			return controller
 		}
 
-		guard let loadMorePublisher = viewModel.loadMorePublisher else {
+		guard let loadMoreAsync = viewModel.loadMore else {
 			controller.display(feed)
 			return
 		}
 
-		let loadMoreAdapter = LoadMorePresentationAdapter(loader: loadMorePublisher)
+		let loadMoreAdapter = LoadMorePresentationAdapter(loader: loadMoreAsync)
 		let loadMore = LoadMoreCellController(callback: loadMoreAdapter.loadResource)
 
 		loadMoreAdapter.presenter = LoadResourcePresenter(

EssentialApp/EssentialApp/SceneDelegate.swift

@@ -49,7 +49,7 @@ class SceneDelegate: UIResponder, UIWindowSceneDelegate {
 
 	private lazy var navigationController = UINavigationController(
 		rootViewController: FeedUIComposer.feedComposedWith(
-			feedLoader: makeRemoteFeedLoaderWithLocalFallback,
+			feedLoader: loadRemoteFeedWithLocalFallback,
 			imageLoader: loadLocalImageWithRemoteFallback,
 			selection: showComments))
 
@@ -127,22 +127,6 @@ class SceneDelegate: UIResponder, UIWindowSceneDelegate {
 		let (data, response) = try await httpClient.get(from: url)
 		return try FeedItemsMapper.map(data, from: response)
 	}
-	
-	private func makeRemoteFeedLoaderWithLocalFallback() -> AnyPublisher<Paginated<FeedImage>, Error> {
-		Deferred {
-			Future { completion in
-				Task.immediate {
-					do {
-						let feed = try await self.loadRemoteFeedWithLocalFallback()
-						completion(.success(feed))
-					} catch {
-						completion(.failure(error))
-					}
-				}
-			}
-		}
-		.eraseToAnyPublisher()
-	}
 
 	private func loadMoreRemoteFeed(last: FeedImage?) async throws -> Paginated<FeedImage> {
 		async let cachedItems = try await loadLocalFeed()
@@ -158,38 +142,13 @@ class SceneDelegate: UIResponder, UIWindowSceneDelegate {
 		return try await makePage(items: items, last: newItems.last)
 	}
 
-	private func makeRemoteLoadMoreLoader(last: FeedImage?) -> AnyPublisher<Paginated<FeedImage>, Error> {
-		Deferred {
-			Future { completion in
-				Task.immediate {
-					do {
-						let feed = try await self.loadMoreRemoteFeed(last: last)
-						completion(.success(feed))
-					} catch {
-						completion(.failure(error))
-					}
-				}
-			}
-		}
-		.eraseToAnyPublisher()
-	}
-	
-	private func makeRemoteFeedLoader(after: FeedImage? = nil) -> AnyPublisher<[FeedImage], Error> {
-		let url = FeedEndpoint.get(after: after).url(baseURL: baseURL)
-		
-		return httpClient
-			.getPublisher(url: url)
-			.tryMap(FeedItemsMapper.map)
-			.eraseToAnyPublisher()
-	}
-	
 	private func makeFirstPage(items: [FeedImage]) -> Paginated<FeedImage> {
 		makePage(items: items, last: items.last)
 	}
 
 	private func makePage(items: [FeedImage], last: FeedImage?) -> Paginated<FeedImage> {
-		Paginated(items: items, loadMorePublisher: last.map { last in
-			{ self.makeRemoteLoadMoreLoader(last: last) }
+		Paginated(items: items, loadMore: last.map { last in
+			{ @MainActor @Sendable in try await self.loadMoreRemoteFeed(last: last) }
 		})
 	}