soundcloud-wrapper 0.9.0

package/dist/client.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoundCloudClient = void 0;
+class SoundCloudClient {
+    constructor(clientId, clientSecret, redirectUri, PKCECodeVerifier) {
+        this.baseUrl = "https://api.soundcloud.com";
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
+        this.redirectUri = redirectUri;
+        this.PKCECodeVerifier = PKCECodeVerifier;
+    }
+}
+exports.SoundCloudClient = SoundCloudClient;
+exports.default = SoundCloudClient;

package/dist/endpoints/likes.js

@@ -0,0 +1,107 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Likes = void 0;
+const client_1 = __importDefault(require("../client"));
+const axios_1 = __importDefault(require("axios"));
+class Likes extends client_1.default {
+    // likes a specific track
+    likeTrack(authToken, trackId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.likeRequest(authToken, "/tracks", trackId);
+        });
+    }
+    // likes a specific playlist
+    likePlaylist(authToken, playlistId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.likeRequest(authToken, "/playlists", playlistId);
+        });
+    }
+    // unlikes a specific track
+    unlikeTrack(authToken, trackId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.unlikeRequest(authToken, "/tracks", trackId);
+        });
+    }
+    // unlikes a specific playlist
+    unlikePlaylist(authToken, playlistId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.unlikeRequest(authToken, "/playlists", playlistId);
+        });
+    }
+    // --- REQUESTS ---
+    likeRequest(authToken, endpoint, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = {
+                    method: "POST",
+                    maxBodyLength: Infinity,
+                    url: `${this.baseUrl}/likes${endpoint}/${id}`,
+                    headers: {
+                        accept: "application/json; charset=utf-8",
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `OAuth ${authToken}`,
+                    },
+                };
+                const response = yield axios_1.default
+                    .request(config)
+                    .then((response) => {
+                    return response.data;
+                })
+                    .catch((error) => {
+                    console.log(error);
+                    throw new Error("Failed to get me");
+                });
+                return response;
+            }
+            catch (error) {
+                console.error("SoundCloud API Error:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error);
+                throw error;
+            }
+        });
+    }
+    unlikeRequest(authToken, endpoint, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = {
+                    method: "DELETE",
+                    maxBodyLength: Infinity,
+                    url: `${this.baseUrl}/likes${endpoint}/${id}`,
+                    headers: {
+                        accept: "application/json; charset=utf-8",
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `OAuth ${authToken}`,
+                    },
+                };
+                const response = yield axios_1.default
+                    .request(config)
+                    .then((response) => {
+                    return response.data;
+                })
+                    .catch((error) => {
+                    console.log(error);
+                    throw new Error("Failed to get me");
+                });
+                return response;
+            }
+            catch (error) {
+                console.error("SoundCloud API Error:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error);
+                throw error;
+            }
+        });
+    }
+}
+exports.Likes = Likes;

package/dist/endpoints/me.js

