For example, I have a playlist with 45 tracks, and when I use PageIterator for getPlaylistTracks I receive a partial tracks list. Here minimal code to reproduce the problem:

const playlistTracksIterator = new PageIterator((opts) =>
  getPlaylistTracks(client, PLAYLIST_ID, opts),
);
const playlistTracksList = await playlistTracksIterator.collect();

console.log(preparedTracksList.length); // 44, because last track is missed.

This issue lists Renovate updates and detected dependencies. Read the Dependency Dashboard docs to learn more.

Open

These updates have all been created already. Click a checkbox below to force a retry/rebase of any.

• chore(dependency): update all dependencies (@faker-js/faker, @tanstack/react-query, @types/cookie-parser, @types/express, @types/node, @vitejs/plugin-react, @vitest/coverage-c8, actions/checkout, actions/setup-node, all-contributors-cli, cookies-next, envalid, next, pnpm, prettier, react-router-dom, rimraf, typescript, vite, vitest)
• chore(dependency): lock file maintenance

Detected dependencies

• Check this box to trigger a request for Renovate to run again on this repository

The problem is that the endpoints are a bunch of separate functions that need to pass the client as the first argument each time. In code it look like this:

import { SpoitifyClient, getCurrentUserProfile, getUserProfile } from "soundify-web-api";

const client = new SpotifyClient("ACCESS_TOKEN");

const currentUser = await getCurrentUserProfile(client);
const user123 = await getUserProfile(client, "some-user-id-123");

The obvious question would be: why can't we do that?

import { SpotifyClient } from "soundify-web-api";

const client = new SpotifyCleint("ACCESS_TOKEN");

const currentUser = await client.getCurrentUserProfile();
const user123 = await client.getUserProfile("some-user-id-123");

The answer is this. We want to have a treeshake on the client and not import all the functions we don't need. Plus, personally I don't like to write one huge class with hundreds of methods.
But for the backend, it's much easier to use this type of composition. It would be great for implementing dependencies and a good developer experience. So what can we do?

Currently, api calls are presented as separate functions, such as this one.

export const getCurrentUserProfile = (spotifyClient: ISpotifyClient) => {
    return spotifyClient.fetch<UserPrivate>("/me");
};

// Usage example
const spotifyClient = new SpotifyClient(...);
const user = await getCurrentUserProfile(spotifyClient);

But in most api libraries, you can see a single class that contains all the api calls, so you can just do that.

const spotifyAPI = new SpotifyAPI()
const user = await spotifyAPI.getCurrentUserProfile();

What do you prefer to use?
Please write what you think about it. You can just "prefer functions" or "prefer class".

From my point of view, I can highlight some pros and cons:

• Pros
  • Easy to treeshake in a web bundle.
  • Decomposition. Much easier to support a bunch of functions than one big class (in my opinion).
• Cons.
  • A class is just easier to use. You can pass it throughout your application and use it. It's awkwardly to pass a client every time just to use call. Idk

There is an error with this repository's Renovate configuration that needs to be fixed. As a precaution, Renovate will stop PRs until it is resolved.

Location: .github/renovate.json
Error type: The renovate configuration file contains some invalid settings
Message: "fileMatch" may not be defined at the top level of a config and must instead be within a manager block

Authorization flows

• Authorization Code Flow - AuthCode namespace
• Implicit Grant Flow - ImplicitGrant namespace
• Client Credentials Flow - ClientCredentials namespace
• Authorization code with PKCE - PKCEAuthCode namespace

API coverage

• Albums
• • GET /albums/{album_id} - getAlbum()
• • GET /albums - getAlbums()
• • GET /albums/{album_id}/tracks - getAlbumTracks()
• • GET /me/albums - getSavedAlbums()
• • PUT /me/albums - saveAlbums(), saveAlbum()
• • DELETE /me/albums - removeSavedAlbums(), removeSavedAlbum()
• • GET /me/albums/contains - checkSavedAlbums(), checkSavedAlbum()
• • GET /browse/new-releases - getNewAlbumReleases()
• Artists
• • GET /artists/{artist_id} - getArtist()
• • GET /artists - getArtists()
• • GET /artists/{artist_id}/albums - getArtistAlbums()
• • GET /artists/{artist_id}/top-tracks - getArtistTopTracks()
• • GET /artists/{artist_id}/related-artists - getArtistRelatedArtists()
• Tracks
• • GET /tracks/{track_id} - getTrack()
• • GET /tracks - getTracks()
• • GET /me/tracks - getSavedTracks()
• • PUT /me/tracks - saveTracks(), saveTrack()
• • DELETE /me/tracks - removeSavedTracks(), removeSavedTrack()
• • GET /me/tracks/contains - checkSavedTracks(), checkSavedTrack()
• • GET /audio-features - getTracksAudioFeatures()
• • GET /audio-features/{track_id} - getTrackAudioFeatures()
• • GET /audio-analysis/{track_id} - getTracksAudioAnalysis()
• • GET /recommendations - getRecommendations()
• Search
• • GET /search
• Users
• • GET /me - getCurrentUserProfile()
• • GET /me/top/{type} - getUserTopItems(), getUserTopArtists(), getUserTopTracks().
• • GET /users/{user_id} - getUserProfile()
• • PUT /playlists/{playlist_id}/followers - followPlaylist()
• • DELETE /playlists/{playlist_id}/followers - unfollowPlaylist()
• • GET /me/following - getFollowedArtists()
• • PUT /me/following - followArtists(), followArtist(), followUsers(), followUser()
• • DELETE /me/following - unfollowArtists(), unfollowArtist(), unfollowUsers(), unfollowUser()
• • GET /me/following/contains - checkIfUserFollowsArtists(), checkIfUserFollowsArtist(), checkIfUserFollowsUsers(), checkIfUserFollowsUser()
• • GET /playlists/{playlist_id}/followers/contains - checkIfUsersFollowPlaylist(), checkIfUserFollowsPlaylist()
• Playlists
• • GET /playlists/{playlist_id}
• • PUT /playlists/{playlist_id}
• • GET /playlists/{playlist_id}/tracks
• • POST /playlists/{playlist_id}/tracks
• • PUT /playlists/{playlist_id}/tracks
• • DELETE /playlists/{playlist_id}/tracks
• • GET /me/playlists
• • GET /users/{user_id}/playlists
• • POST /users/{user_id}/playlists
• • GET /browse/featured-playlists
• • GET /browse/categories/{category_id}/playlists
• • GET /playlists/{playlist_id}/images
• • PUT /playlists/{playlist_id}/images
• Categories
• • GET /browse/categories - getBrowseCategories()
• • GET /browse/categories/{category_id} - getBrowseCategory()
• Genres
• • GET /recommendations/available-genre-seeds - getAvailableGenres()
• Markets
• • GET /markets - getAvaibleMarkets()

