rocksky 0.3.0 → 0.4.0

data/lib/rocksky/client.rb

@@ -1,84 +0,0 @@
-module Rocksky
-  # Top-level client for the Rocksky XRPC API.
-  #
-  #   client = Rocksky.new(token: ENV["ROCKSKY_TOKEN"])
-  #   client.actor.get_profile(did: "alice.bsky.social")
-  #
-  # Resources are lazily instantiated and memoised: `client.actor`, `client.album`,
-  # `client.artist`, `client.scrobble`, etc.
-  class Client
-    DEFAULT_BASE_URL = "https://api.rocksky.app".freeze
-
-    attr_reader :base_url, :token, :headers, :user_agent,
-                :open_timeout, :read_timeout
-
-    def initialize(
-      base_url: nil,
-      token: nil,
-      headers: {},
-      user_agent: "rocksky-ruby/#{Rocksky::VERSION}",
-      open_timeout: HTTP::DEFAULT_OPEN_TIMEOUT,
-      read_timeout: HTTP::DEFAULT_READ_TIMEOUT
-    )
-      @base_url = normalize_base_url(base_url || ENV["ROCKSKY_BASE_URL"] || DEFAULT_BASE_URL)
-      @token = token || ENV["ROCKSKY_TOKEN"]
-      @headers = headers.dup
-      @user_agent = user_agent
-      @open_timeout = open_timeout
-      @read_timeout = read_timeout
-      @http = HTTP.new(self)
-    end
-
-    # Return a derived client that uses the given token (everything else copied).
-    # Handy for sharing one client across users in a request-scoped server.
-    def with_token(new_token)
-      self.class.new(
-        base_url: base_url,
-        token: new_token,
-        headers: headers,
-        user_agent: user_agent,
-        open_timeout: open_timeout,
-        read_timeout: read_timeout
-      )
-    end
-
-    # ---- Raw XRPC access ---------------------------------------------------
-
-    def query(nsid, **params)
-      @http.query(nsid, params)
-    end
-
-    def procedure(nsid, params: {}, body: nil)
-      @http.procedure(nsid, params, body)
-    end
-
-    # ---- Resource accessors ------------------------------------------------
-
-    def actor;    @actor    ||= Resources::Actor.new(@http); end
-    def album;    @album    ||= Resources::Album.new(@http); end
-    def apikey;   @apikey   ||= Resources::Apikey.new(@http); end
-    def artist;   @artist   ||= Resources::Artist.new(@http); end
-    def charts;   @charts   ||= Resources::Charts.new(@http); end
-    def feed;     @feed     ||= Resources::Feed.new(@http); end
-    def graph;    @graph    ||= Resources::Graph.new(@http); end
-    def like;     @like     ||= Resources::Like.new(@http); end
-    def mirror;   @mirror   ||= Resources::Mirror.new(@http); end
-    def player;   @player   ||= Resources::Player.new(@http); end
-    def playlist; @playlist ||= Resources::Playlist.new(@http); end
-    def scrobble; @scrobble ||= Resources::Scrobble.new(@http); end
-    def shout;    @shout    ||= Resources::Shout.new(@http); end
-    def song;     @song     ||= Resources::Song.new(@http); end
-    def spotify;  @spotify  ||= Resources::Spotify.new(@http); end
-    def stats;    @stats    ||= Resources::Stats.new(@http); end
-
-    def inspect
-      "#<Rocksky::Client base_url=#{base_url.inspect} token=#{token ? "[FILTERED]" : nil.inspect}>"
-    end
-
-    private
-
-    def normalize_base_url(url)
-      url.to_s.sub(%r{/+\z}, "")
-    end
-  end
-end

data/lib/rocksky/error.rb

@@ -1,58 +0,0 @@
-module Rocksky
-  class Error < StandardError
-    attr_reader :status, :body, :nsid
-
-    def initialize(message, status: nil, body: nil, nsid: nil)
-      super(message)
-      @status = status
-      @body = body
-      @nsid = nsid
-    end
-
-    def self.from_response(status, body, nsid: nil)
-      message = extract_message(body) || "request failed"
-      klass = klass_for(status)
-      klass.new(message, status: status, body: body, nsid: nsid)
-    end
-
-    def self.from_transport(cause, nsid: nil)
-      TransportError.new(
-        "transport error: #{cause.class}: #{cause.message}",
-        body: nil,
-        nsid: nsid
-      )
-    end
-
-    def self.klass_for(status)
-      case status
-      when 400 then BadRequest
-      when 401 then Unauthorized
-      when 403 then Forbidden
-      when 404 then NotFound
-      when 429 then RateLimited
-      when 500..599 then ServerError
-      else HTTPError
-      end
-    end
-    private_class_method :klass_for
-
-    def self.extract_message(body)
-      case body
-      when Hash
-        body["message"] || body["error"] || body[:message] || body[:error]
-      when String
-        body unless body.empty?
-      end
-    end
-    private_class_method :extract_message
-  end
-
-  class HTTPError < Error; end
-  class BadRequest < HTTPError; end
-  class Unauthorized < HTTPError; end
-  class Forbidden < HTTPError; end
-  class NotFound < HTTPError; end
-  class RateLimited < HTTPError; end
-  class ServerError < HTTPError; end
-  class TransportError < Error; end
-end