@@ -0,0 +1,175 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Me = void 0;
+const client_1 = __importDefault(require("../client"));
+const axios_1 = __importDefault(require("axios"));
+class Me extends client_1.default {
+    // Returns authenticated users info
+    me(authToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getRequest(authToken, "/me");
+        });
+    }
+    // Returns authenticated users activity
+    getActivity(authToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getRequest(authToken, "/me/activities");
+        });
+    }
+    // Returns authenticated users track activity
+    getTrackActivity(authToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getRequest(authToken, "/me/activities/tracks");
+        });
+    }
+    // Returns authenticated users track likes activity
+    getTrackLikes(authToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getRequest(authToken, "/me/likes/tracks");
+        });
+    }
+    // Returns authenticated users playlist likes activity
+    getPlaylistLikes(authToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getRequest(authToken, "/me/likes/playlists");
+        });
+    }
+    // Returns people authenticated user is following
+    getFollowings(authToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getRequest(authToken, "/me/followings");
+        });
+    }
+    // Returns peoples tracks authenticated user is following
+    getFollowingsTracks(authToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getRequest(authToken, "/me/followings/tracks");
+        });
+    }
+    // Follows the specified user
+    followUser(authToken, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.followRequest(authToken, "/me/followings", userId);
+        });
+    }
+    // Unfollows the specified user
+    unfollowUser(authToken, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.unfollowRequest(authToken, "/me/followings", userId);
+        });
+    }
+    // TODO: bind authToken to object so it does not need to be passed everytime
+    // --- REQUESTS ---
+    getRequest(authToken, endpoint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = {
+                    method: "GET",
+                    maxBodyLength: Infinity,
+                    url: `${this.baseUrl}${endpoint}`,
+                    headers: {
+                        accept: "application/json; charset=utf-8",
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `OAuth ${authToken}`,
+                    },
+                };
+                const response = yield axios_1.default
+                    .request(config)
+                    .then((response) => {
+                    return response.data;
+                })
+                    .catch((error) => {
+                    console.log(error);
+                    throw new Error("Failed to get me");
+                });
+                return response;
+            }
+            catch (error) {
+                console.error("SoundCloud API Error:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error);
+                throw error;
+            }
+        });
+    }
+    followRequest(authToken, endpoint, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = {
+                    method: "PUT",
+                    maxBodyLength: Infinity,
+                    url: `${this.baseUrl}${endpoint}/${userId}`,
+                    headers: {
+                        accept: "application/json; charset=utf-8",
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `OAuth ${authToken}`,
+                    },
+                    data: {
+                        user_id: userId,
+                    },
+                };
+                const response = yield axios_1.default
+                    .request(config)
+                    .then((response) => {
+                    return response.data;
+                })
+                    .catch((error) => {
+                    console.log(error);
+                    throw new Error("Failed to get me");
+                });
+                return response;
+            }
+            catch (error) {
+                console.error("SoundCloud API Error:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error);
+                throw error;
+            }
+        });
+    }
+    unfollowRequest(authToken, endpoint, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = {
+                    method: "DELETE",
+                    maxBodyLength: Infinity,
+                    url: `${this.baseUrl}${endpoint}/${userId}`,
+                    headers: {
+                        accept: "application/json; charset=utf-8",
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `OAuth ${authToken}`,
+                    },
+                    data: {
+                        user_id: userId,
+                    },
+                };
+                const response = yield axios_1.default
+                    .request(config)
+                    .then((response) => {
+                    return response.data;
+                })
+                    .catch((error) => {
+                    console.log(error);
+                    throw new Error("Failed to get me");
+                });
+                return response;
+            }
+            catch (error) {
+                console.error("SoundCloud API Error:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error);
+                throw error;
+            }
+        });
+    }
+}
+exports.Me = Me;

package/dist/endpoints/misc.js

@@ -0,0 +1,48 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Misc = void 0;
+const client_1 = __importDefault(require("../client"));
+const axios_1 = __importDefault(require("axios"));
+class Misc extends client_1.default {
+    resolveUrl(authToken, url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.resolveRequest(authToken, url);
+        });
+    }
+    // --- REQUESTS ---
+    resolveRequest(authToken, url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = {
+                    method: "GET",
+                    maxBodyLength: Infinity,
+                    url: `${this.baseUrl}/resolve?url=${url}`,
+                    headers: {
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `OAuth ${authToken}`,
+                    },
+                };
+                const response = yield axios_1.default.request(config);
+                return response.data;
+            }
+            catch (error) {
+                console.error("SoundCloud API Error:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error);
+                throw error;
+            }
+        });
+    }
+}
+exports.Misc = Misc;

package/dist/endpoints/playlists.js

