uploados 0.1.0

package/ios/Upload/UploadModels.swift

@@ -0,0 +1,305 @@
+import Foundation
+
+enum UploadState: String, Codable {
+  case created
+  case validating
+  case compressing
+  case queued
+  case connecting
+  case uploading
+  case verifying
+  case retrying
+  case completed
+  case paused
+  case failed
+  case cancelled
+}
+
+enum UploadNetworkPolicy: String, Codable {
+  case wait
+  case failFast
+}
+
+enum UploadErrorCode: String, Codable {
+  case FILE_NOT_FOUND
+  case FILE_TOO_LARGE
+  case NETWORK_ERROR
+  case AUTH_ERROR
+  case PROVIDER_ERROR
+  case MULTIPART_FAILED
+  case COMPRESSION_FAILED
+  case BACKGROUND_RESTRICTED
+  case CANCELLED
+  case UNKNOWN
+}
+
+struct UploadErrorPayload: Codable {
+  let code: UploadErrorCode
+  let message: String
+  let retryable: Bool
+  let taskId: String
+  let phase: String?
+  let httpStatus: Int?
+  let providerCode: String?
+  let providerMessage: String?
+  let nativeCause: String?
+
+  func toDictionary() -> [String: Any] {
+    var dict: [String: Any] = [
+      "code": code.rawValue,
+      "message": message,
+      "retryable": retryable,
+      "taskId": taskId,
+    ]
+    if let phase {
+      dict["phase"] = phase
+    }
+    if let httpStatus {
+      dict["httpStatus"] = httpStatus
+    }
+    if let providerCode {
+      dict["providerCode"] = providerCode
+    }
+    if let providerMessage {
+      dict["providerMessage"] = providerMessage
+    }
+    if let nativeCause {
+      dict["nativeCause"] = nativeCause
+    }
+    return dict
+  }
+}
+
+struct UploadProgress: Codable {
+  var bytesUploaded: Int
+  var totalBytes: Int
+  var percentage: Double
+}
+
+struct UploadFileMetadata: Codable {
+  let originalUri: String
+  let uploadUri: String
+  let isStaged: Bool
+  let sizeBytes: Int?
+
+  func toDictionary() -> [String: Any] {
+    var dict: [String: Any] = [
+      "originalUri": originalUri,
+      "uploadUri": uploadUri,
+      "isStaged": isStaged,
+    ]
+    if let sizeBytes {
+      dict["sizeBytes"] = sizeBytes
+    }
+    return dict
+  }
+}
+
+struct UploadTaskRecord: Codable {
+  let id: String
+  let localUri: String
+  var stagedFilePath: String?
+  var optimizedFilePath: String?
+  var compressionEnabled: Bool
+  var compressionPreset: String?
+  var originalSize: Int?
+  var optimizedSize: Int?
+  let uploadUrl: String
+  let method: String
+  var state: UploadState
+  var progress: UploadProgress
+  let background: Bool
+  let networkPolicy: UploadNetworkPolicy
+  var attempt: Int
+  let maxAttempts: Int
+  var nextRetryAt: TimeInterval?
+  let createdAt: TimeInterval
+  var updatedAt: TimeInterval
+  var headers: [String: String]
+  var sessionTaskIdentifier: Int?
+  var error: UploadErrorPayload?
+
+  init(
+    id: String,
+    localUri: String,
+    stagedFilePath: String? = nil,
+    optimizedFilePath: String? = nil,
+    compressionEnabled: Bool = false,
+    compressionPreset: String? = nil,
+    originalSize: Int? = nil,
+    optimizedSize: Int? = nil,
+    uploadUrl: String,
+    method: String,
+    state: UploadState,
+    progress: UploadProgress,
+    background: Bool,
+    networkPolicy: UploadNetworkPolicy,
+    attempt: Int,
+    maxAttempts: Int,
+    nextRetryAt: TimeInterval?,
+    createdAt: TimeInterval,
+    updatedAt: TimeInterval,
+    headers: [String: String],
+    sessionTaskIdentifier: Int?,
+    error: UploadErrorPayload?
+  ) {
+    self.id = id
+    self.localUri = localUri
+    self.stagedFilePath = stagedFilePath
+    self.optimizedFilePath = optimizedFilePath
+    self.compressionEnabled = compressionEnabled
+    self.compressionPreset = compressionPreset
+    self.originalSize = originalSize
+    self.optimizedSize = optimizedSize
+    self.uploadUrl = uploadUrl
+    self.method = method
+    self.state = state
+    self.progress = progress
+    self.background = background
+    self.networkPolicy = networkPolicy
+    self.attempt = attempt
+    self.maxAttempts = max(1, maxAttempts)
+    self.nextRetryAt = nextRetryAt
+    self.createdAt = createdAt
+    self.updatedAt = updatedAt
+    self.headers = headers
+    self.sessionTaskIdentifier = sessionTaskIdentifier
+    self.error = error
+  }
+
+  enum CodingKeys: String, CodingKey {
+    case id
+    case localUri
+    case stagedFilePath
+    case optimizedFilePath
+    case compressionEnabled
+    case compressionPreset
+    case originalSize
+    case optimizedSize
+    case uploadUrl
+    case method
+    case state
+    case progress
+    case background
+    case networkPolicy
+    case attempt
+    case maxAttempts
+    case nextRetryAt
+    case createdAt
+    case updatedAt
+    case headers
+    case sessionTaskIdentifier
+    case error
+  }
+
+  init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: CodingKeys.self)
+    id = try container.decode(String.self, forKey: .id)
+    localUri = try container.decode(String.self, forKey: .localUri)
+    stagedFilePath = try container.decodeIfPresent(String.self, forKey: .stagedFilePath)
+    optimizedFilePath = try container.decodeIfPresent(String.self, forKey: .optimizedFilePath)
+    compressionEnabled = try container.decodeIfPresent(Bool.self, forKey: .compressionEnabled) ?? false
+    compressionPreset = try container.decodeIfPresent(String.self, forKey: .compressionPreset)
+    originalSize = try container.decodeIfPresent(Int.self, forKey: .originalSize)
+    optimizedSize = try container.decodeIfPresent(Int.self, forKey: .optimizedSize)
+    uploadUrl = try container.decode(String.self, forKey: .uploadUrl)
+    method = try container.decode(String.self, forKey: .method)
+    state = try container.decode(UploadState.self, forKey: .state)
+    progress = try container.decode(UploadProgress.self, forKey: .progress)
+    background = try container.decode(Bool.self, forKey: .background)
+    networkPolicy = try container.decodeIfPresent(UploadNetworkPolicy.self, forKey: .networkPolicy) ?? .wait
+    attempt = try container.decodeIfPresent(Int.self, forKey: .attempt) ?? 0
+    maxAttempts = max(1, try container.decodeIfPresent(Int.self, forKey: .maxAttempts) ?? 3)
+    nextRetryAt = try container.decodeIfPresent(TimeInterval.self, forKey: .nextRetryAt)
+    createdAt = try container.decode(TimeInterval.self, forKey: .createdAt)
+    updatedAt = try container.decode(TimeInterval.self, forKey: .updatedAt)
+    headers = try container.decodeIfPresent([String: String].self, forKey: .headers) ?? [:]
+    sessionTaskIdentifier = try container.decodeIfPresent(Int.self, forKey: .sessionTaskIdentifier)
+    error = try container.decodeIfPresent(UploadErrorPayload.self, forKey: .error)
+  }
+
+  func fileMetadata() -> UploadFileMetadata {
+    let uploadPath = optimizedFilePath ?? stagedFilePath
+    let uploadUri: String
+    if let uploadPath {
+      uploadUri = URL(fileURLWithPath: uploadPath).absoluteString
+    } else if localUri.hasPrefix("file://") {
+      uploadUri = localUri
+    } else {
+      uploadUri = URL(fileURLWithPath: localUri).absoluteString
+    }
+    let sizeBytes = optimizedSize ?? originalSize ?? (progress.totalBytes > 0 ? progress.totalBytes : nil)
+    return UploadFileMetadata(
+      originalUri: localUri,
+      uploadUri: uploadUri,
+      isStaged: stagedFilePath != nil || optimizedFilePath != nil,
+      sizeBytes: sizeBytes
+    )
+  }
+
+  func compressionStatsDictionary() -> [String: Any]? {
+    guard compressionEnabled,
+          let preset = compressionPreset,
+          let originalSize,
+          let optimizedSize else {
+      return nil
+    }
+    return [
+      "preset": preset,
+      "originalSize": originalSize,
+      "optimizedSize": optimizedSize,
+      "format": "jpeg",
+    ]
+  }
+
+  func toDictionary() -> [String: Any] {
+    let file = fileMetadata()
+    var dict: [String: Any] = [
+      "id": id,
+      "localUri": localUri,
+      "uploadUrl": uploadUrl,
+      "file": file.toDictionary(),
+      "method": method,
+      "state": state.rawValue,
+      "progress": [
+        "bytesUploaded": progress.bytesUploaded,
+        "totalBytes": progress.totalBytes,
+        "percentage": progress.percentage,
+      ],
+      "background": background,
+      "networkPolicy": networkPolicy.rawValue,
+      "attempt": attempt,
+      "maxAttempts": maxAttempts,
+      "createdAt": createdAt,
+      "updatedAt": updatedAt,
+    ]
+    if let nextRetryAt {
+      dict["nextRetryAt"] = nextRetryAt
+    }
+    if let originalSize {
+      dict["originalSize"] = originalSize
+    }
+    if let optimizedSize {
+      dict["optimizedSize"] = optimizedSize
+    }
+    if let compression = compressionStatsDictionary() {
+      dict["compression"] = compression
+    }
+    if let error {
+      dict["error"] = error.toDictionary()
+    }
+    return dict
+  }
+}
+
+struct CreateUploadOptions {
+  let localUri: String
+  let uploadUrl: String
+  let method: String
+  let headers: [String: String]
+  let background: Bool
+  let networkPolicy: UploadNetworkPolicy
+  let maxAttempts: Int
+  let compressionEnabled: Bool
+  let compressionPreset: CompressionPreset
+}

