Merge pull request #72 from rryam/feature/add-infavorites-property

Add inFavorites property support for music items

Author: rudrankriyam

Musadora/Musadora/Music Items/Song/SongsView.swift

@@ -13,6 +13,7 @@ struct SongsView: View {
   private var songs: Songs
   @State private var favoritedSongIDs: Set<MusicItemID> = []
   @State private var favoritingSongIDs: Set<MusicItemID> = []
+  @State private var isLoadingFavorites = false
 
   init(with songs: Songs) {
     self.songs = songs
@@ -81,8 +82,8 @@ struct SongsView: View {
               }
             } label: {
               let isFavorited = favoritedSongIDs.contains(song.id)
-              Image(systemName: isFavorited ? "heart.fill" : "heart")
-                .foregroundColor(isFavorited ? .red : .secondary)
+              Image(systemName: isFavorited ? "star.fill" : "star")
+                .foregroundColor(isFavorited ? .yellow : .secondary)
             }
             .buttonStyle(.plain)
             .disabled(favoritingSongIDs.contains(song.id) || favoritedSongIDs.contains(song.id))
@@ -104,5 +105,31 @@ struct SongsView: View {
     #if os(iOS)
     .navigationBarTitleDisplayMode(.large)
     #endif
+    .onChange(of: songs.count) { _, _ in
+      Task {
+        await loadFavoritesStatus()
+      }
+    }
+  }
+
+  private func loadFavoritesStatus() async {
+    guard !isLoadingFavorites else { return }
+    isLoadingFavorites = true
+
+    for song in songs {
+      do {
+        let isFavorite = try await song.inFavorites
+        if isFavorite {
+          await MainActor.run {
+            favoritedSongIDs.insert(song.id)
+          }
+        }
+      } catch {
+        // Song is not in library or other error - silently skip
+        continue
+      }
+    }
+
+    isLoadingFavorites = false
   }
 }

Sources/MusadoraKit/Library/InFavoritesParser.swift

@@ -0,0 +1,90 @@
+//
+//  InFavoritesParser.swift
+//  MusadoraKit
+//
+//  Created by Rudrank Riyam on 10/11/25.
+//
+
+import Foundation
+
+/// Response structure for Apple Music API inFavorites queries.
+private struct InFavoritesResponse: Decodable {
+  let data: [InFavoritesResponseItem]
+}
+
+private struct InFavoritesResponseItem: Decodable {
+  let attributes: InFavoritesAttributes?
+  let relationships: InFavoritesRelationships?
+}
+
+private struct InFavoritesAttributes: Decodable {
+  let inFavorites: Bool?
+}
+
+private struct InFavoritesRelationships: Decodable {
+  let library: InFavoritesLibrary?
+}
+
+private struct InFavoritesLibrary: Decodable {
+  struct Item: Decodable {}
+  let data: [Item]
+}
+
+/// Internal parser for extracting inFavorites status from Apple Music API responses.
+internal enum InFavoritesParser {
+  /// Parse the inFavorites response from Apple Music API data.
+  ///
+  /// This function extracts the inFavorites boolean value from the API response,
+  /// checking both that the item is in the library and that the inFavorites attribute exists.
+  ///
+  /// - Parameters:
+  ///   - data: The raw Data from the API response
+  ///   - itemType: The type of music item being parsed
+  /// - Returns: The inFavorites boolean value
+  /// - Throws: MusadoraKitError if parsing fails, item not found, not in library, or inFavorites not found
+  static func parse(from data: Data, itemType: LibraryMusicItemType) throws -> Bool {
+    let response = try JSONDecoder().decode(InFavoritesResponse.self, from: data)
+
+    guard let item = response.data.first else {
+      throw MusadoraKitError.notFound(for: "\(itemType.rawValue) in catalog")
+    }
+
+    guard let libraryData = item.relationships?.library?.data, !libraryData.isEmpty else {
+      throw MusadoraKitError.notInLibrary(item: itemType.rawValue)
+    }
+
+    guard let inFavorites = item.attributes?.inFavorites else {
+      throw MusadoraKitError.notFound(for: "inFavorites")
+    }
+
+    return inFavorites
+  }
+
+  /// Fetch inFavorites status for a music item from the Apple Music API.
+  ///
+  /// This helper method handles the common logic for fetching favorite status across all music item types.
+  ///
+  /// - Parameters:
+  ///   - id: The catalog ID of the music item
+  ///   - itemType: The type of music item
+  /// - Returns: `true` if the item is in favorites, `false` otherwise
+  /// - Throws: An error if the item is not in library or if the request fails
+  static func fetchInFavorites(for id: MusicItemID, itemType: LibraryMusicItemType) async throws -> Bool {
+    let storefront = try await MusicDataRequest.currentCountryCode
+    var components = AppleMusicURLComponents()
+    components.path = "catalog/\(storefront)/\(itemType.rawValue)/\(id.rawValue)"
+    components.queryItems = [
+      URLQueryItem(name: "relate", value: "library"),
+      URLQueryItem(name: "extend", value: "inFavorites")
+    ]
+
+    guard let url = components.url else {
+      throw URLError(.badURL)
+    }
+
+    let request = MusicDataRequest(urlRequest: .init(url: url))
+    let response = try await request.response()
+
+    return try parse(from: response.data, itemType: itemType)
+  }
+}