data/lib/rocksky/generated/types.rb

@@ -1,219 +0,0 @@
-# frozen_string_literal: true
-# AUTO-GENERATED FILE -- DO NOT EDIT.
-# Source: apps/api/lexicons/**/*.json
-# Regenerate via: bun run lexgen:types
-
-module Rocksky
-  module Generated
-    BlobRef = Struct.new(:type, :ref, :mimeType, :size, keyword_init: true)
-
-    ActorArtistViewBasic = Struct.new(:id, :name, :picture, :uri, :user1Rank, :user2Rank, :weight, keyword_init: true)
-    ActorCompatibilityViewBasic = Struct.new(:compatibilityLevel, :compatibilityPercentage, :sharedArtists, :topSharedArtistNames, :topSharedDetailedArtists, :user1ArtistCount, :user2ArtistCount, keyword_init: true)
-    ActorNeighbourViewBasic = Struct.new(:userId, :did, :handle, :displayName, :avatar, :sharedArtistsCount, :similarityScore, :topSharedArtistNames, :topSharedArtistsDetails, keyword_init: true)
-    ActorProfileViewBasic = Struct.new(:id, :did, :handle, :displayName, :avatar, :createdAt, :updatedAt, keyword_init: true)
-    ActorProfileViewDetailed = Struct.new(:id, :did, :handle, :displayName, :avatar, :createdAt, :updatedAt, keyword_init: true)
-    ActorTrackView = Struct.new(:name, :artist, :album, :albumCoverUrl, :durationMs, :source, :recordingMbId, keyword_init: true)
-    AddDirectoryToQueueParams = Struct.new(:playerId, :directory, :position, :shuffle, keyword_init: true)
-    AddItemsToQueueParams = Struct.new(:playerId, :items, :position, :shuffle, keyword_init: true)
-    AlbumRecord = Struct.new(:title, :artist, :duration, :releaseDate, :year, :genre, :albumArt, :albumArtUrl, :tags, :youtubeLink, :spotifyLink, :tidalLink, :appleMusicLink, :createdAt, keyword_init: true)
-    AlbumViewBasic = Struct.new(:id, :uri, :title, :artist, :artistUri, :year, :albumArt, :releaseDate, :sha256, :playCount, :uniqueListeners, keyword_init: true)
-    AlbumViewDetailed = Struct.new(:id, :uri, :title, :artist, :artistUri, :year, :albumArt, :releaseDate, :sha256, :playCount, :uniqueListeners, :tags, :tracks, keyword_init: true)
-    ApiKeyView = Struct.new(:id, :name, :description, :createdAt, keyword_init: true)
-    ArtistListenerViewBasic = Struct.new(:id, :did, :handle, :displayName, :avatar, :mostListenedSong, :totalPlays, :rank, keyword_init: true)
-    ArtistMbid = Struct.new(:mbid, :name, keyword_init: true)
-    ArtistRecentListenerView = Struct.new(:id, :did, :handle, :displayName, :avatar, :timestamp, :scrobbleUri, keyword_init: true)
-    ArtistRecord = Struct.new(:name, :bio, :picture, :pictureUrl, :tags, :born, :died, :bornIn, :createdAt, keyword_init: true)
-    ArtistSongViewBasic = Struct.new(:uri, :title, :playCount, keyword_init: true)
-    ArtistViewBasic = Struct.new(:id, :uri, :name, :picture, :sha256, :playCount, :uniqueListeners, :tags, keyword_init: true)
-    ArtistViewDetailed = Struct.new(:id, :uri, :name, :picture, :sha256, :playCount, :uniqueListeners, :tags, keyword_init: true)
-    ChartsScrobbleViewBasic = Struct.new(:date, :count, keyword_init: true)
-    ChartsView = Struct.new(:scrobbles, keyword_init: true)
-    CreateApikeyInput = Struct.new(:name, :description, keyword_init: true)
-    CreatePlaylistParams = Struct.new(:name, :description, keyword_init: true)
-    CreateScrobbleInput = Struct.new(:title, :artist, :album, :duration, :mbId, :isrc, :albumArt, :trackNumber, :releaseDate, :year, :discNumber, :lyrics, :composer, :copyrightMessage, :label, :artistPicture, :spotifyLink, :lastfmLink, :tidalLink, :appleMusicLink, :youtubeLink, :deezerLink, :timestamp, keyword_init: true)
-    CreateShoutInput = Struct.new(:message, keyword_init: true)
-    CreateSongInput = Struct.new(:title, :artist, :albumArtist, :album, :duration, :mbId, :isrc, :albumArt, :trackNumber, :releaseDate, :year, :discNumber, :lyrics, keyword_init: true)
-    DescribeFeedGeneratorOutput = Struct.new(:did, :feeds, keyword_init: true)
-    DescribeFeedGeneratorParams = Struct.new(keyword_init: true)
-    DislikeShoutInput = Struct.new(:uri, keyword_init: true)
-    DislikeSongInput = Struct.new(:uri, keyword_init: true)
-    DownloadFileParams = Struct.new(:fileId, keyword_init: true)
-    DropboxFileListView = Struct.new(:files, keyword_init: true)
-    DropboxFileView = Struct.new(:id, :name, :pathLower, :pathDisplay, :clientModified, :serverModified, keyword_init: true)
-    DropboxTemporaryLinkView = Struct.new(:link, keyword_init: true)
-    FeedGeneratorsView = Struct.new(:feeds, keyword_init: true)
-    FeedGeneratorView = Struct.new(:id, :name, :description, :uri, :avatar, :creator, keyword_init: true)
-    FeedItemView = Struct.new(:scrobble, keyword_init: true)
-    FeedRecommendationsView = Struct.new(:recommendations, :cursor, keyword_init: true)
-    FeedRecommendationView = Struct.new(:title, :artist, :album, :albumArt, :trackUri, :artistUri, :albumUri, :genres, :recommendationScore, :source, :likesCount, keyword_init: true)
-    FeedRecommendedAlbumsView = Struct.new(:albums, :cursor, keyword_init: true)
-    FeedRecommendedAlbumView = Struct.new(:id, :uri, :title, :artist, :artistUri, :year, :albumArt, :recommendationScore, :source, keyword_init: true)
-    FeedRecommendedArtistsView = Struct.new(:artists, :cursor, keyword_init: true)
-    FeedRecommendedArtistView = Struct.new(:id, :uri, :name, :picture, :genres, :recommendationScore, :source, keyword_init: true)
-    FeedSearchResultsView = Struct.new(:hits, :processingTimeMs, :limit, :offset, :estimatedTotalHits, keyword_init: true)
-    FeedStoriesView = Struct.new(:stories, keyword_init: true)
-    FeedStoryView = Struct.new(:album, :albumArt, :albumArtist, :albumUri, :artist, :artistUri, :avatar, :createdAt, :did, :handle, :id, :title, :trackId, :trackUri, :uri, keyword_init: true)
-    FeedUriView = Struct.new(:uri, keyword_init: true)
-    FeedView = Struct.new(:feed, :cursor, keyword_init: true)
-    FollowAccountOutput = Struct.new(:subject, :followers, :cursor, keyword_init: true)
-    FollowAccountParams = Struct.new(:account, keyword_init: true)
-    FollowRecord = Struct.new(:createdAt, :subject, :via, keyword_init: true)
-    GeneratorRecord = Struct.new(:did, :avatar, :displayName, :description, :createdAt, keyword_init: true)
-    GetActorAlbumsOutput = Struct.new(:albums, keyword_init: true)
-    GetActorAlbumsParams = Struct.new(:did, :limit, :offset, :startDate, :endDate, keyword_init: true)
-    GetActorArtistsOutput = Struct.new(:artists, keyword_init: true)
-    GetActorArtistsParams = Struct.new(:did, :limit, :offset, :startDate, :endDate, keyword_init: true)
-    GetActorCompatibilityOutput = Struct.new(:compatibility, keyword_init: true)
-    GetActorCompatibilityParams = Struct.new(:did, keyword_init: true)
-    GetActorLovedSongsOutput = Struct.new(:tracks, keyword_init: true)
-    GetActorLovedSongsParams = Struct.new(:did, :limit, :offset, keyword_init: true)
-    GetActorNeighboursOutput = Struct.new(:neighbours, keyword_init: true)
-    GetActorNeighboursParams = Struct.new(:did, keyword_init: true)
-    GetActorPlaylistsOutput = Struct.new(:playlists, keyword_init: true)
-    GetActorPlaylistsParams = Struct.new(:did, :limit, :offset, keyword_init: true)
-    GetActorScrobblesOutput = Struct.new(:scrobbles, keyword_init: true)
-    GetActorScrobblesParams = Struct.new(:did, :limit, :offset, keyword_init: true)
-    GetActorSongsOutput = Struct.new(:songs, keyword_init: true)
-    GetActorSongsParams = Struct.new(:did, :limit, :offset, :startDate, :endDate, keyword_init: true)
-    GetAlbumParams = Struct.new(:uri, keyword_init: true)
-    GetAlbumRecommendationsParams = Struct.new(:did, :limit, keyword_init: true)
-    GetAlbumShoutsOutput = Struct.new(:shouts, keyword_init: true)
-    GetAlbumShoutsParams = Struct.new(:uri, :limit, :offset, keyword_init: true)
-    GetAlbumsOutput = Struct.new(:albums, keyword_init: true)
-    GetAlbumsParams = Struct.new(:limit, :offset, :genre, keyword_init: true)
-    GetAlbumTracksOutput = Struct.new(:tracks, keyword_init: true)
-    GetAlbumTracksParams = Struct.new(:uri, keyword_init: true)
-    GetApikeysOutput = Struct.new(:apiKeys, keyword_init: true)
-    GetApikeysParams = Struct.new(:offset, :limit, keyword_init: true)
-    GetArtistAlbumsOutput = Struct.new(:albums, keyword_init: true)
-    GetArtistAlbumsParams = Struct.new(:uri, keyword_init: true)
-    GetArtistListenersOutput = Struct.new(:listeners, keyword_init: true)
-    GetArtistListenersParams = Struct.new(:uri, :offset, :limit, keyword_init: true)
-    GetArtistParams = Struct.new(:uri, keyword_init: true)
-    GetArtistRecentListenersOutput = Struct.new(:listeners, keyword_init: true)
-    GetArtistRecentListenersParams = Struct.new(:uri, :offset, :limit, keyword_init: true)
-    GetArtistRecommendationsParams = Struct.new(:did, :limit, keyword_init: true)
-    GetArtistShoutsOutput = Struct.new(:shouts, keyword_init: true)
-    GetArtistShoutsParams = Struct.new(:uri, :limit, :offset, keyword_init: true)
-    GetArtistsOutput = Struct.new(:artists, keyword_init: true)
-    GetArtistsParams = Struct.new(:limit, :offset, :names, :genre, keyword_init: true)
-    GetArtistTracksOutput = Struct.new(:tracks, keyword_init: true)
-    GetArtistTracksParams = Struct.new(:uri, :limit, :offset, keyword_init: true)
-    GetCurrentlyPlayingParams = Struct.new(:playerId, :actor, keyword_init: true)
-    GetFeedGeneratorOutput = Struct.new(:view, keyword_init: true)
-    GetFeedGeneratorParams = Struct.new(:feed, keyword_init: true)
-    GetFeedGeneratorsParams = Struct.new(:size, keyword_init: true)
-    GetFeedParams = Struct.new(:feed, :limit, :cursor, keyword_init: true)
-    GetFeedSkeletonOutput = Struct.new(:scrobbles, :cursor, keyword_init: true)
-    GetFeedSkeletonParams = Struct.new(:feed, :limit, :offset, :cursor, keyword_init: true)
-    GetFileParams = Struct.new(:fileId, keyword_init: true)
-    GetFilesParams = Struct.new(:at, keyword_init: true)
-    GetFollowersOutput = Struct.new(:subject, :followers, :cursor, :count, keyword_init: true)
-    GetFollowersParams = Struct.new(:actor, :limit, :dids, :cursor, keyword_init: true)
-    GetFollowsOutput = Struct.new(:subject, :follows, :cursor, :count, keyword_init: true)
-    GetFollowsParams = Struct.new(:actor, :limit, :dids, :cursor, keyword_init: true)
-    GetGlobalStatsParams = Struct.new(keyword_init: true)
-    GetKnownFollowersOutput = Struct.new(:subject, :followers, :cursor, keyword_init: true)
-    GetKnownFollowersParams = Struct.new(:actor, :limit, :cursor, keyword_init: true)
-    GetMetadataParams = Struct.new(:path, keyword_init: true)
-    GetMirrorSourcesOutput = Struct.new(:sources, keyword_init: true)
-    GetMirrorSourcesParams = Struct.new(keyword_init: true)
-    GetPlaybackQueueParams = Struct.new(:playerId, keyword_init: true)
-    GetPlaylistParams = Struct.new(:uri, keyword_init: true)
-    GetPlaylistsOutput = Struct.new(:playlists, keyword_init: true)
-    GetPlaylistsParams = Struct.new(:limit, :offset, keyword_init: true)
-    GetProfileParams = Struct.new(:did, keyword_init: true)
-    GetProfileShoutsOutput = Struct.new(:shouts, keyword_init: true)
-    GetProfileShoutsParams = Struct.new(:did, :offset, :limit, keyword_init: true)
-    GetRecommendationsParams = Struct.new(:did, :limit, keyword_init: true)
-    GetScrobbleParams = Struct.new(:uri, keyword_init: true)
-    GetScrobblesChartParams = Struct.new(:did, :artisturi, :albumuri, :songuri, :genre, :from, :to, keyword_init: true)
-    GetScrobblesOutput = Struct.new(:scrobbles, keyword_init: true)
-    GetScrobblesParams = Struct.new(:did, :following, :limit, :offset, keyword_init: true)
-    GetShoutRepliesOutput = Struct.new(:shouts, keyword_init: true)
-    GetShoutRepliesParams = Struct.new(:uri, :limit, :offset, keyword_init: true)
-    GetSongParams = Struct.new(:uri, :mbid, :isrc, :spotifyId, keyword_init: true)
-    GetSongRecentListenersOutput = Struct.new(:listeners, keyword_init: true)
-    GetSongRecentListenersParams = Struct.new(:uri, :offset, :limit, keyword_init: true)
-    GetSongsOutput = Struct.new(:songs, keyword_init: true)
-    GetSongsParams = Struct.new(:limit, :offset, :genre, :mbid, :isrc, :spotifyId, keyword_init: true)
-    GetStatsParams = Struct.new(:did, keyword_init: true)
-    GetStoriesParams = Struct.new(:size, :feed, :following, keyword_init: true)
-    GetTemporaryLinkParams = Struct.new(:path, keyword_init: true)
-    GetTopArtistsOutput = Struct.new(:artists, keyword_init: true)
-    GetTopArtistsParams = Struct.new(:limit, :offset, :startDate, :endDate, keyword_init: true)
-    GetTopTracksOutput = Struct.new(:tracks, keyword_init: true)
-    GetTopTracksParams = Struct.new(:limit, :offset, :startDate, :endDate, keyword_init: true)
-    GetTrackShoutsOutput = Struct.new(:shouts, keyword_init: true)
-    GetTrackShoutsParams = Struct.new(:uri, keyword_init: true)
-    GetWrappedParams = Struct.new(:did, :year, keyword_init: true)
-    GoogledriveFileListView = Struct.new(:files, keyword_init: true)
-    GoogledriveFileView = Struct.new(:id, keyword_init: true)
-    # indicates that a handle or DID could not be resolved
-    GraphNotFoundActor = Struct.new(:actor, :notFound, keyword_init: true)
-    GraphRelationship = Struct.new(:did, :following, :followedBy, keyword_init: true)
-    InsertDirectoryParams = Struct.new(:uri, :directory, :position, keyword_init: true)
-    InsertFilesParams = Struct.new(:uri, :files, :position, keyword_init: true)
-    LikeRecord = Struct.new(:createdAt, :subject, keyword_init: true)
-    LikeShoutInput = Struct.new(:uri, keyword_init: true)
-    LikeSongInput = Struct.new(:uri, keyword_init: true)
-    MatchSongParams = Struct.new(:title, :artist, :mbId, :isrc, keyword_init: true)
-    MirrorSourceView = Struct.new(:provider, :enabled, :externalUsername, :hasCredentials, :lastPolledAt, :lastScrobbleSeenAt, keyword_init: true)
-    NextParams = Struct.new(:playerId, keyword_init: true)
-    PauseParams = Struct.new(:playerId, keyword_init: true)
-    PlayDirectoryParams = Struct.new(:playerId, :directoryId, :shuffle, :recurse, :position, keyword_init: true)
-    PlayerCurrentlyPlayingViewDetailed = Struct.new(:title, keyword_init: true)
-    PlayerPlaybackQueueViewDetailed = Struct.new(:tracks, keyword_init: true)
-    PlayFileParams = Struct.new(:playerId, :fileId, keyword_init: true)
-    PlaylistItemRecord = Struct.new(:subject, :createdAt, :track, :order, keyword_init: true)
-    PlaylistRecord = Struct.new(:name, :description, :picture, :pictureUrl, :createdAt, :spotifyLink, :tidalLink, :youtubeLink, :appleMusicLink, keyword_init: true)
-    # Basic view of a playlist, including its metadata
-    PlaylistViewBasic = Struct.new(:id, :title, :uri, :curatorDid, :curatorHandle, :curatorName, :curatorAvatarUrl, :description, :coverImageUrl, :createdAt, :trackCount, keyword_init: true)
-    # Detailed view of a playlist, including its tracks and metadata
-    PlaylistViewDetailed = Struct.new(:id, :title, :uri, :curatorDid, :curatorHandle, :curatorName, :curatorAvatarUrl, :description, :coverImageUrl, :createdAt, :tracks, keyword_init: true)
-    PlayParams = Struct.new(:playerId, keyword_init: true)
-    PreviousParams = Struct.new(:playerId, keyword_init: true)
-    ProfileRecord = Struct.new(:displayName, :description, :avatar, :banner, :labels, :joinedViaStarterPack, :createdAt, keyword_init: true)
-    PutMirrorSourceInput = Struct.new(:provider, :enabled, :externalUsername, :apiKey, keyword_init: true)
-    RadioRecord = Struct.new(:name, :url, :description, :genre, :logo, :website, :createdAt, keyword_init: true)
-    RadioViewBasic = Struct.new(:id, :name, :description, :createdAt, keyword_init: true)
-    RadioViewDetailed = Struct.new(:id, :name, :description, :website, :url, :genre, :logo, :createdAt, keyword_init: true)
-    RemoveApikeyParams = Struct.new(:id, keyword_init: true)
-    RemovePlaylistParams = Struct.new(:uri, keyword_init: true)
-    RemoveShoutParams = Struct.new(:id, keyword_init: true)
-    RemoveTrackParams = Struct.new(:uri, :position, keyword_init: true)
-    ReplyShoutInput = Struct.new(:shoutId, :message, keyword_init: true)
-    ReportShoutInput = Struct.new(:shoutId, :reason, keyword_init: true)
-    ScrobbleFirstScrobbleView = Struct.new(:handle, :avatar, :timestamp, keyword_init: true)
-    ScrobbleRecord = Struct.new(:title, :artist, :artists, :albumArtist, :album, :duration, :trackNumber, :discNumber, :releaseDate, :year, :genre, :tags, :composer, :lyrics, :copyrightMessage, :wiki, :albumArt, :albumArtUrl, :youtubeLink, :spotifyLink, :tidalLink, :appleMusicLink, :createdAt, :mbid, :label, :isrc, keyword_init: true)
-    ScrobbleViewBasic = Struct.new(:id, :user, :userDisplayName, :userAvatar, :title, :artist, :artistUri, :album, :albumUri, :cover, :date, :uri, :sha256, :liked, :likesCount, keyword_init: true)
-    ScrobbleViewDetailed = Struct.new(:id, :user, :title, :artist, :artistUri, :album, :albumUri, :cover, :date, :uri, :sha256, :liked, :likesCount, :listeners, :scrobbles, :artists, :firstScrobble, keyword_init: true)
-    SearchParams = Struct.new(:query, keyword_init: true)
-    SeekParams = Struct.new(:playerId, :position, keyword_init: true)
-    ShoutAuthor = Struct.new(:id, :did, :handle, :displayName, :avatar, keyword_init: true)
-    ShoutRecord = Struct.new(:message, :createdAt, :parent, :subject, keyword_init: true)
-    ShoutView = Struct.new(:id, :message, :parent, :createdAt, :author, keyword_init: true)
-    SongFirstScrobbleView = Struct.new(:handle, :avatar, :timestamp, keyword_init: true)
-    SongRecentListenerView = Struct.new(:id, :did, :handle, :displayName, :avatar, :timestamp, :scrobbleUri, keyword_init: true)
-    SongRecord = Struct.new(:title, :artist, :artists, :albumArtist, :album, :duration, :trackNumber, :discNumber, :releaseDate, :year, :genre, :tags, :composer, :lyrics, :copyrightMessage, :wiki, :albumArt, :albumArtUrl, :youtubeLink, :spotifyLink, :tidalLink, :appleMusicLink, :createdAt, :mbid, :label, :isrc, keyword_init: true)
-    SongViewBasic = Struct.new(:id, :title, :artist, :albumArtist, :albumArt, :uri, :album, :duration, :trackNumber, :discNumber, :playCount, :uniqueListeners, :albumUri, :artistUri, :sha256, :mbid, :isrc, :tags, :createdAt, keyword_init: true)
-    SongViewDetailed = Struct.new(:id, :title, :artist, :albumArtist, :albumArt, :uri, :album, :duration, :trackNumber, :discNumber, :playCount, :uniqueListeners, :albumUri, :artistUri, :sha256, :mbid, :isrc, :tags, :createdAt, :artists, :firstScrobble, keyword_init: true)
-    SpotifyTrackView = Struct.new(:id, :name, :artist, :album, :duration, :previewUrl, keyword_init: true)
-    StartPlaylistParams = Struct.new(:uri, :shuffle, :position, keyword_init: true)
-    StatsGlobalStatsView = Struct.new(:scrobbles, :users, :artists, :albums, :tracks, keyword_init: true)
-    StatsView = Struct.new(:scrobbles, :artists, :lovedTracks, :albums, :tracks, keyword_init: true)
-    StatsWrappedAlbum = Struct.new(:id, :title, :artist, :albumArt, :uri, :playCount, keyword_init: true)
-    StatsWrappedArtist = Struct.new(:id, :name, :picture, :uri, :playCount, keyword_init: true)
-    StatsWrappedDayCount = Struct.new(:date, :count, keyword_init: true)
-    StatsWrappedGenreCount = Struct.new(:genre, :count, keyword_init: true)
-    StatsWrappedMilestone = Struct.new(:trackTitle, :artistName, :timestamp, :trackUri, keyword_init: true)
-    StatsWrappedMonthCount = Struct.new(:month, :count, keyword_init: true)
-    StatsWrappedTrack = Struct.new(:id, :title, :artist, :albumArt, :uri, :artistUri, :albumUri, :playCount, keyword_init: true)
-    StatsWrappedView = Struct.new(:year, :totalScrobbles, :totalListeningTimeMinutes, :topArtists, :topTracks, :topAlbums, :topGenres, :scrobblesPerMonth, :mostActiveDay, :mostActiveHour, :newArtistsCount, :longestStreak, :firstScrobble, :lastScrobble, keyword_init: true)
-    StatusRecord = Struct.new(:track, :startedAt, :expiresAt, keyword_init: true)
-    StrongRef = Struct.new(:uri, :cid, keyword_init: true)
-    UnfollowAccountOutput = Struct.new(:subject, :followers, :cursor, keyword_init: true)
-    UnfollowAccountParams = Struct.new(:account, keyword_init: true)
-    UpdateApikeyInput = Struct.new(:id, :name, :description, keyword_init: true)
-  end
-end