@@ -0,0 +1,147 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Playlist = void 0;
+const axios_1 = __importDefault(require("axios"));
+const client_1 = __importDefault(require("../client"));
+class Playlist extends client_1.default {
+    // gets a specific playlist
+    getPlaylist(authToken, playlistId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPlaylistRequest(authToken, "", playlistId);
+        });
+    }
+    // gets the tracks of a specific playlist
+    getPlaylistTracks(authToken, playlistId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPlaylistRequest(authToken, "/tracks", playlistId);
+        });
+    }
+    // gets the reposters of a specific playlist
+    getPlaylistReposters(authToken, playlistId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPlaylistRequest(authToken, "/reposters", playlistId);
+        });
+    }
+    // creates a new playlist
+    createPlaylist(authToken, playlistData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.createPlaylistRequest(authToken, playlistData);
+        });
+    }
+    // updates a specific playlist
+    updatePlaylist(authToken, playlistId, playlistData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.updatePlaylistRequest(authToken, playlistId, playlistData);
+        });
+    }
+    // deletes a specific playlist
+    deletePlaylist(authToken, playlistId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.deletePlaylistRequest(authToken, playlistId);
+        });
+    }
+    // --- REQUESTS ---
+    getPlaylistRequest(authToken, endpoint, playlistId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = {
+                    method: "GET",
+                    maxBodyLength: Infinity,
+                    url: `${this.baseUrl}/playlists/${playlistId}${endpoint}`,
+                    headers: {
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `OAuth ${authToken}`,
+                    },
+                };
+                const response = yield axios_1.default.request(config);
+                return response.data;
+            }
+            catch (error) {
+                console.error("SoundCloud API Error:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error);
+                throw error;
+            }
+        });
+    }
+    createPlaylistRequest(authToken, playlistData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = {
+                    method: "POST",
+                    maxBodyLength: Infinity,
+                    url: `${this.baseUrl}/playlists`,
+                    headers: {
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `OAuth ${authToken}`,
+                    },
+                    data: playlistData,
+                };
+                const response = yield axios_1.default.request(config);
+                return response.data;
+            }
+            catch (error) {
+                console.error("SoundCloud API Error:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error);
+                throw error;
+            }
+        });
+    }
+    updatePlaylistRequest(authToken, playlistId, playlistData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = {
+                    method: "PUT",
+                    maxBodyLength: Infinity,
+                    url: `${this.baseUrl}/playlists/${playlistId}`,
+                    headers: {
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `OAuth ${authToken}`,
+                    },
+                    data: playlistData,
+                };
+                const response = yield axios_1.default.request(config);
+                return response.data;
+            }
+            catch (error) {
+                console.error("SoundCloud API Error:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error);
+                throw error;
+            }
+        });
+    }
+    deletePlaylistRequest(authToken, playlistId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = {
+                    method: "DELETE",
+                    maxBodyLength: Infinity,
+                    url: `${this.baseUrl}/playlists/${playlistId}`,
+                    headers: {
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `OAuth ${authToken}`,
+                    },
+                };
+                const response = yield axios_1.default.request(config);
+                return response.data;
+            }
+            catch (error) {
+                console.error("SoundCloud API Error:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error);
+                throw error;
+            }
+        });
+    }
+}
+exports.Playlist = Playlist;

package/dist/endpoints/reposts.js

@@ -0,0 +1,107 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reposts = void 0;
+const axios_1 = __importDefault(require("axios"));
+const client_1 = __importDefault(require("../client"));
+class Reposts extends client_1.default {
+    // reposts a specific track
+    repostTrack(authToken, trackId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.repostRequest(authToken, "/tracks", trackId);
+        });
+    }
+    // removes a repost of a specific track
+    removeRepostTrack(authToken, trackId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.removeRepostRequest(authToken, "/tracks", trackId);
+        });
+    }
+    // reposts a specific playlist
+    repostPlaylist(authToken, playlistId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.repostRequest(authToken, "/playlists", playlistId);
+        });
+    }
+    // removes a repost of a specific playlist
+    removeRepostPlaylist(authToken, playlistId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.removeRepostRequest(authToken, "/playlists", playlistId);
+        });
+    }
+    // --- REQUESTS ---
+    repostRequest(authToken, endpoint, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = {
+                    method: "POST",
+                    maxBodyLength: Infinity,
+                    url: `${this.baseUrl}/reposts${endpoint}/${id}`,
+                    headers: {
+                        accept: "application/json; charset=utf-8",
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `OAuth ${authToken}`,
+                    },
+                };
+                const response = yield axios_1.default
+                    .request(config)
+                    .then((response) => {
+                    return response.data;
+                })
+                    .catch((error) => {
+                    console.log(error);
+                    throw new Error("Failed to get me");
+                });
+                return response;
+            }
+            catch (error) {
+                console.error("SoundCloud API Error:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error);
+                throw error;
+            }
+        });
+    }
+    removeRepostRequest(authToken, endpoint, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = {
+                    method: "DELETE",
+                    maxBodyLength: Infinity,
+                    url: `${this.baseUrl}/reposts${endpoint}/${id}`,
+                    headers: {
+                        accept: "application/json; charset=utf-8",
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `OAuth ${authToken}`,
+                    },
+                };
+                const response = yield axios_1.default
+                    .request(config)
+                    .then((response) => {
+                    return response.data;
+                })
+                    .catch((error) => {
+                    console.log(error);
+                    throw new Error("Failed to get me");
+                });
+                return response;
+            }
+            catch (error) {
+                console.error("SoundCloud API Error:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error);
+                throw error;
+            }
+        });
+    }
+}
+exports.Reposts = Reposts;