Sources/MusadoraKit/Library/MLibrary+Album.swift

@@ -209,6 +209,26 @@ public extension Album {
       return catalogId
     }
   }
+
+  /// A Boolean value indicating whether the album is in the user's favorites.
+  ///
+  /// This property fetches the album from the library and checks its favorite status.
+  ///
+  /// Example usage:
+  ///
+  ///     let album: Album = ...
+  ///     if try await album.inFavorites {
+  ///         print("This album is in favorites!")
+  ///     }
+  ///
+  /// - Returns: `true` if the album is in favorites, `false` otherwise.
+  /// - Throws: An error if the album is not in library or if the request fails.
+  var inFavorites: Bool {
+    get async throws {
+      let catalogId = try self.catalogID
+      return try await InFavoritesParser.fetchInFavorites(for: catalogId, itemType: .albums)
+    }
+  }
 }
 
 struct AlbumPlayParameters: Codable {

Sources/MusadoraKit/Library/MLibrary+Artist.swift

@@ -141,3 +141,24 @@ public extension MLibrary {
     }
   }
 }
+
+public extension Artist {
+  /// A Boolean value indicating whether the artist is in the user's favorites.
+  ///
+  /// This property fetches the artist from the library and checks its favorite status.
+  ///
+  /// Example usage:
+  ///
+  ///     let artist: Artist = ...
+  ///     if try await artist.inFavorites {
+  ///         print("This artist is in favorites!")
+  ///     }
+  ///
+  /// - Returns: `true` if the artist is in favorites, `false` otherwise.
+  /// - Throws: An error if the artist is not in library or if the request fails.
+  var inFavorites: Bool {
+    get async throws {
+      return try await InFavoritesParser.fetchInFavorites(for: id, itemType: .artists)
+    }
+  }
+}

Sources/MusadoraKit/Library/MLibrary+Playlist.swift

