@manhgdev/soundcloud-package 0.1.0

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@manhgdev/soundcloud-package",
+  "version": "0.1.0",
+  "description": "JavaScript wrapper for SoundCloud API",
+  "main": "dist/index.js",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bun build ./src/index.js --outdir ./dist --target node",
+    "prod": "npm publish",
+    "test": "bun test",
+    "lint": "eslint src --ext .js",
+    "format": "prettier --write \"src/**/*.js\""
+  },
+  "keywords": [
+    "soundcloud",
+    "api",
+    "music",
+    "streaming",
+    "audio"
+  ],
+  "author": "manhg dev",
+  "license": "MIT",
+  "dependencies": {
+    "query-string": "^8.1.0"
+  },
+  "devDependencies": {
+    "eslint": "^8.0.0",
+    "prettier": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+} 

package/src/index.js

@@ -0,0 +1,203 @@
+import queryString from "query-string";
+
+import SearchModule from "./modules/search.js";
+import TracksModule from "./modules/tracks.js";
+import UsersModule from "./modules/users.js";
+import PlaylistsModule from "./modules/playlists.js";
+import MediaModule from "./modules/media.js";
+import DiscoverModule from "./modules/discover.js";
+
+class SoundCloudAPI {
+  constructor(options = {}) {
+    // Chỉ sử dụng client ID được cung cấp, không có giá trị mặc định
+    this.clientId = options.clientId;
+    this.baseURL = "https://api-v2.soundcloud.com";
+    this.appVersion = options.appVersion || "1753870647";
+    this.appLocale = options.appLocale || "en";
+    this.autoFetchClientId = options.autoFetchClientId !== false;
+    this.clientIdCache = {
+      value: this.clientId,
+      expirationTime: this.clientId ? Date.now() + 360000 : 0, // Nếu không có clientId, đặt expirationTime = 0 để buộc fetch
+    };
+    this.clientIdPromise = null; // Track ongoing client ID fetch requests
+
+    this.headers = {
+      "User-Agent":
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36",
+      Accept: "application/json, text/javascript, */*; q=0.01",
+      Origin: "https://soundcloud.com",
+      Referer: "https://soundcloud.com/",
+      "Accept-Language": "en,vi;q=0.9,en-US;q=0.8",
+    };
+
+    this.search = new SearchModule(this);
+    this.tracks = new TracksModule(this);
+    this.users = new UsersModule(this);
+    this.playlists = new PlaylistsModule(this);
+    this.media = new MediaModule(this);
+    this.discover = new DiscoverModule(this);
+
+    // Luôn fetch client ID khi autoFetchClientId là true
+    if (this.autoFetchClientId) {
+      // Không await ở đây để tránh làm constructor trở thành async
+      this._initClientId();
+    }
+  }
+
+  async _initClientId() {
+    try {
+      const newClientId = await this.getClientId(); // Use getClientId to avoid duplication
+    } catch (error) {
+      console.error(
+        "[SOUNDCLOUD] Error initializing client ID:",
+        error.message,
+      );
+    }
+  }
+
+  async getClientId() {
+    // Nếu không có clientId hoặc cache đã hết hạn, fetch mới
+    if (
+      this.autoFetchClientId &&
+      (!this.clientId || Date.now() > this.clientIdCache.expirationTime)
+    ) {
+      try {
+        // If there's already a fetch in progress, return that promise
+        if (this.clientIdPromise) {
+          return await this.clientIdPromise;
+        }
+
+        // Create a new promise for fetching the client ID
+        this.clientIdPromise = this.fetchClientIdFromWeb();
+
+        const newClientId = await this.clientIdPromise;
+        if (newClientId) {
+          this.clientId = newClientId;
+          this.clientIdCache = {
+            value: newClientId,
+            expirationTime: Date.now() + 180000, // 3 minutes
+          };
+        }
+
+        // Clear the promise after it's resolved
+        this.clientIdPromise = null;
+      } catch (error) {
+        // Clear the promise if there's an error
+        this.clientIdPromise = null;
+        console.error("[SOUNDCLOUD] Error fetching client ID:", error.message);
+      }
+    }
+
+    return this.clientId;
+  }
+
+  async fetchClientIdFromWeb() {
+    const webURL = "https://www.soundcloud.com/";
+    let script = "";
+
+    try {
+      console.log("[SOUNDCLOUD] Fetching client ID from web...");
+      // Fetch the main SoundCloud page
+      const response = await fetch(webURL, {
+        headers: this.headers,
+      });
+
+      if (!response.ok) {
+        throw new Error(`Failed to fetch SoundCloud page: ${response.status}`);
+      }
+
+      const html = await response.text();
+
+      // Extract script URLs
+      const scriptUrlRegex =
+        /(?!<script crossorigin src=")https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*\.js)(?=">)/g;
+      const urls = html.match(scriptUrlRegex) || [];
+
+      if (urls.length === 0) {
+        throw new Error("No script URLs found in SoundCloud page");
+      }
+
+      // Find the script containing the client ID
+      for (let i = urls.length - 1; i >= 0; i--) {
+        const scriptUrl = urls[i];
+        // console.log(`[SOUNDCLOUD] Checking script: ${scriptUrl}`);
+
+        const scriptResponse = await fetch(scriptUrl, {
+          headers: this.headers,
+        });
+
+        if (!scriptResponse.ok) continue;
+
+        script = await scriptResponse.text();
+
+        if (script.includes(',client_id:"')) {
+          const match = script.match(/,client_id:"(\w+)"/);
+          if (match && match[1]) {
+            const clientId = match[1];
+            // console.log(`[SOUNDCLOUD] Found client ID: ${clientId}`);
+            return clientId;
+          }
+        }
+      }
+
+      // Nếu không tìm thấy client ID trong bất kỳ script nào
+      throw new Error("Client ID not found in any script");
+    } catch (error) {
+      console.error(
+        "[SOUNDCLOUD] Error in fetchClientIdFromWeb:",
+        error.message,
+      );
+      throw error; // Ném lại lỗi để caller xử lý
+    }
+  }
+
+  async request(endpoint, params = {}) {
+    // Get the latest client ID before making the request
+    const clientId = await this.getClientId();
+
+    if (!clientId) {
+      throw new Error(
+        "SoundCloud API Error: No client ID available. Please provide a client ID or enable autoFetchClientId.",
+      );
+    }
+
+    const defaultParams = {
+      client_id: clientId,
+      app_version: this.appVersion,
+      app_locale: this.appLocale,
+    };
+
+    const queryParams = queryString.stringify({
+      ...defaultParams,
+      ...params,
+    });
+
+    const url = `${this.baseURL}${endpoint}?${queryParams}`;
+
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: this.headers,
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          `SoundCloud API Error: ${response.status} - ${JSON.stringify(errorData)}`,
+        );
+      }
+
+      return await response.json();
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error("SoundCloud API Error: Request was aborted");
+      } else if (error.name === "TypeError") {
+        throw new Error("SoundCloud API Error: Network error");
+      } else {
+        throw error;
+      }
+    }
+  }
+}
+
+export default SoundCloudAPI;

