Resource with generic Error as default

Author: lightsprint09

Source/NetworkService+ResourceWithError.swift

@@ -52,9 +52,9 @@ extension NetworkService {
      */
     @discardableResult
     public func requestResultWithResponse<Success, E: Error>(
-        for resource: ResourceWithError<Success, E>
+        for resource: Resource<Success, E>
     ) async -> Result<(Success, HTTPURLResponse), E> {
-        let resourceWithoutError = Resource(request: resource.request, parse: resource.parse)
+        let resourceWithoutError = Resource<Success, NetworkError>(request: resource.request, parse: resource.parse)
         return await self.requestResultWithResponse(for: resourceWithoutError)
             .mapError(resource.mapError)
     }
@@ -85,9 +85,9 @@ extension NetworkService {
      */
     @discardableResult
     public func requestResult<Success, E: Error>(
-        for resource: ResourceWithError<Success, E>
+        for resource: Resource<Success, E>
     ) async -> Result<Success, E> {
-        let resourceWithoutError = Resource(request: resource.request, parse: resource.parse)
+        let resourceWithoutError = Resource<Success, NetworkError>(request: resource.request, parse: resource.parse)
         return await requestResultWithResponse(for: resourceWithoutError)
             .mapError(resource.mapError)
             .map({ $0.0 })
@@ -120,13 +120,18 @@ extension NetworkService {
      */
     @discardableResult
     public func request<Success, E: Error>(
-        _ resource: ResourceWithError<Success, E>
+        _ resource: Resource<Success, E>
     ) async throws -> Success {
-        let resourceWithoutError = Resource(request: resource.request, parse: resource.parse)
+        let resourceWithoutError = Resource<Success, NetworkError>(request: resource.request, parse: resource.parse)
         return try await requestResultWithResponse(for: resourceWithoutError)
             .mapError(resource.mapError)
             .map({ $0.0 })
             .get()
     }
 
+    @discardableResult
+    func requestWithResponse<Success, E: Error>(for resource: Resource<Success, E>) async throws -> (Success, HTTPURLResponse) {
+        return try await requestResultWithResponse(for: resource).get()
+    }
+
 }

Source/NetworkService.swift

@@ -57,7 +57,7 @@ public protocol NetworkService: Sendable {
      - returns: a running network task
      */
     @discardableResult
-    func requestResultWithResponse<Success>(for resource: Resource<Success>) async -> Result<(Success, HTTPURLResponse), NetworkError>
+    func requestResultWithResponse<Success>(for resource: Resource<Success, NetworkError>) async -> Result<(Success, HTTPURLResponse), NetworkError>
 }
 
 public extension NetworkService {
@@ -87,7 +87,7 @@ public extension NetworkService {
      - returns: a running network task
      */
     @discardableResult
-    func requestResult<Success>(for resource: Resource<Success>) async -> Result<Success, NetworkError> {
+    func requestResult<Success>(for resource: Resource<Success, NetworkError>) async -> Result<Success, NetworkError> {
         return await requestResultWithResponse(for: resource).map({ $0.0 })
     }
 
@@ -116,7 +116,12 @@ public extension NetworkService {
      - returns: a running network task
      */
     @discardableResult
-    func request<Success>(_ resource: Resource<Success>) async throws -> Success {
+    func request<Success>(_ resource: Resource<Success, NetworkError>) async throws -> Success {
         return try await requestResultWithResponse(for: resource).get().0
     }
+
+    @discardableResult
+    func requestWithResponse<Success>(for resource: Resource<Success, NetworkError>) async throws -> (Success, HTTPURLResponse) {
+        return try await requestResultWithResponse(for: resource).get()
+    }
 }

Source/NetworkServices/BasicNetworkService.swift

@@ -73,7 +73,7 @@ public final class BasicNetworkService: NetworkService {
      - returns: a running network task
      */
     @discardableResult
-    public func requestResultWithResponse<Success>(for resource: Resource<Success>) async -> Result<(Success, HTTPURLResponse), NetworkError> {
+    public func requestResultWithResponse<Success>(for resource: Resource<Success, NetworkError>) async -> Result<(Success, HTTPURLResponse), NetworkError> {
         do {
             let (data, response) = try await networkAccess.load(request: resource.request)
             guard let response = response as? HTTPURLResponse else {

Source/NetworkServices/ModifyRequestNetworkService.swift

@@ -80,11 +80,11 @@ public final class ModifyRequestNetworkService: NetworkService {
      - returns: a running network task
      */
     @discardableResult
-    public func requestResultWithResponse<Success>(for resource: Resource<Success>) async -> Result<(Success, HTTPURLResponse), NetworkError> {
+    public func requestResultWithResponse<Success>(for resource: Resource<Success, NetworkError>) async -> Result<(Success, HTTPURLResponse), NetworkError> {
         let request = requestModifications.reduce(resource.request, { request, modify in
             return modify(request)
         })
-        let newResource = Resource(request: request, parse: resource.parse)
+        let newResource = Resource<Success, NetworkError>(request: request, parse: resource.parse)
         return await networkService.requestResultWithResponse(for: newResource)
     }
 }

Source/NetworkServices/NetworkServiceMock.swift

@@ -147,7 +147,7 @@ public final actor NetworkServiceMock: NetworkService {
      - parameter onError: Callback which gets called when fetching or transforming fails.
 
      */
-    public func requestResultWithResponse<Success>(for resource: Resource<Success>) async -> Result<(Success, HTTPURLResponse), NetworkError> {
+    public func requestResultWithResponse<Success>(for resource: Resource<Success, NetworkError>) async -> Result<(Success, HTTPURLResponse), NetworkError> {
         lastRequests.append(resource.request)
         if !responses.isEmpty {
             let scheduled = responses.removeFirst()

Source/NetworkServices/RetryNetworkService.swift

@@ -81,7 +81,7 @@ public final class RetryNetworkService: NetworkService {
 
      - returns: a running network task
      */
-    public func requestResultWithResponse<Success>(for resource: Resource<Success>) async -> Result<(Success, HTTPURLResponse), NetworkError> {
+    public func requestResultWithResponse<Success>(for resource: Resource<Success, NetworkError>) async -> Result<(Success, HTTPURLResponse), NetworkError> {
         let result = await networkService.requestResultWithResponse(for: resource)
         switch result {
         case .success:
@@ -94,20 +94,24 @@ public final class RetryNetworkService: NetworkService {
     private func requestResultWithResponseOnError<Success>(
         error: NetworkError,
         numberOfRetriesLeft: Int,
-        resource: Resource<Success>
+        resource: Resource<Success, NetworkError>
     ) async -> Result<(Success, HTTPURLResponse), NetworkError> {
         if self.shouldRetry(error), numberOfRetriesLeft > 0 {
             let duration = UInt64(idleTimeInterval * 1_000_000_000)
             try? await Task.sleep(nanoseconds: duration)
-            #warning("check for cancellation")
-            
-            let result = await networkService.requestResultWithResponse(for: resource)
-            switch result {
-            case .success:
-                return result
-            case .failure(let failure):
-                return await requestResultWithResponseOnError(error: failure, numberOfRetriesLeft: numberOfRetriesLeft - 1, resource: resource)
+            do {
+                try Task.checkCancellation()
+                let result = await networkService.requestResultWithResponse(for: resource)
+                switch result {
+                case .success:
+                    return result
+                case .failure(let failure):
+                    return await requestResultWithResponseOnError(error: failure, numberOfRetriesLeft: numberOfRetriesLeft - 1, resource: resource)
+                }
+            } catch {
+                return .failure(.cancelled)
             }
+
         } else {
             return .failure(error)
         }

Source/Resource+Decodable.swift

@@ -31,12 +31,13 @@ extension Resource where Model: Decodable {
     /// - Parameters:
     ///   - request: The request to get the remote data payload
     ///   - decoder: a decoder which can decode the payload into the model type
-    public init(request: URLRequest, decoder: JSONDecoder) {
-        self.init(request: request, parse: { try decoder.decode(Model.self, from: $0) })
+    ///   - mapError: a closure which maps to Error
+    public init(request: URLRequest, decoder: JSONDecoder, mapError: @escaping (_ networkError: NetworkError) -> E) {
+        self.init(request: request, parse: { try decoder.decode(Model.self, from: $0) }, mapError: mapError)
     }
 }
 
-extension ResourceWithError where Model: Decodable {
+extension Resource where Model: Decodable, E: NetworkErrorConvertible {
 
     /// Creates an instace of Resource where the result type is `Decodable` and
     /// can be decoded with the given decoder
@@ -45,7 +46,7 @@ extension ResourceWithError where Model: Decodable {
     ///   - request: The request to get the remote data payload
     ///   - decoder: a decoder which can decode the payload into the model type
     ///   - mapError: a closure which maps to Error
-    public init(request: URLRequest, decoder: JSONDecoder, mapError: @escaping (_ networkError: NetworkError) -> E) {
-        self.init(request: request, parse: { try decoder.decode(Model.self, from: $0) }, mapError: mapError)
+    public init(request: URLRequest, decoder: JSONDecoder) {
+        self.init(request: request, parse: { try decoder.decode(Model.self, from: $0) }, mapError: { E(networkError: $0) })
     }
 }

Source/Resource+Inspect.swift

@@ -27,7 +27,7 @@ extension Resource {
      This lets one inspect the data payload before data gets parsed.
 
      ```swift
-     let resource: Resource<Train> = //
+     let resource: Resource<Train, NetworkError> = //
      resource.inspectData { data in
         print(String(bytes: data, encoding: .utf8))
      }
@@ -36,11 +36,12 @@ extension Resource {
      - parameter inspector: closure which gets passed the data
      - returns: a new resource which gets instepcted before parsing
      */
-    public func inspectData(_ inspector: @escaping (Data) -> Void) -> Resource<Model> {
-        return Resource(request: request, parse: { data in
+    public func inspectData(_ inspector: @escaping (Data) -> Void) -> Resource<Model, E> {
+        let parse: (Data) throws -> Model = { data in
             inspector(data)
             return try self.parse(data)
-        })
+        }
+        return Resource<Model, E>(request: request, parse: parse, mapError: mapError)
     }
 
 }

Source/Resource+Map.swift

@@ -27,27 +27,10 @@ extension Resource {
     ///
     /// - Parameter transform: transforms the original result of the resource
     /// - Returns: the transformed resource
-    public func map<T>(transform: @escaping (Model) throws -> T) -> Resource<T> {
-        return Resource<T>(request: request, parse: { data in
-            return try transform(try self.parse(data))
-        })
-    }
-}
-
-extension ResourceWithError {
-
-    /// Maps a resource result to a different resource. This is useful when you have result of R which contains T and your API request a resource of T,
-    ///
-    /// Error parsing is not changed
-    ///
-    /// - Parameter transform: transforms the original result of the resource
-    /// - Returns: the transformed resource
-    public func map<T>(transform: @escaping (Model) throws -> T) -> ResourceWithError<T, E> {
-        return ResourceWithError<T, E>(
+    public func map<T>(transform: @escaping (Model) throws -> T) -> Resource<T, E> {
+        return Resource<T, E>(
             request: request,
-            parse: { data in
-                return try transform(try self.parse(data))
-            },
+            parse: {  return try transform(try self.parse($0)) },
             mapError: mapError
         )
     }

Source/Resource+Void.swift

@@ -13,19 +13,20 @@ public extension Resource where Model == Void {
     ///
     /// - Parameters:
     ///   - request: The request to get the remote data payload
-    init(request: URLRequest) {
-        self.init(request: request, parse: { _ in })
+    ///   - mapError: a closure which maps to Error
+    init(request: URLRequest, mapError: @escaping (_ networkError: NetworkError) -> E) {
+        self.init(request: request, parse: { _ in }, mapError: mapError)
     }
 }
 
-extension ResourceWithError where Model == Void {
+public extension Resource where Model == Void, E: NetworkErrorConvertible {
 
     /// Creates an instace of Resource where the result type is `Void`
     ///
     /// - Parameters:
     ///   - request: The request to get the remote data payload
-    ///   - mapError: a closure which maps to Error
-    public init(request: URLRequest, mapError: @escaping (_ networkError: NetworkError) -> E) {
-        self.init(request: request, parse: { _ in }, mapError: mapError)
+    init(request: URLRequest) {
+        self.init(request: request, parse: { _ in }, mapError: { E(networkError: $0) })
     }
+
 }