SwiftUI時代におけるminneのリアクティブアーキテクチャ

import SwiftUI
import UIKit

struct ProductListView: View {
  enum TransitionItem { case productDetail(product: Product, repository: ProductRepository) }

  @ObservedObject private var viewModel: ProductListViewModel
  // 画面遷移は外側のUIHostingControllerで行うので、pushの処理をConstructor Injectionで提供する
  private let pushAction: (UIViewController) -> Void

  init(
    viewModel: ProductListViewModel = ProductListViewModel,
    pushAction: @escaping (UIViewController) -> Void
  ) {
    self.viewModel = viewModel
    self.pushAction = pushAction
  }

  var body: some View {
    CustomList(viewModel.products) { product in
      ProductRow(product: product)
    }
    .onAppear(perform: viewModel.onAppear)
    .onReceive(viewModel.$transitionItem, perform: transition)
  }

  private func transition(to transitionItem: TransitionItem?) {
    guard let transitionItem = transitionItem else { return }
    switch transitionItem {
    case let .productDetail(product, repository):
      let productDetail = ProductDetailViewController(product: product, repository: repository)
      pushAction(vc)
    }
  }
}

import Combine

protocol ProductViewModelInputs {
  func hogeButtonDidTap()
}
protocol ProductListViewModelOutputs {
  var shouldDismissKeyboard: AnyPublisher<Bool, Never> { get }
  var hogeButtonIsEnabled: AnyPublisher<Bool, Never> { get }
  var transitionItem: AnyPublisher<ProductListViewController.TransitionItem?, Never> { get }
}
protocol ProductListViewModelType {
  var inputs: ProductListViewModelInputs { get }
  var outputs: ProductListViewModelOutputs { get }
}

final class ProductListViewModel: ProductListViewModelType {
  typealias Dependency = HasErrorHandler
  typealias TransitionItem = ProductListViewController.TransitionItem

  // MARK: - ProductListViewModelType
  var inputs: ProductListViewModelInputs { self }
  var outputs: ProductListViewModelOutputs { self }

  // 常に状態を持たない、イベント系のデータなので、PassthroughSubjectを使う
  // Equatable準拠なので、Voidではなく、Boolを使う
  private let _shouldDismissKeyboard = PassthroughSubject<Bool, Never>()
  // 常に、enable状態が存在するので、`@Published`または`CurrentValueSubject`を使う
  // @Publishedのほうが若干記述量少ないので、便利
  @Published private var _hogeButtonIsEnabled = false
  @Published private var _transitionItem: TransitionItem?

  private let dependency: Dependency
  private let repository: ProductRepositoryProtocol
  private var cancellables: Set<AnyCancellable> = []

  init(
    dependency: Dependency = AppDependency(),
    repository: ProductListRepositoryProtocol = ProductListRepository()
  ) {
    self.dependency = dependency
    self.repository = repository
  }

}

// MARK: - ProductListViewModelOutputs
extension ProductListViewModel: ProductListViewModelOutputs {

  var shouldDismissKeyboard: AnyPublisher<Bool, Never> { _shouldDismissKeyboard.eraseToAnyPublisher() }

  var hogeButtonIsEnabled: AnyPublisher<Bool, Never> { $_hogeButtonIsEnabled.eraseToAnyPublisher() }

  var transitionItem: AnyPublisher<TransitionItem?, Never> { $_transitionItem.eraseToAnyPublisher() }

}

// MARK: - ProductListViewModelInputs
extension ProductListViewModel: ProductListViewModelInputs {

  func hogeButtonDidTap() {
    makeNetworkRequest()
  }

}

// MARK: - Private
private extension ProductListViewModel {

  func makeNetworkRequest() {...}

}

final class ProductListViewModel: ObservableObject {
  typealias TransitionItem = ProductListView.TransitionItem
  typealias Dependency = HasLogger & HasErrorHandler

  // MARK: - Outputs
  @Published var isLoading = true // @Bindingとして扱うために`private(set)`にできない
  @Published private(set) var products: [Product] = []
  @Published private(set) var transitionItem: TransitionItem?

  private let repository: ProductRepositoryProtocol
  private let dependency: Dependency
  private var cancellables: Set<AnyCancellable> = []

  init(
    repository: ProductRepositoryProtocol = ProductRepository(),
    dependency: Dependency = AppDependency()
  ) {
    self.repository = repository
    self.dependency = dependency
  }
}

