apple_kit

Apple-native services for Radroots iOS and macOS apps
git clone https://radroots.dev/git/apple_kit.git
Log | Files | Refs | README | LICENSE

RadrootsBackgroundTransferRequest.swift (5269B)


      1 import Foundation
      2 
      3 public struct RadrootsBackgroundTransferRequest: Sendable, Equatable, Hashable, Codable,
      4     CustomDebugStringConvertible {
      5     public static let defaultMaximumTransferBytes: UInt64 = 64 * 1024 * 1024
      6     public static let absoluteMaximumTransferBytes: UInt64 = 512 * 1024 * 1024
      7 
      8     public let identifier: RadrootsBackgroundTransferIdentifier
      9     public let remoteURL: URL
     10     public let method: RadrootsBackgroundTransferMethod
     11     public let operation: RadrootsBackgroundTransferOperation
     12     public let headers: [String: String]
     13     public let metadata: [String: String]
     14     public let networkPolicy: RadrootsBackgroundTransferNetworkPolicy
     15     public let responsePolicy: RadrootsBackgroundTransferResponsePolicy
     16     public let expectedSourceSHA256: String?
     17     public let maximumTransferBytes: UInt64
     18 
     19     public init(
     20         identifier: RadrootsBackgroundTransferIdentifier = .generated(), remoteURL: URL,
     21         method: RadrootsBackgroundTransferMethod,
     22         operation: RadrootsBackgroundTransferOperation, headers: [String: String] = [:],
     23         metadata: [String: String] = [:],
     24         networkPolicy: RadrootsBackgroundTransferNetworkPolicy = .publicHTTPS,
     25         responsePolicy: RadrootsBackgroundTransferResponsePolicy = .discard,
     26         expectedSourceSHA256: String? = nil,
     27         maximumTransferBytes: UInt64 = Self.defaultMaximumTransferBytes
     28     ) throws {
     29         try RadrootsBackgroundTransferValidation.validate(
     30             remoteURL: remoteURL, method: method, operation: operation, headers: headers,
     31             metadata: metadata, networkPolicy: networkPolicy,
     32             responsePolicy: responsePolicy, expectedSourceSHA256: expectedSourceSHA256,
     33             maximumTransferBytes: maximumTransferBytes
     34         )
     35         self.identifier = identifier
     36         self.remoteURL = remoteURL
     37         self.method = method
     38         self.operation = operation
     39         self.headers = headers
     40         self.metadata = metadata
     41         self.networkPolicy = networkPolicy
     42         self.responsePolicy = responsePolicy
     43         self.expectedSourceSHA256 = expectedSourceSHA256
     44         self.maximumTransferBytes = maximumTransferBytes
     45     }
     46 
     47     public var debugDescription: String {
     48         "RadrootsBackgroundTransferRequest(identifier: \(identifier.rawValue), method: \(method.rawValue), "
     49             + "operation: \(operation.redactedLabel), headers: <redacted>, metadata: <redacted>, "
     50             + "maximumTransferBytes: \(maximumTransferBytes), responseBodyLimit: \(responsePolicy.maximumBodyBytes))"
     51     }
     52 
     53     func redactedForPersistence() throws -> Self {
     54         try Self(
     55             identifier: identifier, remoteURL: remoteURL, method: method, operation: operation,
     56             headers: [:], metadata: [:],
     57             networkPolicy: networkPolicy, responsePolicy: responsePolicy,
     58             expectedSourceSHA256: expectedSourceSHA256,
     59             maximumTransferBytes: maximumTransferBytes
     60         )
     61     }
     62 
     63     private enum CodingKeys: String, CodingKey {
     64         case identifier
     65         case remoteURL
     66         case method
     67         case operation
     68         case metadata
     69         case networkPolicy
     70         case responsePolicy
     71         case expectedSourceSHA256
     72         case maximumTransferBytes
     73     }
     74 
     75     public init(from decoder: any Decoder) throws {
     76         let values = try decoder.container(keyedBy: CodingKeys.self)
     77         try self.init(
     78             identifier: values.decode(RadrootsBackgroundTransferIdentifier.self, forKey: .identifier),
     79             remoteURL: values.decode(URL.self, forKey: .remoteURL),
     80             method: values.decode(RadrootsBackgroundTransferMethod.self, forKey: .method),
     81             operation: values.decode(RadrootsBackgroundTransferOperation.self, forKey: .operation),
     82             headers: [:],
     83             metadata: values.decode([String: String].self, forKey: .metadata),
     84             networkPolicy: values.decodeIfPresent(
     85                 RadrootsBackgroundTransferNetworkPolicy.self, forKey: .networkPolicy
     86             ) ?? .publicHTTPS,
     87             responsePolicy: values.decodeIfPresent(
     88                 RadrootsBackgroundTransferResponsePolicy.self, forKey: .responsePolicy
     89             ) ?? .discard,
     90             expectedSourceSHA256: values.decodeIfPresent(String.self, forKey: .expectedSourceSHA256),
     91             maximumTransferBytes: values.decodeIfPresent(UInt64.self, forKey: .maximumTransferBytes)
     92                 ?? Self.defaultMaximumTransferBytes
     93         )
     94     }
     95 
     96     public func encode(to encoder: any Encoder) throws {
     97         var values = encoder.container(keyedBy: CodingKeys.self)
     98         try values.encode(identifier, forKey: .identifier)
     99         try values.encode(remoteURL, forKey: .remoteURL)
    100         try values.encode(method, forKey: .method)
    101         try values.encode(operation, forKey: .operation)
    102         // Headers and host metadata are transient, including direct Codable exports.
    103         try values.encode([String: String](), forKey: .metadata)
    104         try values.encode(networkPolicy, forKey: .networkPolicy)
    105         try values.encode(responsePolicy, forKey: .responsePolicy)
    106         try values.encodeIfPresent(expectedSourceSHA256, forKey: .expectedSourceSHA256)
    107         try values.encode(maximumTransferBytes, forKey: .maximumTransferBytes)
    108     }
    109 }