Update index.js

index.js

@@ -1493,6 +1493,165 @@ result : {name: file?.name,
         code: 500
      });
 }
+})
+.get('/spotifySearch', async (req, res) => {
+    try {
+        async function spotifySearch(query) {
+            let acc = [
+              {
+                id: "e22d2dda8830401b88e4aebaf1327d21",
+                secret: "37d4c71ee45a47c1baccec2ae6f789d6",
+              },
+              {
+                id: "2a16c7e8b59a459c91e0f6e5f734dbad",
+                secret: "b000f142441545ceb2a831c341145c3d",
+              },
+              {
+                id: "189a1643acfa4fd3b9a665a84d2f9b8f",
+                secret: "bf82850195df4066b652801e262238cd",
+              },
+              {
+                id: "6430383e20eb4bccac72961146c55240",
+                secret: "d46acaa4104f4016b3a228206497fc32",
+              },
+              {
+                id: "7e15fc4078014b45954582148be5bc85",
+                secret: "55a465fa161f4f24bc9f0ef7384d4b96",
+              },
+            ];
+            acc = acc[Math.floor(Math.random() * acc.length)];
+        
+            async function getToken() {
+              try {
+                const response = await axios.post(
+                  "https://accounts.spotify.com/api/token",
+                  new URLSearchParams({
+                    grant_type: "client_credentials",
+                    client_id: acc?.id,
+                    client_secret: acc?.secret,
+                  }),
+                  {
+                    headers: {
+                      "Content-Type": "application/x-www-form-urlencoded",
+                    },
+                  }
+                );
+                return response.data.access_token;
+              } catch (error) {
+                return null;
+              }
+            }
+        
+            const token = await getToken();
+            if (!token) {
+              return [];
+            }
+        
+            async function searchSpotifyTrack(query, token) {
+              const url = "https://api.spotify.com/v1/search";
+              const config = {
+                headers: {
+                  Authorization: `Bearer ${token}`,
+                },
+                params: {
+                  q: query,
+                  type: "track",
+                  market: "ID",
+                  include_external: "audio",
+                },
+              };
+        
+              try {
+                const response = await axios.get(url, config);
+                const tracks = response.data.tracks.items;
+                const trackInfo = tracks.map((track) => ({
+                  name: track.name,
+                  artist: track.artists.map((artist) => artist.name).join(", "),
+                  album: track.album.name,
+                  id: track.album.id,
+                  release_date: track.album.release_date,
+                  url: track.external_urls.spotify,
+                  popularity: track.popularity,
+                  preview_url: track.preview_url,
+                  duration_ms: track.duration_ms,
+                  explicit: track.explicit,
+                  thumbnail: track.album.images[0] ? track.album.images[0].url : null,
+                  track_number: track.track_number,
+                  total_tracks: track.album.total_tracks,
+                  is_local: track.is_local,
+                }));
+        
+                return trackInfo;
+              } catch (error) {
+                console.error(
+                  "Error searching Spotify track:",
+                  error.response ? error.response.data : error.message
+                );
+                return [];
+              }
+            }
+        
+            async function getSpotifyInfoFromURL(url, token) {
+              try {
+                const spotifyId = url.split("/").pop().split("?")[0];
+                if (!spotifyId) return [];
+                const response = await axios.get(
+                  `https://api.spotify.com/v1/tracks/${spotifyId}`,
+                  {
+                    headers: {
+                      Authorization: `Bearer ${token}`,
+                    },
+                  }
+                );
+        
+                const track = response.data;
+                return [
+                  {
+                    name: track.name,
+                    artist: track.artists.map((artist) => artist.name).join(", "),
+                    album: track.album.name,
+                    id: track.album.id,
+                    release_date: track.album.release_date,
+                    url: track.external_urls.spotify,
+                    popularity: track.popularity,
+                    preview_url: track.preview_url,
+                    duration_ms: track.duration_ms,
+                    explicit: track.explicit,
+                    thumbnail: track.album.images[0] ? track.album.images[0].url : null,
+                    track_number: track.track_number,
+                    total_tracks: track.album.total_tracks,
+                    is_local: track.is_local,
+                  },
+                ];
+              } catch (error) {
+                console.error(
+                  "Error fetching Spotify info from URL:",
+                  error.response ? error.response.data : error.message
+                );
+                return [];
+              }
+            }
+        
+            let results = [];
+        
+            if (query.startsWith("https://open.spotify.com/track/")) {
+              results = await getSpotifyInfoFromURL(query, token);
+            } else {
+              results = await searchSpotifyTrack(query, token);
+            }
+        
+            return results;
+          }
+          let q = req.query.q || req.query.query;
+        if (!q) return res.json({ message: 'Input parameter q' });
+        let get = await spotifySearch(q)
+        return res.json({message: "Success", code: 200, data: get})
+    } catch (e) {
+        console.log(e);
+    return res.json({ message: "Internal Server Error",
+        code: 500
+     });
+    }
 })
   .use((req, res, next) => {
     res.redirect('/');