package/ios/Upload/UploadSessionDelegate.swift

@@ -0,0 +1,82 @@
+import Foundation
+
+final class UploadSessionDelegate: NSObject, URLSessionDelegate, URLSessionTaskDelegate, URLSessionDataDelegate {
+  weak var manager: UploadManager?
+  private let responseDataLock = NSLock()
+  private var responseDataByTaskId: [String: Data] = [:]
+  private let maxResponseBodyBytes = 16 * 1024
+
+  func urlSession(
+    _ session: URLSession,
+    task: URLSessionTask,
+    didSendBodyData bytesSent: Int64,
+    totalBytesSent: Int64,
+    totalBytesExpectedToSend: Int64
+  ) {
+    guard let taskId = task.taskDescription else {
+      return
+    }
+    let totalBytes: Int
+    if totalBytesExpectedToSend > 0 {
+      totalBytes = Int(totalBytesExpectedToSend)
+    } else if let storedTotal = UploadTaskStore.shared.task(id: taskId)?.progress.totalBytes,
+              storedTotal > 0 {
+      totalBytes = storedTotal
+    } else {
+      return
+    }
+    manager?.handleProgress(
+      taskId: taskId,
+      bytesUploaded: Int(totalBytesSent),
+      totalBytes: totalBytes
+    )
+  }
+
+  func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+    guard let taskId = task.taskDescription else {
+      return
+    }
+    if let error {
+      manager?.handleFailure(taskId: taskId, error: error, response: task.response)
+      _ = takeResponseBody(taskId: taskId)
+      return
+    }
+    if let http = task.response as? HTTPURLResponse, !(200...299).contains(http.statusCode) {
+      manager?.handleHttpFailure(
+        taskId: taskId,
+        statusCode: http.statusCode,
+        responseBody: takeResponseBody(taskId: taskId)
+      )
+      return
+    }
+    _ = takeResponseBody(taskId: taskId)
+    manager?.handleCompletion(taskId: taskId)
+  }
+
+  func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
+    guard let taskId = dataTask.taskDescription else {
+      return
+    }
+    responseDataLock.lock()
+    var existing = responseDataByTaskId[taskId] ?? Data()
+    if existing.count < maxResponseBodyBytes {
+      existing.append(data.prefix(maxResponseBodyBytes - existing.count))
+      responseDataByTaskId[taskId] = existing
+    }
+    responseDataLock.unlock()
+  }
+
+  func urlSessionDidFinishEvents(forBackgroundURLSession session: URLSession) {
+    UploadManager.shared.invokeBackgroundCompletionHandler(for: session.configuration.identifier)
+  }
+
+  private func takeResponseBody(taskId: String) -> String? {
+    responseDataLock.lock()
+    let data = responseDataByTaskId.removeValue(forKey: taskId)
+    responseDataLock.unlock()
+    guard let data, !data.isEmpty else {
+      return nil
+    }
+    return String(data: data, encoding: .utf8)
+  }
+}