package/dist/endpoints/search.js

@@ -0,0 +1,71 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Search = void 0;
+const client_1 = __importDefault(require("../client"));
+const axios_1 = __importDefault(require("axios"));
+// TODO: full query support
+class Search extends client_1.default {
+    // searches for tracks
+    tracks(authToken, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.searchRequest(authToken, `/tracks?q=${query}`);
+        });
+    }
+    // searches for playlists
+    playlists(authToken, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.searchRequest(authToken, `/playlists?q=${query}`);
+        });
+    }
+    // searches for users
+    users(authToken, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.searchRequest(authToken, `/users?q=${query}`);
+        });
+    }
+    // --- REQUESTS ---
+    searchRequest(authToken, endpoint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = {
+                    method: "GET",
+                    maxBodyLength: Infinity,
+                    url: `${this.baseUrl}${endpoint}`,
+                    headers: {
+                        accept: "application/json; charset=utf-8",
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `OAuth ${authToken}`,
+                    },
+                };
+                const response = yield axios_1.default
+                    .request(config)
+                    .then((response) => {
+                    return response.data;
+                })
+                    .catch((error) => {
+                    console.log(error);
+                    throw new Error("Failed to get me");
+                });
+                return response;
+            }
+            catch (error) {
+                console.error("SoundCloud API Error:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error);
+                throw error;
+            }
+        });
+    }
+}
+exports.Search = Search;

package/dist/endpoints/token.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Token = void 0;
+const client_1 = __importDefault(require("../client"));
+const axios_1 = __importDefault(require("axios"));
+const qs_1 = __importDefault(require("qs"));
+class Token extends client_1.default {
+    // Returns access token for logged in user
+    getToken(PKCECodeChallenge) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getAccessToken(this.clientId, this.clientSecret, this.redirectUri, this.PKCECodeVerifier, PKCECodeChallenge);
+        });
+    }
+    // --- REQUESTS ---
+    getAccessToken(clientId, clientSecret, redirectUri, PKCECodeVerifier, PKCECodeChallenge) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = qs_1.default.stringify({
+                grant_type: "authorization_code",
+                client_id: clientId,
+                client_secret: clientSecret,
+                redirect_uri: redirectUri,
+                code_verifier: PKCECodeVerifier,
+                code: PKCECodeChallenge,
+            });
+            const config = {
+                method: "post",
+                url: "https://secure.soundcloud.com/oauth/token",
+                headers: {
+                    accept: "application/json; charset=utf-8",
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+                data: data,
+            };
+            const response = yield axios_1.default.request(config);
+            return response.data;
+        });
+    }
+}
+exports.Token = Token;

package/dist/endpoints/tracks.js

