[번역] Clean Architecture and MVVM on iOS (Oleh kudinov)

protocol SearchMoviesUseCase {
	func execute(requestValue: SearchMoviesUseCaseRequestValue,
    			 completion: @escaping (Result<MoviesPage, Error>) -> Void) -> Cancellable?
}

final class DefaultSearchMoviesUseCase: SearchMoviesUseCase {

	private let moviesRepository: MoviesRepository
    private let moviesQueriesRespository: MoviesQueriesRepository
    
    init(moviesRepository: MoviesRepository, moviesQueriesRepository: MoviesQueriesRepository) {
    	self.moviesRepository = moviesRepository
        self.moviesQueriesRepository = moviesQueriesRepository 
    }
    
    func execute(requestValue: SearchMoviesUseCaseRequestValue,
    			 completion: @escaping (Result<MoviesPage, Error>) -> Void) -> Cancellable? {
     	return moviesRepository.fetchMoviesList(query: requestValue, page: requestValue.page) { result in
        
        	if case .success = result {
            	self.moviesQueriesRepository.saveRecentQuery(query: requestValue.query) { _ in }
            }
            
            completion(result)
        
        }
	}

}

// Repository Interface
protocol MoviesRepository {
	func fetchMoviesList(query: MovieQuery, page: Int, completion: @escaping (Result<MoviePage, Error>) -> Void) -> Cancellable?
}

protocol MoviesQueriesRepository {
	func fetchRecentQueries(maxCount: Int, completion: @escaping (Result<[MovieQuery], Error>) -> Void)
    func saveRecentQuery(query: MovieQuery: completion: @escaping (Result<MovieQuery, Error>) -> Void)
    
}

// Note: We canbit gave any UI frameworks(like UIKit or SwiftUI) imports here.

protocol MoviesListViewModelInput {
	func didSearch(query: String)
    func didSelect(at indexPath: IndexPath)
}

protocol MoviesListViewModelOutput {
	var items: Observable<[MoviesListItemViewModel]> { get }
    var error: Observable<String> { get }
}

protocol MoviesListViewModel: MoviesListViewModelInput, MoviesListViewModelOutput { }

struct MoviesListViewModelActions {
	// Note: if you would need to edit movie inside Details screen and update this
    // MoviesList screen with Updated movie then you would need this closure:
    // showMovieDetais: (Movie, @escaping (_ updated: Movie) -> Void) -> Void
	let showMovieDetails: (Movie) -> Void
}

final class DefaultMoviesListViewModel: MoviesListViewModel {

	private let searchMoviesUseCase: SearchMoviesUseCase
    private let actions: MoviesListModelActions?
    
    private var movies: [Movie] = []
    
    // MARK: - INPUT
    let items: Observable<[MoviesListItemViewModel]> = Observable([])
    let error: Observable<String> = Observable("")
    
    init(searchMoviesUseCase: SearchMoviesUseCase,
    	 actions: MoviesListViewModelActions) {
        self.searchMoviesUseCase = searchMoviesUseCase
        self.actions = actions
    }
    
    private func load(movieQuery: MovieQuery) {
    
    	searchMoviesUseCase.execute(movieQuery: movieQuery) { result in
    		switch result {
            	case .success(let moviesPage):
                	// Note: We must map here from Domain Entities into Item View Models
                	self.items.value += moviesPage.movies.map(MoviesListItemViewModel.init)
                    self.movies += moviesPage.movies
                case .failure:
                	self.error.value = NSLocalizedString("Failed loading movies", comment: "")
            }
        }
    }
}

// MARK: - INPUT. View event methods
extension MoviesListViewModel {

    func didSearch(query: String) {
        laod(movieQuery: MovieQuery(query: query))
    }
    
    func didSelect(at indexPath: IndexPath) {
    	actions.showMovieDetails(movies[indexPath.row])
    }

}

// Note: This item view model is to display data and does not contain any domain model
struct MoviesListItemViewModel: Equatable {
	let title: String
}

extension MoviesListItemViewModel {
	init(movie: Movie) {
    	self.title = movie.title ?? ""
    }
}

import UIKit

final class MoviesListViewController: UIViewController, StoryboardInstantiable, UISearchBarDelegate {

	private let viewModel: MoviesListViewModel!
    
    final class func create(with viewModel: MoviesListViewModel) -> MoviesListViewController {
    	let vc = MoviesListViewController.instantiateViewController()
        vc.viewModel = viewModel
        return vc
    }
    
    override func viewDidLoad() {
    	super.viewDidLoad()
        
        bind(to: viewModel)
    }
    
    private func bind(to viewModel: MoviesListViewModel) {
    	viewModel.items.observe(on: self) { [weak self] items in
        	self?.moviesTableViewController?.items = items
        }
        viewModel.error.observe(on: self) { [weak self] error in
        	self?.showError(error)
        }
    }
    
    func searchBarSearchButtonClicked(_ searchBar: UISearchBar) {
    	guard let searchText = searchBar.text, !searchText.isEmpty else { return }
    	viewModel.didSearch(query: searchText)
    }
}

