Creating sync tasks for ahrdcover ids

Author: Hirobreak

BookPlayer.xcodeproj/project.pbxproj

@@ -1071,6 +1071,26 @@ class LibraryServiceProtocolMock: LibraryServiceProtocol {
             return removeExternalResourceProviderNameForReturnValue
         }
     }
+    //MARK: - getExternalResources
+
+    var getExternalResourcesForCallsCount = 0
+    var getExternalResourcesForCalled: Bool {
+        return getExternalResourcesForCallsCount > 0
+    }
+    var getExternalResourcesForReceivedRelativePath: String?
+    var getExternalResourcesForReceivedInvocations: [String] = []
+    var getExternalResourcesForReturnValue: [SimpleExternalResource]! = []
+    var getExternalResourcesForClosure: ((String) async -> [SimpleExternalResource])?
+    func getExternalResources(for relativePath: String) async -> [SimpleExternalResource] {
+        getExternalResourcesForCallsCount += 1
+        getExternalResourcesForReceivedRelativePath = relativePath
+        getExternalResourcesForReceivedInvocations.append(relativePath)
+        if let getExternalResourcesForClosure = getExternalResourcesForClosure {
+            return await getExternalResourcesForClosure(relativePath)
+        } else {
+            return getExternalResourcesForReturnValue
+        }
+    }
     //MARK: - getHardcoverBook
 
     var getHardcoverBookForCallsCount = 0

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

@@ -7,6 +7,7 @@
 //
 
 import SwiftUI