package/src/modules/discover.js

@@ -0,0 +1,19 @@
+class DiscoverModule {
+  constructor(api) {
+    this.api = api;
+  }
+
+  getHomeContent() {
+    return this.api.request("/mixed-selections");
+  }
+
+  getRecentTracks(genre = "all genres") {
+    return this.api.request(`/recent-tracks/${encodeURIComponent(genre)}`);
+  }
+
+  getRecentTracksByCountry() {
+    return this.api.request("/recent-tracks/country");
+  }
+}
+
+export default DiscoverModule;

package/src/modules/media.js

@@ -0,0 +1,66 @@
+class MediaModule {
+  constructor(api) {
+    this.api = api;
+  }
+
+  getStreamURL(mediaUrl, trackAuthorization, clientId) {
+    return `${mediaUrl}?client_id=${clientId}&track_authorization=${trackAuthorization}`;
+  }
+
+  async getPlaybackUrl(trackId) {
+    try {
+      return await this.getMediaUrl(trackId, "hls");
+    } catch (error) {
+      throw new Error(`Failed to get playback URL: ${error.message}`);
+    }
+  }
+
+  async getDownloadUrl(trackId) {
+    try {
+      return await this.getMediaUrl(trackId, "progressive");
+    } catch (error) {
+      throw new Error(`Failed to get download URL: ${error.message}`);
+    }
+  }
+
+  async getMediaUrl(trackId, protocol = "hls") {
+    try {
+      const track = await this.api.tracks.getMultiple([trackId]);
+
+      if (!track || !track.length || !track[0]) {
+        throw new Error("Track not found");
+      }
+
+      const trackData = track[0];
+
+      if (
+        !trackData.media ||
+        !trackData.media.transcodings ||
+        !trackData.media.transcodings.length
+      ) {
+        throw new Error("No media transcodings available for this track");
+      }
+
+      const transcoding = trackData.media.transcodings.find(
+        (t) =>
+          t.format.protocol === protocol && t.format.mime_type === "audio/mpeg",
+      );
+
+      if (!transcoding) {
+        throw new Error(`No suitable ${protocol} media transcoding found`);
+      }
+
+      const mediaUrl = transcoding.url;
+
+      return this.getStreamURL(
+        mediaUrl,
+        trackData.track_authorization,
+        this.api.clientId,
+      );
+    } catch (error) {
+      throw new Error(`Failed to get media URL: ${error.message}`);
+    }
+  }
+}
+
+export default MediaModule;

