refactor(storage): improve resumable upload implementation

- Remove unnecessary public modifiers for internal types
- Add DiskResumableCache as default cache implementation
- Simplify Fingerprint interface by removing CustomStringConvertible
- Make cancel() method synchronous for better usability
- Switch default cache from memory to disk-based storage

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: grdsdev

Sources/Storage/Resumable/DiskResumableCache.swift

@@ -0,0 +1,44 @@
+import Foundation
+
+final class DiskResumableCache: ResumableCache, @unchecked Sendable {
+    private let storage: FileManager
+
+    init(storage: FileManager) {
+        self.storage = storage
+    }
+
+    func set(fingerprint: Fingerprint, entry: ResumableCacheEntry) async throws {
+        let data = try JSONEncoder().encode(entry)
+        storage.createFile(atPath: fingerprint.value, contents: data)
+    }
+
+    func get(fingerprint: Fingerprint) async throws -> ResumableCacheEntry? {
+        let data = storage.contents(atPath: fingerprint.value)
+        guard let data = data else {
+            return nil
+        }
+        return try JSONDecoder().decode(ResumableCacheEntry.self, from: data)
+    }
+
+    func remove(fingerprint: Fingerprint) async throws {
+        try storage.removeItem(atPath: fingerprint.value)
+    }
+
+    func clear() async throws {
+        try storage.removeItem(atPath: storage.currentDirectoryPath)
+    }
+
+    func entries() async throws -> [CachePair] {
+        let files = try storage.contentsOfDirectory(atPath: storage.currentDirectoryPath)
+        return try files.compactMap { file -> CachePair? in
+            let data = storage.contents(atPath: file)
+            guard let data = data else {
+                return nil
+            }
+            return (
+                Fingerprint(value: file)!,
+                try JSONDecoder().decode(ResumableCacheEntry.self, from: data)
+            )
+        }
+    }
+}

Sources/Storage/Resumable/Fingerprint.swift

@@ -1,7 +1,7 @@
 import Foundation
 
 public struct Fingerprint: Hashable, Sendable {
-  public let value: String
+  let value: String
 
   private static let fingerprintSeparator = "::"
   private static let fingerprintParts = 2
@@ -10,19 +10,19 @@ public struct Fingerprint: Hashable, Sendable {
     value.components(separatedBy: Self.fingerprintSeparator)
   }
 
-  public var source: String {
+  var source: String {
     parts[0]
   }
 
-  public var size: Int64 {
+  var size: Int64 {
     Int64(parts[1]) ?? 0
   }
 
-  public init(source: String, size: Int64) {
+  init(source: String, size: Int64) {
     self.value = "\(source)\(Self.fingerprintSeparator)\(size)"
   }
 
-  public init?(value: String) {
+  init?(value: String) {
     let parts = value.components(separatedBy: Self.fingerprintSeparator)
     guard parts.count == Self.fingerprintParts else { return nil }
     self.init(source: parts[0], size: Int64(parts[1]) ?? 0)
@@ -48,10 +48,4 @@ extension Fingerprint: Codable {
     var container = encoder.singleValueContainer()
     try container.encode(value)
   }
-}
-
-extension Fingerprint: CustomStringConvertible {
-  public var description: String {
-    value
-  }
 }

Sources/Storage/Resumable/MemoryResumableCache.swift

@@ -1,31 +1,31 @@
 import Foundation
 
-public actor MemoryResumableCache: ResumableCache {
+actor MemoryResumableCache: ResumableCache {
   private var storage: [String: Data] = [:]
 
-  public init() {}
+  init() {}
 
-  public func set(fingerprint: Fingerprint, entry: ResumableCacheEntry) async throws {
+  func set(fingerprint: Fingerprint, entry: ResumableCacheEntry) async throws {
     let data = try JSONEncoder().encode(entry)
     storage[fingerprint.value] = data
   }
 
-  public func get(fingerprint: Fingerprint) async throws -> ResumableCacheEntry? {
+  func get(fingerprint: Fingerprint) async throws -> ResumableCacheEntry? {
     guard let data = storage[fingerprint.value] else {
       return nil
     }
     return try JSONDecoder().decode(ResumableCacheEntry.self, from: data)
   }
 
-  public func remove(fingerprint: Fingerprint) async throws {
+  func remove(fingerprint: Fingerprint) async throws {
     storage.removeValue(forKey: fingerprint.value)
   }
 
-  public func clear() async throws {
+  func clear() async throws {
     storage.removeAll()
   }
 
-  public func entries() async throws -> [CachePair] {
+  func entries() async throws -> [CachePair] {
     var pairs: [CachePair] = []
 
     for (key, data) in storage {

Sources/Storage/Resumable/ResumableCache.swift

@@ -1,28 +1,12 @@
 import Foundation
 
-public struct ResumableCacheEntry: Codable, Sendable {
-  public let uploadURL: String
-  public let path: String
-  public let bucketId: String
-  public let expiration: Date
-  public let upsert: Bool
-  public let contentType: String?
-
-  public init(
-    uploadURL: String,
-    path: String,
-    bucketId: String,
-    expiration: Date,
-    upsert: Bool,
-    contentType: String? = nil
-  ) {
-    self.uploadURL = uploadURL
-    self.path = path
-    self.bucketId = bucketId
-    self.expiration = expiration
-    self.upsert = upsert
-    self.contentType = contentType
-  }
+struct ResumableCacheEntry: Codable, Sendable {
+  let uploadURL: String
+  let path: String
+  let bucketId: String
+  let expiration: Date
+  let upsert: Bool
+  let contentType: String?
 
   enum CodingKeys: String, CodingKey {
     case uploadURL = "upload_url"
@@ -34,16 +18,16 @@ public struct ResumableCacheEntry: Codable, Sendable {
   }
 }
 
-public typealias CachePair = (Fingerprint, ResumableCacheEntry)
+typealias CachePair = (Fingerprint, ResumableCacheEntry)
 
-public protocol ResumableCache: Sendable {
+protocol ResumableCache: Sendable {
   func set(fingerprint: Fingerprint, entry: ResumableCacheEntry) async throws
   func get(fingerprint: Fingerprint) async throws -> ResumableCacheEntry?
   func remove(fingerprint: Fingerprint) async throws
   func clear() async throws
   func entries() async throws -> [CachePair]
 }
 
-public func createDefaultResumableCache() -> some ResumableCache {
-  MemoryResumableCache()
-}
+func createDefaultResumableCache() -> some ResumableCache {
+  DiskResumableCache(storage: FileManager.default)
+}

Sources/Storage/Resumable/ResumableUpload.swift

@@ -61,7 +61,7 @@ public actor ResumableUpload {
     isPaused = true
   }
 
-  public func cancel() async {
+  public func cancel() {
     isCancelled = true
     stateContinuation.finish()
   }

Sources/Storage/Resumable/ResumableUploadState.swift

@@ -33,7 +33,7 @@ public struct ResumableUploadState: Sendable {
     return Float(status.totalBytesSent) / Float(status.contentLength)
   }
 
-  public init(
+  init(
     fingerprint: Fingerprint,
     cacheEntry: ResumableCacheEntry,
     status: UploadStatus,