[Netlens] - finish interceptor

Author: sassiwalid

Sources/NetLens/Data/Mappers/NetworkCallDTO+extension.swift

@@ -0,0 +1,40 @@
+//
+//  NetworkCall.swift
+//  NetLens
+//
+//  Created by NetLens on 09/07/2025.
+//
+import Foundation
+
+extension NetworkCallDTO {
+    func toDomain() -> NetworkCall? {
+        guard let url = URL(string: self.url) else {
+            return nil
+        }
+
+        let httpMethod = HTTPMethod(rawValue: self.method) ?? .GET
+
+        let duration: Duration? = {
+            guard let timeInterval = self.duration else { return nil }
+            return Duration.seconds(timeInterval)
+        }()
+
+        let networkError: NetworkError? = {
+            guard let errorString = self.error else { return nil }
+            return .networkFailure(errorString)
+        }()
+
+        return NetworkCall(
+            url: url,
+            method: httpMethod,
+            headers: headers,
+            requestBody: requestBody,
+            responseBody: responseBody,
+            statusCode: statusCode,
+            timeStamp: timeStamp,
+            duration: duration,
+            error: networkError
+        )
+    }
+}
+

Sources/NetLens/Data/Mappers/NetworkRequestDTO+extension.swift

@@ -9,17 +9,22 @@ import Foundation
 
 struct NetworkCallDTO: Sendable {
 
-    let id: UUID
+    let timeStamp: Date
 
-    let request: NetworkRequestDTO
+    let url: String
 
-    let response: NetworkResponseDTO?
+    let method: String
 
-    let error: String?
+    let headers: [String: String]
+
+    let requestBody: Data?
 
-    let timestamp: Date
+    let responseBody: Data?
 
-    let duration: TimeInterval
+    let statusCode: Int?
 
+    let duration: TimeInterval?
+
+    let error: String?
 }
 

Sources/NetLens/Data/Mappers/NetworkResponseDTO+extension.swift

@@ -1,5 +1,5 @@
 //
-//  NetworkCall.swift
+//  NetLensURLProtocol.swift
 //  NetLens
 //
 //  Created by NetLens on 08/07/2025.
@@ -8,11 +8,17 @@
 import Foundation
 
 class NetLensURLProtocol: URLProtocol {
+
     @MainActor
     static weak var interceptor: URLProtocolNetworkInterceptor?
 
-    override class func canInit(with request: URLRequest) -> Bool {
+    private var networkCallDTO: NetworkCallDTO?
+
+    private var dataTask: URLSessionDataTask?
 
+    private var startTime: Date?
+
+    override class func canInit(with request: URLRequest) -> Bool {
         URLProtocol.property(
             forKey: "NetLensProcessed",
             in: request
@@ -24,18 +30,76 @@ class NetLensURLProtocol: URLProtocol {
     }
 
     override func startLoading() {
-
-        let mutableRequest = NSMutableURLRequest(url: self.request.url!)
+        let mutableRequest = (self.request as NSURLRequest).mutableCopy() as! NSMutableURLRequest
 
         URLProtocol.setProperty(
             true,
             forKey: "NetLensProcessed",
             in: mutableRequest
         )
 
-    }
+        let startTime = Date()
 
-    override func stopLoading() {}
+        self.networkCallDTO = NetworkCallDTO(
+            timeStamp: startTime,
+            url: request.url?.absoluteString ?? "",
+            method: request.httpMethod ?? "GET",
+            headers: request.allHTTPHeaderFields ?? [:],
+            requestBody: request.httpBody,
+            responseBody: nil,
+            statusCode: nil,
+            duration: nil,
+            error: nil
+        )
 
-}
+        let session = URLSession(configuration: .default)
+
+        dataTask = session.dataTask(with: mutableRequest as URLRequest) { [weak self] data, response, error in
+            guard let self else { return }
 
+            let endTime = Date()
+
+            let duration = self.startTime.map { endTime.timeIntervalSince($0) }
+
+            self.networkCallDTO = NetworkCallDTO(
+                timeStamp: self.networkCallDTO?.timeStamp ?? startTime,
+                url: self.request.url?.absoluteString ?? "",
+                method: self.request.httpMethod ?? "GET",
+                headers: self.request.allHTTPHeaderFields ?? [:],
+                requestBody: self.request.httpBody,
+                responseBody: data,
+                statusCode: (response as? HTTPURLResponse)?.statusCode,
+                duration: duration,
+                error: error?.localizedDescription
+            )
+
+            if let networkCallDTO = self.networkCallDTO,
+               let networkCall = networkCallDTO.toDomain()
+            {
+                Task { @MainActor in
+                    await Self.interceptor?.onNetworkCallIntercepted?(networkCall)
+                }
+            }
+
+            // Gérer la réponse pour le client
+            if let error = error {
+                self.client?.urlProtocol(self, didFailWithError: error)
+            } else {
+                if let response = response {
+                    self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+                }
+                if let data = data {
+                    self.client?.urlProtocol(self, didLoad: data)
+                }
+                self.client?.urlProtocolDidFinishLoading(self)
+            }
+        }
+
+        dataTask?.resume()
+    }
+
+    override func stopLoading() {
+        dataTask?.cancel()
+        dataTask = nil
+    }
+}

Sources/NetLens/Data/Models/NetworkCallDTO.swift

@@ -42,7 +42,7 @@ actor URLProtocolNetworkInterceptor: @preconcurrency NetworkInterceptor {
         _isEnabled
     }
 
-    var onNetworkCallIntercepted: ((NetworkCall) async -> Void)?
+    var onNetworkCallIntercepted: (@Sendable(NetworkCall) async -> Void)?
 
 
 }

Sources/NetLens/Data/Models/NetworkRequestDTO.swift

@@ -99,3 +99,16 @@ extension NetworkCall {
     }
 }
 
+struct NetworkRequest: Sendable {
+    let url: String
+    let method: String
+    let headers: [String: String]
+    let body: Data?
+}
+
+struct NetworkResponse: Sendable {
+    let statusCode: Int
+    let headers: [String: String]
+    let body: Data?
+}
+

Sources/NetLens/Data/Models/NetworkResponseDTO.swift

@@ -8,22 +8,11 @@
 import Foundation
 
 @frozen
-public struct NetworkError: Error, Sendable {
-    public let code: Int
-
-    public let message: String
-
-    public let underlyingError: String?
-    
-    public init(
-        code: Int,
-        message: String,
-        underlyingError: Error? = nil
-    ) {
-        self.code = code
-
-        self.message = message
-
-        self.underlyingError = underlyingError?.localizedDescription
-    }
+public enum NetworkError: Error, Sendable {
+    case invalidURL
+    case noResponse
+    case networkFailure(String)
+    case decodingError
+    case timeout
+    case unknown
 }