data/lib/rocksky/http.rb

@@ -1,123 +0,0 @@
-require "json"
-require "net/http"
-require "uri"
-
-module Rocksky
-  # Low-level XRPC transport. Most users should go through the resource
-  # accessors on {Rocksky::Client} (e.g. `client.actor.get_profile(...)`).
-  class HTTP
-    DEFAULT_OPEN_TIMEOUT = 10
-    DEFAULT_READ_TIMEOUT = 30
-
-    attr_reader :client
-
-    def initialize(client)
-      @client = client
-    end
-
-    # GET /xrpc/<nsid>?...
-    def query(nsid, params = {})
-      request(method: :get, nsid: nsid, params: params)
-    end
-
-    # POST /xrpc/<nsid>?... with optional JSON body.
-    def procedure(nsid, params = {}, body = nil)
-      request(method: :post, nsid: nsid, params: params, body: body)
-    end
-
-    private
-
-    def request(method:, nsid:, params: {}, body: nil)
-      uri = build_uri(nsid, params)
-      req = build_request(method, uri, body)
-      apply_headers(req)
-
-      response = perform(uri, req)
-      handle_response(response, nsid)
-    rescue Timeout::Error, Errno::ECONNREFUSED, SocketError, IOError,
-           Net::OpenTimeout, Net::ReadTimeout => e
-      raise Error.from_transport(e, nsid: nsid)
-    end
-
-    def build_uri(nsid, params)
-      url = "#{client.base_url}/xrpc/#{nsid}"
-      uri = URI.parse(url)
-      encoded = encode_params(params)
-      uri.query = URI.encode_www_form(encoded) unless encoded.empty?
-      uri
-    end
-
-    def build_request(method, uri, body)
-      req =
-        case method
-        when :get  then Net::HTTP::Get.new(uri.request_uri)
-        when :post then Net::HTTP::Post.new(uri.request_uri)
-        else raise ArgumentError, "unsupported method: #{method}"
-        end
-
-      if body && !body.empty?
-        req["content-type"] = "application/json"
-        req.body = JSON.generate(body)
-      end
-
-      req
-    end
-
-    def apply_headers(req)
-      req["accept"] = "application/json"
-      req["user-agent"] = client.user_agent if client.user_agent
-      req["authorization"] = "Bearer #{client.token}" if client.token
-      client.headers.each { |name, value| req[name] = value }
-    end
-
-    def perform(uri, req)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = (uri.scheme == "https")
-      http.open_timeout = client.open_timeout
-      http.read_timeout = client.read_timeout
-      http.request(req)
-    end
-
-    def handle_response(response, nsid)
-      status = response.code.to_i
-      body = parse_body(response)
-
-      return body if status.between?(200, 299)
-
-      raise Error.from_response(status, body, nsid: nsid)
-    end
-
-    def parse_body(response)
-      return nil if response.body.nil? || response.body.empty?
-
-      content_type = response["content-type"].to_s
-      if content_type.include?("application/json")
-        JSON.parse(response.body)
-      else
-        response.body
-      end
-    rescue JSON::ParserError
-      response.body
-    end
-
-    # Drop nil values; convert symbol keys to strings; join arrays with commas
-    # (matches the lexicon-defined array encoding used by other SDKs).
-    def encode_params(params)
-      return {} if params.nil?
-
-      Hash(params).each_with_object({}) do |(key, value), out|
-        next if value.nil?
-
-        out[key.to_s] = encode_value(value)
-      end
-    end
-
-    def encode_value(value)
-      case value
-      when Array then value.join(",")
-      when true, false then value.to_s
-      else value
-      end
-    end
-  end
-end