package/src/modules/playlists.js

@@ -0,0 +1,26 @@
+class PlaylistsModule {
+  constructor(api) {
+    this.api = api;
+  }
+
+  getPlaylist(playlistId, options = {}) {
+    return this.api.request(`/playlists/${playlistId}`, options);
+  }
+
+  getLikers(playlistId, options = {}) {
+    return this.api.request(`/playlists/${playlistId}/likers`, options);
+  }
+
+  getReposters(playlistId, options = {}) {
+    return this.api.request(`/playlists/${playlistId}/reposters`, options);
+  }
+
+  getByGenre(genre, options = {}) {
+    return this.api.request("/playlists/discovery", {
+      tag: genre,
+      ...options,
+    });
+  }
+}
+
+export default PlaylistsModule;

package/src/modules/search.js

@@ -0,0 +1,52 @@
+class SearchModule {
+  constructor(api) {
+    this.api = api;
+  }
+
+  all(query, options = {}) {
+    return this.api.request("/search", {
+      q: query,
+      ...options,
+    });
+  }
+
+  tracks(query, options = {}) {
+    const params = {
+      q: query,
+      ...options,
+    };
+
+    return this.api.request("/search/tracks", params);
+  }
+
+  users(query, options = {}) {
+    return this.api.request("/search/users", {
+      q: query,
+      ...options,
+    });
+  }
+
+  albums(query, options = {}) {
+    return this.api.request("/search/albums", {
+      q: query,
+      ...options,
+    });
+  }
+
+  playlists(query, options = {}) {
+    return this.api.request("/search/playlists_without_albums", {
+      q: query,
+      ...options,
+    });
+  }
+
+  byGenre(genre, options = {}) {
+    return this.tracks("*", {
+      "filter.genre_or_tag": genre,
+      sort: "popular",
+      ...options,
+    });
+  }
+}
+
+export default SearchModule;

package/src/modules/tracks.js

@@ -0,0 +1,56 @@
+class TracksModule {
+  constructor(api) {
+    this.api = api;
+  }
+
+  getMultiple(ids) {
+    if (!Array.isArray(ids)) {
+      throw new Error("IDs must be an array");
+    }
+
+    return this.api.request("/tracks", {
+      ids: ids.join(","),
+    });
+  }
+
+  getComments(trackId, options = {}) {
+    return this.api.request(`/tracks/${trackId}/comments`, options);
+  }
+
+  getRelated(trackId, options = {}) {
+    return this.api.request(`/tracks/${trackId}/related`, options);
+  }
+
+  async getStreamUrl(trackId) {
+    try {
+      const trackInfo = await this.api.request(`/tracks/${trackId}`);
+
+      if (!trackInfo || !trackInfo.media || !trackInfo.media.transcodings) {
+        throw new Error("Track streaming information not available");
+      }
+
+      const hlsTranscoding = trackInfo.media.transcodings.find(
+        (t) =>
+          t.format.protocol === "hls" && t.format.mime_type === "audio/mpeg",
+      );
+
+      if (!hlsTranscoding) {
+        throw new Error("HLS streaming not available for this track");
+      }
+
+      const mediaUrl = hlsTranscoding.url;
+      const mediaTranscodingId = mediaUrl.split("/").pop();
+
+      const streamInfo = await this.api.request(
+        `/media/soundcloud:tracks:${trackId}/${mediaTranscodingId}/stream/hls`,
+        { track_authorization: trackInfo.track_authorization },
+      );
+
+      return streamInfo.url;
+    } catch (error) {
+      throw new Error(`Failed to get stream URL: ${error.message}`);
+    }
+  }
+}
+
+export default TracksModule;