package/ios/Upload/UploadTaskStore.swift

@@ -0,0 +1,92 @@
+import Foundation
+
+final class UploadTaskStore {
+  static let shared = UploadTaskStore()
+
+  private let fileName = "uploados-tasks.json"
+  private let queue = DispatchQueue(label: "expo.modules.uploados.store")
+  private var tasks: [String: UploadTaskRecord] = [:]
+
+  private init() {
+    loadFromDisk()
+  }
+
+  func allTasks() -> [UploadTaskRecord] {
+    queue.sync {
+      Array(tasks.values).sorted { $0.createdAt < $1.createdAt }
+    }
+  }
+
+  func task(id: String) -> UploadTaskRecord? {
+    queue.sync { tasks[id] }
+  }
+
+  func upsert(_ task: UploadTaskRecord) {
+    queue.sync {
+      tasks[task.id] = task
+      persistLocked()
+    }
+  }
+
+  func update(id: String, mutate: (inout UploadTaskRecord) -> Void) -> UploadTaskRecord? {
+    queue.sync {
+      guard var task = tasks[id] else {
+        return nil
+      }
+      mutate(&task)
+      task.updatedAt = Date().timeIntervalSince1970 * 1000
+      tasks[id] = task
+      persistLocked()
+      return task
+    }
+  }
+
+  func restorableTasks() -> [UploadTaskRecord] {
+    queue.sync {
+      tasks.values.filter { task in
+        switch task.state {
+        case .created, .validating, .compressing, .queued, .connecting, .uploading, .verifying, .retrying, .paused:
+          return true
+        default:
+          return false
+        }
+      }
+    }
+  }
+
+  private func loadFromDisk() {
+    queue.sync {
+      guard let url = storeURL(),
+            FileManager.default.fileExists(atPath: url.path) else {
+        return
+      }
+      do {
+        let data = try Data(contentsOf: url)
+        let decoded = try JSONDecoder().decode([UploadTaskRecord].self, from: data)
+        tasks = Dictionary(uniqueKeysWithValues: decoded.map { ($0.id, $0) })
+      } catch {
+        tasks = [:]
+      }
+    }
+  }
+
+  private func persistLocked() {
+    guard let url = storeURL() else {
+      return
+    }
+    do {
+      let directory = url.deletingLastPathComponent()
+      try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+      let data = try JSONEncoder().encode(Array(tasks.values))
+      try data.write(to: url, options: .atomic)
+    } catch {
+      // Persistence failures should not crash uploads; state may be lost on restart.
+    }
+  }
+
+  private func storeURL() -> URL? {
+    FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first?
+      .appendingPathComponent("uploados", isDirectory: true)
+      .appendingPathComponent(fileName)
+  }
+}