data/lib/rocksky/resources/actor.rb

@@ -1,60 +0,0 @@
-module Rocksky
-  module Resources
-    # `app.rocksky.actor.*` endpoints.
-    class Actor < Base
-      # Fetch a profile by DID or handle.
-      def get_profile(did:)
-        query("app.rocksky.actor.getProfile", did: did)
-      end
-
-      # Albums an actor has scrobbled.
-      def get_actor_albums(did:, limit: nil, offset: nil, start_date: nil, end_date: nil)
-        query("app.rocksky.actor.getActorAlbums",
-              did: did, limit: limit, offset: offset,
-              startDate: start_date, endDate: end_date)
-      end
-
-      # Artists an actor has scrobbled.
-      def get_actor_artists(did:, limit: nil, offset: nil, start_date: nil, end_date: nil)
-        query("app.rocksky.actor.getActorArtists",
-              did: did, limit: limit, offset: offset,
-              startDate: start_date, endDate: end_date)
-      end
-
-      # Songs an actor has scrobbled.
-      def get_actor_songs(did:, limit: nil, offset: nil, start_date: nil, end_date: nil)
-        query("app.rocksky.actor.getActorSongs",
-              did: did, limit: limit, offset: offset,
-              startDate: start_date, endDate: end_date)
-      end
-
-      # Songs an actor has loved.
-      def get_actor_loved_songs(did:, limit: nil, offset: nil)
-        query("app.rocksky.actor.getActorLovedSongs",
-              did: did, limit: limit, offset: offset)
-      end
-
-      # Scrobbles for an actor.
-      def get_actor_scrobbles(did:, limit: nil, offset: nil)
-        query("app.rocksky.actor.getActorScrobbles",
-              did: did, limit: limit, offset: offset)
-      end
-
-      # Playlists for an actor.
-      def get_actor_playlists(did:, limit: nil, offset: nil)
-        query("app.rocksky.actor.getActorPlaylists",
-              did: did, limit: limit, offset: offset)
-      end
-
-      # Musical neighbours of an actor.
-      def get_actor_neighbours(did:)
-        query("app.rocksky.actor.getActorNeighbours", did: did)
-      end
-
-      # Compatibility score between the authenticated user and another actor.
-      def get_actor_compatibility(did:)
-        query("app.rocksky.actor.getActorCompatibility", did: did)
-      end
-    end
-  end
-end