package/src/modules/users.js

@@ -0,0 +1,58 @@
+class UsersModule {
+  constructor(api) {
+    this.api = api;
+  }
+
+  getUser(userId) {
+    return this.api.request(`/users/${userId}`);
+  }
+
+  getSpotlight(userId) {
+    return this.api.request(`/users/${userId}/spotlight`);
+  }
+
+  getFeaturedProfiles(userId) {
+    return this.api.request(`/users/${userId}/featured-profiles`);
+  }
+
+  getLikes(userId, options = {}) {
+    return this.api.request(`/users/${userId}/likes`, options);
+  }
+
+  getFollowings(userId, options = {}) {
+    return this.api.request(`/users/${userId}/followings`, options);
+  }
+
+  getRelatedArtists(userId, options = {}) {
+    return this.api.request(`/users/${userId}/relatedartists`, options);
+  }
+
+  getComments(userId, options = {}) {
+    return this.api.request(`/users/${userId}/comments`, options);
+  }
+
+  getStream(userId, options = {}) {
+    return this.api.request(`/stream/users/${userId}`, options);
+  }
+
+  getTopTracks(userId, options = {}) {
+    return this.api.request(`/users/${userId}/toptracks`, options);
+  }
+
+  getTracks(userId, options = {}) {
+    return this.api.request(`/users/${userId}/tracks`, options);
+  }
+
+  getPlaylists(userId, options = {}) {
+    return this.api.request(
+      `/users/${userId}/playlists_without_albums`,
+      options,
+    );
+  }
+
+  getWebProfiles(userId) {
+    return this.api.request(`/users/soundcloud:users:${userId}/web-profiles`);
+  }
+}
+
+export default UsersModule;

package/tests/client-id.test.js

@@ -0,0 +1,12 @@
+import { test, expect } from "bun:test";
+import SoundCloudAPI from '../src/index.js';
+
+test('getClientId should return a client ID', async () => {
+  const api = new SoundCloudAPI({ autoFetchClientId: true });
+  
+  const clientId = await api.getClientId();
+  console.log("Final Client ID:", clientId);
+  
+  expect(typeof clientId).toBe('string');
+  expect(clientId.length).toBeGreaterThan(0);
+}); 

package/tests/discover.test.js

@@ -0,0 +1,35 @@
+import { test, expect } from "bun:test";
+import SoundCloudAPI from '../src/index.js';
+
+test('discover.getHomeContent should fetch home content', async () => {
+  const api = new SoundCloudAPI({ autoFetchClientId: true });
+  
+  const result = await api.discover.getHomeContent();
+  console.log("Home Content Result:", JSON.stringify(result, null, 2).substring(0, 500) + "...");
+  
+  expect(result).toBeDefined();
+  expect(result.collection).toBeDefined();
+  expect(Array.isArray(result.collection)).toBe(true);
+});
+
+test('discover.getRecentTracks should fetch recent tracks', async () => {
+  const api = new SoundCloudAPI({ autoFetchClientId: true });
+  
+  const result = await api.discover.getRecentTracks('electronic');
+  console.log("Recent Tracks Result:", JSON.stringify(result, null, 2).substring(0, 500) + "...");
+  
+  expect(result).toBeDefined();
+  expect(result.collection).toBeDefined();
+  expect(Array.isArray(result.collection)).toBe(true);
+});
+
+test('discover.getRecentTracksByCountry should fetch recent tracks by country', async () => {
+  const api = new SoundCloudAPI({ autoFetchClientId: true });
+  
+  const result = await api.discover.getRecentTracksByCountry();
+  console.log("Recent Tracks By Country Result:", JSON.stringify(result, null, 2).substring(0, 500) + "...");
+  
+  expect(result).toBeDefined();
+  expect(result.collection).toBeDefined();
+  expect(Array.isArray(result.collection)).toBe(true);
+}); 