package/ios/Upload/UploadosAppDelegate.swift

@@ -0,0 +1,14 @@
+import ExpoModulesCore
+
+public class UploadosAppDelegate: ExpoAppDelegateSubscriber {
+  public func application(
+    _ application: UIApplication,
+    handleEventsForBackgroundURLSession identifier: String,
+    completionHandler: @escaping () -> Void
+  ) {
+    UploadManager.shared.registerBackgroundCompletionHandler(
+      for: identifier,
+      completionHandler: completionHandler
+    )
+  }
+}

package/ios/Uploados.podspec

@@ -0,0 +1,23 @@
+Pod::Spec.new do |s|
+  s.name           = 'Uploados'
+  s.version        = '0.1.0'
+  s.summary        = 'Native signed-URL upload engine for Expo'
+  s.description    = 'iOS URLSession-based signed-URL upload engine with staging, persistence, and JPEG compression'
+  s.author         = 'bessim boujebli'
+  s.homepage       = 'https://github.com/bessim-dev/uploados'
+  s.platforms      = {
+    :ios => '15.1',
+    :tvos => '15.1'
+  }
+  s.source         = { git: 'https://github.com/bessim-dev/uploados.git' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+  }
+
+  s.source_files = "**/*.{h,m,mm,swift,hpp,cpp}"
+end

