spotify-client 1.0.2 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8531ff35eb3c2054c9d4d99b6e97c5e22848e3805dae010d4be01841e3d535a6
-  data.tar.gz: f4775af30bd3ad47662b06ba8ebaefdef6b0d30378773e2ec520c54a4c672a36
+  metadata.gz: 9fba94340f1fab59fe29af2fe56082fe7a957fe49cdd650dc689e681938fa7dc
+  data.tar.gz: 88842cffcde50db973f10b4ec60a1214fe4356203bf5c2ebe4826ca93789eaef
 SHA512:
-  metadata.gz: 1892e985e4eff8f8f635e9438fc081832a65a6ac8717d73edaa17ee165219bdfcf29838e33b86ea6f06cf77489bedf418a90d06c2f114f1c5fc343e16615560a
-  data.tar.gz: 2ff791f2c9c431305935f27345f1aa4e0001c59eaa132a7d4f1d839b3030ee8d8090aa4ee5be0b8aa75492ec113a243e996b6bd119b81340892e2c593c7cc106
+  metadata.gz: 7189b3aae25dd0b74d9035e2936adae1cd6bdd5fdc1147531566674b262fa9dacdb40f56f07b1ab65c3ba87934f0ec9a6f57fdf41f44528f3927ae4ddf101014
+  data.tar.gz: 3c806b5e89ddf72e7003a1fa30f18dabeb0720c9ac3c8a617a89c0e3677a929e4c5bb8e878a52e4b2216ff00363ba9bb730741ae7942fb5ba37ed925bdaf6a7c

data/README.md

