@wwdrew/expo-apple-music 1.0.0

package/ios/LibraryService.swift

@@ -0,0 +1,313 @@
+// LibraryService.swift
+// Handles user's Apple Music library operations.
+
+import Foundation
+import MusicKit
+
+@available(iOS 16.0, *)
+final class LibraryService {
+
+  // MARK: - Options
+
+  func getArtists(musicUserToken: String, options: BridgePagination) async throws -> [[String: Any]] {
+    let data = try await AppleMusicRestClient.getDataArray(
+      path: "/v1/me/library/artists",
+      musicUserToken: musicUserToken,
+      query: ["limit": "\(options.limit)", "offset": "\(options.offset)"]
+    )
+    return data.map(RestJsonMapper.mapArtist)
+  }
+
+  private func getArtistsNative(options: BridgePagination) async throws -> [[String: Any]] {
+    var request = MusicLibraryRequest<Artist>()
+    request.limit = options.limit
+    request.offset = options.offset
+    let response = try await request.response()
+    return response.items.map(MusicItemMapper.map)
+  }
+
+  func getAlbums(musicUserToken: String, options: BridgePagination) async throws -> [[String: Any]] {
+    let data = try await AppleMusicRestClient.getDataArray(
+      path: "/v1/me/library/albums",
+      musicUserToken: musicUserToken,
+      query: ["limit": "\(options.limit)", "offset": "\(options.offset)"]
+    )
+    return data.map(RestJsonMapper.mapAlbum)
+  }
+
+  private func getAlbumsNative(options: BridgePagination) async throws -> [[String: Any]] {
+    var request = MusicLibraryRequest<Album>()
+    request.limit = options.limit
+    request.offset = options.offset
+    let response = try await request.response()
+    return response.items.map(MusicItemMapper.map)
+  }
+
+  // MARK: - Playlists
+
+  func getPlaylists(musicUserToken: String, options: BridgePagination) async throws -> [[String: Any]] {
+    let data = try await AppleMusicRestClient.getDataArray(
+      path: "/v1/me/library/playlists",
+      musicUserToken: musicUserToken,
+      query: ["limit": "\(options.limit)", "offset": "\(options.offset)"]
+    )
+    return data.map(RestJsonMapper.mapPlaylist)
+  }
+
+  private func getPlaylistsNative(options: BridgePagination) async throws -> [[String: Any]] {
+    var request = MusicLibraryRequest<Playlist>()
+    request.limit = options.limit
+    request.offset = options.offset
+
+    let response = try await request.response()
+
+    // Load tracks for accurate count
+    var playlists: [[String: Any]] = []
+    for playlist in response.items {
+      let detailed = try await playlist.with([.tracks])
+      playlists.append(MusicItemMapper.map(detailed))
+    }
+    return playlists
+  }
+
+  func getPlaylistSongs(musicUserToken: String, playlistId: String) async throws -> [[String: Any]] {
+    let json = try await AppleMusicRestClient.get(
+      path: "/v1/me/library/playlists/\(playlistId)/tracks",
+      musicUserToken: musicUserToken
+    )
+    guard let data = json["data"] as? [[String: Any]] else {
+      throw LibraryServiceError.playlistNotFound
+    }
+    return data.compactMap { row -> [String: Any]? in
+      guard let type = row["type"] as? String, type.contains("song") else { return nil }
+      return RestJsonMapper.mapSong(row)
+    }
+  }
+
+  private func getPlaylistSongsNative(playlistId: String) async throws -> [[String: Any]] {
+    let musicItemId = MusicItemID(playlistId)
+
+    var request = MusicLibraryRequest<Playlist>()
+    request.filter(matching: \.id, equalTo: musicItemId)
+
+    let response = try await request.response()
+    guard let playlist = response.items.first else {
+      throw LibraryServiceError.playlistNotFound
+    }
+
+    let detailed = try await playlist.with([.tracks])
+    var songs: [[String: Any]] = []
+
+    if let tracks = detailed.tracks {
+      for track in tracks {
+        if case .song(let song) = track {
+          songs.append(MusicItemMapper.map(song))
+        }
+      }
+    }
+    return songs
+  }
+
+  // MARK: - Songs
+
+  func getSongs(musicUserToken: String, options: BridgePagination) async throws -> [[String: Any]] {
+    let data = try await AppleMusicRestClient.getDataArray(
+      path: "/v1/me/library/songs",
+      musicUserToken: musicUserToken,
+      query: ["limit": "\(options.limit)", "offset": "\(options.offset)"]
+    )
+    return data.map(RestJsonMapper.mapSong)
+  }
+
+  private func getSongsNative(options: BridgePagination) async throws -> [[String: Any]] {
+    var request = MusicLibraryRequest<Song>()
+    request.limit = options.limit
+    request.offset = options.offset
+
+    let response = try await request.response()
+    return response.items.map(MusicItemMapper.map)
+  }
+
+  func getMusicVideos(musicUserToken: String, options: BridgePagination) async throws -> [[String: Any]] {
+    let data = try await AppleMusicRestClient.getDataArray(
+      path: "/v1/me/library/music-videos",
+      musicUserToken: musicUserToken,
+      query: ["limit": "\(options.limit)", "offset": "\(options.offset)"]
+    )
+    return data.map(RestJsonMapper.mapMusicVideo)
+  }
+
+  private func getMusicVideosNative(options: BridgePagination) async throws -> [[String: Any]] {
+    var request = MusicLibraryRequest<MusicVideo>()
+    request.limit = options.limit
+    request.offset = options.offset
+    let response = try await request.response()
+    return response.items.map(MusicItemMapper.map)
+  }
+
+  struct LibrarySearchResult {
+    let songs: [[String: Any]]
+    let albums: [[String: Any]]
+    let artists: [[String: Any]]
+    let playlists: [[String: Any]]
+    let musicVideos: [[String: Any]]
+  }
+
+  func search(musicUserToken: String, term: String, types: [String], options: BridgePagination) async throws -> LibrarySearchResult {
+    return try await searchViaRest(musicUserToken: musicUserToken, term: term, types: types, options: options)
+  }
+
+  private func searchNative(term: String, types: [String], options: BridgePagination) async throws -> LibrarySearchResult {
+    if options.offset > 0 {
+      return try await searchViaRest(musicUserToken: "", term: term, types: types, options: options)
+    }
+
+    let searchTypes = types.compactMap { Self.librarySearchableType($0) }
+    let resolvedTypes: [any MusicLibrarySearchable.Type]
+    if searchTypes.isEmpty {
+      resolvedTypes = [Song.self, Album.self, Artist.self, Playlist.self, MusicVideo.self]
+    } else {
+      resolvedTypes = searchTypes
+    }
+
+    var request = MusicLibrarySearchRequest(term: term, types: resolvedTypes)
+    request.limit = options.limit
+    let response = try await request.response()
+
+    return LibrarySearchResult(
+      songs: response.songs.map(MusicItemMapper.map),
+      albums: response.albums.map(MusicItemMapper.map),
+      artists: response.artists.map(MusicItemMapper.map),
+      playlists: response.playlists.map(MusicItemMapper.map),
+      musicVideos: response.musicVideos.map(MusicItemMapper.map)
+    )
+  }
+
+  /// MusicKit `MusicLibrarySearchRequest` has no `offset`; REST matches Android pagination.
+  private func searchViaRest(
+    musicUserToken: String,
+    term: String,
+    types: [String],
+    options: BridgePagination
+  ) async throws -> LibrarySearchResult {
+    let typeParam = Array(Set(types.compactMap { Self.librarySearchRestTypeParam($0) })).sorted().joined(
+      separator: ",")
+    let typesQuery = typeParam.isEmpty ? "library-songs,library-albums" : typeParam
+
+    let json = try await AppleMusicRestClient.get(
+      path: "/v1/me/library/search",
+      musicUserToken: musicUserToken,
+      query: [
+        "term": term,
+        "types": typesQuery,
+        "limit": "\(options.limit)",
+        "offset": "\(options.offset)",
+      ]
+    )
+
+    let results = json["results"] as? [String: Any] ?? [:]
+    return LibrarySearchResult(
+      songs: parseLibrarySearchBucket(results: results, key: "library-songs", mapper: RestJsonMapper.mapSong),
+      albums: parseLibrarySearchBucket(results: results, key: "library-albums", mapper: RestJsonMapper.mapAlbum),
+      artists: parseLibrarySearchBucket(results: results, key: "library-artists", mapper: RestJsonMapper.mapArtist),
+      playlists: parseLibrarySearchBucket(
+        results: results, key: "library-playlists", mapper: RestJsonMapper.mapPlaylist),
+      musicVideos: parseLibrarySearchBucket(
+        results: results, key: "library-music-videos", mapper: RestJsonMapper.mapMusicVideo)
+    )
+  }
+
+  private func parseLibrarySearchBucket(
+    results: [String: Any],
+    key: String,
+    mapper: ([String: Any]) -> [String: Any]
+  ) -> [[String: Any]] {
+    guard let bucket = results[key] as? [String: Any],
+      let data = bucket["data"] as? [[String: Any]]
+    else {
+      return []
+    }
+    return data.map(mapper)
+  }
+
+  private static func librarySearchRestTypeParam(_ type: String) -> String? {
+    switch type {
+    case "library-songs", "songs": return "library-songs"
+    case "library-albums", "albums": return "library-albums"
+    case "library-artists", "artists": return "library-artists"
+    case "library-playlists", "playlists": return "library-playlists"
+    case "library-music-videos", "music-videos", "musicVideos": return "library-music-videos"
+    default: return nil
+    }
+  }
+
+  private static func librarySearchableType(_ type: String) -> (any MusicLibrarySearchable.Type)? {
+    switch type {
+    case "library-songs", "songs": return Song.self
+    case "library-albums", "albums": return Album.self
+    case "library-artists", "artists": return Artist.self
+    case "library-playlists", "playlists": return Playlist.self
+    case "library-music-videos", "music-videos", "musicVideos": return MusicVideo.self
+    default: return nil
+    }
+  }
+
+  // MARK: - Fetch Items by ID
+
+  func fetchSong(id: MusicItemID) async throws -> Song? {
+    var request = MusicLibraryRequest<Song>()
+    request.filter(matching: \.id, equalTo: id)
+    let response = try await request.response()
+    return response.items.first
+  }
+
+  func fetchAlbum(id: MusicItemID) async throws -> Album? {
+    var request = MusicLibraryRequest<Album>()
+    request.filter(matching: \.id, equalTo: id)
+    let response = try await request.response()
+    return response.items.first
+  }
+
+  func fetchPlaylist(id: MusicItemID) async throws -> Playlist? {
+    var request = MusicLibraryRequest<Playlist>()
+    request.filter(matching: \.id, equalTo: id)
+    let response = try await request.response()
+    guard let playlist = response.items.first else { return nil }
+    return try await playlist.with([.tracks])
+  }
+
+  // MARK: - Extract Songs from Playlist
+
+  func extractSongs(from playlist: Playlist) async throws -> [Song] {
+    let detailed = try await playlist.with([.tracks])
+    guard let tracks = detailed.tracks else { return [] }
+
+    var songs: [Song] = []
+    for track in tracks {
+      if case .song(let song) = track {
+        songs.append(song)
+      }
+    }
+    return songs
+  }
+}
+
+// MARK: - Errors
+
+enum LibraryServiceError: LocalizedError {
+  case playlistNotFound
+  case songNotFound
+  case albumNotFound
+  case noTracksInPlaylist
+  case noSongsInPlaylist
+
+  var errorDescription: String? {
+    switch self {
+    case .playlistNotFound: return "Playlist not found in library"
+    case .songNotFound: return "Song not found in library"
+    case .albumNotFound: return "Album not found in library"
+    case .noTracksInPlaylist: return "No tracks in playlist"
+    case .noSongsInPlaylist: return "No songs in playlist"
+    }
+  }
+}