@@ -0,0 +1,202 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tracks = void 0;
+const client_1 = __importDefault(require("../client"));
+const axios_1 = __importDefault(require("axios"));
+// TODO: add upload support
+class Tracks extends client_1.default {
+    // gets a specific track
+    getTrack(authToken, trackId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getTrackRequest(authToken, "", trackId);
+        });
+    }
+    // gets the streams of a specific track
+    getTrackStreams(authToken, trackId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getTrackRequest(authToken, "/streams", trackId);
+        });
+    }
+    // gets the comments of a specific track
+    getTrackComments(authToken, trackId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getTrackRequest(authToken, "/comments", trackId);
+        });
+    }
+    // gets the people who liked a specific track
+    getTrackLikers(authToken, trackId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getTrackRequest(authToken, "/favoriters", trackId);
+        });
+    }
+    // gets the people who reposted a specific track
+    getTrackReposters(authToken, trackId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getTrackRequest(authToken, "/reposters", trackId);
+        });
+    }
+    // gets the related tracks of a specific track
+    getRelatedTracks(authToken, trackId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getTrackRequest(authToken, "/related", trackId);
+        });
+    }
+    // creates a comment on a specific track
+    addComment(authToken, trackId, comment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.addCommentRequest(authToken, trackId, comment);
+        });
+    }
+    // updates a specific track
+    updateTrack(authToken, trackId, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.updateTrackRequest(authToken, trackId, data);
+        });
+    }
+    // deletes a specific track
+    deleteTrack(authToken, trackId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.deleteTrackRequest(authToken, trackId);
+        });
+    }
+    // --- REQUESTS ---
+    getTrackRequest(authToken, endpoint, trackId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = {
+                    method: "GET",
+                    maxBodyLength: Infinity,
+                    url: `${this.baseUrl}/tracks/${trackId}${endpoint}`,
+                    headers: {
+                        accept: "application/json; charset=utf-8",
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `OAuth ${authToken}`,
+                    },
+                };
+                const response = yield axios_1.default
+                    .request(config)
+                    .then((response) => {
+                    return response.data;
+                })
+                    .catch((error) => {
+                    console.log(error);
+                    throw new Error("Failed to get me");
+                });
+                return response;
+            }
+            catch (error) {
+                console.error("SoundCloud API Error:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error);
+                throw error;
+            }
+        });
+    }
+    addCommentRequest(authToken, trackId, commentData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = {
+                    method: "POST",
+                    maxBodyLength: Infinity,
+                    url: `${this.baseUrl}/tracks/${trackId}/comments`,
+                    headers: {
+                        accept: "application/json; charset=utf-8",
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `OAuth ${authToken}`,
+                    },
+                    data: commentData,
+                };
+                const response = yield axios_1.default
+                    .request(config)
+                    .then((response) => {
+                    return response.data;
+                })
+                    .catch((error) => {
+                    console.log(error);
+                    throw new Error("Failed to get me");
+                });
+                return response;
+            }
+            catch (error) {
+                console.error("SoundCloud API Error:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error);
+                throw error;
+            }
+        });
+    }
+    updateTrackRequest(authToken, trackId, trackData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = {
+                    method: "PUT",
+                    maxBodyLength: Infinity,
+                    url: `${this.baseUrl}/tracks/${trackId}`,
+                    headers: {
+                        accept: "application/json; charset=utf-8",
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `OAuth ${authToken}`,
+                    },
+                    data: trackData,
+                };
+                const response = yield axios_1.default
+                    .request(config)
+                    .then((response) => {
+                    return response.data;
+                })
+                    .catch((error) => {
+                    console.log(error);
+                    throw new Error("Failed to get me");
+                });
+                return response;
+            }
+            catch (error) {
+                console.error("SoundCloud API Error:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error);
+                throw error;
+            }
+        });
+    }
+    deleteTrackRequest(authToken, trackId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = {
+                    method: "DELETE",
+                    maxBodyLength: Infinity,
+                    url: `${this.baseUrl}/tracks/${trackId}`,
+                    headers: {
+                        accept: "application/json; charset=utf-8",
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `OAuth ${authToken}`,
+                    },
+                };
+                const response = yield axios_1.default
+                    .request(config)
+                    .then((response) => {
+                    return response.data;
+                })
+                    .catch((error) => {
+                    console.log(error);
+                    throw new Error("Failed to get me");
+                });
+                return response;
+            }
+            catch (error) {
+                console.error("SoundCloud API Error:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error);
+                throw error;
+            }
+        });
+    }
+}
+exports.Tracks = Tracks;

package/dist/endpoints/users.js

