delete external resource, hardcover as an er

Author: Hirobreak

BookPlayer.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -1031,6 +1031,46 @@ class LibraryServiceProtocolMock: LibraryServiceProtocol {
         setHardcoverBookForReceivedInvocations.append((hardcoverBook: hardcoverBook, relativePath: relativePath))
         await setHardcoverBookForClosure?(hardcoverBook, relativePath)
     }
+    //MARK: - setExternalResource
+
+    var setExternalResourceProviderNameProviderIdForCallsCount = 0
+    var setExternalResourceProviderNameProviderIdForCalled: Bool {
+        return setExternalResourceProviderNameProviderIdForCallsCount > 0
+    }
+    var setExternalResourceProviderNameProviderIdForReceivedArguments: (providerName: String, providerId: String, uuid: String)?
+    var setExternalResourceProviderNameProviderIdForReceivedInvocations: [(providerName: String, providerId: String, uuid: String)] = []
+    var setExternalResourceProviderNameProviderIdForReturnValue: SyncableExternalResource?
+    var setExternalResourceProviderNameProviderIdForClosure: ((String, String, String) async -> SyncableExternalResource?)?
+    func setExternalResource(providerName: String, providerId: String, for uuid: String) async -> SyncableExternalResource? {
+        setExternalResourceProviderNameProviderIdForCallsCount += 1
+        setExternalResourceProviderNameProviderIdForReceivedArguments = (providerName: providerName, providerId: providerId, uuid: uuid)
+        setExternalResourceProviderNameProviderIdForReceivedInvocations.append((providerName: providerName, providerId: providerId, uuid: uuid))
+        if let setExternalResourceProviderNameProviderIdForClosure = setExternalResourceProviderNameProviderIdForClosure {
+            return await setExternalResourceProviderNameProviderIdForClosure(providerName, providerId, uuid)
+        } else {
+            return setExternalResourceProviderNameProviderIdForReturnValue
+        }
+    }
+    //MARK: - removeExternalResource
+
+    var removeExternalResourceProviderNameForCallsCount = 0
+    var removeExternalResourceProviderNameForCalled: Bool {
+        return removeExternalResourceProviderNameForCallsCount > 0
+    }
+    var removeExternalResourceProviderNameForReceivedArguments: (providerName: String, uuid: String)?
+    var removeExternalResourceProviderNameForReceivedInvocations: [(providerName: String, uuid: String)] = []
+    var removeExternalResourceProviderNameForReturnValue: String?
+    var removeExternalResourceProviderNameForClosure: ((String, String) async -> String?)?
+    func removeExternalResource(providerName: String, for uuid: String) async -> String? {
+        removeExternalResourceProviderNameForCallsCount += 1
+        removeExternalResourceProviderNameForReceivedArguments = (providerName: providerName, uuid: uuid)
+        removeExternalResourceProviderNameForReceivedInvocations.append((providerName: providerName, uuid: uuid))
+        if let removeExternalResourceProviderNameForClosure = removeExternalResourceProviderNameForClosure {
+            return await removeExternalResourceProviderNameForClosure(providerName, uuid)
+        } else {
+            return removeExternalResourceProviderNameForReturnValue
+        }
+    }
     //MARK: - getHardcoverBook
 
     var getHardcoverBookForCallsCount = 0
@@ -2145,6 +2185,36 @@ class SyncServiceProtocolMock: SyncServiceProtocol {
         scheduleUploadArtworkRelativePathUuidReceivedInvocations.append((relativePath: relativePath, uuid: uuid))
         scheduleUploadArtworkRelativePathUuidClosure?(relativePath, uuid)
     }