@@ -2,7 +2,8 @@
 
 Ruby client for the [Spotify Web API](https://developer.spotify.com/documentation/web-api).
 
-[![Gem Version](https://badge.fury.io/rb/spotify-client.svg)](https://rubygems.org/gems/spotify-client)
+[![Test](https://github.com/icoretech/spotify-client/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/icoretech/spotify-client/actions/workflows/test.yml?query=branch%3Amain)
+[![Gem Version](https://badge.fury.io/rb/spotify-client.svg)](https://badge.fury.io/rb/spotify-client)
 
 ## Installation
 
@@ -47,33 +48,84 @@ client = Spotify::Client.new(config)
 ## Public API
 
 ```ruby
+# User
 client.me
-client.me_tracks
+
+# Library
+client.me_albums(params = {})
+client.me_audiobooks(params = {})
+client.me_episodes(params = {})
 client.me_following
-client.user(user_id)
-client.user_playlists(user_id) # user_id kept for backward compatibility; requests /v1/me/playlists
-client.user_playlist(user_id, playlist_id)
-client.user_playlist_tracks(user_id, playlist_id, params = {})
+client.me_shows(params = {})
+client.me_tracks
+client.add_to_library(uris)
+client.remove_from_library(uris)
+client.user_playlists(user_id = nil) # backward-compatible signature; requests /v1/me/playlists
 client.create_user_playlist(user_id, name, is_public = true)
+client.change_playlist_details(user_id, playlist_id, attributes = {})
+
+# Playlist
+client.playlist(playlist_id)
+client.playlist_cover_image(playlist_id)
+client.upload_playlist_cover_image(playlist_id, image_base64_jpeg)
+
+# Backward-compatible playlist helpers
+client.user_playlist(user_id, playlist_id) # delegates to playlist(playlist_id)
+client.user_playlist_tracks(user_id, playlist_id, params = {})
 client.add_user_tracks_to_playlist(user_id, playlist_id, uris = [], position = nil)
 client.remove_user_tracks_from_playlist(user_id, playlist_id, tracks)
 client.replace_user_tracks_in_playlist(user_id, playlist_id, tracks)
 client.truncate_user_playlist(user_id, playlist_id)
+
+# Metadata
 client.album(album_id)
 client.album_tracks(album_id)
 client.albums(album_ids)
-client.track(track_id)
-client.tracks(track_ids)
 client.artist(artist_id)
 client.artists(artist_ids)
 client.artist_albums(artist_id)
-client.search(entity, term, options = {})
 client.artist_top_tracks(artist_id, country_id)
+client.audiobook(audiobook_id, params = {})
+client.audiobook_chapters(audiobook_id, params = {})
+client.chapter(chapter_id, params = {})
+client.episode(episode_id, params = {})
+client.show(show_id, params = {})
+client.show_episodes(show_id, params = {})
+client.track(track_id)
+client.tracks(track_ids)
+
+# Personalisation
+client.me_top(type, params = {}) # type: "artists" or "tracks"
+
+# Player
+client.currently_playing(params = {})
+client.recently_played(params = {})
+client.playback_state(params = {})
+client.available_devices
+client.transfer_playback(device_ids, play = nil)
+client.start_or_resume_playback(payload = {})
+client.pause_playback(params = {})
+client.skip_to_next(params = {})
+client.skip_to_previous(params = {})
+client.seek_to_position(position_ms, params = {})
+client.set_repeat_mode(state, params = {})
+client.set_playback_volume(volume_percent, params = {})
+client.set_shuffle(state, params = {})
+client.playback_queue(params = {})
+client.add_to_playback_queue(uri, params = {})
+
+# Search
+client.search(entity, term, options = {}) # entity: :artist, :album, :track
+
+# Legacy helpers kept for compatibility
+client.user(user_id)
 client.related_artists(artist_id)
 client.follow(type, ids)
 client.follow_playlist(user_id, playlist_id, is_public = true)
-client.request(:get, '/v1/me') # generic helper for newer endpoints
-client.request!(:post, '/v1/some-endpoint', [201], payload, false)
+
+# Generic helpers for forward compatibility
+client.request(:get, '/v1/me', [200], { market: 'IT' }) # GET-style hash payloads become query params
+client.request!(:post, '/v1/some-endpoint', [201], payload, false) # non-GET hash payloads are JSON encoded
 ```
 
 ## Spotify API Migration Notes

data/lib/spotify/client/compatibility_api.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Spotify
+  class Client
+    module CompatibilityAPI
+      def user(user_id)
+        raise_endpoint_unavailable_in_development_mode!(
+          endpoint: 'GET /v1/users/{id}',
+          replacement: 'GET /v1/me'
+        )
+        run(:get, "/v1/users/#{user_id}", [200])
+      end
+
+      def user_playlists(_user_id = nil)
+        run(:get, '/v1/me/playlists', [200])
+      end
+
+      def user_playlist(_user_id, playlist_id)
+        playlist(playlist_id)
+      end
+
+      def user_playlist_tracks(_user_id, playlist_id, params = {})
+        tracks = { 'items' => [] }
+        path = "/v1/playlists/#{playlist_id}/items"
+        query_params = params.dup
+
+        while path
+          response = run(:get, path, [200], query_params)
+          return false unless response
+
+          tracks['items'].concat(response.fetch('items', []))
+          tracks.merge!(response.reject { |key, _value| key == 'items' })
+          path, query_params = next_page_request(response['next'])
+        end
+
+        tracks
+      end
+
+      def create_user_playlist(_user_id, name, is_public = true)
+        run(:post, '/v1/me/playlists', [201], JSON.dump(name: name, public: is_public), false)
+      end
+
+      def change_playlist_details(_user_id, playlist_id, attributes = {})
+        run(:put, "/v1/playlists/#{playlist_id}", [200, 204], JSON.dump(attributes), false)
+      end
+
+      def add_user_tracks_to_playlist(_user_id, playlist_id, uris = [], position = nil)
+        params = { uris: Array(uris)[0..99].join(',') }
+        params.merge!(position: position) if position
+        run(:post, "/v1/playlists/#{playlist_id}/items", [200, 201], JSON.dump(params), false)
+      end
+
+      def remove_user_tracks_from_playlist(_user_id, playlist_id, tracks)
+        run(:delete, "/v1/playlists/#{playlist_id}/items", [200], JSON.dump(items: tracks))
+      end
+
+      def replace_user_tracks_in_playlist(_user_id, playlist_id, tracks)
+        run(:put, "/v1/playlists/#{playlist_id}/items", [200, 201], JSON.dump(uris: tracks))
+      end
+
+      def truncate_user_playlist(user_id, playlist_id)
+        replace_user_tracks_in_playlist(user_id, playlist_id, [])
+      end
+
+      def follow(type, ids)
+        entity_type = type.to_s.strip
+        uris = Array(ids).map do |id|
+          raw = id.to_s
+          next raw if raw.start_with?('spotify:')
+
+          raise(ImplementationError, 'type is required when ids are not full Spotify URIs') if entity_type.empty?
+
+          "spotify:#{entity_type}:#{raw}"
+        end
+        add_to_library(uris)
+      end
+
+      def follow_playlist(_user_id, playlist_id, _is_public = true)
+        add_to_library(["spotify:playlist:#{playlist_id}"])
+      end
+    end
+  end
+end

data/lib/spotify/client/transport.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Spotify
+  class Client
+    module Transport
+      EXCON_ERROR_MAP = {
+        Excon::Errors::NotFound => ResourceNotFound,
+        Excon::Errors::BadRequest => BadRequest,
+        Excon::Errors::Forbidden => InsufficientClientScopeError,
+        Excon::Errors::Unauthorized => AuthenticationError
+      }.freeze
+
+      protected
+
+      def run(verb, path, expected_status_codes, params = {}, idempotent = true)
+        run!(verb, path, expected_status_codes, params, idempotent)
+      rescue Error => e
+        handle_nonbang_error(e)
+      end
+
+      def run!(verb, path, expected_status_codes, params_or_body = nil, idempotent = true)
+        response = @connection.request(
+          build_request_packet(
+            verb: verb,
+            path: path,
+            expected_status_codes: expected_status_codes,
+            params_or_body: params_or_body,
+            idempotent: idempotent
+          )
+        )
+        parse_response_body(response)
+      rescue Excon::Errors::Error => e
+        raise map_transport_error(e)
+      end
+
+      def build_request_packet(verb:, path:, expected_status_codes:, params_or_body:, idempotent:)
+        packet = {
+          idempotent: idempotent,
+          expects: expected_status_codes,
+          method: verb,
+          path: path,
+          read_timeout: @read_timeout,
+          write_timeout: @write_timeout,
+          retry_limit: @retries,
+          headers: {
+            'Content-Type' => 'application/json',
+            'User-Agent' => 'Spotify Ruby Client'
+          }
+        }
+        apply_request_payload(packet, params_or_body)
+
+        packet[:headers].merge!('Authorization' => "Bearer #{@access_token}") if !@access_token.nil? && @access_token != ''
+        packet
+      end
+
+      def apply_request_payload(packet, params_or_body)
+        if params_or_body.is_a?(Hash)
+          packet[:query] = params_or_body
+        else
+          packet[:body] = params_or_body
+        end
+      end
+
+      def parse_response_body(response)
+        return {} if response.body.nil? || response.body.empty?
+
+        ::JSON.parse(response.body)
+      rescue JSON::ParserError => e
+        raise(HTTPError, "Error: #{e.message}")
+      end
+
+      def next_page_request(next_url)
+        return [nil, {}] if next_url.nil? || next_url.empty?
+
+        uri = URI.parse(next_url)
+        [uri.query ? "#{uri.path}?#{uri.query}" : uri.path, {}]
+      end
+
+      def handle_nonbang_error(error)
+        raise error if @raise_errors
+
+        false
+      end
+
+      def map_transport_error(error)
+        error_class = EXCON_ERROR_MAP.find do |transport_error, _client_error|
+          error.is_a?(transport_error)
+        end&.last || HTTPError
+
+        error_class.new("Error: #{error.message}")
+      end
+    end
+  end
+end

data/lib/spotify/client.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+require 'excon'
+require 'json'
+
+require 'spotify/exceptions'
+require 'spotify/client/compatibility_api'
+require 'spotify/client/transport'
+
+module Spotify
+  class Client
+    include CompatibilityAPI
+    include Transport
+
+    BASE_URI = 'https://api.spotify.com'
+
+    attr_accessor :access_token
+
+    # Initialize the client.
+    #
+    # @example
+    #   client = Spotify::Client.new(:access_token => 'longtoken', retries: 0, raise_errors: true)
+    #
+    # @param [Hash] configuration.
+    def initialize(config = {})
+      @access_token = config[:access_token]
+      @raise_errors = config[:raise_errors] || false
+      @retries = config[:retries] || 0
+      @read_timeout = config[:read_timeout] || 10
+      @write_timeout = config[:write_timeout] || 10
+      @app_mode = config[:app_mode].to_s.strip.downcase
+      @connection = Excon.new(BASE_URI, persistent: config[:persistent] || false)
+    end
+
+    def inspect
+      vars = instance_variables.map { |v| "#{v}=#{instance_variable_get(v).inspect}" }.join(', ')
+      "<#{self.class}: #{vars}>"
+    end
+
+    # Closes the connection underlying socket.
+    # Use when you employ persistent connections and are done with your requests.
+    def close_connection
+      @connection.reset
+    end
+
+    def me
+      run(:get, '/v1/me', [200])
+    end
+
+    def me_tracks
+      run(:get, '/v1/me/tracks', [200])
+    end
+
+    def me_albums(params = {})
+      run(:get, '/v1/me/albums', [200], params)
+    end
+
+    def me_audiobooks(params = {})
+      run(:get, '/v1/me/audiobooks', [200], params)
+    end
+
+    def me_episodes(params = {})
+      run(:get, '/v1/me/episodes', [200], params)
+    end
+
+    def me_shows(params = {})
+      run(:get, '/v1/me/shows', [200], params)
+    end
+
+    # params:
+    # - type: Required, The ID type, currently only 'artist' is supported
+    # - limit: Optional. The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.
+    # - after: Optional. The last artist ID retrieved from the previous request.
+    def me_following(params = {})
+      params = params.merge(type: 'artist')
+      run(:get, '/v1/me/following', [200], params)
+    end
+
+    def playlist(playlist_id)
+      run(:get, "/v1/playlists/#{playlist_id}", [200])
+    end
+
+    def playlist_cover_image(playlist_id)
+      run(:get, "/v1/playlists/#{playlist_id}/images", [200], {})
+    end
+
+    def upload_playlist_cover_image(playlist_id, image_base64_jpeg)
+      run(:put, "/v1/playlists/#{playlist_id}/images", [200, 202, 204], image_base64_jpeg.to_s, false)
+    end
+
+    def album(album_id)
+      run(:get, "/v1/albums/#{album_id}", [200])
+    end
+
+    def album_tracks(album_id)
+      run(:get, "/v1/albums/#{album_id}/tracks", [200])
+    end
+
+    def albums(album_ids)
+      { 'albums' => Array(album_ids).map { |album_id| album(album_id) } }
+    end
+
+    def track(track_id)
+      run(:get, "/v1/tracks/#{track_id}", [200])
+    end
+
+    def tracks(track_ids)
+      { 'tracks' => Array(track_ids).map { |track_id| track(track_id) } }
+    end
+
+    def artist(artist_id)
+      run(:get, "/v1/artists/#{artist_id}", [200])
+    end
+
+    def artists(artist_ids)
+      { 'artists' => Array(artist_ids).map { |artist_id| artist(artist_id) } }
+    end
+
+    def artist_albums(artist_id)
+      run(:get, "/v1/artists/#{artist_id}/albums", [200])
+    end
+
+    def audiobook(audiobook_id, params = {})
+      run(:get, "/v1/audiobooks/#{audiobook_id}", [200], params)
+    end
+
+    def audiobook_chapters(audiobook_id, params = {})
+      run(:get, "/v1/audiobooks/#{audiobook_id}/chapters", [200], params)
+    end
+
+    def chapter(chapter_id, params = {})
+      run(:get, "/v1/chapters/#{chapter_id}", [200], params)
+    end
+
+    def episode(episode_id, params = {})
+      run(:get, "/v1/episodes/#{episode_id}", [200], params)
+    end
+
+    def show(show_id, params = {})
+      run(:get, "/v1/shows/#{show_id}", [200], params)
+    end
+
+    def show_episodes(show_id, params = {})
+      run(:get, "/v1/shows/#{show_id}/episodes", [200], params)
+    end
+
+    def search(entity, term, options = {})
+      unless %i[artist album track].include?(entity.to_sym)
+        raise(ImplementationError, "entity needs to be either artist, album or track, got: #{entity}")
+      end
+
+      options = options.dup
+      options[:limit] = [options[:limit].to_i, 10].min if options.key?(:limit)
+
+      params = {
+        q: term.to_s,
+        type: entity
+      }.merge(options)
+      run(:get, '/v1/search', [200], params)
+    end
+
+    # Get Spotify catalog information about an artist's top 10 tracks by country.
+    #
+    # +country_id+ is required. An ISO 3166-1 alpha-2 country code.
+    def artist_top_tracks(artist_id, country_id)
+      raise_endpoint_unavailable_in_development_mode!(endpoint: 'GET /v1/artists/{id}/top-tracks')
+      run(:get, "/v1/artists/#{artist_id}/top-tracks", [200], country: country_id)
+    end
+
+    def related_artists(artist_id)
+      run(:get, "/v1/artists/#{artist_id}/related-artists", [200])
+    end
+
+    def me_top(type, params = {})
+      valid_types = %w[artists tracks]
+      normalized_type = type.to_s
+      unless valid_types.include?(normalized_type)
+        raise(ImplementationError, "type needs to be one of #{valid_types.join(', ')}, got: #{type}")
+      end
+
+      run(:get, "/v1/me/top/#{normalized_type}", [200], params)
+    end
+
+    def currently_playing(params = {})
+      run(:get, '/v1/me/player/currently-playing', [200], params)
+    end
+
+    def recently_played(params = {})
+      run(:get, '/v1/me/player/recently-played', [200], params)
+    end
+
+    def playback_state(params = {})
+      run(:get, '/v1/me/player', [200], params)
+    end
+
+    def available_devices
+      run(:get, '/v1/me/player/devices', [200], {})
+    end
+
+    def transfer_playback(device_ids, play = nil)
+      body = { device_ids: Array(device_ids) }
+      body[:play] = play unless play.nil?
+      run(:put, '/v1/me/player', [200, 204], JSON.dump(body), false)
+    end
+
+    def start_or_resume_playback(payload = {})
+      run(:put, '/v1/me/player/play', [200, 204], JSON.dump(payload), false)
+    end
+
+    def pause_playback(params = {})
+      run(:put, '/v1/me/player/pause', [200, 204], params, false)
+    end
+
+    def skip_to_next(params = {})
+      run(:post, '/v1/me/player/next', [200, 204], params, false)
+    end
+
+    def skip_to_previous(params = {})
+      run(:post, '/v1/me/player/previous', [200, 204], params, false)
+    end
+
+    def seek_to_position(position_ms, params = {})
+      run(:put, '/v1/me/player/seek', [200, 204], params.merge(position_ms: position_ms), false)
+    end
+
+    def set_repeat_mode(state, params = {})
+      run(:put, '/v1/me/player/repeat', [200, 204], params.merge(state: state), false)
+    end
+
+    def set_playback_volume(volume_percent, params = {})
+      run(:put, '/v1/me/player/volume', [200, 204], params.merge(volume_percent: volume_percent), false)
+    end
+
+    def set_shuffle(state, params = {})
+      run(:put, '/v1/me/player/shuffle', [200, 204], params.merge(state: state), false)
+    end
+
+    def playback_queue(params = {})
+      run(:get, '/v1/me/player/queue', [200], params)
+    end
+
+    def add_to_playback_queue(uri, params = {})
+      run(:post, '/v1/me/player/queue', [200, 204], params.merge(uri: uri), false)
+    end
+
+    def add_to_library(uris)
+      run(:put, '/v1/me/library', [200, 204], JSON.dump(uris: Array(uris)), false)
+    end
+
+    def remove_from_library(uris)
+      run(:delete, '/v1/me/library', [200, 204], JSON.dump(uris: Array(uris)), false)
+    end
+
+    # Generic API helper for forward compatibility with newly added endpoints.
+    def request(verb, path, expected_status_codes = [200], params_or_body = {}, idempotent = true)
+      run(
+        verb.to_sym,
+        path,
+        Array(expected_status_codes),
+        normalize_generic_request_payload(verb, params_or_body),
+        idempotent
+      )
+    end
+
+    # Bang variant that propagates mapped API errors.
+    def request!(verb, path, expected_status_codes = [200], params_or_body = {}, idempotent = true)
+      run!(
+        verb.to_sym,
+        path,
+        Array(expected_status_codes),
+        normalize_generic_request_payload(verb, params_or_body),
+        idempotent
+      )
+    end
+
+    protected
+
+    def raise_endpoint_unavailable_in_development_mode!(endpoint:, replacement: nil)
+      return unless development_mode?
+
+      message = "#{endpoint} is unavailable for Spotify Development Mode apps as of March 9, 2026."
+      message += " Use #{replacement} instead." if replacement
+      raise(EndpointUnavailableInDevelopmentMode, message)
+    end
+
+    def development_mode?
+      @app_mode == 'development' || @app_mode == 'development_mode'
+    end
+
+    def normalize_generic_request_payload(verb, params_or_body)
+      return params_or_body unless params_or_body.is_a?(Hash)
+
+      query_verbs = %i[get head options]
+      return params_or_body if query_verbs.include?(verb.to_sym)
+
+      JSON.dump(params_or_body)
+    end
+  end
+end

data/lib/spotify/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Spotify
-  VERSION = '1.0.2'
+  VERSION = '1.1.1'
 end

data/lib/spotify-client.rb

@@ -1 +1,4 @@
-require "#{File.dirname(__FILE__)}/spotify_client"
+lib_dir = __dir__
+$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
+
+require 'spotify/client'

data/lib/spotify_client.rb

@@ -1,294 +1,6 @@
-require 'excon'
-require 'json'
+# frozen_string_literal: true
 
-require "#{File.dirname(__FILE__)}/spotify/exceptions"
+lib_dir = __dir__
+$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
 
-module Spotify
-  class Client
-    BASE_URI = 'https://api.spotify.com'.freeze
-
-    attr_accessor :access_token
-
-    # Initialize the client.
-    #
-    # @example
-    #   client = Spotify::Client.new(:access_token => 'longtoken', retries: 0, raise_errors: true)
-    #
-    # @param [Hash] configuration.
-    def initialize(config = {})
-      @access_token  = config[:access_token]
-      @raise_errors  = config[:raise_errors] || false
-      @retries       = config[:retries] || 0
-      @read_timeout  = config[:read_timeout] || 10
-      @write_timeout = config[:write_timeout] || 10
-      @app_mode      = config[:app_mode].to_s.strip.downcase
-      @connection    = Excon.new(BASE_URI, persistent: config[:persistent] || false)
-    end
-
-    def inspect
-      vars = instance_variables.map { |v| "#{v}=#{instance_variable_get(v).inspect}" }.join(', ')
-      "<#{self.class}: #{vars}>"
-    end
-
-    # Closes the connection underlying socket.
-    # Use when you employ persistent connections and are done with your requests.
-    def close_connection
-      @connection.reset
-    end
-
-    def me
-      run(:get, '/v1/me', [200])
-    end
-
-    def me_tracks
-      run(:get, '/v1/me/tracks', [200])
-    end
-
-    # params:
-    # - type: Required, The ID type, currently only 'artist' is supported
-    # - limit: Optional. The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.
-    # - after: Optional. The last artist ID retrieved from the previous request.
-    def me_following(params = {})
-      params = params.merge(type: 'artist')
-      run(:get, '/v1/me/following', [200], params)
-    end
-
-    def user(user_id)
-      raise_endpoint_unavailable_in_development_mode!(
-        endpoint: 'GET /v1/users/{id}',
-        replacement: 'GET /v1/me'
-      )
-      run(:get, "/v1/users/#{user_id}", [200])
-    end
-
-    def user_playlists(_user_id = nil)
-      run(:get, '/v1/me/playlists', [200])
-    end
-
-    def user_playlist(_user_id, playlist_id)
-      run(:get, "/v1/playlists/#{playlist_id}", [200])
-    end
-
-    def user_playlist_tracks(_user_id, playlist_id, params = {})
-      tracks = { 'items' => [] }
-      path = "/v1/playlists/#{playlist_id}/items"
-
-      while path
-        response = run(:get, path, [200], params)
-        tracks['items'].concat(response.delete('items'))
-        tracks.merge!(response)
-
-        path = response['next']&.gsub(BASE_URI, '')
-      end
-
-      tracks
-    end
-
-    # Create a playlist for a Spotify user. The playlist will be empty until you add tracks.
-    #
-    # Requires playlist-modify-public for a public playlist.
-    # Requires playlist-modify-private for a private playlist.
-    def create_user_playlist(_user_id, name, is_public = true)
-      run(:post, '/v1/me/playlists', [201], JSON.dump(name: name, public: is_public), false)
-    end
-
-    # Add an Array of track uris to an existing playlist.
-    #
-    # Adding tracks to a user's public playlist requires authorization of the playlist-modify-public scope;
-    # adding tracks to a private playlist requires the playlist-modify-private scope.
-    #
-    # client.add_user_tracks_to_playlist(
-    #   '1181346016', '7i3thJWDtmX04dJhFwYb0x', %w(spotify:track:... spotify:track:...)
-    # )
-    def add_user_tracks_to_playlist(_user_id, playlist_id, uris = [], position = nil)
-      params = { uris: Array(uris)[0..99].join(',') }
-      params.merge!(position: position) if position
-      run(:post, "/v1/playlists/#{playlist_id}/items", [200, 201], JSON.dump(params), false)
-    end
-
-    # Removes tracks from playlist
-    #
-    # client.remove_user_tracks_from_playlist(
-    #   '1181346016', '7i3thJWDtmX04dJhFwYb0x', [{ uri: 'spotify:track:...', positions: [0] }]
-    # )
-    def remove_user_tracks_from_playlist(_user_id, playlist_id, tracks)
-      run(:delete, "/v1/playlists/#{playlist_id}/items", [200], JSON.dump(items: tracks))
-    end
-
-    # Replaces all occurrences of tracks with what's in the playlist
-    #
-    # client.replace_user_tracks_in_playlist(
-    #   '1181346016', '7i3thJWDtmX04dJhFwYb0x', %w(spotify:track:... spotify:track:...)
-    # )
-    def replace_user_tracks_in_playlist(_user_id, playlist_id, tracks)
-      run(:put, "/v1/playlists/#{playlist_id}/items", [200, 201], JSON.dump(uris: tracks))
-    end
-
-    # Removes all tracks in playlist
-    #
-    # client.truncate_user_playlist('1181346016', '7i3thJWDtmX04dJhFwYb0x')
-    def truncate_user_playlist(user_id, playlist_id)
-      replace_user_tracks_in_playlist(user_id, playlist_id, [])
-    end
-
-    def album(album_id)
-      run(:get, "/v1/albums/#{album_id}", [200])
-    end
-
-    def album_tracks(album_id)
-      run(:get, "/v1/albums/#{album_id}/tracks", [200])
-    end
-
-    def albums(album_ids)
-      { 'albums' => Array(album_ids).map { |album_id| album(album_id) } }
-    end
-
-    def track(track_id)
-      run(:get, "/v1/tracks/#{track_id}", [200])
-    end
-
-    def tracks(track_ids)
-      { 'tracks' => Array(track_ids).map { |track_id| track(track_id) } }
-    end
-
-    def artist(artist_id)
-      run(:get, "/v1/artists/#{artist_id}", [200])
-    end
-
-    def artists(artist_ids)
-      { 'artists' => Array(artist_ids).map { |artist_id| artist(artist_id) } }
-    end
-
-    def artist_albums(artist_id)
-      run(:get, "/v1/artists/#{artist_id}/albums", [200])
-    end
-
-    def search(entity, term, options = {})
-      unless %i[artist album track].include?(entity.to_sym)
-        raise(ImplementationError, "entity needs to be either artist, album or track, got: #{entity}")
-      end
-
-      options = options.dup
-      options[:limit] = [options[:limit].to_i, 10].min if options.key?(:limit)
-
-      params = {
-        q: term.to_s,
-        type: entity
-      }.merge(options)
-      run(:get, '/v1/search', [200], params)
-    end
-
-    # Get Spotify catalog information about an artist's top 10 tracks by country.
-    #
-    # +country_id+ is required. An ISO 3166-1 alpha-2 country code.
-    def artist_top_tracks(artist_id, country_id)
-      raise_endpoint_unavailable_in_development_mode!(endpoint: 'GET /v1/artists/{id}/top-tracks')
-      run(:get, "/v1/artists/#{artist_id}/top-tracks", [200], country: country_id)
-    end
-
-    def related_artists(artist_id)
-      run(:get, "/v1/artists/#{artist_id}/related-artists", [200])
-    end
-
-    # Follow artists or users
-    #
-    # client.follow('artist', ['0BvkDsjIUla7X0k6CSWh1I'])
-    def follow(type, ids)
-      entity_type = type.to_s.strip
-      uris = Array(ids).map do |id|
-        raw = id.to_s
-        next raw if raw.start_with?('spotify:')
-
-        raise(ImplementationError, 'type is required when ids are not full Spotify URIs') if entity_type.empty?
-
-        "spotify:#{entity_type}:#{raw}"
-      end
-      run(:put, '/v1/me/library', [200, 204], JSON.dump(uris: uris), false)
-    end
-
-    # Follow a playlist
-    #
-    # client.follow_playlist('lukebryan', '0obRj9nNySESpFelMCLSya')
-    def follow_playlist(_user_id, playlist_id, is_public = true)
-      _is_public = is_public # kept for backward-compatible signature
-      run(:put, '/v1/me/library', [200, 204], JSON.dump(uris: ["spotify:playlist:#{playlist_id}"]), false)
-    end
-
-    # Generic API helper for forward compatibility with newly added endpoints.
-    def request(verb, path, expected_status_codes = [200], params_or_body = {}, idempotent = true)
-      run(verb.to_sym, path, Array(expected_status_codes), params_or_body, idempotent)
-    end
-
-    # Bang variant that propagates mapped API errors.
-    def request!(verb, path, expected_status_codes = [200], params_or_body = {}, idempotent = true)
-      run!(verb.to_sym, path, Array(expected_status_codes), params_or_body, idempotent)
-    end
-
-    protected
-
-    def raise_endpoint_unavailable_in_development_mode!(endpoint:, replacement: nil)
-      return unless development_mode?
-
-      message = "#{endpoint} is unavailable for Spotify Development Mode apps as of March 9, 2026."
-      message += " Use #{replacement} instead." if replacement
-      raise(EndpointUnavailableInDevelopmentMode, message)
-    end
-
-    def development_mode?
-      @app_mode == 'development' || @app_mode == 'development_mode'
-    end
-
-    def run(verb, path, expected_status_codes, params = {}, idempotent = true)
-      run!(verb, path, expected_status_codes, params, idempotent)
-    rescue Error => e
-      raise e if @raise_errors
-
-      false
-    end
-
-    def run!(verb, path, expected_status_codes, params_or_body = nil, idempotent = true)
-      packet = {
-        idempotent: idempotent,
-        expects: expected_status_codes,
-        method: verb,
-        path: path,
-        read_timeout: @read_timeout,
-        write_timeout: @write_timeout,
-        retry_limit: @retries,
-        headers: {
-          'Content-Type' => 'application/json',
-          'User-Agent' => 'Spotify Ruby Client'
-        }
-      }
-      if params_or_body.is_a?(Hash)
-        packet.merge!(query: params_or_body)
-      else
-        packet.merge!(body: params_or_body)
-      end
-
-      packet[:headers].merge!('Authorization' => "Bearer #{@access_token}") if !@access_token.nil? && @access_token != ''
-
-      # puts "\033[31m [Spotify] HTTP Request: #{verb.upcase} #{BASE_URI}#{path} #{packet[:headers].inspect} \e[0m"
-      response = @connection.request(packet)
-      return {} if response.body.nil? || response.body.empty?
-
-      ::JSON.parse(response.body)
-    rescue Excon::Errors::NotFound => e
-      raise(ResourceNotFound, "Error: #{e.message}")
-    rescue Excon::Errors::BadRequest => e
-      raise(BadRequest, "Error: #{e.message}")
-    rescue Excon::Errors::Forbidden => e
-      raise(InsufficientClientScopeError, "Error: #{e.message}")
-    rescue Excon::Errors::Unauthorized => e
-      raise(AuthenticationError, "Error: #{e.message}")
-    rescue Excon::Errors::Error => e
-      # Catch all others errors. Samples:
-      #
-      # <Excon::Errors::SocketError: Connection refused - connect(2) (Errno::ECONNREFUSED)>
-      # <Excon::Errors::InternalServerError: Expected([200, 204, 404]) <=> Actual(500 InternalServerError)>
-      # <Excon::Errors::Timeout: read timeout reached>
-      # <Excon::Errors::BadGateway: Expected([200]) <=> Actual(502 Bad Gateway)>
-      raise(HTTPError, "Error: #{e.message}")
-    end
-  end
-end
+require 'spotify/client'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spotify-client
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.1
 platform: ruby
 authors:
 - Claudio Poli
@@ -40,6 +40,9 @@ files:
 - LICENSE
 - README.md
 - lib/spotify-client.rb
+- lib/spotify/client.rb
+- lib/spotify/client/compatibility_api.rb
+- lib/spotify/client/transport.rb
 - lib/spotify/exceptions.rb
 - lib/spotify/version.rb
 - lib/spotify_client.rb