@@ -0,0 +1,99 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Users = void 0;
+const client_1 = __importDefault(require("../client"));
+const axios_1 = __importDefault(require("axios"));
+class Users extends client_1.default {
+    // gets a specific user
+    getUser(authToken, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getUserRequest(authToken, "", userId);
+        });
+    }
+    // gets the followers of a specific user
+    getUserFollowers(authToken, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getUserRequest(authToken, "/followers", userId);
+        });
+    }
+    // gets the people a specific user follows
+    getUserFollowings(authToken, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getUserRequest(authToken, "/followings", userId);
+        });
+    }
+    // gets the playlists of a specific user
+    getUserPlaylists(authToken, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getUserRequest(authToken, "/playlists", userId);
+        });
+    }
+    // gets the tracks of a specific user
+    getUserTracks(authToken, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getUserRequest(authToken, "/tracks", userId);
+        });
+    }
+    // gets the web profiles of a specific user
+    getUserWebProfiles(authToken, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getUserRequest(authToken, "/web-profiles", userId);
+        });
+    }
+    // gets the tracks a specific user liked
+    getUserLikedTracks(authToken, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getUserRequest(authToken, "/likes/tracks", userId);
+        });
+    }
+    // gets the playlists a specific user liked
+    getUserLikedPlaylists(authToken, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getUserRequest(authToken, "/likes/playlists", userId);
+        });
+    }
+    getUserRequest(authToken, endpoint, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = {
+                    method: "GET",
+                    maxBodyLength: Infinity,
+                    url: `${this.baseUrl}/users/${userId}${endpoint}`,
+                    headers: {
+                        accept: "application/json; charset=utf-8",
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `OAuth ${authToken}`,
+                    },
+                };
+                const response = yield axios_1.default
+                    .request(config)
+                    .then((response) => {
+                    return response.data;
+                })
+                    .catch((error) => {
+                    console.log(error);
+                    throw new Error("Failed to get me");
+                });
+                return response;
+            }
+            catch (error) {
+                console.error("SoundCloud API Error:", ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error);
+                throw error;
+            }
+        });
+    }
+}
+exports.Users = Users;

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const me_1 = require("./endpoints/me");
+const token_1 = require("./endpoints/token");
+const search_1 = require("./endpoints/search");
+const playlists_1 = require("./endpoints/playlists");
+const tracks_1 = require("./endpoints/tracks");
+const users_1 = require("./endpoints/users");
+const likes_1 = require("./endpoints/likes");
+const reposts_1 = require("./endpoints/reposts");
+const misc_1 = require("./endpoints/misc");
+class SoundCloud {
+    constructor(clientId, clientSecret, redirectUri, PKCECodeVerifier) {
+        this.token = new token_1.Token(clientId, clientSecret, redirectUri, PKCECodeVerifier);
+        this.me = new me_1.Me(clientId, clientSecret, redirectUri, PKCECodeVerifier);
+        this.search = new search_1.Search(clientId, clientSecret, redirectUri, PKCECodeVerifier);
+        this.playlists = new playlists_1.Playlist(clientId, clientSecret, redirectUri, PKCECodeVerifier);
+        this.tracks = new tracks_1.Tracks(clientId, clientSecret, redirectUri, PKCECodeVerifier);
+        this.users = new users_1.Users(clientId, clientSecret, redirectUri, PKCECodeVerifier);
+        this.likes = new likes_1.Likes(clientId, clientSecret, redirectUri, PKCECodeVerifier);
+        this.reposts = new reposts_1.Reposts(clientId, clientSecret, redirectUri, PKCECodeVerifier);
+        this.misc = new misc_1.Misc(clientId, clientSecret, redirectUri, PKCECodeVerifier);
+    }
+}
+exports.default = SoundCloud;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "soundcloud-wrapper",
+  "version": "0.9.0",
+  "description": "Node wrapper for the SoundCloud API",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": "https://github.com/18-28/soundcloud-api",
+  "homepage": "https://github.com/18-28/soundcloud-api",
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "soundcloud",
+    "api",
+    "wrapper",
+    "node"
+  ],
+  "author": "developer_1828",
+  "license": "ISC",
+  "dependencies": {
+    "@types/qs": "^6.9.18",
+    "axios": "^1.7.9",
+    "qs": "^6.14.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.0",
+    "typescript": "^5.7.3"
+  }
+}