+import BookPlayerKit
 
 struct ItemDetailsHardcoverSectionView: View {
   @Environment(\.dismiss) var dismiss
@@ -16,8 +17,14 @@ struct ItemDetailsHardcoverSectionView: View {
 
   var body: some View {
     Section(
-      header: Text("section_item_hardcover".localized)
-        .foregroundStyle(theme.secondaryColor)
+      header: HStack(spacing: Spacing.S) {
+        Text("section_item_hardcover".localized)
+          .foregroundStyle(theme.secondaryColor)
+        if viewModel.isFetchingBook {
+          ProgressView()
+            .controlSize(.small)
+        }
+      }
     ) {
       NavigationLink(
         destination: {
@@ -40,6 +47,8 @@ struct ItemDetailsHardcoverSectionView: View {
 extension ItemDetailsHardcoverSectionView {
   class Model: ObservableObject {
     @Published var pickerViewModel: HardcoverBookPickerView.Model
+    /// True while fetching the linked book's info from Hardcover via its external resource
+    @Published var isFetchingBook: Bool = false
 
     init(pickerViewModel: HardcoverBookPickerView.Model = .init()) {
       self.pickerViewModel = pickerViewModel

BookPlayer/Generated/AutoMockable.generated.swift

@@ -42,6 +42,11 @@ protocol HardcoverServiceProtocol {
   /// Remove a book from the user's Hardcover library
   /// - Parameter book: The Hardcover book to remove from library
   func removeFromLibrary(_ book: SimpleHardcoverBook) async throws
+
+  /// Fetch a single book's info from Hardcover by its id
+  /// - Parameter id: The Hardcover book id (the external resource's providerId)
+  /// - Returns: The book info, or nil if not found
+  func getBook(id: Int) async throws -> SimpleHardcoverBook?
 }
 
 @Observable
@@ -135,6 +140,38 @@ extension HardcoverService {
     return result
   }
 
+  func getBook(id: Int) async throws -> SimpleHardcoverBook? {
+    Self.logger.info("Fetching Hardcover book info for id \(id)")
+
+    let queryString = """
+        query GetBook($id: Int!) {
+          books(where: {id: {_eq: $id}}, limit: 1) {
+            id
+            title
+            image { url }
+            contributions { author { name } }
+          }
+        }
+        """
+
+    let result = try await graphQL.execute(
+      query: queryString,
+      variables: ["id": id],
+      authorization: authorization,
+      responseType: BookByIdData.self
+    )
+
+    guard let book = result.books.first else { return nil }
+
+    return SimpleHardcoverBook(
+      id: book.id,
+      artworkURL: book.image?.url.flatMap(URL.init(string:)),
+      title: book.title,
+      author: book.contributions?.first?.author?.name ?? "",
+      status: .local
+    )
+  }
+
   private func insertUserBook(bookID: Int, status: HardcoverBook.Status) async throws -> InsertUserBookData {
     let mutation = """
         mutation InsertUserBook($book_id: Int!, $status_id: Int!) {
@@ -234,47 +271,67 @@ extension HardcoverService {
   }
 
   private func handleBookStarted(relativePath: String, percentCompleted: Double) async {
-    guard
-      percentCompleted > readingThreshold,
-      var item = await libraryService.getHardcoverBook(for: relativePath),
-      item.status < .reading
-    else { return }
+    guard percentCompleted > readingThreshold else { return }
 
-    do {
-      Self.logger.info("Updating Hardcover API: book \(item.id) to 'reading' status")
-      _ = try await insertUserBook(
-        bookID: item.id,
-        status: .reading
-      )
-      Self.logger.info("Successfully updated Hardcover API for book \(item.id)")
+    await updateExternalResources(for: relativePath, to: .reading)
+  }
 
-      item.status = .reading
-      await libraryService.setHardcoverBook(item, for: relativePath)
-      Self.logger.info("Updated local status to 'reading' for \(relativePath)")
-    } catch {
-      Self.logger.error("Failed to update Hardcover status for book \(item.id): \(error)")
+  private func handleBookFinished(relativePath: String) async {
+    await updateExternalResources(for: relativePath, to: .read)
+  }
+
+  /// Iterate the item's external resources and run the matching provider action for the new status.
+  private func updateExternalResources(
+    for relativePath: String,
+    to status: HardcoverBook.Status
+  ) async {
+    let resources = await libraryService.getExternalResources(for: relativePath)
+
+    for resource in resources {
+      guard let provider = ExternalResource.ProviderName(rawValue: resource.providerName) else { continue }
+
+      switch provider {
+      case .hardcover:
+        await updateHardcoverStatus(status, providerId: resource.providerId, for: relativePath)
+      case .jellyfin, .audiobookshelf:
+        break
+      }
     }
   }
 
-  private func handleBookFinished(relativePath: String) async {
-    guard
-      var item = await libraryService.getHardcoverBook(for: relativePath),
-      item.status != .read
-    else { return }
+  /// Push the given status to Hardcover for the book identified by `providerId`,
+  /// keeping the local reference in sync. No-op if it already reached `status`.
+  private func updateHardcoverStatus(
+    _ status: HardcoverBook.Status,
+    providerId: String,
+    for relativePath: String
+  ) async {
+    guard let bookID = Int(providerId) else { return }
+
+    let existing = await libraryService.getHardcoverBook(for: relativePath)
+    if let existing, existing.status >= status {
+      return
+    }
 
     do {
-      Self.logger.info("Updating Hardcover API: book \(item.id) to 'read' status")
-      _ = try await insertUserBook(
-        bookID: item.id,
-        status: .read
+      Self.logger.info("Updating Hardcover API: book \(bookID) to '\(String(describing: status))' status")
+      let response = try await insertUserBook(bookID: bookID, status: status)
+
+      var updated = existing ?? SimpleHardcoverBook(
+        id: bookID,
+        artworkURL: nil,
+        title: "",
+        author: "",
+        status: status
       )
-      Self.logger.info("Successfully updated Hardcover API for book \(item.id)")
-
-      item.status = .read
-      await libraryService.setHardcoverBook(item, for: relativePath)
-      Self.logger.info("Updated local status to 'read' for \(relativePath)")
+      updated.status = status
+      if updated.userBookID == nil {
+        updated.userBookID = response.insertUserBook.id
+      }
+      await libraryService.setHardcoverBook(updated, for: relativePath)
+      Self.logger.info("Updated local Hardcover status to '\(String(describing: status))' for \(relativePath)")
     } catch {
-      Self.logger.error("Failed to update Hardcover status for book \(item.id): \(error)")
+      Self.logger.error("Failed to update Hardcover status for book \(bookID): \(error)")
     }
   }
 
@@ -502,3 +559,27 @@ extension SimpleHardcoverBook {
     )
   }
 }
+
+/// Response model for fetching a single book by its Hardcover id.
+private struct BookByIdData: Codable {
+  let books: [Book]
+
+  struct Book: Codable {
+    let id: Int
+    let title: String
+    let image: Artwork?
+    let contributions: [Contribution]?
+
+    struct Artwork: Codable {
+      let url: String?
+    }
+
+    struct Contribution: Codable {
+      let author: Author?
+
+      struct Author: Codable {
+        let name: String?
+      }
+    }
+  }
+}

BookPlayer/Hardcover/ItemDetails Section/ItemDetailsHardcoverSectionView.swift

@@ -100,16 +100,70 @@ final class ItemDetailsViewModel: ObservableObject {
     )
 
     Task {
-      if let item = await libraryService.getHardcoverBook(for: item.relativePath) {
-        hardcoverBook = item
-        hardcoverSectionViewModel?.pickerViewModel.selected = .init(
-          id: item.id,
-          artworkURL: item.artworkURL,
-          title: item.title,
-          author: item.author
-        )
-      }
+      await resolveHardcoverSelection()
+    }
+  }
+
+  /// Populate the Hardcover picker selection. Prefers the full local reference; otherwise
+  /// falls back to the hardcover external resource — showing the item's title right away,
+  /// then fetching the real book info from Hardcover by its providerId.
+  @MainActor
+  private func resolveHardcoverSelection() async {
+    if let book = await libraryService.getHardcoverBook(for: item.relativePath) {
+      hardcoverBook = book
+      hardcoverSectionViewModel?.pickerViewModel.selected = .init(
+        id: book.id,
+        artworkURL: book.artworkURL,
+        title: book.title,
+        author: book.author
+      )
+      return
     }
+
+    /// No full local reference — fall back to the hardcover external resource, if any
+    guard hardcoverSectionViewModel != nil else { return }
+
+    let resources = await libraryService.getExternalResources(for: item.relativePath)
+    guard
+      let resource = resources.first(where: {
+        $0.providerName == ExternalResource.ProviderName.hardcover.rawValue
+      }),
+      let bookID = Int(resource.providerId)
+    else { return }
+
+    /// Show at least the item's title so the row reflects a selection
+    hardcoverBook = SimpleHardcoverBook(
+      id: bookID,
+      artworkURL: nil,
+      title: item.title,
+      author: item.details,
+      status: .local
+    )
+    hardcoverSectionViewModel?.pickerViewModel.selected = .init(
+      id: bookID,
+      artworkURL: nil,
+      title: item.title,
+      author: item.details
+    )
+
+    /// Fetch the real book info from Hardcover and update the selection
+    hardcoverSectionViewModel?.isFetchingBook = true
+    let fetched = try? await hardcoverService.getBook(id: bookID)
+    hardcoverSectionViewModel?.isFetchingBook = false
+
+    /// Discard the result if the selection was swapped or unlinked while fetching
+    guard
+      let fetched,
+      hardcoverSectionViewModel?.pickerViewModel.selected?.id == bookID
+    else { return }
+
+    hardcoverBook = fetched
+    hardcoverSectionViewModel?.pickerViewModel.selected = .init(
+      id: fetched.id,
+      artworkURL: fetched.artworkURL,
+      title: fetched.title,
+      author: fetched.author
+    )
   }
 
   func handleSaveAction(_ loadingState: LoadingOverlayState, success: @escaping () -> Void) {

BookPlayer/Hardcover/Network/HardcoverService.swift

@@ -141,6 +141,8 @@ struct QueuedSyncTasksView: View {
       return "arrow.up.forward.square"
     case .externalResourceToDownload:
       return "link.badge.plus"
+    case .deleteExternalResource:
+      return "xmark.bin"
     }
   }
 }