Examples

• Examples for web (ImplicitGrant, PKCEAuthCode flows) - examples/react-implicit-grant, examples/react-pkce-auth
• Example with NEXT.JS and server-side rendering (AuthCode flow) - examples/next-ssr
• Example with ClientCredentials flow - deno-client-credentials

Other

• Ability to retry when 5xx or 429 is received. Example below

const client = new SpotifyClient("ACCESS_TOKEN", {
  retry5xx: {
    times: 5,
    delay: 0,
  },
  retry429: {
    times: 3,
    delay: 300,
  }
})

Future TODO

• Make tests with json schema validation to ensure that types are correct. Maybe it futures releases.
• Shows, Episodes, Audiobooks, Chapters, Player endpoints

Paginator will create request for every 20 tracks.

const playlistTracks = new Paginator((opts) =>
  getPlaylistTracks(client, "6LPdVFowaGmmHu3nb20Mg3", opts)
);

for await (const track of playlistTracks) {
  console.log(track);
}

You can change the chunk size by setting limit in second argument.

const playlistTracks = new Paginator(
  (opts) => getPlaylistTracks(client, "6LPdVFowaGmmHu3nb20Mg3", opts),
  { limit: 50 }
);

• - Episodes + Shows
• - Audiobooks + Chapters
• - Player

I just saw you are using while (true), which is blocking operation. It shouldn't ever been used in libs, but i'm not sure about implementation here. Need some deep dive checking.

describe("getEpisode", async () => {
  test("returns an episode object", async () => {
    const episode_id = "123";
    const market = "EN" as Market;
    const spotify_episode_response = {
      description:
        "A Spotify podcast sharing fresh insights on important topics of the moment—in a way only Spotify can. You’ll hear from experts in the music, podcast and tech industries as we discover and uncover stories about our work and the world around us.",
      html_description:
        "<p>A Spotify podcast sharing fresh insights on important topics of the moment—in a way only Spotify can. You’ll hear from experts in the music, podcast and tech industries as we discover and uncover stories about our work and the world around us.</p>",
      duration_ms: 1686230,
      explicit: false,
      external_urls: {
        spotify: "string"
      },
      href: "https://api.spotify.com/v1/episodes/5Xt5DXGzch68nYYamXrNxZ",
      id: "5Xt5DXGzch68nYYamXrNxZ",
      images: [
        {
          url: "https://i.scdn.co/image/ab67616d00001e02ff9ca10b55ce82ae553c8228",
          height: 300,
          width: 300
        }
      ],
      is_externally_hosted: false,
      is_playable: false,
      language: "en",
      languages: ["fr", "en"],
      name: "Starting Your Own Podcast: Tips, Tricks, and Advice From Anchor Creators",
      release_date: "1981-12-15",
      release_date_precision: "day",
      resume_point: {
        fully_played: false,
        resume_position_ms: 0
      },
      type: "episode",
      uri: "spotify:episode:0zLhl3WsOCQHbe1BPTiHgr",
      restrictions: {
        reason: "string"
      },
      show: {
        available_markets: ["string"],
        copyrights: [
          {
            text: "string",
            type: "string"
          }
        ],
        description: "string",
        html_description: "string",
        explicit: false,
        external_urls: {
          spotify: "string"
        },
        href: "string",
        id: "string",
        images: [
          {
            url: "https://i.scdn.co/image/ab67616d00001e02ff9ca10b55ce82ae553c8228",
            height: 300,
            width: 300
          }
        ],
        languages: ["string"],
        media_type: "string",
        name: "string",
        publisher: "string",
        type: "show",
        uri: "string",
        total_episodes: 0
      }
    };

    const mockedFetch = vi.fn();
    mockedFetch.mockResolvedValue(spotify_episode_response);
    const client: HTTPClient = {
      fetch: mockedFetch
    };

    const result = await getEpisode(client, episode_id, market);

    expect(client.fetch).toHaveBeenCalledWith(
      `/episodes/${episode_id}`,
      "json",
      { query: { market } }
    );
    expect(result).toBeDefined();
    expect(result).toMatchObject(spotify_episode_response);
  });
});

There is what i got for getEpisode, wanna see you opinion is this enough or we need more tests for api methods. Because I think it's not full. Or, I just want to see you @MellKam code for this tests as a example.