Unify Configuration Management

Package.swift

@@ -18,8 +18,10 @@ let package = Package(
         .library(name: "UserScript", targets: ["UserScript"]),
         .library(name: "Crashes", targets: ["Crashes"]),
         .library(name: "ContentBlocking", targets: ["ContentBlocking"]),
+        .library(name: "PrivacyDashboard", targets: ["PrivacyDashboard"]),
+        .library(name: "Configuration", targets: ["Configuration"]),
+        .library(name: "API", targets: ["API"]),
         .library(name: "Navigation", targets: ["Navigation"]),
-        .library(name: "PrivacyDashboard", targets: ["PrivacyDashboard"])
     ],
     dependencies: [
         .package(name: "Autofill", url: "https://github.com/duckduckgo/duckduckgo-autofill.git", .exact("6.3.0")),
@@ -76,7 +78,7 @@ let package = Package(
             name: "BloomFilter",
             resources: [
                 .process("CMakeLists.txt")
-            ]),    
+            ]),
         .target(
             name: "Crashes"
         ),
@@ -111,7 +113,7 @@ let package = Package(
             ]),
         .target(
             name: "UserScript"
-            ),
+        ),
         .target(
             name: "PrivacyDashboard",
             dependencies: [
@@ -122,7 +124,24 @@ let package = Package(
                 .product(name: "PrivacyDashboardResources", package: "privacy-dashboard")
             ],
             path: "Sources/PrivacyDashboard"
-            ),
+        ),
+        .target(
+            name: "Configuration",
+            dependencies: [
+                "API",
+                "BrowserServicesKit",
+                "Common"
+            ]),
+        .target(
+            name: "API",
+            dependencies: [
+                "Common"
+            ]),
+        .target(
+            name: "TestUtils",
+            dependencies: [
+                "API"
+            ]),
 
         // MARK: - Test targets
         .testTarget(
@@ -139,6 +158,11 @@ let package = Package(
             dependencies: [
                 "Common"
             ]),
+        .testTarget(
+            name: "APITests",
+            dependencies: [
+                "TestUtils"
+            ]),
         .testTarget(
             name: "NavigationTests",
             dependencies: [
@@ -160,7 +184,15 @@ let package = Package(
         .testTarget(
             name: "PersistenceTests",
             dependencies: [
-                "Persistence"
+                "Persistence",
+                "TrackerRadarKit"
+            ]
+        ),
+        .testTarget(
+            name: "ConfigurationTests",
+            dependencies: [
+                "Configuration",
+                "TestUtils"
             ]
         )
     ],

Sources/API/APIHeaders.swift

@@ -0,0 +1,60 @@
+//
+//  APIHeaders.swift
+//  DuckDuckGo
+//
+//  Copyright © 2023 DuckDuckGo. All rights reserved.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+import Foundation
+
+public typealias HTTPHeaders = [String: String]
+
+public struct APIHeaders {
+
+    public typealias UserAgent = String
+    private static var userAgent: UserAgent?
+    public static func setUserAgent(_ userAgent: UserAgent) {
+        self.userAgent = userAgent
+    }
+
+    public init() { }
+
+    public var defaultHeaders: HTTPHeaders {
+        guard let userAgent = APIHeaders.userAgent else {
+            fatalError("Please set the userAgent before accessing defaultHeaders.")
+        }
+
+        let acceptEncoding = "gzip;q=1.0, compress;q=0.5"
+        let languages = Locale.preferredLanguages.prefix(6)
+        let acceptLanguage = languages.enumerated().map { index, language in
+            let q = 1.0 - (Double(index) * 0.1)
+            return "\(language);q=\(q)"
+        }.joined(separator: ", ")
+
+        return [
+            HTTPHeaderField.acceptEncoding: acceptEncoding,
+            HTTPHeaderField.acceptLanguage: acceptLanguage,
+            HTTPHeaderField.userAgent: userAgent
+        ]
+    }
+
+    public func defaultHeaders(with etag: String?) -> HTTPHeaders {
+        guard let etag = etag else {
+            return defaultHeaders
+        }
+        return defaultHeaders.merging([HTTPHeaderField.ifNoneMatch: etag]) { (_, new) in new }
+    }
+
+}

Sources/API/APIRequest.swift

@@ -0,0 +1,99 @@
+//
+//  APIRequest.swift
+//  DuckDuckGo
+//
+//  Copyright © 2023 DuckDuckGo. All rights reserved.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+import Foundation
+
+public typealias APIResponse = (data: Data?, response: HTTPURLResponse)
+public typealias APIRequestCompletion = (APIResponse?, APIRequest.Error?) -> Void
+
+public struct APIRequest {
+
+    private let request: URLRequest
+    private let urlSession: URLSession
+    private let requirements: APIResponseRequirements
+
+    public init<QueryParams: Collection>(configuration: APIRequest.Configuration<QueryParams>,
+                                         requirements: APIResponseRequirements = [],
+                                         urlSession: URLSession = .shared) {
+        self.request = configuration.request
+        self.requirements = requirements
+        self.urlSession = urlSession
+    }
+
+    @available(*, deprecated, message: "This method is deprecated. Please use the 'fetch()' async method instead.")
+    @discardableResult
+    public func fetch(completion: @escaping APIRequestCompletion) -> URLSessionDataTask {
+        let task = urlSession.dataTask(with: request) { (data, response, error) in
+            if let error = error {
+                completion(nil, .urlSession(error))
+            } else {
+                do {
+                    let response = try self.validateAndUnwrap(data: data, response: response)
+                    completion(response, nil)
+                } catch {
+                    completion(nil, error as? APIRequest.Error ?? .urlSession(error))
+                }
+            }
+        }
+        task.resume()
+        return task
+    }
+
+    private func validateAndUnwrap(data: Data?, response: URLResponse?) throws -> APIResponse {
+        let httpResponse = try getHTTPResponse(from: response)
+
+        var data = data
+        if requirements.contains(.allow304), httpResponse.statusCode == HTTPURLResponse.Constants.notModifiedStatusCode {
+            data = nil // Avoid returning empty data
+        } else {
+            try httpResponse.assertSuccessfulStatusCode()
+            let data = data ?? Data()
+            if requirements.contains(.nonEmptyData), data.isEmpty {
+                throw APIRequest.Error.emptyData
+            }
+        }
+
+        if requirements.contains(.etag), httpResponse.etag == nil {
+            throw APIRequest.Error.missingEtagInResponse
+        }
+
+        return (data, httpResponse)
+    }
+
+    private func getHTTPResponse(from response: URLResponse?) throws -> HTTPURLResponse {
+        guard let httpResponse = response?.asHTTPURLResponse else {
+            throw APIRequest.Error.invalidResponse
+        }
+        return httpResponse
+    }
+
+    public func fetch() async throws -> APIResponse {
+        let (data, response) = try await fetch(for: request)
+        return try validateAndUnwrap(data: data, response: response)
+    }
+
+    private func fetch(for request: URLRequest) async throws -> (Data, URLResponse) {
+        do {
+            return try await urlSession.data(for: request)
+        } catch let error {
+            throw Error.urlSession(error)
+        }
+    }
+
+}

Sources/API/APIRequestConfiguration.swift

@@ -0,0 +1,70 @@
+//
+//  APIRequestConfiguration.swift
+//  DuckDuckGo
+//
+//  Copyright © 2023 DuckDuckGo. All rights reserved.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+import Foundation
+import Common
+
+extension APIRequest {
+
+    public struct Configuration<QueryParams: Collection> where QueryParams.Element == (key: String, value: String) {
+
+        let url: URL
+        let method: HTTPMethod
+        let queryParameters: QueryParams
+        let allowedQueryReservedCharacters: CharacterSet?
+        let headers: HTTPHeaders
+        let body: Data?
+        let timeoutInterval: TimeInterval
+        let attribution: URLRequestAttribution?
+
+        public init(url: URL,
+                    method: HTTPMethod = .get,
+                    queryParameters: QueryParams = [],
+                    allowedQueryReservedCharacters: CharacterSet? = nil,
+                    headers: HTTPHeaders = APIHeaders().defaultHeaders,
+                    body: Data? = nil,
+                    timeoutInterval: TimeInterval = 60.0,
+                    attribution: URLRequestAttribution? = nil) {
+            self.url = url
+            self.method = method
+            self.queryParameters = queryParameters
+            self.allowedQueryReservedCharacters = allowedQueryReservedCharacters
+            self.headers = headers
+            self.body = body
+            self.timeoutInterval = timeoutInterval
+            self.attribution = attribution
+        }
+
+        var request: URLRequest {
+            let url = url.appendingParameters(queryParameters, allowedReservedCharacters: allowedQueryReservedCharacters)
+            var request = URLRequest(url: url, timeoutInterval: timeoutInterval)
+            request.allHTTPHeaderFields = headers
+            request.httpMethod = method.rawValue
+            request.httpBody = body
+            if #available(iOS 15.0, macOS 12.0, *) {
+                if let attribution = attribution?.urlRequestAttribution {
+                    request.attribution = attribution
+                }
+            }
+            return request
+        }
+
+    }
+
+}

Sources/API/APIRequestError.swift

@@ -0,0 +1,48 @@
+//
+//  APIRequestError.swift
+//  DuckDuckGo
+//
+//  Copyright © 2023 DuckDuckGo. All rights reserved.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+import Foundation
+
+extension APIRequest {
+
+    public enum Error: Swift.Error, LocalizedError {
+
+        case urlSession(Swift.Error)
+        case invalidResponse
+        case missingEtagInResponse
+        case emptyData
+        case invalidStatusCode(Int)
+
+        public var errorDescription: String? {
+            switch self {
+            case .urlSession(let error):
+                return "URL session error: \(error.localizedDescription)"
+            case .invalidResponse:
+                return "Invalid response received."
+            case .missingEtagInResponse:
+                return "ETag header missing in response."
+            case .emptyData:
+                return "Empty data received in response."
+            case .invalidStatusCode(let statusCode):
+                return "Invalid status code received in response (\(statusCode))."
+            }
+        }
+    }
+
+}