package/ios/MusicItemMapper.swift

@@ -0,0 +1,171 @@
+// MusicItemMapper.swift
+// Maps MusicKit types to bridge dictionaries (must match RestJsonMapper / AppleMusicJsonMapper).
+
+import Foundation
+import MusicKit
+
+@available(iOS 16.0, *)
+enum MusicItemMapper {
+
+  // MARK: - Song
+
+  static func map(_ song: Song) -> [String: Any] {
+    [
+      "id": catalogPlaybackId(from: song),
+      "title": song.title,
+      "artistName": song.artistName,
+      "artworkUrl": extractArtworkURL(song.artwork),
+      "duration": durationMillis(song.duration),
+    ]
+  }
+
+  // MARK: - Album
+
+  static func map(_ album: Album) -> [String: Any] {
+    [
+      "id": musicItemId(album.id),
+      "title": album.title,
+      "artistName": album.artistName,
+      "artworkUrl": extractArtworkURL(album.artwork),
+      "trackCount": album.trackCount,
+    ]
+  }
+
+  // MARK: - Artist
+
+  static func map(_ artist: Artist) -> [String: Any] {
+    [
+      "id": musicItemId(artist.id),
+      "name": artist.name,
+      "artworkUrl": extractArtworkURL(artist.artwork),
+    ]
+  }
+
+  // MARK: - Playlist
+
+  static func map(_ playlist: Playlist) -> [String: Any] {
+    [
+      "id": musicItemId(playlist.id),
+      "name": playlist.name,
+      "description": playlist.standardDescription ?? "",
+      "artworkUrl": extractArtworkURL(playlist.artwork),
+      "trackCount": playlistTrackCount(playlist),
+    ]
+  }
+
+  // MARK: - Station
+
+  static func map(_ station: Station) -> [String: Any] {
+    [
+      "id": musicItemId(station.id),
+      "name": station.name,
+      "artworkUrl": extractArtworkURL(station.artwork),
+    ]
+  }
+
+  // MARK: - Music Video
+
+  @available(iOS 16.0, *)
+  static func map(_ musicVideo: MusicVideo) -> [String: Any] {
+    [
+      "id": catalogPlaybackId(from: musicVideo),
+      "title": musicVideo.title,
+      "artistName": musicVideo.artistName,
+      "artworkUrl": extractArtworkURL(musicVideo.artwork),
+      "duration": durationMillis(musicVideo.duration),
+    ]
+  }
+
+  // MARK: - Recently Played Items
+
+  @available(iOS 16.0, *)
+  static func map(_ item: RecentlyPlayedMusicItem) -> [String: Any] {
+    var result: [String: Any] = [
+      "id": musicItemId(item.id),
+      "title": item.title,
+      "subtitle": String(describing: item.subtitle ?? ""),
+    ]
+
+    switch item {
+    case .album:
+      result["type"] = "album"
+    case .playlist:
+      result["type"] = "playlist"
+    case .station:
+      result["type"] = "station"
+    default:
+      result["type"] = "unknown"
+    }
+
+    return result
+  }
+
+  // MARK: - Playback Status
+
+  static func describePlaybackStatus(_ status: MusicPlayer.PlaybackStatus) -> String {
+    switch status {
+    case .playing: return "playing"
+    case .paused: return "paused"
+    case .stopped: return "stopped"
+    case .interrupted: return "interrupted"
+    case .seekingForward: return "seekingForward"
+    case .seekingBackward: return "seekingBackward"
+    @unknown default: return "unknown"
+    }
+  }
+
+  // MARK: - ID & duration helpers (parity with RestJsonMapper / Android)
+
+  static func musicItemId(_ id: MusicItemID) -> String {
+    id.rawValue
+  }
+
+  static func catalogPlaybackId(from song: Song) -> String {
+    if let playId = catalogPlaybackId(from: song.playParameters) {
+      return playId
+    }
+    return musicItemId(song.id)
+  }
+
+  static func catalogPlaybackId(from musicVideo: MusicVideo) -> String {
+    if let playId = catalogPlaybackId(from: musicVideo.playParameters) {
+      return playId
+    }
+    return musicItemId(musicVideo.id)
+  }
+
+  /// MusicKit no longer exposes `PlayParameters.id`; decode Codable payload (parity with RestJsonMapper).
+  private static func catalogPlaybackId(from playParameters: PlayParameters?) -> String? {
+    guard let playParameters,
+          let data = try? JSONEncoder().encode(playParameters),
+          let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+    else { return nil }
+    if let id = json["id"] as? String, !id.isEmpty { return id }
+    if let catalogId = json["catalogId"] as? String, !catalogId.isEmpty { return catalogId }
+    return nil
+  }
+
+  /// MusicKit `duration` is seconds; bridge uses milliseconds (matches `durationInMillis` from REST).
+  static func durationMillis(_ seconds: TimeInterval?) -> Int {
+    Int((seconds ?? 0) * 1000)
+  }
+
+  private static func playlistTrackCount(_ playlist: Playlist) -> Int {
+    if let count = playlist.tracks?.count, count > 0 {
+      return count
+    }
+    return playlist.entries?.count ?? 0
+  }
+
+  // MARK: - Private Helpers
+
+  private static func extractArtworkURL(_ artwork: Artwork?, width: Int = 200, height: Int = 200) -> String {
+    guard let artwork = artwork,
+          let url = artwork.url(width: width, height: height),
+          url.scheme == "https" || url.scheme == "http"
+    else {
+      return ""
+    }
+    return url.absoluteString
+  }
+}