data/lib/rocksky/resources/album.rb

@@ -1,22 +0,0 @@
-module Rocksky
-  module Resources
-    # `app.rocksky.album.*` endpoints.
-    class Album < Base
-      # Fetch an album by AT-URI.
-      def get_album(uri:)
-        query("app.rocksky.album.getAlbum", uri: uri)
-      end
-
-      # List albums.
-      def get_albums(limit: nil, offset: nil, genre: nil)
-        query("app.rocksky.album.getAlbums",
-              limit: limit, offset: offset, genre: genre)
-      end
-
-      # Tracks belonging to an album.
-      def get_album_tracks(uri:)
-        query("app.rocksky.album.getAlbumTracks", uri: uri)
-      end
-    end
-  end
-end

data/lib/rocksky/resources/apikey.rb

@@ -1,28 +0,0 @@
-module Rocksky
-  module Resources
-    # `app.rocksky.apikey.*` endpoints. All require an authenticated client.
-    class Apikey < Base
-      # List your API keys.
-      def get_apikeys(limit: nil, offset: nil)
-        query("app.rocksky.apikey.getApikeys", limit: limit, offset: offset)
-      end
-
-      # Create a new API key.
-      def create_apikey(name:, description: nil)
-        body = { name: name, description: description }.compact
-        procedure("app.rocksky.apikey.createApikey", body: body)
-      end
-
-      # Update an API key.
-      def update_apikey(id:, name: nil, description: nil)
-        body = { id: id, name: name, description: description }.compact
-        procedure("app.rocksky.apikey.updateApikey", body: body)
-      end
-
-      # Remove an API key.
-      def remove_apikey(id:)
-        procedure("app.rocksky.apikey.removeApikey", params: { id: id })
-      end
-    end
-  end
-end

