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/Upload/UploadQueue.swift

@@ -1,28 +1,57 @@
-import SQLiteData
-import StructuredFieldValues
+private var queueProcessingTask: Task<Void, Never>?
+private var queueProcessingLock = NSLock()
 
-class UploadQueue {
-  private static let structuredEncoder = StructuredFieldValueEncoder()
-  private static var queueProcessingTask: Task<Void, Never>?
-  private static var queueProcessingLock = NSLock()
+final class UploadQueue<StoreRepo: StoreProtocol, TaskRepo: TaskProtocol, StatusListener: TaskStatusListener> {
+  private let storeRepository: StoreRepo
+  private let taskRepository: TaskRepo
+  private let statusListener: StatusListener
 
-  private let db: DatabasePool
   private let cellularSession: URLSession
   private let wifiOnlySession: URLSession
-  private let statusListener: StatusEventListener
+  private var uploadObserver: NSObjectProtocol?
+  private var downloadObserver: NSObjectProtocol?
+  private var networkObserver: NSObjectProtocol?
 
-  init(db: DatabasePool, cellularSession: URLSession, wifiOnlySession: URLSession, statusListener: StatusEventListener)
-  {
-    self.db = db
+  init(
+    storeRepository: StoreRepo,
+    taskRepository: TaskRepo,
+    statusListener: StatusListener,
+    cellularSession: URLSession,
+    wifiOnlySession: URLSession
+  ) {
+    self.storeRepository = storeRepository
+    self.taskRepository = taskRepository
     self.cellularSession = cellularSession
     self.wifiOnlySession = wifiOnlySession
     self.statusListener = statusListener
+
+    uploadObserver = NotificationCenter.default.addObserver(forName: .uploadTaskDidComplete, object: nil, queue: nil) {
+      [weak self] _ in
+      self?.startQueueProcessing()
+    }
+    downloadObserver = NotificationCenter.default.addObserver(
+      forName: .downloadTaskDidComplete,
+      object: nil,
+      queue: nil
+    ) { [weak self] _ in
+      self?.startQueueProcessing()
+    }
+    networkObserver = NotificationCenter.default.addObserver(forName: .networkDidConnect, object: nil, queue: nil) {
+      [weak self] _ in
+      self?.startQueueProcessing()
+    }
   }
-  
+
+  deinit {
+    uploadObserver.map(NotificationCenter.default.removeObserver(_:))
+    downloadObserver.map(NotificationCenter.default.removeObserver(_:))
+    networkObserver.map(NotificationCenter.default.removeObserver(_:))
+  }
+
   func enqueueFiles(paths: [String]) async throws {
     guard !paths.isEmpty else { return dPrint("No paths to enqueue") }
 
-    guard let deviceId = (try? await db.read { conn in try Store.get(conn, StoreKey.deviceId) }) else {
+    guard let deviceId = try? storeRepository.get(StoreKey.deviceId) else {
       throw StoreError.notFound
     }
 
@@ -75,72 +104,36 @@ class UploadQueue {
       try await group.waitForAll()
     }
 
-    try await db.write { conn in
-      var draft = UploadTask.Draft(
-        attempts: 0,
-        createdAt: Date(),
-        filePath: nil,
-        isLivePhoto: nil,
-        lastError: nil,
-        livePhotoVideoId: nil,
-        localId: "",
-        method: .multipart,
-        priority: 0.5,
-        retryAfter: nil,
-        status: .downloadPending,
-      )
-      for path in paths {
-        draft.filePath = URL(fileURLWithPath: path, isDirectory: false)
-        try UploadTask.insert { draft }.execute(conn)
-      }
-    }
+    try await taskRepository.enqueue(files: paths)
     dPrint("Enqueued \(paths.count) assets for upload")
   }
 
   func startQueueProcessing() {
     dPrint("Starting upload queue processing")
-    Self.queueProcessingLock.withLock {
-      guard Self.queueProcessingTask == nil else { return }
-      Self.queueProcessingTask = Task {
+    queueProcessingLock.withLock {
+      guard queueProcessingTask == nil else { return }
+      queueProcessingTask = Task {
         await startUploads()
-        Self.queueProcessingLock.withLock { Self.queueProcessingTask = nil }
+        queueProcessingLock.withLock { queueProcessingTask = nil }
       }
     }
   }
 
   private func startUploads() async {
-    dPrint("Processing download queue")
+    dPrint("Processing upload queue")
     guard NetworkMonitor.shared.isConnected,
-      let backupEnabled = try? await db.read({ conn in try Store.get(conn, StoreKey.enableBackup) }),
-      backupEnabled
-    else { return dPrint("Download queue paused: network disconnected or backup disabled") }
+      let backupEnabled = try? storeRepository.get(StoreKey.enableBackup), backupEnabled,
+      let url = try? storeRepository.get(StoreKey.serverEndpoint),
+      let accessToken = try? storeRepository.get(StoreKey.accessToken)
+    else { return dPrint("Upload queue paused: missing preconditions") }
 
     do {
-      let tasks: [LocalAssetUploadData] = try await db.read({ conn in
-        guard let backupEnabled = try Store.get(conn, StoreKey.enableBackup), backupEnabled else { return [] }
-        return try UploadTask.join(LocalAsset.all) { task, asset in task.localId.eq(asset.id) }
-          .where { task, asset in
-            asset.checksum.isNot(nil) && task.status.eq(TaskStatus.uploadPending)
-              && task.attempts < TaskConfig.maxRetries
-              && task.filePath.isNot(nil)
-          }
-          .select { task, asset in
-            LocalAssetUploadData.Columns(
-              filePath: task.filePath.unwrapped,
-              priority: task.priority,
-              taskId: task.id,
-              type: asset.type
-            )
-          }
-          .limit { task, _ in UploadTaskStat.availableUploadSlots }
-          .order { task, asset in (task.priority.desc(), task.createdAt) }
-          .fetchAll(conn)
-      })
+      let tasks = try await taskRepository.getUploadTasks()
       if tasks.isEmpty { return dPrint("No upload tasks to process") }
 
       await withTaskGroup(of: Void.self) { group in
         for task in tasks {
-          group.addTask { await self.startUpload(multipart: task) }
+          group.addTask { await self.startUpload(multipart: task, url: url, accessToken: accessToken) }
         }
       }
     } catch {
@@ -148,33 +141,18 @@ class UploadQueue {
     }
   }
 
-  private func startUpload(multipart task: LocalAssetUploadData) async {
+  private func startUpload(multipart task: LocalAssetUploadData, url: URL, accessToken: String) async {
     dPrint("Uploading asset resource at \(task.filePath) of task \(task.taskId)")
     defer { startQueueProcessing() }
 
-    let (url, accessToken, session): (URL, String, URLSession)
-    do {
-      (url, accessToken, session) = try await db.read { conn in
-        guard let url = try Store.get(conn, StoreKey.serverEndpoint),
-          let accessToken = try Store.get(conn, StoreKey.accessToken)
-        else {
-          throw StoreError.notFound
-        }
-
-        let session =
-          switch task.type {
-          case .image:
-            (try? Store.get(conn, StoreKey.useWifiForUploadPhotos)) ?? false ? cellularSession : wifiOnlySession
-          case .video:
-            (try? Store.get(conn, StoreKey.useWifiForUploadVideos)) ?? false ? cellularSession : wifiOnlySession
-          default: wifiOnlySession
-          }
-        return (url, accessToken, session)
+    let session =
+      switch task.type {
+      case .image:
+        (try? storeRepository.get(StoreKey.useWifiForUploadPhotos)) ?? false ? wifiOnlySession : cellularSession
+      case .video:
+        (try? storeRepository.get(StoreKey.useWifiForUploadVideos)) ?? false ? wifiOnlySession : cellularSession
+      default: wifiOnlySession
       }
-    } catch {
-      dPrint("Upload failed for \(task.taskId), could not retrieve server URL or access token: \(error)")
-      return handleFailure(task: task, code: .noServerUrl)
-    }
 
     var request = URLRequest(url: url.appendingPathComponent("/assets"))
     request.httpMethod = "POST"
@@ -186,18 +164,11 @@ class UploadQueue {
     sessionTask.priority = task.priority
     do {
       try? FileManager.default.removeItem(at: task.filePath)  // upload task already copied the file
-      try await db.write { conn in
-        try UploadTask.update { row in
-          row.status = .uploadQueued
-          row.filePath = nil
-        }
-        .where { $0.id.eq(task.taskId) }
-        .execute(conn)
-      }
+      try await taskRepository.markUploadQueued(taskId: task.taskId)
       statusListener.onTaskStatus(
         UploadApiTaskStatus(
           id: String(task.taskId),
-          filename: task.filePath.lastPathComponent,
+          filename: task.filename,
           status: .uploadQueued,
         )
       )
@@ -209,11 +180,16 @@ class UploadQueue {
     }
   }
 
-  private func handleFailure(task: LocalAssetUploadData, code: UploadErrorCode) {
+  private func handleFailure(task: LocalAssetUploadData, code: UploadErrorCode) async {
     do {
-      try db.write { conn in
-        try UploadTask.retryOrFail(code: code, status: .uploadFailed).where { $0.id.eq(task.taskId) }.execute(conn)
-      }
+      try await taskRepository.retryOrFail(taskId: task.taskId, code: code, status: .uploadFailed)
+      statusListener.onTaskStatus(
+        UploadApiTaskStatus(
+          id: String(task.taskId),
+          filename: task.filename,
+          status: .uploadFailed
+        )
+      )
     } catch {
       dPrint("Failed to update upload failure status for task \(task.taskId): \(error)")
     }