package/ios/MusicKitAuthStorage.swift

@@ -0,0 +1,38 @@
+// MusicKitAuthStorage.swift
+// Persists developer and music user tokens for Apple Music REST (parity with Android).
+
+import Foundation
+
+@available(iOS 16.0, *)
+enum MusicKitAuthStorage {
+  private static let developerTokenKey = "expo.modules.applemusic.developerToken"
+  private static let musicUserTokenKey = "expo.modules.applemusic.musicUserToken"
+
+  static func saveDeveloperToken(_ token: String) {
+    UserDefaults.standard.set(token, forKey: developerTokenKey)
+    AuthenticatedSessionCache.invalidate()
+  }
+
+  static func getDeveloperToken() -> String? {
+    UserDefaults.standard.string(forKey: developerTokenKey)
+  }
+
+  static func saveMusicUserToken(_ token: String) {
+    UserDefaults.standard.set(token, forKey: musicUserTokenKey)
+    AuthenticatedSessionCache.invalidate()
+  }
+
+  static func getMusicUserToken() -> String? {
+    UserDefaults.standard.string(forKey: musicUserTokenKey)
+  }
+
+  static func clearMusicUserToken() {
+    UserDefaults.standard.removeObject(forKey: musicUserTokenKey)
+    AuthenticatedSessionCache.invalidate()
+  }
+
+  static func clearDeveloperToken() {
+    UserDefaults.standard.removeObject(forKey: developerTokenKey)
+    AuthenticatedSessionCache.invalidate()
+  }
+}

