@tinkerlandai/indiana-react-native 0.9.2 → 0.9.5

package/native-sdk/ios/HTTPTransport.swift

@@ -0,0 +1,74 @@
+import Foundation
+
+public struct IndianaConfiguration: Sendable {
+    public let baseURL: URL
+    internal var apiOrigin: String {
+        var parts = URLComponents(url: baseURL, resolvingAgainstBaseURL: true)!
+        parts.path = ""; parts.query = nil; parts.fragment = nil
+        parts.host = parts.host?.lowercased(); if parts.port == 443 { parts.port = nil }
+        return parts.string!
+    }
+    public let scope: IndianaScope
+    public let timeout: TimeInterval
+    /// Override baseURL explicitly for test services; Sandbox is a business scope, not a deployment selector.
+    public init(baseURL: URL = URL(string: "https://api.tinker.cash")!, scope: IndianaScope, timeout: TimeInterval = 15) throws {
+        guard baseURL.scheme == "https", baseURL.host != nil, baseURL.user == nil, baseURL.password == nil,
+              baseURL.query == nil, baseURL.fragment == nil, timeout > 0, timeout <= 120 else { throw IndianaClientError.invalidConfiguration }
+        self.baseURL = baseURL; self.scope = scope; self.timeout = timeout
+    }
+}
+protocol IndianaHTTP: Sendable {
+    func send(path: String, method: String, authorization: String, body: Data?) async throws -> Data
+}
+final class IndianaURLTransport: IndianaHTTP, Sendable {
+    static func requireCurrentProtocol(_ value: String?) throws {
+        guard value == IndianaProtocol.wireProtocol else { throw IndianaClientError.invalidResponse }
+    }
+    private let configuration: IndianaConfiguration
+    private let requestOrigin: URL
+    private let session: URLSession
+    // Internal test seam: the public configuration remains HTTPS-only. A wire fixture
+    // may use only a loopback HTTP origin; no public SDK caller can select it.
+    init(configuration: IndianaConfiguration, sessionConfiguration: URLSessionConfiguration = .ephemeral, loopbackFixtureOrigin: URL? = nil) {
+        self.configuration = configuration
+        if let origin = loopbackFixtureOrigin {
+            precondition(origin.scheme == "http" && origin.host == "127.0.0.1" && (origin.port ?? 0) > 1024 && origin.user == nil && origin.password == nil && origin.query == nil && origin.fragment == nil && origin.path.isEmpty)
+        }
+        self.requestOrigin = loopbackFixtureOrigin ?? configuration.baseURL
+        let config = sessionConfiguration.copy() as! URLSessionConfiguration
+        config.urlCache = nil; config.httpCookieStorage = nil; config.httpShouldSetCookies = false; config.urlCredentialStorage = nil; config.requestCachePolicy = .reloadIgnoringLocalCacheData
+        let ownedHeaders = Set(["authorization", "cookie", "x-indiana-project", "x-indiana-environment", "x-indiana-protocol", "x-indiana-sdk-version"])
+        config.httpAdditionalHeaders = config.httpAdditionalHeaders?.filter { !ownedHeaders.contains(String(describing: $0.key).lowercased()) }
+        config.timeoutIntervalForRequest = configuration.timeout; config.timeoutIntervalForResource = configuration.timeout
+        self.session = URLSession(configuration: config, delegate: NoRedirect(), delegateQueue: nil)
+    }
+    func send(path: String, method: String, authorization: String, body: Data?) async throws -> Data {
+        guard !path.contains(".."), !path.contains("?"), !path.contains("#"), !path.hasPrefix("/") else { throw IndianaClientError.invalidConfiguration }
+        var request = URLRequest(url: requestOrigin.appendingPathComponent("api/v1").appendingPathComponent(path))
+        request.httpMethod = method; request.httpBody = body
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        if !authorization.isEmpty { request.setValue("Bearer \(authorization)", forHTTPHeaderField: "Authorization") }
+        request.setValue(configuration.scope.projectId.uuidString.lowercased(), forHTTPHeaderField: "X-Indiana-Project")
+        request.setValue(configuration.scope.environment.rawValue, forHTTPHeaderField: "X-Indiana-Environment")
+        request.setValue(IndianaProtocol.wireProtocol, forHTTPHeaderField: "X-Indiana-Protocol")
+        request.setValue(IndianaSDK.version, forHTTPHeaderField: "X-Indiana-SDK-Version")
+        do {
+            let (bytes, response) = try await session.bytes(for: request)
+            guard let http = response as? HTTPURLResponse, (200..<300).contains(http.statusCode) else {
+                throw IndianaClientError.requestFailed((response as? HTTPURLResponse)?.statusCode ?? 0)
+            }
+            try Self.requireCurrentProtocol(http.value(forHTTPHeaderField: "X-Indiana-Protocol"))
+            if response.expectedContentLength > 2_097_152 { throw IndianaClientError.invalidResponse }
+            var data = Data()
+            for try await byte in bytes {
+                guard data.count < 2_097_152 else { throw IndianaClientError.invalidResponse }
+                data.append(byte)
+            }
+            return data
+        } catch let error as IndianaClientError { throw error }
+        catch { throw IndianaClientError.temporaryUnavailable }
+    }
+    private final class NoRedirect: NSObject, URLSessionTaskDelegate, Sendable {
+        func urlSession(_ session: URLSession, task: URLSessionTask, willPerformHTTPRedirection response: HTTPURLResponse, newRequest request: URLRequest, completionHandler: @escaping (URLRequest?) -> Void) { completionHandler(nil) }
+    }
+}