background upload plugin

add schemas

sync variants

formatting

initial implementation

use existing db, wip

move to separate folder

fix table definitions

wip

wiring it up

repository pattern

mobile/ios/Runner/Schemas/Constants.swift

@@ -2,6 +2,8 @@ import SQLiteData
 
 extension Notification.Name {
   static let networkDidConnect = Notification.Name("networkDidConnect")
+  static let downloadTaskDidComplete = Notification.Name("downloadTaskDidComplete")
+  static let uploadTaskDidComplete = Notification.Name("uploadTaskDidComplete")
 }
 
 enum TaskConfig {
@@ -12,6 +14,7 @@ enum TaskConfig {
   static let sessionId = "app.mertalev.immich.upload"
   static let downloadCheckIntervalNs: UInt64 = 30_000_000_000  // 30 seconds
   static let downloadTimeoutS = TimeInterval(60)
+  static let progressThrottleInterval = TimeInterval(0.1)
   static let transferSpeedAlpha = 0.4
   static let originalsDir = FileManager.default.temporaryDirectory.appendingPathComponent(
     "originals",
@@ -214,6 +217,18 @@ enum UploadError: Error {
   case fileCreationFailed
   case iCloudError(UploadErrorCode)
   case photosError(UploadErrorCode)
+  case unknown
+
+  var code: UploadErrorCode {
+    switch self {
+    case .iCloudError(let code), .photosError(let code):
+      return code
+    case .unknown:
+      return .unknown
+    case .fileCreationFailed:
+      return .writeFailed
+    }
+  }
 }
 
 enum UploadErrorCode: Int, QueryBindable {
@@ -228,9 +243,6 @@ enum UploadErrorCode: Int, QueryBindable {
   case networkError
   case photosInternalError
   case photosUnknownError
-  case noServerUrl
-  case noDeviceId
-  case noAccessToken
   case interrupted
   case cancelled
   case downloadStalled
@@ -243,6 +255,9 @@ enum UploadErrorCode: Int, QueryBindable {
   case invalidResponse
   case badRequest
   case internalServerError
+  case unauthorized
+
+  static let fatal: [UploadErrorCode] = [.assetNotFound, .resourceNotFound, .invalidResource, .badRequest, .unauthorized]
 }
 
 enum AssetType: Int, QueryBindable {

mobile/ios/Runner/Schemas/Store.swift

@@ -1,160 +0,0 @@
-import SQLiteData
-
-enum StoreError: Error {
-  case invalidJSON(String)
-  case invalidURL(String)
-  case encodingFailed
-  case notFound
-}
-
-protocol StoreConvertible {
-  static var cacheKeyPath: ReferenceWritableKeyPath<StoreCache, [StoreKey: Self]> { get }
-  associatedtype StorageType
-  static func fromValue(_ value: StorageType) throws(StoreError) -> Self
-  static func toValue(_ value: Self) throws(StoreError) -> StorageType
-}
-
-extension StoreConvertible {
-  static func get(_ cache: StoreCache, key: StoreKey) -> Self? {
-    os_unfair_lock_lock(&cache.lock)
-    defer { os_unfair_lock_unlock(&cache.lock) }
-    return cache[keyPath: cacheKeyPath][key]
-  }
-
-  static func set(_ cache: StoreCache, key: StoreKey, value: Self?) {
-    os_unfair_lock_lock(&cache.lock)
-    defer { os_unfair_lock_unlock(&cache.lock) }
-    cache[keyPath: cacheKeyPath][key] = value
-  }
-}
-
-final class StoreCache {
-  fileprivate var lock = os_unfair_lock()
-  fileprivate var intCache: [StoreKey: Int] = [:]
-  fileprivate var boolCache: [StoreKey: Bool] = [:]
-  fileprivate var dateCache: [StoreKey: Date] = [:]
-  fileprivate var stringCache: [StoreKey: String] = [:]
-  fileprivate var urlCache: [StoreKey: URL] = [:]
-  fileprivate var endpointArrayCache: [StoreKey: [Endpoint]] = [:]
-  fileprivate var stringDictCache: [StoreKey: [String: String]] = [:]
-
-  func get<T: StoreConvertible>(_ key: StoreKey.Typed<T>) -> T? {
-    T.get(self, key: key.rawValue)
-  }
-
-  func set<T: StoreConvertible>(_ key: StoreKey.Typed<T>, value: T?) {
-    T.set(self, key: key.rawValue, value: value)
-  }
-}
-
-extension Int: StoreConvertible {
-  static let cacheKeyPath = \StoreCache.intCache
-  static func fromValue(_ value: Int) -> Int { value }
-  static func toValue(_ value: Int) -> Int { value }
-}
-
-extension Bool: StoreConvertible {
-  static let cacheKeyPath = \StoreCache.boolCache
-  static func fromValue(_ value: Int) -> Bool { value == 1 }
-  static func toValue(_ value: Bool) -> Int { value ? 1 : 0 }
-}
-
-extension Date: StoreConvertible {
-  static let cacheKeyPath = \StoreCache.dateCache
-  static func fromValue(_ value: Int) -> Date { Date(timeIntervalSince1970: TimeInterval(value) / 1000) }
-  static func toValue(_ value: Date) -> Int { Int(value.timeIntervalSince1970 * 1000) }
-}
-
-extension String: StoreConvertible {
-  static let cacheKeyPath = \StoreCache.stringCache
-  static func fromValue(_ value: String) -> String { value }
-  static func toValue(_ value: String) -> String { value }
-}
-
-extension URL: StoreConvertible {
-  static let cacheKeyPath = \StoreCache.urlCache
-  static func fromValue(_ value: String) throws(StoreError) -> URL {
-    guard let url = URL(string: value) else {
-      throw StoreError.invalidURL(value)
-    }
-    return url
-  }
-  static func toValue(_ value: URL) -> String { value.absoluteString }
-}
-
-extension StoreConvertible where Self: Codable, StorageType == String {
-  static var jsonDecoder: JSONDecoder { JSONDecoder() }
-  static var jsonEncoder: JSONEncoder { JSONEncoder() }
-
-  static func fromValue(_ value: String) throws(StoreError) -> Self {
-    do {
-      return try jsonDecoder.decode(Self.self, from: Data(value.utf8))
-    } catch {
-      throw StoreError.invalidJSON(value)
-    }
-  }
-
-  static func toValue(_ value: Self) throws(StoreError) -> String {
-    let encoded: Data
-    do {
-      encoded = try jsonEncoder.encode(value)
-    } catch {
-      throw StoreError.encodingFailed
-    }
-
-    guard let string = String(data: encoded, encoding: .utf8) else {
-      throw StoreError.encodingFailed
-    }
-    return string
-  }
-}
-
-extension Array: StoreConvertible where Element == Endpoint {
-  static let cacheKeyPath = \StoreCache.endpointArrayCache
-  typealias StorageType = String
-}
-
-extension Dictionary: StoreConvertible where Key == String, Value == String {
-  static let cacheKeyPath = \StoreCache.stringDictCache
-  typealias StorageType = String
-}
-
-extension Store {
-  static let cache = StoreCache()
-  
-  static func get<T: StoreConvertible>(_ conn: Database, _ key: StoreKey.Typed<T>) throws -> T?
-  where T.StorageType == Int {
-    if let cached = cache.get(key) { return cached }
-    let query = Store.select(\.intValue).where { $0.id.eq(key.rawValue) }
-    if let value = try query.fetchOne(conn) ?? nil {
-      let converted = try T.fromValue(value)
-      cache.set(key, value: converted)
-    }
-    return nil
-  }
-
-  static func get<T: StoreConvertible>(_ conn: Database, _ key: StoreKey.Typed<T>) throws -> T?
-  where T.StorageType == String {
-    if let cached = cache.get(key) { return cached }
-    let query = Store.select(\.stringValue).where { $0.id.eq(key.rawValue) }
-    if let value = try query.fetchOne(conn) ?? nil {
-      let converted = try T.fromValue(value)
-      cache.set(key, value: converted)
-    }
-    return nil
-  }
-
-  static func set<T: StoreConvertible>(_ conn: Database, _ key: StoreKey.Typed<T>, value: T) throws
-  where T.StorageType == Int {
-    let converted = try T.toValue(value)
-    try Store.upsert { Store(id: key.rawValue, stringValue: nil, intValue: converted) }.execute(conn)
-    cache.set(key, value: value)
-  }
-
-  static func set<T: StoreConvertible>(_ conn: Database, _ key: StoreKey.Typed<T>, value: T) throws
-  where T.StorageType == String {
-    let converted = try T.toValue(value)
-    try Store.upsert { Store(id: key.rawValue, stringValue: converted, intValue: nil) }.execute(conn)
-    cache.set(key, value: value)
-  }
-}

mobile/ios/Runner/Schemas/Tables.swift

@@ -73,11 +73,6 @@ struct LocalAlbum: Identifiable {
   let updatedAt: Date
 }
 
-extension LocalAlbum {
-  static let selected = Self.where { $0.backupSelection.eq(BackupSelection.selected) }
-  static let excluded = Self.where { $0.backupSelection.eq(BackupSelection.excluded) }
-}
-
 @Table("local_album_asset_entity")
 struct LocalAlbumAsset {
   let id: ID
@@ -93,15 +88,6 @@ struct LocalAlbumAsset {
   }
 }
 
-extension LocalAlbumAsset {
-  static let selected = Self.where {
-    $0.id.assetId.eq(LocalAsset.columns.id) && $0.id.albumId.in(LocalAlbum.selected.select(\.id))
-  }
-  static let excluded = Self.where {
-    $0.id.assetId.eq(LocalAsset.columns.id) && $0.id.albumId.in(LocalAlbum.excluded.select(\.id))
-  }
-}
-
 @Table("local_asset_entity")
 struct LocalAsset: Identifiable {
   let id: String
@@ -119,18 +105,6 @@ struct LocalAsset: Identifiable {
   @Column("updated_at")
   let updatedAt: String
   let width: Int?
-
-  static func getCandidates() -> Where<LocalAsset> {
-    return Self.where { local in
-      LocalAlbumAsset.selected.exists()
-        && !LocalAlbumAsset.excluded.exists()
-        && !RemoteAsset.where {
-          local.checksum.eq($0.checksum)
-            && $0.ownerId.eq(Store.select(\.stringValue).where { $0.id.eq(StoreKey.currentUser.rawValue) }.unwrapped)
-        }.exists()
-        && !UploadTask.where { $0.localId.eq(local.id) }.exists()
-    }
-  }
 }
 
 @Selection
@@ -143,6 +117,7 @@ struct LocalAssetCandidate {
 struct LocalAssetDownloadData {
   let checksum: String?
   let createdAt: String
+  let filename: String
   let livePhotoVideoId: RemoteAsset.ID?
   let localId: LocalAsset.ID
   let taskId: UploadTask.ID
@@ -151,6 +126,7 @@ struct LocalAssetDownloadData {
 
 @Selection
 struct LocalAssetUploadData {
+  let filename: String
   let filePath: URL
   let priority: Float
   let taskId: UploadTask.ID
@@ -375,16 +351,7 @@ struct UploadTask: Identifiable {
   var priority: Float
   @Column("retry_after", as: Date?.UnixTimeRepresentation.self)
   let retryAfter: Date?
-  let status: TaskStatus
-
-  static func retryOrFail(code: UploadErrorCode, status: TaskStatus) -> Update<UploadTask, ()> {
-    return Self.update { row in
-      row.status = Case().when(row.attempts.lte(TaskConfig.maxRetries), then: TaskStatus.downloadPending).else(status)
-      row.attempts += 1
-      row.lastError = code
-      row.retryAfter = #sql("unixepoch('now') + (\(4 << row.attempts))")
-    }
-  }
+  var status: TaskStatus
 }
 
 @Table("upload_task_stats")