package/ios/MusicKitCatalogSearchStore.swift

@@ -0,0 +1,62 @@
+// MusicKitCatalogSearchStore.swift
+// Catalog search via native MusicCatalogSearchRequest.
+
+import Foundation
+import MusicKit
+
+@available(iOS 16.0, *)
+struct MusicKitCatalogSearchStore: CatalogSearchStore {
+
+  static let missingDeveloperTokenMessage =
+    "Apple Music catalog search needs a developer JWT on this device. "
+    + "From the repo root: npm run dev-token -- --write-env example/.env.local "
+    + "then restart Metro (npx expo start --clear), rebuild, and tap Authorize. "
+    + "See docs/CLI.md. (Native MusicKit auto-token returned 404 for this bundle ID.)"
+
+  func search(
+    term: String,
+    types: [String],
+    options: CatalogService.SearchOptions
+  ) async throws -> CatalogService.SearchResult {
+    let searchTypes = types.compactMap { typeString -> MusicCatalogSearchable.Type? in
+      switch typeString {
+      case "songs": return Song.self
+      case "albums": return Album.self
+      case "artists": return Artist.self
+      case "playlists": return Playlist.self
+      case "stations": return Station.self
+      case "music-videos": return MusicVideo.self
+      default: return nil
+      }
+    }
+
+    var request = MusicCatalogSearchRequest(term: term, types: searchTypes)
+    request.limit = options.limit
+    request.offset = options.offset
+
+    let response = try await request.response()
+
+    return CatalogService.SearchResult(
+      songs: response.songs.map(MusicItemMapper.map),
+      albums: response.albums.map(MusicItemMapper.map),
+      artists: response.artists.map(MusicItemMapper.map),
+      playlists: response.playlists.map(MusicItemMapper.map),
+      stations: response.stations.map(MusicItemMapper.map),
+      musicVideos: response.musicVideos.map(MusicItemMapper.map)
+    )
+  }
+
+  static func isClientNotRegistered(_ error: Error) -> Bool {
+    let ns = error as NSError
+    if ns.domain == "ICError", ns.code == -8200 { return true }
+    if ns.localizedDescription.contains("Client not found") { return true }
+    if ns.localizedDescription.contains("developerTokenRequestFailed") { return true }
+    if let underlying = ns.userInfo[NSUnderlyingErrorKey] as? NSError,
+      underlying.domain == "AMSErrorDomain",
+      underlying.code == 301
+    {
+      return true
+    }
+    return false
+  }
+}