data/lib/rocksky/resources/artist.rb

@@ -1,40 +0,0 @@
-module Rocksky
-  module Resources
-    # `app.rocksky.artist.*` endpoints.
-    class Artist < Base
-      # Fetch an artist by AT-URI.
-      def get_artist(uri:)
-        query("app.rocksky.artist.getArtist", uri: uri)
-      end
-
-      # List artists. `names` may be an Array of strings; it will be joined CSV-style.
-      def get_artists(limit: nil, offset: nil, names: nil, genre: nil)
-        query("app.rocksky.artist.getArtists",
-              limit: limit, offset: offset, names: names, genre: genre)
-      end
-
-      # Albums by an artist.
-      def get_artist_albums(uri:)
-        query("app.rocksky.artist.getArtistAlbums", uri: uri)
-      end
-
-      # Tracks by an artist.
-      def get_artist_tracks(uri:, limit: nil, offset: nil)
-        query("app.rocksky.artist.getArtistTracks",
-              uri: uri, limit: limit, offset: offset)
-      end
-
-      # All-time listeners for an artist.
-      def get_artist_listeners(uri:, limit: nil, offset: nil)
-        query("app.rocksky.artist.getArtistListeners",
-              uri: uri, limit: limit, offset: offset)
-      end
-
-      # Recent listeners for an artist.
-      def get_artist_recent_listeners(uri:, limit: nil, offset: nil)
-        query("app.rocksky.artist.getArtistRecentListeners",
-              uri: uri, limit: limit, offset: offset)
-      end
-    end
-  end
-end

data/lib/rocksky/resources/base.rb

@@ -1,24 +0,0 @@
-module Rocksky
-  module Resources
-    # Shared plumbing for resource classes. Each subclass calls {#query} or
-    # {#procedure} with the lexicon NSID; the {Rocksky::HTTP} instance does the
-    # actual transport work.
-    class Base
-      attr_reader :http
-
-      def initialize(http)
-        @http = http
-      end
-
-      protected
-
-      def query(nsid, **params)
-        @http.query(nsid, params)
-      end
-
-      def procedure(nsid, params: {}, body: nil)
-        @http.procedure(nsid, params, body)
-      end
-    end
-  end
-end