+    //MARK: - scheduleExternalResourceUpload
+
+    var scheduleExternalResourceUploadRelativePathUuidCallsCount = 0
+    var scheduleExternalResourceUploadRelativePathUuidCalled: Bool {
+        return scheduleExternalResourceUploadRelativePathUuidCallsCount > 0
+    }
+    var scheduleExternalResourceUploadRelativePathUuidReceivedArguments: (resource: SyncableExternalResource, relativePath: String, uuid: String)?
+    var scheduleExternalResourceUploadRelativePathUuidReceivedInvocations: [(resource: SyncableExternalResource, relativePath: String, uuid: String)] = []
+    var scheduleExternalResourceUploadRelativePathUuidClosure: ((SyncableExternalResource, String, String) -> Void)?
+    func scheduleExternalResourceUpload(_ resource: SyncableExternalResource, relativePath: String, uuid: String) {
+        scheduleExternalResourceUploadRelativePathUuidCallsCount += 1
+        scheduleExternalResourceUploadRelativePathUuidReceivedArguments = (resource: resource, relativePath: relativePath, uuid: uuid)
+        scheduleExternalResourceUploadRelativePathUuidReceivedInvocations.append((resource: resource, relativePath: relativePath, uuid: uuid))
+        scheduleExternalResourceUploadRelativePathUuidClosure?(resource, relativePath, uuid)
+    }
+    //MARK: - scheduleExternalResourceDeletion
+
+    var scheduleExternalResourceDeletionProviderNameProviderIdRelativePathUuidCallsCount = 0
+    var scheduleExternalResourceDeletionProviderNameProviderIdRelativePathUuidCalled: Bool {
+        return scheduleExternalResourceDeletionProviderNameProviderIdRelativePathUuidCallsCount > 0
+    }
+    var scheduleExternalResourceDeletionProviderNameProviderIdRelativePathUuidReceivedArguments: (providerName: String, providerId: String, relativePath: String, uuid: String)?
+    var scheduleExternalResourceDeletionProviderNameProviderIdRelativePathUuidReceivedInvocations: [(providerName: String, providerId: String, relativePath: String, uuid: String)] = []
+    var scheduleExternalResourceDeletionProviderNameProviderIdRelativePathUuidClosure: ((String, String, String, String) -> Void)?
+    func scheduleExternalResourceDeletion(providerName: String, providerId: String, relativePath: String, uuid: String) {
+        scheduleExternalResourceDeletionProviderNameProviderIdRelativePathUuidCallsCount += 1
+        scheduleExternalResourceDeletionProviderNameProviderIdRelativePathUuidReceivedArguments = (providerName: providerName, providerId: providerId, relativePath: relativePath, uuid: uuid)
+        scheduleExternalResourceDeletionProviderNameProviderIdRelativePathUuidReceivedInvocations.append((providerName: providerName, providerId: providerId, relativePath: relativePath, uuid: uuid))
+        scheduleExternalResourceDeletionProviderNameProviderIdRelativePathUuidClosure?(providerName, providerId, relativePath, uuid)
+    }
     //MARK: - getAllQueuedJobs
 
     var getAllQueuedJobsCallsCount = 0

BookPlayer/Generated/AutoMockable.generated.swift

