@wwdrew/expo-spotify-sdk 0.7.1 → 1.0.0

package/ios/SpotifyAuthCoordinator.swift

@@ -1,3 +1,4 @@
+import ExpoModulesCore
 import Foundation
 import SpotifyiOS
 
@@ -9,7 +10,7 @@ enum SpotifyError: Error {
   case authInProgress
   case userCancelled
   case spotifyNotInstalled
-  case underlying(Error)
+  case underlying(message: String, cause: Error)
 
   var code: String {
     switch self {
@@ -23,13 +24,45 @@ enum SpotifyError: Error {
 
   var message: String {
     switch self {
-    case .invalidConfiguration(let m): return m
-    case .authInProgress:              return "Another authentication request is already in progress"
-    case .userCancelled:               return "Authentication was cancelled by the user"
-    case .spotifyNotInstalled:         return "The Spotify app is not installed on this device"
-    case .underlying(let err):         return err.localizedDescription
+    case .invalidConfiguration(let m):     return m
+    case .authInProgress:                  return "Another authentication request is already in progress"
+    case .userCancelled:                   return "Authentication was cancelled by the user"
+    case .spotifyNotInstalled:             return "The Spotify app is not installed on this device"
+    case .underlying(let message, _):      return message
     }
   }
+
+  /// The original error that caused this failure, if any. Surfaced as the
+  /// JS-facing exception's `cause` so debugging / Sentry breadcrumbs keep the
+  /// full chain rather than collapsing into "undefined reason".
+  var underlyingCause: Error? {
+    switch self {
+    case .underlying(_, let cause): return cause
+    default:                        return nil
+    }
+  }
+}
+
+/// `Exception` subclass that projects a `SpotifyError`'s `code` and `message`
+/// through `expo-modules-core`'s exception bridge so JS receives the structured
+/// code and a meaningful reason — not the default "undefined reason" placeholder.
+///
+/// Without this wrapper an `AsyncFunction` rejection collapses to
+/// `FunctionCallException` → `cause.reason = "undefined reason"` because the
+/// previously-used `GenericException<String>` does not override `reason`.
+final class SpotifyAuthException: Exception, @unchecked Sendable {
+  private let spotifyCode: String
+  private let spotifyMessage: String
+
+  init(_ error: SpotifyError, file: String = #fileID, line: UInt = #line, function: String = #function) {
+    self.spotifyCode = error.code
+    self.spotifyMessage = error.message
+    super.init(file: file, line: line, function: function)
+    self.cause = error.underlyingCause
+  }
+
+  override var code: String { spotifyCode }
+  override var reason: String { spotifyMessage }
 }
 
 /// `actor` ensures `pending` is mutated only on the actor's serial executor;
@@ -38,7 +71,7 @@ actor SpotifyAuthCoordinator {
   static let shared: SpotifyAuthCoordinator? = SpotifyAuthCoordinator.create()
 
   private let sptConfiguration: SPTConfiguration
-  private let sessionManager: SPTSessionManager
+  nonisolated(unsafe) private let sessionManager: SPTSessionManager
   private let bridge: SpotifySessionDelegateBridge
   private var pending: CheckedContinuation<SPTSession, Error>?
 
@@ -72,7 +105,15 @@ actor SpotifyAuthCoordinator {
   /// Synchronous URL-handler dispatcher used by the AppDelegate / SceneDelegate
   /// subscribers to forward redirects to the SPTSessionManager.
   nonisolated func handleOpenURL(_ url: URL, options: [UIApplication.OpenURLOptionsKey: Any]) -> Bool {
-    sessionManager.application(UIApplication.shared, open: url, options: options)
+    let openSession: () -> Bool = { [self] in
+      MainActor.assumeIsolated {
+        sessionManager.application(UIApplication.shared, open: url, options: options)
+      }
+    }
+    if Thread.isMainThread {
+      return openSession()
+    }
+    return DispatchQueue.main.sync(execute: openSession)
   }
 
   func authenticate(
@@ -112,6 +153,20 @@ actor SpotifyAuthCoordinator {
     pending = nil
     cont?.resume(with: result)
   }
+
+  /// Forcibly cancel any in-flight authenticate() call. The pending
+  /// continuation (if any) is resumed with `userCancelled` and `pending` is
+  /// cleared. Safe to call when nothing is in flight (no-op).
+  ///
+  /// Needed because the SPTSessionManager delegate callbacks are not
+  /// guaranteed to fire — e.g. when Spotify never redirects back to the host
+  /// app — leaving `pending` set forever and every subsequent authenticate()
+  /// rejecting with `authInProgress`.
+  func cancelPending() {
+    guard let cont = pending else { return }
+    pending = nil
+    cont.resume(throwing: SpotifyError.userCancelled)
+  }
 }
 
 /// `SPTSessionManagerDelegate` requires NSObject conformance, which an actor
@@ -153,11 +208,10 @@ final class SpotifySessionDelegateBridge: NSObject, SPTSessionManagerDelegate {
     if description.contains("cancel") {
       return SpotifyError.userCancelled
     }
-    return SpotifyError.underlying(NSError(
-      domain: nsError.domain,
-      code: nsError.code,
-      userInfo: [NSLocalizedDescriptionKey: describeError(nsError)]
-    ))
+    // Keep the original NSError as `cause` so the structured underlying-chain
+    // is preserved (Sentry, debug breadcrumbs); the rendered string goes to
+    // `message` so JS callers get a single human-readable line.
+    return SpotifyError.underlying(message: describeError(nsError), cause: nsError)
   }
 
   /// Build a diagnostic string from an NSError that includes the domain,

package/ios/SpotifyTokenRefreshClient.swift

@@ -1,3 +1,4 @@
+import ExpoModulesCore
 import Foundation
 
 enum SpotifyRefreshError: Error {
@@ -28,6 +29,33 @@ enum SpotifyRefreshError: Error {
       return m
     }
   }
+
+  /// The original error that caused this failure, if any. Surfaced as the
+  /// JS-facing exception's `cause`.
+  var underlyingCause: Error? {
+    switch self {
+    case .network(let err): return err
+    default:                return nil
+    }
+  }
+}
+
+/// `Exception` subclass that projects a `SpotifyRefreshError`'s `code` and
+/// `message` through `expo-modules-core` so JS sees the structured taxonomy
+/// instead of "undefined reason". Mirrors `SpotifyAuthException`.
+final class SpotifyRefreshException: Exception, @unchecked Sendable {
+  private let spotifyCode: String
+  private let spotifyMessage: String
+
+  init(_ error: SpotifyRefreshError, file: String = #fileID, line: UInt = #line, function: String = #function) {
+    self.spotifyCode = error.code
+    self.spotifyMessage = error.message
+    super.init(file: file, line: line, function: function)
+    self.cause = error.underlyingCause
+  }
+
+  override var code: String { spotifyCode }
+  override var reason: String { spotifyMessage }
 }
 
 struct SpotifyRefreshResult {
@@ -113,6 +141,9 @@ struct SpotifyTokenRefreshClient {
   private func formURLEncoded(_ pairs: [String: String]) -> String {
     var components = URLComponents()
     components.queryItems = pairs.map { URLQueryItem(name: $0.key, value: $0.value) }
-    return components.percentEncodedQuery ?? ""
+    // `URLComponents.percentEncodedQuery` does NOT escape `+`, but in
+    // `application/x-www-form-urlencoded` bodies `+` means space. Replace it
+    // explicitly so refresh tokens containing `+` survive the round-trip.
+    return (components.percentEncodedQuery ?? "").replacingOccurrences(of: "+", with: "%2B")
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wwdrew/expo-spotify-sdk",
-  "version": "0.7.1",
-  "description": "Expo module wrapping the native Spotify iOS (v5) and Android (v4) SDKs for OAuth authentication",
+  "version": "1.0.0",
+  "description": "Expo module wrapping the native Spotify iOS (v5) and Android (v4) SDKs for OAuth authentication and App Remote playback control",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "scripts": {
@@ -51,5 +51,6 @@
     "expo": "*",
     "react": "*",
     "react-native": "*"
-  }
+  },
+  "dependencies": {}
 }