package/ios/UploadosModule.swift

@@ -0,0 +1,87 @@
+import ExpoModulesCore
+
+public class UploadosModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("Uploados")
+
+    Events("onUploadEvent")
+
+    OnCreate {
+      UploadManager.shared.setEventEmitter { [weak self] payload in
+        self?.sendEvent("onUploadEvent", payload)
+      }
+      _ = UploadManager.shared.restoreQueue()
+    }
+
+    AsyncFunction("createUploadAsync") { (options: [String: Any]) -> [String: Any] in
+      let parsed = try Self.parseCreateOptions(options)
+      let task = try UploadManager.shared.createUpload(options: parsed)
+      return task.toDictionary()
+    }
+
+    AsyncFunction("cancelUploadAsync") { (taskId: String) -> [String: Any] in
+      let task = try UploadManager.shared.cancelUpload(taskId: taskId)
+      return task.toDictionary()
+    }
+
+    AsyncFunction("retryUploadAsync") { (taskId: String) -> [String: Any] in
+      let task = try UploadManager.shared.retryUpload(taskId: taskId)
+      return task.toDictionary()
+    }
+
+    AsyncFunction("getTaskAsync") { (taskId: String) -> [String: Any]? in
+      UploadTaskStore.shared.task(id: taskId)?.toDictionary()
+    }
+
+    AsyncFunction("getAllTasksAsync") { () -> [[String: Any]] in
+      UploadTaskStore.shared.allTasks().map { $0.toDictionary() }
+    }
+
+    AsyncFunction("restoreQueueAsync") { () -> [[String: Any]] in
+      UploadManager.shared.restoreQueue().map { $0.toDictionary() }
+    }
+  }
+
+  private static func parseCreateOptions(_ options: [String: Any]) throws -> CreateUploadOptions {
+    guard let localUri = options["localUri"] as? String else {
+      throw InvalidOptionsException("localUri")
+    }
+    guard let uploadUrl = options["uploadUrl"] as? String else {
+      throw InvalidOptionsException("uploadUrl")
+    }
+    let method = (options["method"] as? String)?.uppercased() ?? "PUT"
+    guard method == "PUT" || method == "POST" else {
+      throw InvalidOptionsException("method")
+    }
+    let networkPolicyRaw = options["networkPolicy"] as? String ?? "wait"
+    guard let networkPolicy = UploadNetworkPolicy(rawValue: networkPolicyRaw) else {
+      throw InvalidOptionsException("networkPolicy")
+    }
+    let retry = options["retry"] as? [String: Any]
+    let maxAttemptsValue = retry?["maxAttempts"] as? NSNumber
+    let maxAttempts = max(1, maxAttemptsValue?.intValue ?? 3)
+    let headers = options["headers"] as? [String: String] ?? [:]
+    let background = options["background"] as? Bool ?? false
+    let compression = options["compression"] as? [String: Any]
+    let compressionEnabled = compression?["enabled"] as? Bool ?? false
+    let compressionPresetRaw = compression?["preset"] as? String ?? CompressionPreset.balanced.rawValue
+    let compressionPreset = CompressionPreset(raw: compressionPresetRaw)
+    return CreateUploadOptions(
+      localUri: localUri,
+      uploadUrl: uploadUrl,
+      method: method,
+      headers: headers,
+      background: background,
+      networkPolicy: background ? .wait : networkPolicy,
+      maxAttempts: maxAttempts,
+      compressionEnabled: compressionEnabled,
+      compressionPreset: compressionPreset
+    )
+  }
+}
+
+internal final class InvalidOptionsException: GenericException<String>, @unchecked Sendable {
+  override var reason: String {
+    "Missing or invalid upload option: \(param)"
+  }
+}

