react-native-nitro-fetch 0.1.7 → 0.2.1

package/ios/HybridUrlRequestBuilder.swift

@@ -0,0 +1,255 @@
+import Foundation
+import NitroModules
+
+class HybridUrlRequestBuilder: HybridUrlRequestBuilderSpec {
+  private let url: String
+  private let session: URLSession
+  private let executor: DispatchQueue
+
+  // Callbacks stored as optionals and set via setter methods
+  private var onRedirectReceivedCallback: ((_ info: UrlResponseInfo, _ newLocationUrl: String) -> Void)?
+  private var onResponseStartedCallback: ((_ info: UrlResponseInfo) -> Void)?
+  private var onReadCompletedCallback: ((_ info: UrlResponseInfo, _ byteBuffer: ArrayBuffer, _ bytesRead: Double) -> Void)?
+  private var onSucceededCallback: ((_ info: UrlResponseInfo) -> Void)?
+  private var onFailedCallback: ((_ info: UrlResponseInfo?, _ error: RequestException) -> Void)?
+  private var onCanceledCallback: ((_ info: UrlResponseInfo?) -> Void)?
+
+  private var urlRequest: URLRequest
+  private var priority: Float = 0.5
+
+  init(
+    url: String,
+    session: URLSession,
+    executor: DispatchQueue
+  ) {
+    self.url = url
+    self.session = session
+    self.executor = executor
+
+    guard let urlObj = URL(string: url) else {
+      fatalError("Invalid URL: \(url)")
+    }
+    self.urlRequest = URLRequest(url: urlObj)
+  }
+
+  // MARK: - Callback Setters
+  // Each setter takes only 1 callback to avoid Swift compiler bug (crashes with 4+ callbacks)
+
+  func onSucceeded(callback: @escaping (_ info: UrlResponseInfo) -> Void) {
+    self.onSucceededCallback = callback
+  }
+
+  func onFailed(callback: @escaping (_ info: UrlResponseInfo?, _ error: RequestException) -> Void) {
+    self.onFailedCallback = callback
+  }
+
+  func onCanceled(callback: @escaping (_ info: UrlResponseInfo?) -> Void) {
+    self.onCanceledCallback = callback
+  }
+
+  func onRedirectReceived(callback: @escaping (_ info: UrlResponseInfo, _ newLocationUrl: String) -> Void) {
+    self.onRedirectReceivedCallback = callback
+  }
+
+  func onResponseStarted(callback: @escaping (_ info: UrlResponseInfo) -> Void) {
+    self.onResponseStartedCallback = callback
+  }
+
+  func onReadCompleted(callback: @escaping (_ info: UrlResponseInfo, _ byteBuffer: ArrayBuffer, _ bytesRead: Double) -> Void) {
+    self.onReadCompletedCallback = callback
+  }
+
+  func setHttpMethod(httpMethod: String) throws {
+    self.urlRequest.httpMethod = httpMethod
+  }
+
+  func addHeader(name: String, value: String) throws {
+    self.urlRequest.addValue(value, forHTTPHeaderField: name)
+  }
+
+  func setUploadBody(body: Variant_ArrayBuffer_String) throws {
+    switch body {
+    case .first(let arrayBuffer):
+      self.urlRequest.httpBody = arrayBuffer.toData(copyIfNeeded: true)
+    case .second(let string):
+      self.urlRequest.httpBody = string.data(using: .utf8)
+    }
+  }
+
+  func disableCache() throws {
+    self.urlRequest.cachePolicy = .reloadIgnoringLocalAndRemoteCacheData
+  }
+
+  func build() throws -> any HybridUrlRequestSpec {
+    let delegate = URLSessionDelegateAdapter(
+      onRedirectReceived: onRedirectReceivedCallback,
+      onResponseStarted: onResponseStartedCallback,
+      onReadCompleted: onReadCompletedCallback,
+      onSucceeded: onSucceededCallback,
+      onFailed: onFailedCallback,
+      onCanceled: onCanceledCallback,
+      executor: executor,
+      hybridRequest: nil
+    )
+
+    let config = URLSessionConfiguration.default
+    config.urlCache = session.configuration.urlCache
+    config.requestCachePolicy = urlRequest.cachePolicy
+
+    let delegateSession = URLSession(
+      configuration: config,
+      delegate: delegate,
+      delegateQueue: nil
+    )
+
+    let task: URLSessionDataTask = delegateSession.dataTask(with: urlRequest)
+
+    task.priority = priority
+    delegate.task = task
+
+    let request = HybridUrlRequest(task: task, delegate: delegate)
+    delegate.hybridRequest = request
+
+    return request
+  }
+}
+
+// MARK: - URLSession Delegate Adapter
+
+private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSessionTaskDelegate {
+  let onRedirectReceived: ((_ info: UrlResponseInfo, _ newLocationUrl: String) -> Void)?
+  let onResponseStarted: ((_ info: UrlResponseInfo) -> Void)?
+  let onReadCompleted: ((_ info: UrlResponseInfo, _ byteBuffer: ArrayBuffer, _ bytesRead: Double) -> Void)?
+  let onSucceeded: ((_ info: UrlResponseInfo) -> Void)?
+  let onFailed: ((_ info: UrlResponseInfo?, _ error: RequestException) -> Void)?
+  let onCanceled: ((_ info: UrlResponseInfo?) -> Void)?
+
+  let executor: DispatchQueue
+  weak var task: URLSessionDataTask?
+  weak var hybridRequest: HybridUrlRequest?
+
+  private var response: HTTPURLResponse?
+
+  init(
+    onRedirectReceived: ((_ info: UrlResponseInfo, _ newLocationUrl: String) -> Void)?,
+    onResponseStarted: ((_ info: UrlResponseInfo) -> Void)?,
+    onReadCompleted: ((_ info: UrlResponseInfo, _ byteBuffer: ArrayBuffer, _ bytesRead: Double) -> Void)?,
+    onSucceeded: ((_ info: UrlResponseInfo) -> Void)?,
+    onFailed: ((_ info: UrlResponseInfo?, _ error: RequestException) -> Void)?,
+    onCanceled: ((_ info: UrlResponseInfo?) -> Void)?,
+    executor: DispatchQueue,
+    hybridRequest: HybridUrlRequest?
+  ) {
+    self.onRedirectReceived = onRedirectReceived
+    self.onResponseStarted = onResponseStarted
+    self.onReadCompleted = onReadCompleted
+    self.onSucceeded = onSucceeded
+    self.onFailed = onFailed
+    self.onCanceled = onCanceled
+    self.executor = executor
+    self.hybridRequest = hybridRequest
+    super.init()
+  }
+
+  func urlSession(
+    _ session: URLSession,
+    task: URLSessionTask,
+    willPerformHTTPRedirection response: HTTPURLResponse,
+    newRequest request: URLRequest,
+    completionHandler: @escaping (URLRequest?) -> Void
+  ) {
+    executor.sync { [weak self] in
+      guard let self = self else { return }
+      if let callback = self.onRedirectReceived {
+        let info = response.toNitro()
+        let newUrl = request.url?.absoluteString ?? ""
+        callback(info, newUrl)
+      }
+    }
+    completionHandler(request)
+  }
+
+  func urlSession(
+    _ session: URLSession,
+    task: URLSessionTask,
+    didCompleteWithError error: Error?
+  ) {
+    executor.sync { [weak self] in
+      guard let self = self else { return }
+      self.hybridRequest?.markDone()
+
+      if let error = error {
+        let nsError = error as NSError
+        if nsError.code == NSURLErrorCancelled {
+          if let callback = self.onCanceled {
+            let nitroInfo = self.response?.toNitro()
+            callback(nitroInfo)
+          }
+        } else {
+          if let callback = self.onFailed {
+            let nitroError = error.toNitro()
+            let nitroInfo = self.response?.toNitro()
+            callback(nitroInfo, nitroError)
+          }
+        }
+      } else if let response = self.response {
+        if let callback = self.onSucceeded {
+          let info = response.toNitro()
+          callback(info)
+        }
+      }
+    }
+  }
+
+  func urlSession(
+    _ session: URLSession,
+    dataTask: URLSessionDataTask,
+    didReceive response: URLResponse,
+    completionHandler: @escaping (URLSession.ResponseDisposition) -> Void
+  ) {
+    guard let httpResponse = response as? HTTPURLResponse else {
+      completionHandler(.cancel)
+      return
+    }
+
+    self.response = httpResponse
+
+    executor.sync { [weak self] in
+      guard let self = self else { return }
+      if let callback = self.onResponseStarted {
+        let info = httpResponse.toNitro()
+        callback(info)
+      }
+    }
+
+    completionHandler(.allow)
+  }
+
+  func urlSession(
+    _ session: URLSession,
+    dataTask: URLSessionDataTask,
+    didReceive data: Data
+  ) {
+    if let callback = self.onReadCompleted {
+      executor.sync { [weak self] in
+        guard let self = self, let response = self.response else { return }
+
+        let arrayBuffer: ArrayBuffer
+        do {
+          arrayBuffer = try ArrayBuffer.copy(data: data)
+        } catch {
+          if let failedCallback = self.onFailed {
+            let nitroError = error.toNitro()
+            let nitroInfo = response.toNitro()
+            failedCallback(nitroInfo, nitroError)
+          }
+          return
+        }
+
+        let info = response.toNitro()
+        let bytesRead = Double(data.count)
+        callback(info, arrayBuffer, bytesRead)
+      }
+    }
+  }
+}

