[#324] Use Moya as the main Network Layer

Podfile

@@ -19,7 +19,7 @@ target '{PROJECT_NAME}' do
   pod 'SnapKit'
 
   # Rx
-  pod 'RxAlamofire'
+  pod 'Moya/RxSwift'
   pod 'RxCocoa'
   pod 'RxDataSources'
   pod 'RxSwift'

{PROJECT_NAME}/Sources/Data/NetworkAPI/Core/NetworkAPIProtocol.swift

@@ -2,43 +2,23 @@
 //  NetworkAPIProtocol.swift
 //
 
-import Alamofire
-import RxAlamofire
+import Moya
 import RxSwift
 
 protocol NetworkAPIProtocol {
 
-    func performRequest<T: Decodable>(_ configuration: RequestConfiguration, for type: T.Type) -> Single<T>
+    func performRequest<T: Decodable>(_ configuration: TargetType, for type: T.Type) -> Single<T>
 }
 
 extension NetworkAPIProtocol {
-
     func request<T: Decodable>(
-        session: Session,
-        configuration: RequestConfiguration,
+        provider: MoyaProvider<MultiTarget>,
+        configuration: TargetType,
         decoder: JSONDecoder
     ) -> Single<T> {
-        return session.rx.request(
-            configuration.method,
-            configuration.url,
-            parameters: configuration.parameters,
-            encoding: configuration.encoding,
-            headers: configuration.headers,
-            interceptor: configuration.interceptor
-        )
-        .responseData()
-        .flatMap { _, data -> Observable<T> in
-            Observable.create { observer in
-                do {
-                    let decodable = try decoder.decode(T.self, from: data)
-                    observer.on(.next(decodable))
-                } catch {
-                    observer.on(.error(error))
-                }
-                observer.on(.completed)
-                return Disposables.create()
-            }
-        }
-        .asSingle()
+        provider
+            .rx
+            .request(MultiTarget(configuration))
+            .map(T.self, using: decoder)
     }
 }

{PROJECT_NAME}/Sources/Data/NetworkAPI/NetworkAPI.swift

@@ -2,23 +2,24 @@
 //  NetworkAPI.swift
 //
 
-import Alamofire
 import Foundation
+import Moya
 import RxSwift
 
 final class NetworkAPI: NetworkAPIProtocol {
 
+    private let provider: MoyaProvider<MultiTarget>
     private let decoder: JSONDecoder
 
-    init(decoder: JSONDecoder = JSONDecoder()) {
+    init(
+        provider: MoyaProvider<MultiTarget> = MoyaProvider<MultiTarget>(),
+        decoder: JSONDecoder = JSONDecoder()
+    ) {
+        self.provider = provider
         self.decoder = decoder
     }
 
-    func performRequest<T: Decodable>(_ configuration: RequestConfiguration, for type: T.Type) -> Single<T> {
-        request(
-            session: Session(),
-            configuration: configuration,
-            decoder: decoder
-        )
+    func performRequest<T: Decodable>(_ configuration: TargetType, for type: T.Type) -> Single<T> {
+        request(provider: provider, configuration: configuration, decoder: decoder)
     }
 }

{PROJECT_NAME}/Sources/Supports/Helpers/Typealiases/Typealiases.swift

@@ -3,6 +3,8 @@
 //  Typealiases.swift
 //
 
+import Moya
 import UIKit
 
 typealias AlertCompletion = (UIAlertAction) -> Void
+typealias TargetType = Moya.TargetType