package/jest.config.js

@@ -0,0 +1,15 @@
+/** @type {import('jest').Config} */
+module.exports = {
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/__tests__/**/*.test.ts'],
+  transform: {
+    '^.+\\.(ts|tsx)$': [
+      'babel-jest',
+      {
+        presets: ['babel-preset-expo'],
+      },
+    ],
+  },
+  modulePathIgnorePatterns: ['<rootDir>/build/'],
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "uploados",
+  "version": "0.1.0",
+  "description": "Native signed-URL upload engine for Expo apps",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "node internal/module_scripts/build.js",
+    "clean": "node internal/module_scripts/clean.js",
+    "lint": "eslint src/",
+    "test": "node internal/module_scripts/test.js",
+    "prepare": "node internal/module_scripts/prepare.js",
+    "open:ios": "node internal/module_scripts/open-ios.js",
+    "open:android": "node internal/module_scripts/open-android.js"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "uploads",
+    "presigned-url",
+    "background-uploads",
+    "image-compression",
+    "uploados",
+    "Uploados"
+  ],
+  "repository": "https://github.com/bessim-dev/uploados",
+  "bugs": {
+    "url": "https://github.com/bessim-dev/uploados/issues"
+  },
+  "author": "bessim boujebli <bessim.boujebli@gmail.com> (bessim-dev)",
+  "license": "MIT",
+  "homepage": "https://github.com/bessim-dev/uploados#readme",
+  "dependencies": {},
+  "devDependencies": {
+    "@babel/core": "^7.26.0",
+    "@babel/runtime": "^7.29.7",
+    "@types/jest": "^29.2.1",
+    "@types/react": "~19.2.14",
+    "babel-preset-expo": "~56.0.0",
+    "eslint": "~9.39.4",
+    "eslint-config-universe": "^15.0.3",
+    "expo": "^56.0.5",
+    "jest": "^29.7.0",
+    "jest-expo": "~56.0.4",
+    "prettier": "^3.0.0",
+    "react-native": "0.85.3",
+    "typescript": "~6.0.3"
+  },
+  "peerDependencies": {
+    "expo": ">=52.0.0 <57.0.0",
+    "react": ">=18.3.1 <20.0.0",
+    "react-native": ">=0.76.0 <0.86.0"
+  }
+}