// MARK: - Inputs
extension ProductListViewModel {

  func onAppear() {
    dependency.logger.post(tag: .screen(.productList))
    downloadProduct()
  }

  func didTapProduct(_ product: Product) {
    transitionItem = .productDetail(id: product.id)
  }

  func didShowProduct(at index: Int) {
    guard repository.shouldPreDownload(displayedCount: index) else { return }
    downloadNextProductItems()
  }
}

// MARK: - Private
private extension ProductListViewModel {
  func downloadNextInfoItems() {...}
}

import Combine

protocol ProductRepositoryProtocol {
  func fetchNewestProducts() -> AnyPublisher<Product, RepositoryError>
}

final class ProductRepository: ProductRepositoryProtocol {
  // テストしやすいように、UserDefaultsやデータベースなどを直接保持しない
  private let userDefaultsProvider: UserDefaultsProviderProtocol
  private let db: ProductDatabaseProtocol
  private let requester: ProductRequesterProtocol

  init(...) {...}

  /// 最新の作品を取得し、dbにキャッシュする
  func fetchNewestProducts() -> AnyPublisher<Product, RepositoryError> {...}
}

struct Product {
  let name: String
  let cost: Int
}

import Combine

protocol ProductRequesterProtocol {
  func getProduct(id: String) -> NetworkPublisher<GETProductEndpoint>
}

struct ProductRequester: ProductRequesterProtocol {
  private let apiClient: APIClientProtocol
  init(apiClient: APIClientProcotol = APIClient()) {
    self.apiClient = apiClient
  }

  func getProduct(id: String) -> NetworkPublisher<GETProductEndpoint> {
    let endpoint = GETProductEndpoint(id: id)
    return apiClient.request(endpoint: endpoint)
  }
}

import WebKit

final class WKNavigationDelegateAdaptor: NSObject, WKNavigationDelegate {
  typealias DecidePolicyFor = ((URL, WKNavigationAction, (WKNavigationActionPolicy) -> Void) -> Void)
  private let decidePolicyFor: DecidePolicyFor

  typealias DidFail = ((URL, WKNavigation, Error) -> Void)
  private let didFail: DidFail

  typealias DidFailProvisionalNavigation = ((URL, WKNavigation, Error) -> Void)
  private let didFailProvisionalNavigation: DidFailProvisionalNavigation

  init(
    decidePolicyFor: @escaping DecidePolicyFor = { _, _, decisionHandler in decisionHandler(.allow) },
    didFail: @escaping DidFail = { _, _, _ in },
    didFailProvisionalNavigation: @escaping DidFailProvisionalNavigation = { _, _, _ in }
  ) {
    self.decidePolicyFor = decidePolicyFor
    self.didFail = didFail
    self.didFailProvisionalNavigation = didFailProvisionalNavigation
  }

  func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {
    if let url = webView.url {
      decidePolicyFor(url, navigationAction, decisionHandler)
    } else {
      assertionFailure("urlがない")
      decisionHandler(.cancel)
    }
  }

  func webView(_ webView: WKWebView, didFail navigation: WKNavigation!, withError error: Error) {
    if let url = webView.url {
      didFail(url, navigation, error)
    } else {
      assertionFailure("urlがない")
    }
  }

  func webView(_ webView: WKWebView, didFailProvisionalNavigation navigation: WKNavigation, withError error: Error) {
    if let url = webView.url {
      didFailProvisionalNavigation(url, navigation, error)
    } else {
      assertionFailure("urlがない")
    }
  }
}

private let hoge: HogeProtocol

init(hoge: HogeProtocol = Hoge()) {
  self.hoge = hoge
}

// 利用側

final class ViewModel {
  typealias Dependency = HasLogger & HasAppUser

  let repository: ProductRepositoryProtocol
  let dependency: Dependency

  init(
    repository: ProductRepositoryProtocol = ProductRepository(), // ここだけで使うので、従来どおりのでconstructor injection
    dependency: Dependency = AppDependency()
  ) {
    self.repository = repository
    self.dependency = dependency
  }
}

// 定義

protocol HasLogger {
  var logger: LoggerProtocol { get }
}
protocol HasAppUser {
  var appUser: AppUserProtocol { get }
}
struct AppDependency: HasLogger, HasAppUser {
  let logger: LoggerProtocol
  let appUser: AppUserProtocol
  //...
}