@@ -50,6 +50,7 @@ final class HardcoverService: BPLogger, HardcoverServiceProtocol {
   private let graphQL = GraphQLClient(baseURL: "https://api.hardcover.app/v1/graphql")
   private var audioMetadataService: AudioMetadataServiceProtocol!
   private var libraryService: LibraryServiceProtocol!
+  private var syncService: SyncServiceProtocol?
 
   private var metadataSubscription: AnyCancellable?
   private var progressSubscription: AnyCancellable?
@@ -71,10 +72,12 @@ final class HardcoverService: BPLogger, HardcoverServiceProtocol {
 
   func setup(
     libraryService: LibraryServiceProtocol,
+    syncService: SyncServiceProtocol? = nil,
     keychain: KeychainServiceProtocol = KeychainService(),
     audioMetadataService: AudioMetadataServiceProtocol = AudioMetadataService()
   ) {
     self.libraryService = libraryService
+    self.syncService = syncService
     self.keychain = keychain
     self.audioMetadataService = audioMetadataService
 
@@ -325,6 +328,7 @@ extension HardcoverService {
         }
 
         await libraryService.setHardcoverBook(book, for: match.item.relativePath)
+        await uploadExternalResource(for: book, to: match.item)
         Self.logger.info("Auto-matched '\(match.item.title)' to Hardcover ID \(bookID)")
         processedCount += 1
       } catch {
@@ -343,6 +347,9 @@ extension HardcoverService {
     _ book: SimpleHardcoverBook?,
     to item: SimpleLibraryItem
   ) async {
+    /// Remove any existing hardcover resource first (handles both unlink and swap)
+    await deleteExternalResource(for: item)
+
     guard let book else {
       await libraryService.setHardcoverBook(nil, for: item.relativePath)
       Self.logger.info("Removed Hardcover assignment from '\(item.title)'")
@@ -351,26 +358,66 @@ extension HardcoverService {
 
     Self.logger.info("Assigning Hardcover book \(book.id) to '\(item.title)'")
 
-    guard autoAddWantToReadEnabled, authorization != nil else {
+    if autoAddWantToReadEnabled, authorization != nil {
+      do {
+        let response = try await insertUserBook(
+          bookID: book.id,
+          status: .library
+        )
+        Self.logger.info("Added '\(item.title)' to Hardcover Want to Read list")
+
+        var updated = book
+        updated.status = .library
+        updated.userBookID = response.insertUserBook.id
+        await libraryService.setHardcoverBook(updated, for: item.relativePath)
+      } catch {
+        Self.logger.error("Failed to add '\(item.title)' to Hardcover Want to Read: \(error)")
+        await libraryService.setHardcoverBook(book, for: item.relativePath)
+      }
+    } else {
       await libraryService.setHardcoverBook(book, for: item.relativePath)
-      return
     }
 
-    do {
-      let response = try await insertUserBook(
-        bookID: book.id,
-        status: .library
+    await uploadExternalResource(for: book, to: item)
+  }
+
+  /// Create the hardcover external resource for the item and sync-upload it if a sync service is available.
+  private func uploadExternalResource(
+    for book: SimpleHardcoverBook,
+    to item: SimpleLibraryItem
+  ) async {
+    guard
+      let syncable = await libraryService.setExternalResource(
+        providerName: ExternalResource.ProviderName.hardcover.rawValue,
+        providerId: String(book.id),
+        for: item.uuid
       )
-      Self.logger.info("Added '\(item.title)' to Hardcover Want to Read list")
+    else { return }
 
-      var updated = book
-      updated.status = .library
-      updated.userBookID = response.insertUserBook.id
-      await libraryService.setHardcoverBook(updated, for: item.relativePath)
-    } catch {
-      Self.logger.error("Failed to add '\(item.title)' to Hardcover Want to Read: \(error)")
-      await libraryService.setHardcoverBook(book, for: item.relativePath)
-    }
+    syncService?.scheduleExternalResourceUpload(
+      syncable,
+      relativePath: item.relativePath,
+      uuid: item.uuid
+    )
+  }
+
+  /// Delete the hardcover external resource for the item and schedule a delete sync task if a sync service is available.
+  private func deleteExternalResource(for item: SimpleLibraryItem) async {
+    let providerName = ExternalResource.ProviderName.hardcover.rawValue
+
+    guard
+      let providerId = await libraryService.removeExternalResource(
+        providerName: providerName,
+        for: item.uuid
+      )
+    else { return }
+
+    syncService?.scheduleExternalResourceDeletion(
+      providerName: providerName,
+      providerId: providerId,
+      relativePath: item.relativePath,
+      uuid: item.uuid
+    )
   }
 
   func removeFromLibrary(_ book: SimpleHardcoverBook) async throws {

BookPlayer/Hardcover/Network/HardcoverService.swift

@@ -98,7 +98,7 @@ final class AppServices: BPLogger {
         playbackService: playbackService,
         playerManager: playerManager
       )
-      let hardcoverService = makeHardcoverService(libraryService: libraryService)
+      let hardcoverService = makeHardcoverService(libraryService: libraryService, syncService: syncService)
 
       let preferencesService = PreferencesSyncService()
       preferencesService.setup(
@@ -268,9 +268,9 @@ final class AppServices: BPLogger {
     return service
   }
 
-  private func makeHardcoverService(libraryService: LibraryService) -> HardcoverService {
+  private func makeHardcoverService(libraryService: LibraryService, syncService: SyncService) -> HardcoverService {
     let service = HardcoverService()
-    service.setup(libraryService: libraryService)
+    service.setup(libraryService: libraryService, syncService: syncService)
     return service
   }
 }

BookPlayer/Utils/AppServices.swift

@@ -173,7 +173,13 @@ public protocol LibraryServiceProtocol: AnyObject {
   func setHardcoverBook(_ hardcoverBook: SimpleHardcoverBook?, for relativePath: String) async
   /// Get hardcover book for an item
   func getHardcoverBook(for relativePath: String) async -> SimpleHardcoverBook?
-    
+  /// Create an external resource linking the item (by uuid) to a provider's resource.
+  /// Returns the syncable representation to upload, or nil if it already exists or the item is missing.
+  func setExternalResource(providerName: String, providerId: String, for uuid: String) async -> SyncableExternalResource?
+  /// Remove the external resource of the given provider from the item (by uuid).
+  /// Returns the deleted resource's providerId, or nil if there was nothing to delete.
+  func removeExternalResource(providerName: String, for uuid: String) async -> String?
+
   func getExternalResource(for providerId: String) async -> ExternalResource?
 
   func findResource(for providerId: String, context: NSManagedObjectContext?) -> ExternalResource?
@@ -3000,6 +3006,79 @@ extension LibraryService {
     }
   }
 
+  public func setExternalResource(
+    providerName: String,
+    providerId: String,
+    for uuid: String
+  ) async -> SyncableExternalResource? {
+    return await withCheckedContinuation { continuation in
+      let context = dataManager.getBackgroundContext()
+
+      context.perform { [unowned self, context] in
+        let fetchRequest: NSFetchRequest<LibraryItem> = LibraryItem.fetchRequest()
+        fetchRequest.predicate = NSPredicate(format: "%K == %@", #keyPath(LibraryItem.uuid), uuid)
+        fetchRequest.fetchLimit = 1
+
+        guard let item = try? context.fetch(fetchRequest).first else {
+          continuation.resume(returning: nil)
+          return
+        }
+
+        /// Skip if the same resource is already linked
+        if item.resourcesArray.contains(where: {
+          $0.providerName == providerName && $0.providerId == providerId
+        }) {
+          continuation.resume(returning: nil)
+          return
+        }
+
+        let syncable = SyncableExternalResource(
+          providerName: providerName,
+          providerId: providerId,
+          syncStatus: ExternalResource.SyncStatus.notSynced.rawValue,
+          lastSyncedAt: nil,
+          processedFile: true,
+          hostId: nil
+        )
+
+        _ = ExternalResource.create(syncable, libraryItem: item, in: context)
+
+        dataManager.saveSyncContext(context)
+        continuation.resume(returning: syncable)
+      }
+    }
+  }
+
+  public func removeExternalResource(
+    providerName: String,
+    for uuid: String
+  ) async -> String? {
+    return await withCheckedContinuation { continuation in
+      let context = dataManager.getBackgroundContext()
+
+      context.perform { [unowned self, context] in
+        let fetchRequest: NSFetchRequest<LibraryItem> = LibraryItem.fetchRequest()
+        fetchRequest.predicate = NSPredicate(format: "%K == %@", #keyPath(LibraryItem.uuid), uuid)
+        fetchRequest.fetchLimit = 1
+
+        guard
+          let item = try? context.fetch(fetchRequest).first,
+          let resource = item.resourcesArray.first(where: { $0.providerName == providerName })
+        else {
+          continuation.resume(returning: nil)
+          return
+        }
+
+        let providerId = resource.providerId
+        item.removeFromExternalResources(resource)
+        context.delete(resource)
+
+        dataManager.saveSyncContext(context)
+        continuation.resume(returning: providerId)
+      }
+    }
+  }
+
   public func getHardcoverBook(for relativePath: String) async -> SimpleHardcoverBook? {
     return await withCheckedContinuation { continuation in
       let context = dataManager.getBackgroundContext()

Shared/Services/LibraryService.swift

@@ -25,6 +25,7 @@ public enum LibraryAPI {
   case uploadArtwork(path: String, filename: String, uploaded: Bool?, uuid: String)
   case matchUuids(uuidsDictionary: [String: String])
   case externalResourceToDownload(uuid: String, uploaded: Bool)
+  case deleteExternalResource(uuid: String, providerName: String, providerId: String)
 }
 
 extension LibraryAPI: Endpoint {
@@ -62,6 +63,8 @@ extension LibraryAPI: Endpoint {
       return "/v1/library/external"
     case .externalResourceToDownload:
       return "/v1/library/external_set"
+    case .deleteExternalResource:
+      return "/v1/library/external"
     }
   }
 
@@ -99,6 +102,8 @@ extension LibraryAPI: Endpoint {
       return .put
     case .externalResourceToDownload:
       return .post
+    case .deleteExternalResource:
+      return .delete
     }
   }
 
@@ -181,6 +186,12 @@ extension LibraryAPI: Endpoint {
         "uuid": uuid,
         "uploaded": uploaded
       ]
+    case .deleteExternalResource(let uuid, let providerName, let providerId):
+      return [
+        "uuid": uuid,
+        "providerName": providerName,
+        "providerId": providerId
+      ]
     }
   }
 }

Shared/Services/Sync/LibraryAPI.swift

@@ -147,6 +147,17 @@ class LibraryItemSyncOperation: Operation, BPLogger {
         case .externalResourceToDownload:
           try await handleExternalResourceToDownload()
           finish()
+        case .deleteExternalResource:
+          guard
+            let providerName = parameters["providerName"] as? String,
+            let providerId = parameters["providerId"] as? String
+          else {
+            throw BookPlayerError.runtimeError("Missing parameters for deleting an external resource")
+          }
+          let _: Empty = try await self.provider.request(
+            .deleteExternalResource(uuid: uuid, providerName: providerName, providerId: providerId)
+          )
+          finish()
         }
       } catch {
         self.error = error