samgilmore · samgilmore · Jul 24, 2024 · Jul 22, 2024 · Jul 23, 2024 · Jul 23, 2024
diff --git a/Sources/SwiftNetKit/BaseRequest.swift b/Sources/SwiftNetKit/BaseRequest.swift
diff --git a/Sources/SwiftNetKit/CookieManager.swift b/Sources/SwiftNetKit/CookieManager.swift
@@ -0,0 +1,133 @@
+//
+//  CookieManager.swift
+//
+//
+//  Created by Sam Gilmore on 7/22/24.
+//
+
+import Foundation
+
+public class CookieManager {
+    static let shared = CookieManager()
+
+    private static let userDefaultsKey = "SWIFTNETKIT_SAVED_COOKIES"
+    private let userDefaults = UserDefaults(suiteName: "SWIFTNETKIT_COOKIE_SUITE")
+
+    var syncCookiesWithUserDefaults: Bool = true
+
+    private init() {
+        cleanExpiredCookies()
+        syncCookies()
+    }
+
+    func includeCookiesIfNeeded(for urlRequest: inout URLRequest, includeCookies: Bool) {
+        if includeCookies {
+            CookieManager.shared.syncCookies()
+            let cookies = CookieManager.shared.getCookiesForURL(for: urlRequest.url!)
+            let cookieHeader = HTTPCookie.requestHeaderFields(with: cookies)
+
+            if let existingCookieHeader = urlRequest.allHTTPHeaderFields?[HTTPCookie.requestHeaderFields(with: []).keys.first ?? ""] {
+                let mergedCookies = (existingCookieHeader + "; " + (cookieHeader.values.first ?? "")).trimmingCharacters(in: .whitespacesAndNewlines)
+                urlRequest.allHTTPHeaderFields?[HTTPCookie.requestHeaderFields(with: []).keys.first ?? ""] = mergedCookies
+            } else {
+                urlRequest.allHTTPHeaderFields = urlRequest.allHTTPHeaderFields?.merging(cookieHeader) { (existing, new) in
+                    return existing + "; " + new
+                } ?? cookieHeader
+            }
+        }
+    }
+
+    func saveCookiesIfNeeded(from response: URLResponse?, saveResponseCookies: Bool) {
+        guard saveResponseCookies,
+              let httpResponse = response as? HTTPURLResponse,
+              let url = httpResponse.url else { return }
+
+        let setCookieHeaders = httpResponse.allHeaderFields.filter { $0.key as? String == "Set-Cookie" }
+
+        let cookies = HTTPCookie.cookies(withResponseHeaderFields: setCookieHeaders as! [String: String], for: url)
+
+        saveCookiesToSession(cookies)
+
+        if syncCookiesWithUserDefaults {
+            saveCookiesToUserDefaults(cookies)
+        }
+    }
+
+    func getCookiesForURL(for url: URL) -> [HTTPCookie] {
+        return HTTPCookieStorage.shared.cookies(for: url) ?? []
+    }
+
+    func syncCookies() {
+        if syncCookiesWithUserDefaults {
+            // Sync cookies from user defaults to session storage
+            loadCookiesFromUserDefaults()
+
+            // Sync cookies from session storage to user defaults
+            saveCookiesToUserDefaults(getAllCookiesFromSession())
+        }
+    }
+
+    func getAllCookiesFromSession() -> [HTTPCookie] {
+        return HTTPCookieStorage.shared.cookies ?? []
+    }
+
+    func saveCookiesToSession(_ cookies: [HTTPCookie]) {
+        for cookie in cookies {
+            HTTPCookieStorage.shared.setCookie(cookie)
+        }
+    }
+
+    func saveCookiesToUserDefaults(_ cookies: [HTTPCookie]) {
+        var cookieDataArray: [Data] = []
+        for cookie in cookies {
+            if let data = try? NSKeyedArchiver.archivedData(withRootObject: cookie.properties ?? [:], requiringSecureCoding: false) {
+                cookieDataArray.append(data)
+            }
+        }
+        userDefaults?.set(cookieDataArray, forKey: CookieManager.userDefaultsKey)
+    }
+
+    func loadCookiesFromUserDefaults() {
+        guard let cookieDataArray = userDefaults?.array(forKey: CookieManager.userDefaultsKey) as? [Data] else { return }
+
+        let allowedClasses: [AnyClass] = [NSDictionary.self, NSString.self, NSDate.self, NSNumber.self, NSURL.self]
+
+        for cookieData in cookieDataArray {
+            if let cookieProperties = try? NSKeyedUnarchiver.unarchivedObject(ofClasses: allowedClasses, from: cookieData) as? [HTTPCookiePropertyKey: Any],
+               let cookie = HTTPCookie(properties: cookieProperties) {
+                HTTPCookieStorage.shared.setCookie(cookie)
+            }
+        }
+    }
+
+    func deleteAllCookies() {
+        HTTPCookieStorage.shared.cookies?.forEach(HTTPCookieStorage.shared.deleteCookie)
+        if syncCookiesWithUserDefaults {
+            userDefaults?.removeObject(forKey: CookieManager.userDefaultsKey)
+        }
+    }
+
+    func deleteExpiredCookies() {
+        guard let cookieDataArray = userDefaults?.array(forKey: CookieManager.userDefaultsKey) as? [Data] else { return }
+        var validCookieDataArray: [Data] = []
+
+        let allowedClasses: [AnyClass] = [NSDictionary.self, NSString.self, NSDate.self, NSNumber.self, NSURL.self]
+
+        for cookieData in cookieDataArray {
+            if let cookieProperties = try? NSKeyedUnarchiver.unarchivedObject(ofClasses: allowedClasses, from: cookieData) as? [HTTPCookiePropertyKey: Any],
+               let cookie = HTTPCookie(properties: cookieProperties),
+               cookie.expiresDate ?? Date.distantFuture > Date() {
+                validCookieDataArray.append(cookieData)
+            }
+        }
+
+        userDefaults?.set(validCookieDataArray, forKey: CookieManager.userDefaultsKey)
+    }
+
+    func cleanExpiredCookies() {
+        deleteExpiredCookies()
+        if syncCookiesWithUserDefaults {
+            loadCookiesFromUserDefaults()
+        }
+    }
+}
diff --git a/Sources/SwiftNetKit/Models/MethodType.swift b/Sources/SwiftNetKit/Models/MethodType.swift
@@ -5,7 +5,7 @@
 //  Created by Sam Gilmore on 7/17/24.
 //
 
