Added: HTTPURLResponse to: NetworkError.serializationError(let error, let response, let data).

Author: hoereth

Source/NetworkError.swift

@@ -36,7 +36,7 @@ public enum NetworkError: Error, Sendable {
     /// Error on the server (HTTP Error 500...511)
     case serverError(response: HTTPURLResponse?, data: Data?)
     /// Parsing the body into expected type failed.
-    case serializationError(error: Error, data: Data?)
+    case serializationError(error: Error, response: HTTPURLResponse, data: Data?)
     /// Complete request failed.
     case requestError(error: Error)
 
@@ -75,21 +75,21 @@ extension NetworkError: CustomDebugStringConvertible {
         case .cancelled:
             return "Request cancelled"
         case .unauthorized(let response, let data):
-            return "Authorization error: \(response), response: ".appendingContentsOf(data: data)
+            return "Authorization error, response headers: \(response), response body: ".appendingContentsOf(data: data)
         case .clientError(let response, let data):
             if let response = response {
-                return "Client error: \((response)), response: ".appendingContentsOf(data: data)
+                return "Client error, response headers: \((response)), response body: ".appendingContentsOf(data: data)
             }
-            return "Client error, response: ".appendingContentsOf(data: data)
-        case .serializationError(let description, let data):
-            return "Serialization error: \(description), response: ".appendingContentsOf(data: data)
+            return "Client error, response headers: nil, response body: ".appendingContentsOf(data: data)
+        case .serializationError(let error, let response, let data):
+            return "Serialization error: \(error), response headers: \(response), response body: ".appendingContentsOf(data: data)
         case .requestError(let error):
             return "Request error: \(error)"
         case .serverError(let response, let data):
-            if let response = response {
-                return "Server error: \(String(describing: response)), response: ".appendingContentsOf(data: data)
+            if let response {
+                return "Server error, response headers: \(String(describing: response)), response body: ".appendingContentsOf(data: data)
             } else {
-                return "Server error: nil, response: ".appendingContentsOf(data: data)
+                return "Server error: nil, response body: ".appendingContentsOf(data: data)
             }
         }
     }

Source/NetworkServices/BasicNetworkService.swift

@@ -84,9 +84,9 @@ public final class BasicNetworkService: NetworkService {
             }
 
             do {
-                return .success((try resource.parse(data), response))
+                return .success((try resource.parse(response, data), response))
             } catch let error {
-                return .failure(.serializationError(error: error, data: data))
+                return .failure(.serializationError(error: error, response: response, data: data))
             }
         } catch let error {
             if case URLError.cancelled = error {

Source/NetworkServices/NetworkServiceMock.swift

@@ -182,7 +182,7 @@ public final class NetworkServiceMock: NetworkService, @unchecked Sendable  {
             switch scheduled {
             case .success((let data, let httpURLResponse)):
                 do {
-                    let result = try resource.parse(data)
+                    let result = try resource.parse(httpURLResponse, data)
                     return .success((result, httpURLResponse))
                 } catch {
                     fatalError("Not able to parse data. Error: \(error)")

Source/Resource+Decodable.swift

@@ -33,7 +33,11 @@ extension Resource where Model: Decodable {
     ///   - 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 @Sendable  (_ networkError: NetworkError) -> E) {
-        self.init(request: request, parse: { try decoder.decode(Model.self, from: $0) }, mapError: mapError)
+        self.init(request: request, parse: {
+                try decoder.decode(Model.self, from: $1)
+            },
+            mapError: mapError
+        )
     }
 }
 
@@ -47,6 +51,12 @@ extension Resource where Model: Decodable, E: NetworkErrorConvertible {
     ///   - 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) {
-        self.init(request: request, parse: { try decoder.decode(Model.self, from: $0) }, mapError: { E(networkError: $0) })
+        self.init(request: request, parse: {
+                try decoder.decode(Model.self, from: $1)
+            },
+            mapError: {
+                E(networkError: $0)
+            }
+        )
     }
 }

Source/Resource+Inspect.swift

@@ -36,10 +36,10 @@ extension Resource {
      - parameter inspector: closure which gets passed the data
      - returns: a new resource which gets instepcted before parsing
      */
-    public func inspectData(_ inspector: @escaping @Sendable  (Data) -> Void) -> Resource<Model, E> {
-        let parse: @Sendable (Data) throws -> Model = { data in
-            inspector(data)
-            return try self.parse(data)
+    public func inspectData(_ inspector: @escaping @Sendable  (HTTPURLResponse, Data) -> Void) -> Resource<Model, E> {
+        let parse: @Sendable (HTTPURLResponse, Data) throws -> Model = { response, data in
+            inspector(response, data)
+            return try self.parse(response, data)
         }
         return Resource<Model, E>(request: request, parse: parse, mapError: mapError)
     }

Source/Resource+Map.swift

@@ -30,7 +30,9 @@ extension Resource {
     public func map<T>(transform: @escaping @Sendable  (Model) throws -> T) -> Resource<T, E> {
         return Resource<T, E>(
             request: request,
-            parse: {  return try transform(try self.parse($0)) },
+            parse: { response, data in
+                return try transform(try self.parse(response, data))
+            },
             mapError: mapError
         )
     }

Source/Resource+Void.swift

@@ -15,7 +15,7 @@ public extension Resource where Model == Void {
     ///   - request: The request to get the remote data payload
     ///   - mapError: a closure which maps to Error
     init(request: URLRequest, mapError: @escaping @Sendable  (_ networkError: NetworkError) -> E) {
-        self.init(request: request, parse: { _ in }, mapError: mapError)
+        self.init(request: request, parse: { _, _ in }, mapError: mapError)
     }
 }
 
@@ -26,7 +26,7 @@ public extension Resource where Model == Void, E: NetworkErrorConvertible {
     /// - Parameters:
     ///   - request: The request to get the remote data payload
     init(request: URLRequest) {
-        self.init(request: request, parse: { _ in }, mapError: { E(networkError: $0) })
+        self.init(request: request, parse: { _, _ in }, mapError: { E(networkError: $0) })
     }
 
 }

Source/Resource.swift

@@ -40,7 +40,7 @@ public struct Resource<Model, E: Error>: Sendable {
     public let request: URLRequest
 
     /// Parses data into given model.
-    public let parse: @Sendable (_ data: Data) throws -> Model
+    public let parse: @Sendable (_ response: HTTPURLResponse, _ data: Data) throws -> Model
     public let mapError: @Sendable (_ networkError: NetworkError) -> E
 
     /// Creates a type safe resource, which can be used to fetch it with NetworkService
@@ -49,7 +49,7 @@ public struct Resource<Model, E: Error>: Sendable {
     /// - request: The request to get the remote data payload
     /// - parse: Parses data fetched with the request into given Model
 
-    public init(request: URLRequest, parse: @escaping @Sendable  (Data) throws -> Model, mapError: @escaping @Sendable  (_ networkError: NetworkError) -> E) {
+    public init(request: URLRequest, parse: @escaping @Sendable (HTTPURLResponse, Data) throws -> Model, mapError: @escaping @Sendable  (_ networkError: NetworkError) -> E) {
         self.request = request
         self.parse = parse
         self.mapError = mapError

Source/ResourceWithError+NetworkErrorConvertible.swift

@@ -9,7 +9,7 @@ import Foundation
 
 public extension Resource where E: NetworkErrorConvertible {
 
-    init(request: URLRequest, parse: @escaping @Sendable (Data) throws -> Model) {
+    init(request: URLRequest, parse: @escaping @Sendable (HTTPURLResponse, Data) throws -> Model) {
         self.request = request
         self.parse = parse
         self.mapError = { E(networkError: $0) }

Tests/DecodableResoureTest.swift

@@ -33,25 +33,25 @@ class DecodableResoureTest: XCTestCase {
 
     func testResource_withValidData() {
         //When
-        let fetchedTrain = try? resource.parse(Train.validJSONData)
-        
+        let fetchedTrain = try? resource.parse(HTTPURLResponse.defaultMock, Train.validJSONData)
+
         //Then
         XCTAssertEqual(fetchedTrain?.name, "ICE")
     }
 
     func testResource_withMAppedResult() {
         //When
         let nameResource = resource.map { $0.name }
-        let fetchedTrainName = try? nameResource.parse(Train.validJSONData)
-        
+        let fetchedTrainName = try? nameResource.parse(HTTPURLResponse.defaultMock, Train.validJSONData)
+
         //Then
         XCTAssertEqual(fetchedTrainName, "ICE")
     }
 
     func testResource_WithInvalidData() throws {
         //When
         do {
-            _ = try resource.parse(Train.invalidJSONData)
+            _ = try resource.parse(HTTPURLResponse.defaultMock, Train.invalidJSONData)
             XCTFail("Expected method to throws")
         } catch { }
     }