protocol MoviesSearchFlowCoordinatorDependencies {
	func makeMoviesListViewController() -> UIViewController
    func makeMoviesDetailsViewController(movie: Movie) -> UIViewController 
}

final class MoviesSearchFlowCoordinator {

	private weak navigationController: UINavigationController?
    private let dependencies: MoviesSearchFlowCoordinatorDependencies
    
    init(navigationController: UINavigationController,
    	 dependencies: MoviesSearchFlowCoordinatorDependencies) {
        self.navigationController = navigationController
        self.dependencies = dependencies
    }
    
    func start() {
    	// Note: here we keep strong reference with actions closures, this way this flow do not need to be strong referneced 
        let actions = MoviesListViewModelActions(showMovieDetails: showMovieDetails)
        let vc = dependencies.makeMoviesListViewController(actions: actions)
        
        navigationController?.pushViewController(vc, animated: true)
    }
    
    private func showMovieDetails(movie: Movie) {
    	let vc = dependencies.makeMoviesDetailsViewController(movie: movie)
        navigationController?.pushViewController(vc, animated: true)
    }
}

// MARK: - Movies Queries Suggestions List
func makeMoviesQueriesSuggestionsListViewController(didSelect: @escaping MoviesQueryListViewModelDidSelectAction) -> UIViewController {
	if #available(iOS 13.0, *) { // SwiftUI
    	let view = MoviesQueryListView(viewModelWrapper: makeMoviesQueryListViewModelWrapper(didSelect: didSelect))
        return UIHostingController(rootView: view)
    } else { // UIKit
    	return MoviesQueriesTableViewController.create(with: makeMoviesQueryListViewModel(didSelect: didSelect))
    }
}

final class DefualtMoviesRepository {

	private let dataTransferService: DataTransfer
    
    init(dataTransferService: DataTransfer) {
    	self.dataTransferService = dataTransferService
    }

}

extension DefaultMoviesRepository: MoviesRepository {

	public func fetchMoviesList(query: MovieQuery, page: Int, completion: @escaping (Result<MoviesPage, Error>) -> Void) -> Cancellable? {
    
    	let endpoint = APIEndpoints.getMovies(with: MoviesResponseDTO(query: query.query, 
        		  													  page: page))
        return dataTransferSerice.request(with: endpoint) { (response: Result<MoviesResponseDTO, Error>) in
            switch response {
            case .success(let moviesResponseDTO):
                completion(.success(moviesResponseDTO.toDomain()))
            case .failure(let error):
                completion(.failure(error))
            }
        }
    }
}

// MARK: - Data Transfer Object (DTO)
// It is used as intermediate to encode/decode JSON response into domain, inside DataTransferService
struct MoviesRequestDTO: Encodable {
	let query: String
    let page: Int
}

struct MoviesResponseDTO: Decodable {
	private enum CodingKeys: String, CodingKey {
    	case page
        case totalPages = "total_pages"
        case movies = "results"
    }
    let page: Int
    let totalPages: Int
    let movies: [MovieDTO]
}
...
// MARK: - Mappings to Domain

extension MoviesResponseDTO {
	func toDomain() -> MoviesPage {
    	return .init(page: pages,
        			 totalPages: totalPages,
                     movies: movies.map { $0.toDomain() } )
    }
}
...

struct APIEndpoints {

	static func getMovies(with movieReqeustDTO: MoviesRequestDTO) -> Endpoint<MoviesResponseDTO> {
    
    	return Endpoint(path: "search/movie/",
        				method: .get,
                        queryParametersEncodable: moviesRequestDTO)
    }
}

let config = ApiDataNetworkConfig(baseURL: URL(string: appConfigurations.apiBaseURL)!,
								  queryParameters: ["api_key": appConfigurations.apiKey])
let apiDataNetwork = DefaultNetworkService(session: URLSession.shard,
									       config: config)

let endpoint = APIEndpoints.getMovies(with: MovieRequestDTO(query: query.query,
															page: page))
dataTransferService.request(with: endpoint) { (response: Result<MoviesResponseDTO, Error>) in
	let moviesPage = try? response.get()
}

public final class Observable<Value> {

	private var closure: ((Value) -> ())?
    
    public var value: Value {
    	didSet { closure?(value) } 
    }

	public init(_ value: Value) {
    	self.value = value
    }
    
    public func observe(_ closure: @escaping (Value) -> Void) {
    	self.closure = closure
        closure(value)
    }

}

final class ExampleViewController: UIViewController {

	private var viewModel: MoviesListViewModel!
    
    private func bind(to viewModel: MoviesListViewModel) {
    	self.viewModel = viewModel
        viewModel.items.observe(on: self) { [weak self] items in
        	self?.tableViewController?.items = itmes
            // Important: You cannot use viewModel inside this closure, it will cause retain cycle momory leak (viewModel.items.value not allowed)
            // self?.tableViewController.items = viewModel.items.value // This would be retain cycle. You can access viewModel only with self?.viewModel
        }
        // Or in one line
        viewModel.items.observe(on: self) { [weak self] in self?.tableViewController?.items = $0 }
    }
}

final class MoviesListItemCell: UITableViewCell {
	