package/tests/find-ids.test.js

@@ -0,0 +1,14 @@
+import { test, expect } from "bun:test";
+import SoundCloudAPI from '../src/index.js';
+
+test('find popular user and track IDs', async () => {
+  const api = new SoundCloudAPI({ autoFetchClientId: true });
+  
+  // Tìm user phổ biến
+  const userResult = await api.search.users('skrillex', { limit: 1 });
+  console.log("Found User:", JSON.stringify(userResult.collection[0], null, 2));
+  
+  // Tìm track phổ biến
+  const trackResult = await api.search.tracks('skrillex bangarang', { limit: 1 });
+  console.log("Found Track:", JSON.stringify(trackResult.collection[0], null, 2));
+}); 

package/tests/media.test.js

@@ -0,0 +1,27 @@
+import { test, expect } from "bun:test";
+import SoundCloudAPI from '../src/index.js';
+
+// Sử dụng ID thật từ kết quả tìm kiếm
+const TEST_TRACK_ID = 45719017; // Skrillex - Bangarang feat Sirah
+
+test('media.getPlaybackUrl should fetch playback URL', async () => {
+  const api = new SoundCloudAPI({ autoFetchClientId: true });
+  
+  const result = await api.media.getMediaUrl(TEST_TRACK_ID, 'hls');
+  console.log("Playback URL Result:", result);
+  
+  expect(result).toBeDefined();
+  expect(typeof result).toBe('string');
+  expect(result.startsWith('https://')).toBe(true);
+});
+
+test('media.getDownloadUrl should fetch download URL', async () => {
+  const api = new SoundCloudAPI({ autoFetchClientId: true });
+  
+  const result = await api.media.getMediaUrl(TEST_TRACK_ID, 'progressive');
+  console.log("Download URL Result:", result);
+  
+  expect(result).toBeDefined();
+  expect(typeof result).toBe('string');
+  expect(result.startsWith('https://')).toBe(true);
+});

package/tests/playlists.test.js

@@ -0,0 +1,45 @@
+import { test, expect } from "bun:test";
+import SoundCloudAPI from '../src/index.js';
+
+// Cần tìm một playlist ID thật
+// Sử dụng kết quả từ search để tìm một playlist
+test('find a playlist ID for testing', async () => {
+  const api = new SoundCloudAPI({ autoFetchClientId: true });
+  
+  const result = await api.search.playlists('skrillex', { limit: 1 });
+  console.log("Found Playlist:", JSON.stringify(result.collection[0], null, 2));
+  
+  // Lưu playlist ID cho các test tiếp theo
+  const playlistId = result.collection[0].id;
+  
+  expect(playlistId).toBeDefined();
+  expect(typeof playlistId).toBe('number');
+  
+  return playlistId;
+});
+
+test('playlists.getPlaylist should fetch playlist information', async () => {
+  const api = new SoundCloudAPI({ autoFetchClientId: true });
+  
+  // Tìm một playlist ID
+  const searchResult = await api.search.playlists('skrillex', { limit: 1 });
+  const playlistId = searchResult.collection[0].id;
+  
+  const result = await api.playlists.getPlaylist(playlistId);
+  console.log("Playlist Info Result:", JSON.stringify(result, null, 2).substring(0, 500) + "...");
+  
+  expect(result).toBeDefined();
+  expect(result.id).toBeDefined();
+  expect(result.kind).toBe('playlist');
+});
+
+test('playlists.getByGenre should fetch playlists by genre', async () => {
+  const api = new SoundCloudAPI({ autoFetchClientId: true });
+  
+  const result = await api.playlists.getByGenre('electronic', { limit: 5 });
+  console.log("Playlists By Genre Result:", JSON.stringify(result, null, 2).substring(0, 500) + "...");
+  
+  expect(result).toBeDefined();
+  expect(result.collection).toBeDefined();
+  expect(Array.isArray(result.collection)).toBe(true);
+});