Added new methods to protocols (#15)

* Reorder methods

* Added async methods to return Generic Decodable Types

Author: hishd

Sources/Networking/DataTranserService/NetworkDataTransferService.swift

@@ -31,9 +31,17 @@ public protocol NetworkDataTransferService: AnyObject {
     @available(iOS 16, *)
     func request<T: Decodable, E: RequestableEndpoint>(with endpoint: E) async -> TaskType<T> where E.ResponseType == T
 
+    @available(macOS 10.15, *)
+    @available(iOS 16, *)
+    func request<T: Decodable, E: RequestableEndpoint>(with endpoint: E) async throws -> T where E.ResponseType == T
+    
     @available(iOS 16, *)
     @available(macOS 10.15, *)
     func request<T: Decodable, E: RequestableEndpoint>(with endpoints: [E]) async -> TaskTypeCollection<T> where E.ResponseType == T
+    
+    @available(iOS 16, *)
+    @available(macOS 10.15, *)
+    func request<T: Decodable, E: RequestableEndpoint>(with endpoints: [E]) async throws -> [T] where E.ResponseType == T
 }
 
 // MARK: Concrete Implementation
@@ -68,6 +76,35 @@ public final class DefaultNetworkDataTransferService {
             group.leave()
         }
     }
+    
+    
+    private func decode<T: Decodable>(data: Data?, decoder: ResponseDecoder) -> Result<T, NetworkDataTransferError> {
+        do {
+            guard let data = data else {
+                return .failure(NetworkDataTransferError.noResponse)
+            }
+            
+            let decoded: T = try decoder.decode(data: data)
+            return .success(decoded)
+        } catch {
+            self.logger.log(error: error)
+            return .failure(NetworkDataTransferError.parsing(error))
+        }
+    }
+    
+    private func decode<T: Decodable>(data: Data?, decoder: ResponseDecoder) throws -> T {
+        do {
+            guard let data = data else {
+                throw NetworkDataTransferError.noResponse
+            }
+            
+            let decoded: T = try decoder.decode(data: data)
+            return decoded
+        } catch {
+            self.logger.log(error: error)
+            throw NetworkDataTransferError.parsing(error)
+        }
+    }
 }
 
 extension DefaultNetworkDataTransferService: NetworkDataTransferService {
@@ -101,6 +138,36 @@ extension DefaultNetworkDataTransferService: NetworkDataTransferService {
         return requestCollection
     }
 
+    public func request<T: Decodable, E: RequestableEndpoint>(
+        with endpoint: E,
+        on queue: (any NetworkDataTransferQueue)? = nil,
+        completion: @escaping (Result<T, NetworkDataTransferError>) -> Void
+    ) -> (any CancellableHttpRequest)? where E.ResponseType == T {
+        
+        return networkService.request(endpoint: endpoint) { result in
+            let completionResult: Result<T, NetworkDataTransferError>
+            
+            defer {
+                if let queue = queue {
+                    queue.asyncExecute {
+                        completion(completionResult)
+                    }
+                }
+                completion(completionResult)
+            }
+            
+            switch result {
+            case .success(let data):
+                let result: Result<T, NetworkDataTransferError> = self.decode(data: data, decoder: endpoint.responseDecoder)
+                completionResult = result
+            case .failure(let error):
+                self.logger.log(error: error)
+                completionResult = .failure(.networkFailure(error))
+            }
+        }
+        
+    }
+    
     @available(macOS 10.15, *)
     @available(iOS 16, *)
     public func request<T: Decodable, E: RequestableEndpoint>(with endpoints: [E]) async -> TaskTypeCollection<T> where T == E.ResponseType {
@@ -130,72 +197,45 @@ extension DefaultNetworkDataTransferService: NetworkDataTransferService {
 
     @available(macOS 10.15, *)
     @available(iOS 16, *)
-    public func request<T:Decodable, E: RequestableEndpoint>(with endpoint: E) async -> TaskType<T> where T == E.ResponseType {
-        let task = Task {
-            let responseData = try await networkService.request(endpoint: endpoint).value
-            let decodedData:T = try self.decode(data: responseData, decoder: endpoint.responseDecoder)
-            
-            return decodedData
-        }
-        
-        return task
-    }
-    
-    public func request<T: Decodable, E: RequestableEndpoint>(
-        with endpoint: E,
-        on queue: (any NetworkDataTransferQueue)? = nil,
-        completion: @escaping (Result<T, NetworkDataTransferError>) -> Void
-    ) -> (any CancellableHttpRequest)? where E.ResponseType == T {
-        
-        return networkService.request(endpoint: endpoint) { result in
-            let completionResult: Result<T, NetworkDataTransferError>
-            
-            defer {
-                if let queue = queue {
-                    queue.asyncExecute {
-                        completion(completionResult)
-                    }
+    public func request<T: Decodable, E: RequestableEndpoint>(with endpoints: [E]) async throws -> [T] where T == E.ResponseType {
+        let responseData = try await withThrowingTaskGroup(of: T.self, returning: [T].self) { taskGroup in
+            for endpoint in endpoints {
+                taskGroup.addTask {
+                    try await self.request(with: endpoint).value
                 }
-                completion(completionResult)
             }
 
-            switch result {
-            case .success(let data):
-                let result: Result<T, NetworkDataTransferError> = self.decode(data: data, decoder: endpoint.responseDecoder)
-                completionResult = result
-            case .failure(let error):
-                self.logger.log(error: error)
-                completionResult = .failure(.networkFailure(error))
+            var data: [T] = []
+            
+            for try await item in taskGroup {
+                data.append(item)
             }
+            
+            return data
         }
 
+        return responseData
     }
 
-    private func decode<T: Decodable>(data: Data?, decoder: ResponseDecoder) -> Result<T, NetworkDataTransferError> {
-        do {
-            guard let data = data else {
-                return .failure(NetworkDataTransferError.noResponse)
-            }
+    @available(macOS 10.15, *)
+    @available(iOS 16, *)
+    public func request<T:Decodable, E: RequestableEndpoint>(with endpoint: E) async -> TaskType<T> where T == E.ResponseType {
+        let task = Task {
+            let responseData = try await networkService.request(endpoint: endpoint).value
+            let decodedData:T = try self.decode(data: responseData, decoder: endpoint.responseDecoder)
 
-            let decoded: T = try decoder.decode(data: data)
-            return .success(decoded)
-        } catch {
-            self.logger.log(error: error)
-            return .failure(NetworkDataTransferError.parsing(error))
+            return decodedData
         }
+        
+        return task
     }
 
-    private func decode<T: Decodable>(data: Data?, decoder: ResponseDecoder) throws -> T {
-        do {
-            guard let data = data else {
-                throw NetworkDataTransferError.noResponse
-            }
-            
-            let decoded: T = try decoder.decode(data: data)
-            return decoded
-        } catch {
-            self.logger.log(error: error)
-            throw NetworkDataTransferError.parsing(error)
-        }
+    @available(macOS 10.15, *)
+    @available(iOS 16, *)
+    public func request<T:Decodable, E: RequestableEndpoint>(with endpoint: E) async throws -> T where T == E.ResponseType {
+        let responseData = try await networkService.request(endpoint: endpoint).value
+        let decodedData:T = try self.decode(data: responseData, decoder: endpoint.responseDecoder)
+        
+        return decodedData
     }
 }