package/ios/NitroAutoPrefetcher.swift

@@ -29,8 +29,10 @@ public final class NitroAutoPrefetcher: NSObject {
                              headers: headers,
                              bodyString: nil,
                              bodyBytes: nil,
+                             bodyFormData: nil,
                              timeoutMs: nil,
-                             followRedirects: true)
+                             followRedirects: true,
+                             requestId: nil)
       Task {
         do { try await NitroFetchClient.prefetchStatic(req) } catch { /* ignore – best effort */ }
       }

package/ios/NitroFetchClient.swift

@@ -2,6 +2,29 @@ import Foundation
 import NitroModules
 
 final class NitroFetchClient: HybridNitroFetchClientSpec {
+
+  private var _lock = os_unfair_lock()
+  private var activeTasks: [String: Task<Void, Never>] = [:]
+
+  private func storeTask(_ task: Task<Void, Never>, forKey key: String) {
+    os_unfair_lock_lock(&_lock)
+    activeTasks[key] = task
+    os_unfair_lock_unlock(&_lock)
+  }
+
+  private func removeTask(forKey key: String) {
+    os_unfair_lock_lock(&_lock)
+    activeTasks.removeValue(forKey: key)
+    os_unfair_lock_unlock(&_lock)
+  }
+
+  func cancelRequest(requestId: String) throws {
+    os_unfair_lock_lock(&_lock)
+    let task = activeTasks.removeValue(forKey: requestId)
+    os_unfair_lock_unlock(&_lock)
+    task?.cancel()
+  }
+
   func requestSync(req: NitroRequest) throws -> NitroResponse {
     let semaphore = DispatchSemaphore(value: 0)
     var result: Result<NitroResponse, Error>?
@@ -29,7 +52,14 @@ final class NitroFetchClient: HybridNitroFetchClientSpec {
   // Async version - returns Promise<NitroResponse>
   func request(req: NitroRequest) throws -> Promise<NitroResponse> {
     let promise = Promise<NitroResponse>.init()
-    Task {
+    let requestId = req.requestId
+
+    let task = Task { [weak self] in
+      defer {
+        if let rid = requestId {
+          self?.removeTask(forKey: rid)
+        }
+      }
       do {
         let response = try await NitroFetchClient.requestStatic(req)
         promise.resolve(withResult: response)
@@ -37,6 +67,10 @@ final class NitroFetchClient: HybridNitroFetchClientSpec {
         promise.reject(withError: error)
       }
     }
+
+    if let rid = requestId {
+      storeTask(task, forKey: rid)
+    }
     return promise
   }
   
@@ -119,7 +153,7 @@ final class NitroFetchClient: HybridNitroFetchClientSpec {
       }
     }
 
-    let (urlRequest, finalURL) = try buildURLRequest(req)
+    let (urlRequest, finalURL) = try await buildURLRequest(req)
     let (data, response) = try await session.data(for: urlRequest)
     guard let http = response as? HTTPURLResponse else {
       throw NSError(domain: "NitroFetch", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid response"])
@@ -167,7 +201,7 @@ final class NitroFetchClient: HybridNitroFetchClientSpec {
     FetchCache.addPending(key) { _ in /* ignored here */ }
     Task.detached {
       do {
-        let (urlRequest, finalURL) = try buildURLRequest(req)
+        let (urlRequest, finalURL) = try await buildURLRequest(req)
         let (data, response) = try await session.data(for: urlRequest)
         guard let http = response as? HTTPURLResponse else {
           throw NSError(domain: "NitroFetch", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid response"])
@@ -199,7 +233,7 @@ final class NitroFetchClient: HybridNitroFetchClientSpec {
     return req.method?.stringValue
   }
 
-  private static func buildURLRequest(_ req: NitroRequest) throws -> (URLRequest, URL?) {
+  private static func buildURLRequest(_ req: NitroRequest) async throws -> (URLRequest, URL?) {
     guard let url = URL(string: req.url) else {
       throw NSError(domain: "NitroFetch", code: -3, userInfo: [NSLocalizedDescriptionKey: "Invalid URL: \(req.url)"])
     }
@@ -208,13 +242,61 @@ final class NitroFetchClient: HybridNitroFetchClientSpec {
     if let headers = req.headers {
       for h in headers { r.addValue(h.value, forHTTPHeaderField: h.key) }
     }
-    if let s = req.bodyString {
+    if let parts = req.bodyFormData, !parts.isEmpty {
+      let (body, contentType) = try await buildMultipartBody(parts)
+      r.httpBody = body
+      r.setValue(contentType, forHTTPHeaderField: "Content-Type")
+    } else if let s = req.bodyString {
       r.httpBody = s.data(using: .utf8)
     }
     if let t = req.timeoutMs, t > 0 { r.timeoutInterval = TimeInterval(t) / 1000.0 }
     return (r, nil)
   }
 
+  private static func buildMultipartBody(_ parts: [NitroFormDataPart]) async throws -> (Data, String) {
+    let boundary = "NitroFetch-\(UUID().uuidString)"
+    var body = Data()
+    let crlf = "\r\n"
+
+    for part in parts {
+      body.append("--\(boundary)\(crlf)".data(using: .utf8)!)
+
+      if let fileUri = part.fileUri {
+        let fileName = part.fileName ?? "file"
+        let mimeType = part.mimeType ?? "application/octet-stream"
+        body.append("Content-Disposition: form-data; name=\"\(part.name)\"; filename=\"\(fileName)\"\(crlf)".data(using: .utf8)!)
+        body.append("Content-Type: \(mimeType)\(crlf)\(crlf)".data(using: .utf8)!)
+
+        let fileData = try await readFileData(fileUri)
+        body.append(fileData)
+      } else {
+        let value = part.value ?? ""
+        body.append("Content-Disposition: form-data; name=\"\(part.name)\"\(crlf)\(crlf)".data(using: .utf8)!)
+        body.append(value.data(using: .utf8)!)
+      }
+
+      body.append(crlf.data(using: .utf8)!)
+    }
+
+    body.append("--\(boundary)--\(crlf)".data(using: .utf8)!)
+    return (body, "multipart/form-data; boundary=\(boundary)")
+  }
+
+  private static func readFileData(_ uri: String) async throws -> Data {
+    if uri.hasPrefix("http://") || uri.hasPrefix("https://") {
+      guard let url = URL(string: uri) else {
+        throw NSError(domain: "NitroFetch", code: -4, userInfo: [NSLocalizedDescriptionKey: "Invalid URL: \(uri)"])
+      }
+      let (data, _) = try await session.data(from: url)
+      return data
+    }
+    let path = uri.hasPrefix("file://") ? String(uri.dropFirst(7)) : uri
+    guard let data = FileManager.default.contents(atPath: path) else {
+      throw NSError(domain: "NitroFetch", code: -4, userInfo: [NSLocalizedDescriptionKey: "Cannot read file at: \(uri)"])
+    }
+    return data
+  }
+
   private static func detectCharset(from http: HTTPURLResponse) -> String.Encoding? {
     if let ct = http.value(forHTTPHeaderField: "Content-Type")?.lowercased() {
       if let range = ct.range(of: "charset=") {

package/ios/URLSessionExtensions.swift

@@ -0,0 +1,36 @@
+import Foundation
+import NitroModules
+
+extension HTTPURLResponse {
+  func toNitro() -> UrlResponseInfo {
+    let headersMap = allHeaderFields.reduce(into: [String: String]()) { result, pair in
+      if let key = pair.key as? String {
+        result[key] = String(describing: pair.value)
+      }
+    }
+
+    let headersList = allHeaderFields.compactMap { pair -> HttpHeader? in
+      guard let key = pair.key as? String else { return nil }
+      return HttpHeader(key: key, value: String(describing: pair.value))
+    }
+
+    return UrlResponseInfo(
+      url: url?.absoluteString ?? "",
+      httpStatusCode: Double(statusCode),
+      httpStatusText: HTTPURLResponse.localizedString(forStatusCode: statusCode),
+      allHeaders: headersMap,
+      allHeadersAsList: headersList,
+      urlChain: [url?.absoluteString ?? ""],
+      negotiatedProtocol: "",
+      proxyServer: "",
+      receivedByteCount: Double(expectedContentLength),
+      wasCached: false
+    )
+  }
+}
+
+extension Error {
+  func toNitro() -> RequestException {
+    return RequestException(message: localizedDescription)
+  }
+}

package/lib/module/NitroCronet.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=NitroCronet.nitro.js.map

package/lib/module/NitroCronet.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["NitroCronet.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/NitroInstances.js

@@ -5,4 +5,5 @@ import { NitroModules } from 'react-native-nitro-modules';
 export const NitroFetch = NitroModules.createHybridObject('NitroFetch');
 export const NativeStorage = NitroModules.createHybridObject('NativeStorage');
 export const boxedNitroFetch = NitroModules.box(NitroFetch);
+export const NitroCronetSingleton = NitroModules.createHybridObject('NitroCronet');
 //# sourceMappingURL=NitroInstances.js.map

package/lib/module/NitroInstances.js.map

@@ -1 +1 @@
-{"version":3,"names":["NitroModules","NitroFetch","createHybridObject","NativeStorage","boxedNitroFetch","box"],"sourceRoot":"../../src","sources":["NitroInstances.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAMzD;AACA,OAAO,MAAMC,UAA0B,GACrCD,YAAY,CAACE,kBAAkB,CAAiB,YAAY,CAAC;AAE/D,OAAO,MAAMC,aAAgC,GAC3CH,YAAY,CAACE,kBAAkB,CAAoB,eAAe,CAAC;AAErE,OAAO,MAAME,eAAe,GAAGJ,YAAY,CAACK,GAAG,CAACJ,UAAU,CAAC","ignoreList":[]}
+{"version":3,"names":["NitroModules","NitroFetch","createHybridObject","NativeStorage","boxedNitroFetch","box","NitroCronetSingleton"],"sourceRoot":"../../src","sources":["NitroInstances.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAOzD;AACA,OAAO,MAAMC,UAA0B,GACrCD,YAAY,CAACE,kBAAkB,CAAiB,YAAY,CAAC;AAE/D,OAAO,MAAMC,aAAgC,GAC3CH,YAAY,CAACE,kBAAkB,CAAoB,eAAe,CAAC;AAErE,OAAO,MAAME,eAAe,GAAGJ,YAAY,CAACK,GAAG,CAACJ,UAAU,CAAC;AAE3D,OAAO,MAAMK,oBAAoB,GAC/BN,YAAY,CAACE,kBAAkB,CAAc,aAAa,CAAC","ignoreList":[]}