	private var viewModel: MoviesListItemViewModel! { didSet { unbind(from: oldValue) } }
    
    func fill(with viewModel: MoviesListItemViewModel) {
    	eslf.viewModel = viewModel
        bind(to: viewModel)
    }
    
    private func bind(to viewModel: MoviesListItemViewModel) {
    	viewModel.posterImage.observe(on: self) { [weak self] in self?.imageView.image = $0.flatMap(UIImage.init) }
    }
    
    private func unbind(from item: MoviesListItemViewMdoel) {
    	item?.posterImage.remove(observer: self)
    }
}

// Step 1: Define delegate and add it to first ViewModel as weak property
protocol MoviesQueryListViewModelDelegate: AnyObject {
	func moviesQueriesListDidSelect(movieQuery: MovieQuery)
}
...
final class DefaultMoviesQueryListViewModel: MoviesListViewModel {
	private weak var delegate: MoviesQueryListViewModelDelgate?
    
    func didSelect(item: MoviesQueryListViewItemModel) {
    	// Note: We have to map here from View Item Model to Domain Entity
        delegate?.moviesQueriesListDidSelect(movieQuery: MovieQuery(query: item.query))
    }
}

// Step 2: Make second ViewModel to conform to this delegate
extension MoviesListViewModel: MoviesQueryListViewModelDelegate {
	func moviesQueriesListDidSelect(movieQuery: MovieQuery) {
    	update(movieQuery: movieQuery)
    }
}

// MovieQueryList.swift

// Step 1: Define action closure to communicate to another ViewModel, e.g. here we not notify MovieList when query is selected
typealias MoviesQueryListViewModelDidSelectAction = (MovieQuery) -> Void

// Step 2: Call action closure when needed
class MoviesQueryListViewModel {
	init(didSelect: MoviesQueryListViewModelDidSelectAction? = nil) {
    	self.didSelect = didSelect
    }
    func didSelect(item: MovieQueryListItemViewModel) {
    	didSelect?(MovieQuery(query: item.query))
    }
}

// MoviesQueryList.swift

// Step 3: When presenting MoviesQueryListView we need to pass this action closure as parameter (_ didSelect: MovieQuery) -> Void
struct MoviesListViewModelActions {
	let showMovieQueriesSuggestions: (@escaping (_ didSelect: MovieQuery) -> Void) -> Void
}

class MoviesListViewModel {
	var actions: MoviesListViewModelActions?
    
    func showQueriesSuggestions() {
    	actions?.showMovieQueriesSuggestions { self.update(movieQuery: $0) }
    }
}

// FlowCoordinator.swift

// Step 4: Inside FlowCoordinator we connect communication of two viewModels, by injecting actions closures as self function
class MoviesSearchFlowCoordinator {
	func start() {
    	let actions = MoviesListViewModelActions(showMovieQueriesSuggestions: self.showMovieQueriesSuggestions)
        let vc = dependencies.makeMoviesListViewController(actions: actions)
        present(vc)
    }
    
    private func showMovieQueriesSuggestions(didSelect: @escaping (MovieQuery) -> Void) {
    	let vc = dependencies.makeMoviesQueriesSuggestionsListViewController(didSelect: didSelect)
		present(vc)
	}
}

// Define Dependencies protocol for class or structure that needs it
protocol MoviesSearchFlowCoordinatorDependencies {
	func makeMoviesListViewController() -> MoviesListViewController
}

class MoviesSearchFlowCoordinator {

	private let dependencies: MoviesSearchFlowCoordinatorDependencies
    
    init(dependencies: MoviesSearchFlowCoordinatorDependencies) {
    	self.dependencies = dependencies
    }
...
}

// Make the DIContainer ot conform to this protocol
extension MoviesSceneDIContainer: MoviesSearchFlowCoordinatorDependencies { }

// And inject MoviesSceneDIContainer `self` into class that needs it
final class MoviesSceneDIContainer{
	...
    // MARK: - Flow Coordinators
    func makeMoviesSearchFlowCoordinator(navigationController: UINavigationController) {
    	return MoviesSearchFlowCoordinator(navigationController: navigagtionController,
        								   dependencies: dependencies)
    }
}

// Define makeMoviesListViewController closure that returns MoviesListViewController
class MoviesSearchFlowCoordinator {

	private var makeMoviesListViewController: () -> MoviesListViewController
    
    init(navigationController: UINavigationController,
    	 makeMoviesListViewController: @escaping () -> MoviesListViewController) }
    	...
        self.makeMoviesListViewController = makeMoviesListViewController
	}
	...
}

// And inject MoviesSceneDIContainer's `self`.makeMoviesListViewController function into class that needs it
final class MoviesSceneDIContainer {
	...
    // NARK: - Flow Coordinators
    func makeMoviesSearchFlowCoordinator(navigationController: UINavigationController) {
    	return MoviesSearchFlowCoordinator(navigationController: navigationController,
        								   makeMoviesListViewController: self.makeMoviesListViewController)
    }
    
    // MARK: - Movies List
    func makeMoviesListViewController() -> MoviesListViewController {
    	...
    }
}