@benliam12/spotify-api-helper 1.0.0-DEV.5 → 1.0.0-DEV.7

package/README.md

@@ -1,2 +1,48 @@
 # Spotify API Helper
-Help you use the Spotify API without having to implement everything. 
+
+Help you use the Spotify API without having to implement everything.
+
+## Installation
+
+1. Install this helper using `npm install @benliam12/spotify-api-helper`
+2. Add the helper to your project.
+
+Here is a quick example using NodeJS, and NodeJS, using Module type project.
+
+```javascript
+import express from 'express';
+import dotenv from 'dotenv';
+import {
+  SpotifyHelper,
+  SpotifyConfiguration,
+} from '@benliam12/spotify-api-helper';
+
+dotenv.config();
+
+const spotifyConfig = new SpotifyConfiguration({
+  clientId: process.env.SPOTIFY_CLIENT_ID,
+  clientSecret: process.env.SPOTIFY_CLIENT_SECRET,
+  redirectUri: process.env.SPOTIFY_REDIRECT_URI,
+});
+
+const spotifyHelperInstance = new SpotifyHelper(spotifyConfig, {
+  onError: (error) => {
+    console.error('Spotify API Error:', error);
+  },
+});
+
+app.get('/', async (req, res) => {
+  const trackData = await instance.getTrack('YOUR FAVORITE TRACK ID');
+  res.send('Hello World!');
+});
+
+instance.initialize().then(() => {
+  app.listen(port, () => {
+    console.log(`Example app listening at http://localhost:${port}`);
+  });
+});
+```
+
+## Contribution
+
+Please open issues for any feature request or bug report. As for contributing directly to the project, feel free to make pull requests.

package/dist/core/SpotifyConfiguration.js

@@ -1,11 +1,11 @@
 export class SpotifyConfiguration {
     constructor(config) {
-        this.clientId = config.clientId ?? "";
-        this.clientSecret = config.clientSecret ?? "";
-        this.redirectUri = config.redirectUri ?? "";
+        this.clientId = config.clientId ?? '';
+        this.clientSecret = config.clientSecret ?? '';
+        this.redirectUri = config.redirectUri ?? '';
     }
     isValid() {
-        return this.clientId !== "" && this.clientSecret !== "" && this.redirectUri !== "";
+        return this.clientId !== '' && this.clientSecret !== '' && this.redirectUri !== '';
     }
     getClientID() {
         return this.clientId;

package/dist/core/SpotifyHelper.d.ts

@@ -1,5 +1,5 @@
-import { SpotifyConfiguration } from "./SpotifyConfiguration.js";
-import { Album, Track, Artist, SearchType } from "./SpotifyTypes.js";
+import { SpotifyConfiguration } from './SpotifyConfiguration.js';
+import { Album, Track, Artist, UserToken, SearchType, SpotifyScope } from './SpotifyTypes.js';
 /**
  * Result wrapper for operations that can fail
  */
@@ -75,6 +75,14 @@ export declare class SpotifyHelper {
      * Returns null if the request fails.
      */
     getAlbum(albumId: string): Promise<Album | null>;
+    /**
+     * Get a list of albums by their IDs.
+     * @param albumIds
+     * @returns
+     * @throws Error if more than 20 IDs are provided (Spotify API limit)
+     */
+    getAlbums(albumIds: string[]): Promise<(Album | null)[]>;
+    getAlbumTracks(albumId: string, limit?: number, offset?: number): Promise<Track[] | null>;
     /**
      * Get a track by ID.
      * Returns null if the request fails.
@@ -92,10 +100,40 @@ export declare class SpotifyHelper {
     getPlaylist(playlistId: string): Promise<any | null>;
     /**
      * Get available markets.
-     * Returns empty array if the request fails.
+     * @returns Returns empty array if the request fails.
      */
     getAvailableMarkets(): Promise<string[]>;
+    /**
+     * Use the search endpoint.
+     * @param query
+     * @param type
+     * @param limit
+     * @param offset
+     * @returns Parsed search results or null if request fails
+     */
     search(query: string, type: SearchType, limit?: number, offset?: number): Promise<any | null>;
+    /** Builds the Spotify authorization URL for user login. */
+    getAuthorizationUrl(scopes: SpotifyScope[], state?: string): string;
+    /** Exchanges an authorization code for a UserToken. */
+    exchangeAuthCode(code: string): Promise<UserToken | null>;
+    /** Refreshes an expired user token using its refresh token. */
+    refreshUserToken(refreshToken: string): Promise<UserToken | null>;
+    /** Makes an API request using a user-provided token. */
+    private makeUserRequest;
+    /** Get the current user's profile. Requires `user-read-private` scope. */
+    getCurrentUserProfile(userToken: UserToken): Promise<any | null>;
+    /** Get the current user's playlists. Requires `playlist-read-private` scope. */
+    getUserPlaylists(userToken: UserToken, limit?: number, offset?: number): Promise<any | null>;
+    /** Get the current user's top artists or tracks. Requires `user-top-read` scope. */
+    getUserTopItems(userToken: UserToken, type: 'artists' | 'tracks', limit?: number, offset?: number): Promise<any | null>;
+    /** Get the current user's saved tracks. Requires `user-library-read` scope. */
+    getUserSavedTracks(userToken: UserToken, limit?: number, offset?: number): Promise<any | null>;
+    /**
+     * Make Raw request to a given Spotify API URL.
+     * @param url
+     * @returns Parsed JSON data or null if request fails
+     */
+    getDataFromURL(url: string): Promise<any | null>;
     /**
      * Check if the helper is properly authenticated.
      * Useful for health checks.
@@ -105,6 +143,10 @@ export declare class SpotifyHelper {
      * Manually clear the token (useful for testing or forcing a refresh).
      */
     clearToken(): void;
+    /**
+     * Get the current configuration.
+     */
+    getConfig(): SpotifyConfiguration;
     /**
      * Get token info for debugging (without exposing the actual token).
      */

package/dist/core/SpotifyHelper.js

@@ -6,7 +6,7 @@ export class SpotifyHelper {
         this.options = {
             tokenRefreshBufferMs: options.tokenRefreshBufferMs ?? 60000,
             onError: options.onError ?? (() => { }),
-            logErrors: options.logErrors ?? false
+            logErrors: options.logErrors ?? false,
         };
     }
     /**
@@ -53,7 +53,7 @@ export class SpotifyHelper {
         const now = new Date();
         const expiryTime = this.clientToken.expires_at.getTime();
         const currentTime = now.getTime();
-        return currentTime >= (expiryTime - this.options.tokenRefreshBufferMs);
+        return currentTime >= expiryTime - this.options.tokenRefreshBufferMs;
     }
     /**
      * Fetches a new token from Spotify.
@@ -63,45 +63,45 @@ export class SpotifyHelper {
         const params = new URLSearchParams();
         params.append('grant_type', 'client_credentials');
         try {
-            const response = await fetch("https://accounts.spotify.com/api/token", {
-                method: "POST",
+            const response = await fetch('https://accounts.spotify.com/api/token', {
+                method: 'POST',
                 headers: {
-                    "Content-Type": "application/x-www-form-urlencoded",
-                    "Authorization": "Basic " + Buffer.from(this.config.clientId + ":" + this.config.clientSecret).toString("base64")
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Authorization: 'Basic ' + Buffer.from(this.config.clientId + ':' + this.config.clientSecret).toString('base64'),
                 },
-                body: params.toString()
+                body: params.toString(),
             });
             if (!response.ok) {
                 const errorText = await response.text();
                 this.handleError({
                     message: `Failed to get token: ${response.status} ${response.statusText} - ${errorText}`,
                     statusCode: response.status,
-                    operation: "fetchNewToken",
-                    timestamp: new Date()
+                    operation: 'fetchNewToken',
+                    timestamp: new Date(),
                 });
                 return null;
             }
             const data = await response.json();
             if (!data.access_token || !data.expires_in) {
                 this.handleError({
-                    message: "Invalid token response from Spotify - missing access_token or expires_in",
-                    operation: "fetchNewToken",
-                    timestamp: new Date()
+                    message: 'Invalid token response from Spotify - missing access_token or expires_in',
+                    operation: 'fetchNewToken',
+                    timestamp: new Date(),
                 });
                 return null;
             }
             const token = {
                 access_token: data.access_token,
                 token_type: data.token_type,
-                expires_at: new Date(Date.now() + data.expires_in * 1000)
+                expires_at: new Date(Date.now() + data.expires_in * 1000),
             };
             return token;
         }
         catch (error) {
             this.handleError({
                 message: `Network error fetching token: ${error instanceof Error ? error.message : String(error)}`,
-                operation: "fetchNewToken",
-                timestamp: new Date()
+                operation: 'fetchNewToken',
+                timestamp: new Date(),
             });
             return null;
         }
@@ -115,7 +115,7 @@ export class SpotifyHelper {
         if (!token) {
             return {
                 success: false,
-                error: "Failed to obtain valid authentication token"
+                error: 'Failed to obtain valid authentication token',
             };
         }
         try {
@@ -123,8 +123,8 @@ export class SpotifyHelper {
                 ...options,
                 headers: {
                     ...options.headers,
-                    "Authorization": `Bearer ${token.access_token}`
-                }
+                    Authorization: `Bearer ${token.access_token}`,
+                },
             });
             if (!response.ok) {
                 const errorText = await response.text();
@@ -132,12 +132,12 @@ export class SpotifyHelper {
                     message: `API request failed: ${response.status} ${response.statusText} - ${errorText}`,
                     statusCode: response.status,
                     operation,
-                    timestamp: new Date()
+                    timestamp: new Date(),
                 });
                 return {
                     success: false,
                     error: `Request failed: ${response.status} ${response.statusText}`,
-                    statusCode: response.status
+                    statusCode: response.status,
                 };
             }
             const data = await response.json();
@@ -148,11 +148,11 @@ export class SpotifyHelper {
             this.handleError({
                 message: `Network error during ${operation}: ${errorMessage}`,
                 operation,
-                timestamp: new Date()
+                timestamp: new Date(),
             });
             return {
                 success: false,
-                error: `Network error: ${errorMessage}`
+                error: `Network error: ${errorMessage}`,
             };
         }
     }
@@ -170,7 +170,7 @@ export class SpotifyHelper {
      * Returns null if the request fails.
      */
     async getAlbum(albumId) {
-        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/albums/${albumId}`, "getAlbum", { method: "GET" });
+        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/albums/${albumId}`, 'getAlbum', { method: 'GET' });
         if (!result.success) {
             return null;
         }
@@ -178,32 +178,121 @@ export class SpotifyHelper {
         const album = {
             id: data.id,
             name: data.name,
-            market: data.market,
             album_type: data.album_type,
             total_tracks: data.total_tracks,
-            data: data
+            data: data.data,
         };
         return album;
     }
+    /**
+     * Get a list of albums by their IDs.
+     * @param albumIds
+     * @returns
+     * @throws Error if more than 20 IDs are provided (Spotify API limit)
+     */
+    async getAlbums(albumIds) {
+        const idsParam = albumIds.join(',');
+        if (albumIds.length === 0) {
+            return [];
+        }
+        if (albumIds.length > 20) {
+            throw new Error('Spotify API allows a maximum of 20 album IDs per request.');
+        }
+        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/albums?ids=${idsParam}`, 'getAlbums', { method: 'GET' });
+        if (result.success) {
+            return result.data.map((data) => {
+                if (!data) {
+                    return null;
+                }
+                const album = {
+                    id: data.id,
+                    name: data.name,
+                    album_type: data.album_type,
+                    total_tracks: data.total_tracks,
+                    data: data.data,
+                };
+                return album;
+            });
+        }
+        return [];
+    }
+    async getAlbumTracks(albumId, limit = 50, offset = 0) {
+        if (limit < 1 || limit > 50) {
+            throw new Error('Limit must be between 1 and 50');
+        }
+        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/albums/${albumId}/tracks?limit=${limit}&offset=${offset}`, 'getAlbumTracks', { method: 'GET' });
+        if (!result.success) {
+            return null;
+        }
+        const tracks = result.data.items.map((item) => {
+            const track = {
+                id: item.id,
+                name: item.name,
+                artists: item.artists.map((artistData) => {
+                    const { id, name, ...data } = artistData;
+                    const artist = {
+                        id: id,
+                        name: name,
+                        data: data,
+                    };
+                    return artist;
+                }),
+                album: {
+                    id: albumId,
+                    name: '',
+                    album_type: '',
+                    total_tracks: 0,
+                    data: {},
+                },
+                data: item,
+            };
+            return track;
+        });
+        return tracks;
+    }
     /**
      * Get a track by ID.
      * Returns null if the request fails.
      */
     async getTrack(trackId) {
-        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/tracks/${trackId}`, "getTrack", { method: "GET" });
+        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/tracks/${trackId}`, 'getTrack', { method: 'GET' });
         if (!result.success) {
             return null;
         }
-        // Map to your Track type based on your type definition
-        // For now returning null as placeholder
-        return null;
+        else {
+            const { id, name, album_type, total_tracks, ...data } = result.data.album;
+            const trackAlbumData = {
+                id: id,
+                name: name,
+                album_type: album_type,
+                total_tracks: total_tracks,
+                data: data,
+            };
+            const trackArtistData = result.data.artists.map((artistData) => {
+                const { id, name, ...data } = artistData;
+                const artist = {
+                    id: id,
+                    name: name,
+                    data: data,
+                };
+                return artist;
+            });
+            const trackData = {
+                id: result.data.id,
+                name: result.data.name,
+                artists: trackArtistData,
+                album: trackAlbumData,
+                data: result.data,
+            };
+            return trackData;
+        }
     }
     /**
      * Get an artist by ID.
      * Returns null if the request fails.
      */
     async getArtist(artistId) {
-        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/artists/${artistId}`, "getArtist", { method: "GET" });
+        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/artists/${artistId}`, 'getArtist', { method: 'GET' });
         if (!result.success) {
             return null;
         }
@@ -216,7 +305,7 @@ export class SpotifyHelper {
      * Returns null if the request fails.
      */
     async getPlaylist(playlistId) {
-        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/playlists/${playlistId}`, "getPlaylist", { method: "GET" });
+        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/playlists/${playlistId}`, 'getPlaylist', { method: 'GET' });
         if (!result.success) {
             return null;
         }
@@ -224,17 +313,215 @@ export class SpotifyHelper {
     }
     /**
      * Get available markets.
-     * Returns empty array if the request fails.
+     * @returns Returns empty array if the request fails.
      */
     async getAvailableMarkets() {
-        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/markets`, "getAvailableMarkets", { method: "GET" });
+        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/markets`, 'getAvailableMarkets', { method: 'GET' });
         if (!result.success) {
             return [];
         }
         return result.data.markets || [];
     }
+    /**
+     * Use the search endpoint.
+     * @param query
+     * @param type
+     * @param limit
+     * @param offset
+     * @returns Parsed search results or null if request fails
+     */
     async search(query, type, limit = 20, offset = 0) {
-        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/search?q=${encodeURIComponent(query)}&type=${type}&limit=${limit}&offset=${offset}`, "search", { method: "GET" });
+        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/search?q=${encodeURIComponent(query)}&type=${type}&limit=${limit}&offset=${offset}`, 'search', { method: 'GET' });
+        if (!result.success) {
+            return null;
+        }
+        return result.data;
+    }
+    // ─── Authorization Code Flow (User Token) ───
+    /** Builds the Spotify authorization URL for user login. */
+    getAuthorizationUrl(scopes, state) {
+        const params = new URLSearchParams({
+            response_type: 'code',
+            client_id: this.config.clientId,
+            redirect_uri: this.config.redirectUri,
+            scope: scopes.join(' '),
+        });
+        if (state) {
+            params.set('state', state);
+        }
+        return `https://accounts.spotify.com/authorize?${params.toString()}`;
+    }
+    /** Exchanges an authorization code for a UserToken. */
+    async exchangeAuthCode(code) {
+        const params = new URLSearchParams({
+            grant_type: 'authorization_code',
+            code,
+            redirect_uri: this.config.redirectUri,
+        });
+        try {
+            const response = await fetch('https://accounts.spotify.com/api/token', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Authorization: 'Basic ' + Buffer.from(this.config.clientId + ':' + this.config.clientSecret).toString('base64'),
+                },
+                body: params.toString(),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                this.handleError({
+                    message: `Failed to exchange auth code: ${response.status} ${response.statusText} - ${errorText}`,
+                    statusCode: response.status,
+                    operation: 'exchangeAuthCode',
+                    timestamp: new Date(),
+                });
+                return null;
+            }
+            const data = await response.json();
+            if (!data.access_token || !data.refresh_token) {
+                this.handleError({
+                    message: 'Invalid token response - missing access_token or refresh_token',
+                    operation: 'exchangeAuthCode',
+                    timestamp: new Date(),
+                });
+                return null;
+            }
+            return {
+                access_token: data.access_token,
+                refresh_token: data.refresh_token,
+                token_type: data.token_type,
+                expires_at: new Date(Date.now() + data.expires_in * 1000),
+                scope: data.scope ?? '',
+            };
+        }
+        catch (error) {
+            this.handleError({
+                message: `Network error exchanging auth code: ${error instanceof Error ? error.message : String(error)}`,
+                operation: 'exchangeAuthCode',
+                timestamp: new Date(),
+            });
+            return null;
+        }
+    }
+    /** Refreshes an expired user token using its refresh token. */
+    async refreshUserToken(refreshToken) {
+        const params = new URLSearchParams({
+            grant_type: 'refresh_token',
+            refresh_token: refreshToken,
+        });
+        try {
+            const response = await fetch('https://accounts.spotify.com/api/token', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Authorization: 'Basic ' + Buffer.from(this.config.clientId + ':' + this.config.clientSecret).toString('base64'),
+                },
+                body: params.toString(),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                this.handleError({
+                    message: `Failed to refresh user token: ${response.status} ${response.statusText} - ${errorText}`,
+                    statusCode: response.status,
+                    operation: 'refreshUserToken',
+                    timestamp: new Date(),
+                });
+                return null;
+            }
+            const data = await response.json();
+            if (!data.access_token) {
+                this.handleError({
+                    message: 'Invalid refresh response - missing access_token',
+                    operation: 'refreshUserToken',
+                    timestamp: new Date(),
+                });
+                return null;
+            }
+            return {
+                access_token: data.access_token,
+                refresh_token: data.refresh_token ?? refreshToken,
+                token_type: data.token_type,
+                expires_at: new Date(Date.now() + data.expires_in * 1000),
+                scope: data.scope ?? '',
+            };
+        }
+        catch (error) {
+            this.handleError({
+                message: `Network error refreshing user token: ${error instanceof Error ? error.message : String(error)}`,
+                operation: 'refreshUserToken',
+                timestamp: new Date(),
+            });
+            return null;
+        }
+    }
+    // ─── User-Scoped API Methods ───
+    /** Makes an API request using a user-provided token. */
+    async makeUserRequest(url, userToken, operation, options = {}) {
+        try {
+            const response = await fetch(url, {
+                ...options,
+                headers: {
+                    ...options.headers,
+                    Authorization: `Bearer ${userToken.access_token}`,
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                this.handleError({
+                    message: `API request failed: ${response.status} ${response.statusText} - ${errorText}`,
+                    statusCode: response.status,
+                    operation,
+                    timestamp: new Date(),
+                });
+                return {
+                    success: false,
+                    error: `Request failed: ${response.status} ${response.statusText}`,
+                    statusCode: response.status,
+                };
+            }
+            const data = await response.json();
+            return { success: true, data };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.handleError({
+                message: `Network error during ${operation}: ${errorMessage}`,
+                operation,
+                timestamp: new Date(),
+            });
+            return {
+                success: false,
+                error: `Network error: ${errorMessage}`,
+            };
+        }
+    }
+    /** Get the current user's profile. Requires `user-read-private` scope. */
+    async getCurrentUserProfile(userToken) {
+        const result = await this.makeUserRequest('https://api.spotify.com/v1/me', userToken, 'getCurrentUserProfile');
+        return result.success ? result.data : null;
+    }
+    /** Get the current user's playlists. Requires `playlist-read-private` scope. */
+    async getUserPlaylists(userToken, limit = 20, offset = 0) {
+        const result = await this.makeUserRequest(`https://api.spotify.com/v1/me/playlists?limit=${limit}&offset=${offset}`, userToken, 'getUserPlaylists');
+        return result.success ? result.data : null;
+    }
+    /** Get the current user's top artists or tracks. Requires `user-top-read` scope. */
+    async getUserTopItems(userToken, type, limit = 20, offset = 0) {
+        const result = await this.makeUserRequest(`https://api.spotify.com/v1/me/top/${type}?limit=${limit}&offset=${offset}`, userToken, 'getUserTopItems');
+        return result.success ? result.data : null;
+    }
+    /** Get the current user's saved tracks. Requires `user-library-read` scope. */
+    async getUserSavedTracks(userToken, limit = 20, offset = 0) {
+        const result = await this.makeUserRequest(`https://api.spotify.com/v1/me/tracks?limit=${limit}&offset=${offset}`, userToken, 'getUserSavedTracks');
+        return result.success ? result.data : null;
+    }
+    /**
+     * Make Raw request to a given Spotify API URL.
+     * @param url
+     * @returns Parsed JSON data or null if request fails
+     */
+    async getDataFromURL(url) {
+        const result = await this.makeAuthenticatedRequest(url, 'getDataFromURL', { method: 'GET' });
         if (!result.success) {
             return null;
         }
@@ -254,6 +541,12 @@ export class SpotifyHelper {
     clearToken() {
         this.clientToken = null;
     }
+    /**
+     * Get the current configuration.
+     */
+    getConfig() {
+        return this.config;
+    }
     /**
      * Get token info for debugging (without exposing the actual token).
      */
@@ -261,7 +554,7 @@ export class SpotifyHelper {
         return {
             hasToken: this.clientToken !== null,
             expiresAt: this.clientToken?.expires_at || null,
-            isExpiringSoon: this.isTokenExpiringSoon()
+            isExpiringSoon: this.isTokenExpiringSoon(),
         };
     }
 }

package/dist/core/SpotifyTypes.d.ts

@@ -1,23 +1,58 @@
 export interface Album {
     id: string;
     name: string;
-    market: string;
     album_type: string;
     total_tracks: number;
-    data?: any;
+    data: any;
 }
 export interface Track {
+    id: string;
+    name: string;
+    artists: Artist[];
+    album: Album;
+    data: any;
 }
 export interface Artist {
+    id: string;
+    name: string;
+    data: any;
 }
 export interface ClientToken {
     access_token: string;
     token_type: string;
     expires_at: Date;
 }
+export interface UserToken {
+    access_token: string;
+    refresh_token: string;
+    token_type: string;
+    expires_at: Date;
+    scope: string;
+}
 export declare enum SearchType {
     ALBUM = "album",
     ARTIST = "artist",
     TRACK = "track",
     PLAYLIST = "playlist"
 }
+export declare enum SpotifyScope {
+    UGC_IMAGE_UPLOAD = "ugc-image-upload",
+    USER_READ_PLAYBACK_STATE = "user-read-playback-state",
+    USER_MODIFY_PLAYBACK_STATE = "user-modify-playback-state",
+    USER_READ_CURRENTLY_PLAYING = "user-read-currently-playing",
+    STREAMING = "streaming",
+    APP_REMOTE_CONTROL = "app-remote-control",
+    USER_READ_EMAIL = "user-read-email",
+    USER_READ_PRIVATE = "user-read-private",
+    PLAYLIST_READ_COLLABORATIVE = "playlist-read-collaborative",
+    PLAYLIST_MODIFY_PUBLIC = "playlist-modify-public",
+    PLAYLIST_READ_PRIVATE = "playlist-read-private",
+    PLAYLIST_MODIFY_PRIVATE = "playlist-modify-private",
+    USER_LIBRARY_MODIFY = "user-library-modify",
+    USER_LIBRARY_READ = "user-library-read",
+    USER_TOP_READ = "user-top-read",
+    USER_READ_RECENTLY_PLAYED = "user-read-recently-played",
+    USER_READ_PLAYBACK_POSITION = "user-read-playback-position",
+    USER_FOLLOW_READ = "user-follow-read",
+    USER_FOLLOW_MODIFY = "user-follow-modify"
+}

package/dist/core/SpotifyTypes.js

@@ -5,3 +5,33 @@ export var SearchType;
     SearchType["TRACK"] = "track";
     SearchType["PLAYLIST"] = "playlist";
 })(SearchType || (SearchType = {}));
+export var SpotifyScope;
+(function (SpotifyScope) {
+    // Images
+    SpotifyScope["UGC_IMAGE_UPLOAD"] = "ugc-image-upload";
+    // Spotify Connect
+    SpotifyScope["USER_READ_PLAYBACK_STATE"] = "user-read-playback-state";
+    SpotifyScope["USER_MODIFY_PLAYBACK_STATE"] = "user-modify-playback-state";
+    SpotifyScope["USER_READ_CURRENTLY_PLAYING"] = "user-read-currently-playing";
+    // Playback
+    SpotifyScope["STREAMING"] = "streaming";
+    SpotifyScope["APP_REMOTE_CONTROL"] = "app-remote-control";
+    // Users
+    SpotifyScope["USER_READ_EMAIL"] = "user-read-email";
+    SpotifyScope["USER_READ_PRIVATE"] = "user-read-private";
+    // Playlists
+    SpotifyScope["PLAYLIST_READ_COLLABORATIVE"] = "playlist-read-collaborative";
+    SpotifyScope["PLAYLIST_MODIFY_PUBLIC"] = "playlist-modify-public";
+    SpotifyScope["PLAYLIST_READ_PRIVATE"] = "playlist-read-private";
+    SpotifyScope["PLAYLIST_MODIFY_PRIVATE"] = "playlist-modify-private";
+    // Library
+    SpotifyScope["USER_LIBRARY_MODIFY"] = "user-library-modify";
+    SpotifyScope["USER_LIBRARY_READ"] = "user-library-read";
+    // Listening History
+    SpotifyScope["USER_TOP_READ"] = "user-top-read";
+    SpotifyScope["USER_READ_RECENTLY_PLAYED"] = "user-read-recently-played";
+    SpotifyScope["USER_READ_PLAYBACK_POSITION"] = "user-read-playback-position";
+    // Follow
+    SpotifyScope["USER_FOLLOW_READ"] = "user-follow-read";
+    SpotifyScope["USER_FOLLOW_MODIFY"] = "user-follow-modify";
+})(SpotifyScope || (SpotifyScope = {}));

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./core/SpotifyTypes.js";
-export { SpotifyHelper } from "./core/SpotifyHelper.js";
-export { SpotifyConfiguration } from "./core/SpotifyConfiguration.js";
+export * from './core/SpotifyTypes.js';
+export { SpotifyHelper } from './core/SpotifyHelper.js';
+export { SpotifyConfiguration } from './core/SpotifyConfiguration.js';

package/dist/index.js

@@ -1,3 +1,3 @@
-export * from "./core/SpotifyTypes.js";
-export { SpotifyHelper } from "./core/SpotifyHelper.js";
-export { SpotifyConfiguration } from "./core/SpotifyConfiguration.js";
+export * from './core/SpotifyTypes.js';
+export { SpotifyHelper } from './core/SpotifyHelper.js';
+export { SpotifyConfiguration } from './core/SpotifyConfiguration.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@benliam12/spotify-api-helper",
-  "version": "1.0.0-DEV.5",
+  "version": "1.0.0-DEV.7",
   "description": "A utility package for Node.js",
   "type": "module",
   "main": "dist/index.js",
@@ -16,8 +16,8 @@
     "clean": "rimraf dist",
     "lint": "eslint src --ext .ts",
     "prepare": "npm run build",
-    "release": "semantic-release --no-ci",
-    "release:dry": "semantic-release --dry-run --no-ci"
+    "release": "dotenv -e .env -- semantic-release --no-ci --dry-run=false",
+    "release:dry": "dotenv -e .env semantic-release --dry-run --no-ci"
   },
   "keywords": [
     "utility",
@@ -38,6 +38,8 @@
     "@types/node": "^22.19.3",
     "@typescript-eslint/eslint-plugin": "^8.50.1",
     "@typescript-eslint/parser": "^8.50.1",
+    "conventional-changelog-conventionalcommits": "^9.1.0",
+    "dotenv-cli": "^11.0.0",
     "eslint": "^9.39.2",
     "jest": "^29.7.0",
     "rimraf": "^6.1.2",