-enum MethodType: String {
+public enum MethodType: String {
     case get = "GET"
     case post = "POST"
     case delete = "DELETE"

diff --git a/Sources/SwiftNetKit/NetworkService.swift b/Sources/SwiftNetKit/NetworkService.swift
@@ -28,10 +28,14 @@ public struct NetworkService: NetworkServiceProtocol {
             sessionConfiguration.timeoutIntervalForResource = timeoutInterval
         }
 
+        // Handle cookie management manually
+        sessionConfiguration.httpShouldSetCookies = false
+        sessionConfiguration.httpCookieAcceptPolicy = .never
+
         self.session = URLSession(configuration: sessionConfiguration)
     }
 
-    private func configureCache(for urlRequest: inout URLRequest, using request: any RequestProtocol) {
+    private func configureCache<T>(for urlRequest: inout URLRequest, with request: Request<T>) {
         if let cacheConfig = request.cacheConfiguration {
             let cache = URLCache(
                 memoryCapacity: cacheConfig.memoryCapacity,
@@ -53,13 +57,16 @@ public struct NetworkService: NetworkServiceProtocol {
         }
     }
 
-    func start<Request: RequestProtocol>(
-        _ request: Request,
+    func start<T>(
+        _ request: Request<T>,
         retries: Int = 0,
         retryInterval: TimeInterval = 1.0
-    ) async throws -> Request.ResponseType {
+    ) async throws -> T {
         var urlRequest = request.buildURLRequest()
-        self.configureCache(for: &urlRequest, using: request)
+
+        CookieManager.shared.includeCookiesIfNeeded(for: &urlRequest, includeCookies: request.includeCookies)
+
+        self.configureCache(for: &urlRequest, with: request)
 
         var currentAttempt = 0
         var lastError: Error?
@@ -68,6 +75,8 @@ public struct NetworkService: NetworkServiceProtocol {
             do {
                 let (data, response) = try await session.data(for: urlRequest)
 
+                CookieManager.shared.saveCookiesIfNeeded(from: response, saveResponseCookies: request.saveResponseCookies)
+
                 guard let httpResponse = response as? HTTPURLResponse else {
                     throw NetworkError.invalidResponse
                 }
@@ -77,7 +86,7 @@ public struct NetworkService: NetworkServiceProtocol {
                 }
 
                 do {
-                    let decodedObject = try JSONDecoder().decode(Request.ResponseType.self, from: data)
+                    let decodedObject = try JSONDecoder().decode(T.self, from: data)
                     return decodedObject
                 } catch {
                     throw NetworkError.decodingFailed
@@ -94,15 +103,18 @@ public struct NetworkService: NetworkServiceProtocol {
         throw NetworkError.requestFailed(error: lastError ?? NetworkError.unknown)
     }
 
-    func start<Request: RequestProtocol>(
-        _ request: Request,
+    func start<T>(
+        _ request: Request<T>,
         retries: Int = 0,
         retryInterval: TimeInterval = 1.0,
-        completion: @escaping (Result<Request.ResponseType, Error>) -> Void
+        completion: @escaping (Result<T, Error>) -> Void
     ) {
         var urlRequest = request.buildURLRequest()
-        self.configureCache(for: &urlRequest, using: request)
-
+
+        CookieManager.shared.includeCookiesIfNeeded(for: &urlRequest, includeCookies: request.includeCookies)
+
+        self.configureCache(for: &urlRequest, with: request)
+
         var currentAttempt = 0
 
         func attempt() {
@@ -119,6 +131,8 @@ public struct NetworkService: NetworkServiceProtocol {
                     return
                 }
 
+                CookieManager.shared.saveCookiesIfNeeded(from: response, saveResponseCookies: request.saveResponseCookies)
+
                 guard let httpResponse = response as? HTTPURLResponse else {
                     completion(.failure(NetworkError.invalidResponse))
                     return
@@ -131,7 +145,7 @@ public struct NetworkService: NetworkServiceProtocol {
 
                 if let data = data {
                     do {
-                        let decodedObject = try JSONDecoder().decode(Request.ResponseType.self, from: data)
+                        let decodedObject = try JSONDecoder().decode(T.self, from: data)
                         completion(.success(decodedObject))
                     } catch {
                         completion(.failure(NetworkError.decodingFailed))

diff --git a/Sources/SwiftNetKit/Protocols/NetworkServiceProtocol.swift b/Sources/SwiftNetKit/Protocols/NetworkServiceProtocol.swift
@@ -11,16 +11,17 @@ protocol NetworkServiceProtocol {
     var session: URLSession { get }
 
     // Async / Await
-    func start<Request: RequestProtocol>(
-        _ request: Request,
+    func start<T>(
+        _ request: Request<T>,
         retries: Int,
         retryInterval: TimeInterval
-    ) async throws -> Request.ResponseType
+    ) async throws -> T
 
     // Completion Closure
-    func start<Request: RequestProtocol>(
-        _ request: Request, retries: Int,
+    func start<T>(
+        _ request: Request<T>, 
+        retries: Int,
         retryInterval: TimeInterval,
-        completion: @escaping (Result<Request.ResponseType, Error>) -> Void
+        completion: @escaping (Result<T, Error>) -> Void
     )
 }
diff --git a/Sources/SwiftNetKit/Protocols/RequestProtocol.swift b/Sources/SwiftNetKit/Protocols/RequestProtocol.swift
@@ -7,53 +7,15 @@
 
 import Foundation
 
-protocol RequestProtocol {
-    associatedtype ResponseType: Decodable
-
+protocol RequestProtocol {    
     var url: URL { get }
     var method: MethodType { get }
     var parameters: [String: Any]? { get }
     var headers: [String: String]? { get }
     var body: RequestBody? { get }
     var cacheConfiguration: CacheConfiguration? { get }
+    var includeCookies: Bool { get }
+    var saveResponseCookies: Bool { get }
 
     func buildURLRequest() -> URLRequest
 }
-
-extension RequestProtocol {
-    func buildURLRequest() -> URLRequest {
-        var urlRequest = URLRequest(url: self.url)
-
-        urlRequest.cachePolicy = self.cacheConfiguration?.cachePolicy ?? .useProtocolCachePolicy
-
-        if let parameters = self.parameters {
-            let queryItems = parameters.map { key, value in
-                URLQueryItem(name: key, value: "\(value)")
-            }
-            var urlComponents = URLComponents(url: self.url, resolvingAgainstBaseURL: false)
-            urlComponents?.queryItems = queryItems
-            urlRequest.url = urlComponents?.url
-        }
-
-        urlRequest.httpMethod = self.method.rawValue
-        urlRequest.allHTTPHeaderFields = self.headers
-
-        if let body = self.body {
-            switch body {
-            case .data(let data):
-                urlRequest.httpBody = data
-            case .string(let string):
-                urlRequest.httpBody = string.data(using: .utf8)
-            case .jsonEncodable(let encodable):
-                let jsonData = try? JSONEncoder().encode(encodable)
-                urlRequest.httpBody = jsonData
-
-                if headers?["Content-Type"] == nil {
-                    urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
-                }
-            }
-        }
-
-        return urlRequest
-    }
-}