@@ -283,7 +283,9 @@ public extension MLibrary {
   static func madeForYouPlaylists() async throws -> LibraryPlaylists {
     var components = AppleMusicURLComponents()
     components.path = "me/library/playlists"
-    components.queryItems = [URLQueryItem(name: "filter[featured]", value: "made-for-you")]
+    components.queryItems = [
+      URLQueryItem(name: "filter[featured]", value: "made-for-you")
+    ]
 
     guard let url = components.url else {
       throw URLError(.badURL)
@@ -302,8 +304,31 @@ public extension MLibrary {
 
     var components = AppleMusicURLComponents()
     components.path = "me/library/playlists"
-    components.queryItems = [URLQueryItem(name: "limit", value: "\(limit)")]
+    components.queryItems = [
+      URLQueryItem(name: "limit", value: "\(limit)")
+    ]
 
     return components.url
   }
 }
+
+public extension Playlist {
+  /// A Boolean value indicating whether the playlist is in the user's favorites.
+  ///
+  /// This property fetches the playlist from the library and checks its favorite status.
+  ///
+  /// Example usage:
+  ///
+  ///     let playlist: Playlist = ...
+  ///     if try await playlist.inFavorites {
+  ///         print("This playlist is in favorites!")
+  ///     }
+  ///
+  /// - Returns: `true` if the playlist is in favorites, `false` otherwise.
+  /// - Throws: An error if the playlist is not in library or if the request fails.
+  var inFavorites: Bool {
+    get async throws {
+      return try await InFavoritesParser.fetchInFavorites(for: id, itemType: .playlists)
+    }
+  }
+}

Sources/MusadoraKit/Library/MLibrary+Song.swift

@@ -5,6 +5,7 @@
 //  Created by Rudrank Riyam on 14/08/21.
 //
 
+// swiftlint:disable file_length
 import MediaPlayer
 
 public extension MLibrary {
@@ -488,3 +489,58 @@ public extension MLibrary {
     return response.sections
   }
 }
+
+public extension Song {
+  /// A Boolean value indicating whether the song is in the user's favorites.
+  ///
+  /// This property fetches the song from the library and checks its favorite status.
+  ///
+  /// Example usage:
+  ///
+  ///     let song: Song = ...
+  ///     if try await song.inFavorites {
+  ///         print("This song is in favorites!")
+  ///     }
+  ///
+  /// - Returns: `true` if the song is in favorites, `false` otherwise.
+  /// - Throws: An error if the song is not in library or if the request fails.
+  var inFavorites: Bool {
+    get async throws {
+      let catalogId = try self.catalogID
+      return try await InFavoritesParser.fetchInFavorites(for: catalogId, itemType: .songs)
+    }
+  }
+
+  /// The catalog identifier for the song.
+  ///
+  /// This property decodes the play parameters of the song to retrieve its catalog identifier.
+  ///
+  /// - Returns: The catalog ID of the song.
+  /// - Throws: `MusadoraKitError.notFound` if play parameters or catalog ID are not available.
+  var catalogID: MusicItemID {
+    get throws {
+      guard let playParameters = playParameters else {
+        throw MusadoraKitError.notFound(for: "playParameters")
+      }
+
+      let playParamData = try JSONEncoder().encode(playParameters)
+      let params = try JSONDecoder().decode(SongPlayParameters.self, from: playParamData)
+
+      guard let catalogId = params.catalogId else {
+        throw MusadoraKitError.notFound(for: "catalogId")
+      }
+
+      return catalogId
+    }
+  }
+}
+
+internal struct SongPlayParameters: Codable {
+  let isLibrary: Bool?
+  let catalogId: MusicItemID?
+
+  private enum CodingKeys: String, CodingKey {
+    case isLibrary
+    case catalogId
+  }
+}

Sources/MusadoraKit/Models/MusadoraKitError.swift

@@ -12,6 +12,9 @@ public enum MusadoraKitError: Error, Equatable {
   /// The specified music item could not be found.
   case notFound(for: String)
 
+  /// The specified music item is not in the user's library.
+  case notInLibrary(item: String)
+
   /// One or more types must be specified for the operation.
   case typeMissing
 
@@ -75,6 +78,8 @@ extension MusadoraKitError: CustomStringConvertible {
     switch self {
     case let .notFound(id):
       return "The specified music item could not be found for \(id)."
+    case let .notInLibrary(item):
+      return "The \(item) is not in the user's library."
     case .typeMissing:
       return "One or more types must be specified for fetching top results in search suggestions."
     case let .recommendationOverLimit(limit):