q-fi-core 2.3.1

package/dist/api/request.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestPublicApi = exports.requestGet = exports.requestLight = exports.request = void 0;
+const request_1 = __importDefault(require("../lib/request"));
+const cache_1 = __importDefault(require("./cache"));
+/**
+ * Make POST requests to deezer api
+ * @param {Object} body post body
+ * @param {String} method request method
+ */
+const request = async (body, method) => {
+    const cacheKey = method + ':' + Object.entries(body).join(':');
+    const cache = cache_1.default.get(cacheKey);
+    if (cache) {
+        return cache;
+    }
+    const { data: { error, results }, } = await request_1.default.post('/gateway.php', body, { params: { method } });
+    if (Object.keys(results).length > 0) {
+        cache_1.default.set(cacheKey, results);
+        return results;
+    }
+    const errorMessage = Object.entries(error).join(', ');
+    throw new Error(errorMessage);
+};
+exports.request = request;
+/**
+ * Make POST requests to deezer api
+ * @param {Object} body post body
+ * @param {String} method request method
+ */
+const requestLight = async (body, method) => {
+    const cacheKey = method + ':' + Object.entries(body).join(':');
+    const cache = cache_1.default.get(cacheKey);
+    if (cache) {
+        return cache;
+    }
+    const { data: { error, results }, } = await request_1.default.post('https://www.deezer.com/ajax/gw-light.php', body, {
+        params: { method, api_version: '1.0' },
+    });
+    if (Object.keys(results).length > 0) {
+        cache_1.default.set(cacheKey, results);
+        return results;
+    }
+    const errorMessage = Object.entries(error).join(', ');
+    throw new Error(errorMessage);
+};
+exports.requestLight = requestLight;
+/**
+ * Make GET requests to deezer public api
+ * @param {String} method request method
+ * @param {Object} params request parameters
+ */
+const requestGet = async (method, params = {}, key = 'get_request') => {
+    const cacheKey = method + key;
+    const cache = cache_1.default.get(cacheKey);
+    if (cache) {
+        return cache;
+    }
+    const { data: { error, results }, } = await request_1.default.get('/gateway.php', { params: { method, ...params } });
+    if (Object.keys(results).length > 0) {
+        cache_1.default.set(cacheKey, results);
+        return results;
+    }
+    const errorMessage = Object.entries(error).join(', ');
+    throw new Error(errorMessage);
+};
+exports.requestGet = requestGet;
+/**
+ * Make GET requests to deezer public api
+ * @param {String} slug endpoint
+ */
+const requestPublicApi = async (slug) => {
+    const cache = cache_1.default.get(slug);
+    if (cache) {
+        return cache;
+    }
+    const { data } = await request_1.default.get('https://api.deezer.com' + slug);
+    if (data.error) {
+        const errorMessage = Object.entries(data.error).join(', ');
+        throw new Error(errorMessage);
+    }
+    cache_1.default.set(slug, data);
+    return data;
+};
+exports.requestPublicApi = requestPublicApi;

package/dist/converter/deezer.d.ts

@@ -0,0 +1,3 @@
+import type { albumType, trackType } from '../types';
+export declare const isrc2deezer: (name: string, isrc?: string) => Promise<trackType>;
+export declare const upc2deezer: (name: string, upc?: string) => Promise<[albumType, trackType[]]>;

package/dist/converter/deezer.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upc2deezer = exports.isrc2deezer = void 0;
+const delay_1 = __importDefault(require("delay"));
+const api_1 = require("../api");
+const http_1 = require("../lib/http");
+const instance = new http_1.HttpClient({ baseURL: 'https://api.deezer.com/', timeout: 15000 });
+const requestLookup = async (path) => {
+    const { data } = await instance.get(path);
+    if (data.error && data.error.code === 4) {
+        await delay_1.default.range(1000, 1500);
+        return await requestLookup(path);
+    }
+    return data;
+};
+const isrc2deezer = async (name, isrc) => {
+    if (!isrc) {
+        throw new Error('ISRC code not found for ' + name);
+    }
+    const data = await requestLookup('track/isrc:' + isrc);
+    if (data.error) {
+        throw new Error(`No match on deezer for ${name} (ISRC: ${isrc})`);
+    }
+    return await (0, api_1.getTrackInfo)(data.id);
+};
+exports.isrc2deezer = isrc2deezer;
+const upc2deezer = async (name, upc) => {
+    if (!upc) {
+        throw new Error('UPC code not found for ' + name);
+    }
+    else if (upc.length > 12 && upc.startsWith('0')) {
+        upc = upc.slice(-12);
+    }
+    const data = await requestLookup('album/upc:' + upc);
+    if (data.error) {
+        throw new Error(`No match on deezer for ${name} (UPC: ${upc})`);
+    }
+    const albumInfo = await (0, api_1.getAlbumInfo)(data.id);
+    const albumTracks = await (0, api_1.getAlbumTracks)(data.id);
+    return [albumInfo, albumTracks.data];
+};
+exports.upc2deezer = upc2deezer;

package/dist/converter/index.d.ts

@@ -0,0 +1,5 @@
+export * from './parse';
+export * from './deezer';
+export * as tidal from './tidal';
+export * as spotify from './spotify';
+export * as youtube from './youtube';

package/dist/converter/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.youtube = exports.spotify = exports.tidal = void 0;
+__exportStar(require("./parse"), exports);
+__exportStar(require("./deezer"), exports);
+exports.tidal = __importStar(require("./tidal"));
+exports.spotify = __importStar(require("./spotify"));
+exports.youtube = __importStar(require("./youtube"));

package/dist/converter/parse.d.ts

@@ -0,0 +1,18 @@
+import type { albumType, artistInfoType, playlistInfo, trackType } from '../types';
+type linkType = 'track' | 'album' | 'artist' | 'playlist';
+export type urlPartsType = {
+    id: string;
+    type: 'track' | 'album' | 'audiobook' | 'artist' | 'playlist' | 'spotify-track' | 'spotify-album' | 'spotify-playlist' | 'spotify-artist' | 'tidal-track' | 'tidal-album' | 'tidal-playlist' | 'tidal-artist' | 'youtube-track';
+};
+export declare const getUrlParts: (url: string, setToken?: boolean) => Promise<urlPartsType>;
+/**
+ * Deezer, Spotify or Tidal links only
+ * @param {String} url
+ */
+export declare const parseInfo: (url: string) => Promise<{
+    info: urlPartsType;
+    linktype: linkType;
+    linkinfo: Record<string, any> | artistInfoType | albumType | playlistInfo;
+    tracks: trackType[];
+}>;
+export {};

package/dist/converter/parse.js

@@ -0,0 +1,176 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInfo = exports.getUrlParts = void 0;
+const __1 = require("../");
+const spotify_uri_1 = __importDefault(require("spotify-uri"));
+const spotify = __importStar(require("./spotify"));
+const tidal = __importStar(require("./tidal"));
+const youtube = __importStar(require("./youtube"));
+const p_queue_1 = __importDefault(require("p-queue"));
+const http_1 = require("../lib/http");
+const queue = new p_queue_1.default({ concurrency: 10 });
+const getUrlParts = async (url, setToken = false) => {
+    if (url.startsWith('spotify:')) {
+        const spotify = url.split(':');
+        url = 'https://open.spotify.com/' + spotify[1] + '/' + spotify[2];
+    }
+    const site = url.match(/deezer|spotify|tidal|youtu\.?be/);
+    if (!site) {
+        throw new Error('Unknown URL: ' + url);
+    }
+    switch (site[0]) {
+        case 'deezer':
+            if (url.includes('page.link')) {
+                const { request } = await (0, http_1.headRequest)(url);
+                url = request.res.responseUrl;
+            }
+            const deezerUrlParts = url.split(/\/(\w+)\/(\d+)/);
+            return { type: deezerUrlParts[1], id: deezerUrlParts[2] };
+        case 'spotify':
+            const spotifyUrlParts = spotify_uri_1.default.parse(url);
+            if (setToken) {
+                await spotify.setSpotifyAnonymousToken();
+            }
+            return { type: ('spotify-' + spotifyUrlParts.type), id: spotifyUrlParts.id };
+        case 'tidal':
+            const tidalUrlParts = url.split(/\/(\w+)\/(\d+|\w+-\w+-\w+-\w+-\w+)/);
+            return { type: ('tidal-' + tidalUrlParts[1]), id: tidalUrlParts[2] };
+        case 'youtube':
+            let yotubeId = url.split('v=')[1];
+            if (yotubeId.includes('&')) {
+                yotubeId = yotubeId.split('&')[0];
+            }
+            return { type: 'youtube-track', id: yotubeId };
+        case 'youtu.be':
+            return { type: 'youtube-track', id: url.split('/').pop() };
+        default:
+            throw new Error('Unable to parse URL: ' + url);
+    }
+};
+exports.getUrlParts = getUrlParts;
+/**
+ * Deezer, Spotify or Tidal links only
+ * @param {String} url
+ */
+const parseInfo = async (url) => {
+    const info = await (0, exports.getUrlParts)(url, true);
+    if (!info.id) {
+        throw new Error('Unable to parse id');
+    }
+    let linktype = 'track';
+    let linkinfo = {};
+    let tracks = [];
+    switch (info.type) {
+        case 'track': {
+            tracks.push(await (0, __1.getTrackInfo)(info.id));
+            break;
+        }
+        case 'album':
+        case 'audiobook':
+            linkinfo = await (0, __1.getAlbumInfo)(info.id);
+            linktype = 'album';
+            const albumTracks = await (0, __1.getAlbumTracks)(info.id);
+            tracks = albumTracks.data;
+            break;
+        case 'playlist':
+            linkinfo = await (0, __1.getPlaylistInfo)(info.id);
+            linktype = 'playlist';
+            const playlistTracks = await (0, __1.getPlaylistTracks)(info.id);
+            tracks = playlistTracks.data;
+            break;
+        case 'artist':
+            linkinfo = await (0, __1.getArtistInfo)(info.id);
+            linktype = 'artist';
+            const artistAlbums = await (0, __1.getDiscography)(info.id);
+            await queue.addAll(artistAlbums.data.map((album) => {
+                return async () => {
+                    if (album.ARTISTS.find((a) => a.ART_ID === info.id)) {
+                        const albumTracks = await (0, __1.getAlbumTracks)(album.ALB_ID);
+                        tracks = [...tracks, ...albumTracks.data.filter((t) => t.ART_ID === info.id)];
+                    }
+                };
+            }));
+            break;
+        case 'spotify-track':
+            tracks.push(await spotify.track2deezer(info.id));
+            break;
+        case 'spotify-album':
+            const [spotifyAlbumInfo, spotifyTracks] = await spotify.album2deezer(info.id);
+            tracks = spotifyTracks;
+            linkinfo = spotifyAlbumInfo;
+            linktype = 'album';
+            break;
+        case 'spotify-playlist':
+            const [spotifyPlaylistInfo, spotifyPlaylistTracks] = await spotify.playlist2Deezer(info.id);
+            tracks = spotifyPlaylistTracks;
+            linkinfo = spotifyPlaylistInfo;
+            linktype = 'playlist';
+            break;
+        case 'spotify-artist':
+            tracks = await spotify.artist2Deezer(info.id);
+            linktype = 'artist';
+            break;
+        case 'tidal-track':
+            tracks.push(await tidal.track2deezer(info.id));
+            break;
+        case 'tidal-album':
+            const [tidalAlbumInfo, tidalAlbumTracks] = await tidal.album2deezer(info.id);
+            tracks = tidalAlbumTracks;
+            linkinfo = tidalAlbumInfo;
+            linktype = 'album';
+            break;
+        case 'tidal-playlist':
+            const [tidalPlaylistInfo, tidalPlaylistTracks] = await tidal.playlist2Deezer(info.id);
+            tracks = tidalPlaylistTracks;
+            linkinfo = tidalPlaylistInfo;
+            linktype = 'playlist';
+            break;
+        case 'tidal-artist':
+            tracks = await tidal.artist2Deezer(info.id);
+            linktype = 'artist';
+            break;
+        case 'youtube-track':
+            tracks.push(await youtube.track2deezer(info.id));
+            break;
+        default:
+            throw new Error('Unknown type: ' + info.type);
+    }
+    return {
+        info,
+        linktype,
+        linkinfo,
+        tracks: tracks.map((t) => {
+            if (t.VERSION && !t.SNG_TITLE.includes(t.VERSION)) {
+                t.SNG_TITLE += ' ' + t.VERSION;
+            }
+            return t;
+        }),
+    };
+};
+exports.parseInfo = parseInfo;

package/dist/converter/spotify.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="spotify-api" />
+import SpotifyWebApi from 'spotify-web-api-node';
+import type { playlistInfo, trackType } from '../types';
+type tokensType = {
+    clientId: string;
+    accessToken: string;
+    accessTokenExpirationTimestampMs: number;
+    isAnonymous: true;
+};
+/**
+ * Export core spotify module
+ */
+export declare const spotifyApi: SpotifyWebApi;
+/**
+ * Set spotify tokens anonymously. This is required to bypass api limits.
+ * @returns {tokensType}
+ */
+export declare const setSpotifyAnonymousToken: () => Promise<tokensType>;
+/**
+ * Convert spotify songs to deezer
+ * @param {String} id Spotify track id
+ * @returns {trackType}
+ */
+export declare const track2deezer: (id: string) => Promise<trackType>;
+/**
+ * Convert spotify albums to deezer
+ * @param {String} id Spotify track id
+ */
+export declare const album2deezer: (id: string) => Promise<[import("../types").albumType, trackType[]]>;
+/**
+ * Convert playlist to deezer
+ * @param {String} id Spotify track id
+ */
+export declare const playlist2Deezer: (id: string, onError?: ((item: SpotifyApi.PlaylistTrackObject, index: number, err: Error) => void) | undefined) => Promise<[playlistInfo, trackType[]]>;
+/**
+ * Convert artist songs to deezer. Maxium of 10 tracks.
+ * @param {String} id Spotify track id
+ */
+export declare const artist2Deezer: (id: string, onError?: ((item: SpotifyApi.TrackObjectFull, index: number, err: Error) => void) | undefined) => Promise<trackType[]>;
+export {};

package/dist/converter/spotify.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.artist2Deezer = exports.playlist2Deezer = exports.album2deezer = exports.track2deezer = exports.setSpotifyAnonymousToken = exports.spotifyApi = void 0;
+const spotify_web_api_node_1 = __importDefault(require("spotify-web-api-node"));
+const p_queue_1 = __importDefault(require("p-queue"));
+const deezer_1 = require("./deezer");
+const http_1 = require("../lib/http");
+let anonymousToken = null;
+let anonymousTokenPromise = null;
+const hasValidAnonymousToken = () => Boolean(anonymousToken && anonymousToken.accessTokenExpirationTimestampMs - 60000 > Date.now());
+/**
+ * Parse offset number
+ * @param {String} next next page url
+ * @returns {Number}
+ */
+const getOffset = (next) => {
+    if (next) {
+        const o = next.split('&').find((p) => p.includes('offset='));
+        return o ? Number(o.split('=')[1]) : 0;
+    }
+    return 0;
+};
+/**
+ * Limit process concurrency
+ */
+const queue = new p_queue_1.default({ concurrency: 25 });
+/**
+ * Export core spotify module
+ */
+exports.spotifyApi = new spotify_web_api_node_1.default();
+/**
+ * Set spotify tokens anonymously. This is required to bypass api limits.
+ * @returns {tokensType}
+ */
+const setSpotifyAnonymousToken = async () => {
+    if (hasValidAnonymousToken() && anonymousToken) {
+        exports.spotifyApi.setAccessToken(anonymousToken.accessToken);
+        return anonymousToken;
+    }
+    if (!anonymousTokenPromise) {
+        anonymousTokenPromise = (0, http_1.getJson)('https://open.spotify.com/get_access_token?reason=transport&productType=embed')
+            .then((data) => {
+            anonymousToken = data;
+            exports.spotifyApi.setAccessToken(data.accessToken);
+            return data;
+        })
+            .finally(() => {
+            anonymousTokenPromise = null;
+        });
+    }
+    return await anonymousTokenPromise;
+};
+exports.setSpotifyAnonymousToken = setSpotifyAnonymousToken;
+/**
+ * Convert spotify songs to deezer
+ * @param {String} id Spotify track id
+ * @returns {trackType}
+ */
+const track2deezer = async (id) => {
+    const { body } = await exports.spotifyApi.getTrack(id);
+    return await (0, deezer_1.isrc2deezer)(body.name, body.external_ids.isrc);
+};
+exports.track2deezer = track2deezer;
+/**
+ * Convert spotify albums to deezer
+ * @param {String} id Spotify track id
+ */
+const album2deezer = async (id) => {
+    const { body } = await exports.spotifyApi.getAlbum(id);
+    return await (0, deezer_1.upc2deezer)(body.name, body.external_ids.upc);
+};
+exports.album2deezer = album2deezer;
+/**
+ * Convert playlist to deezer
+ * @param {String} id Spotify track id
+ */
+const playlist2Deezer = async (id, onError) => {
+    const { body } = await exports.spotifyApi.getPlaylist(id);
+    const tracks = [];
+    let items = body.tracks.items;
+    let offset = getOffset(body.tracks.next);
+    while (offset !== 0) {
+        const { body } = await exports.spotifyApi.getPlaylistTracks(id, { limit: 100, offset: offset ? offset : 0 });
+        offset = getOffset(body.next);
+        items = [...items, ...body.items];
+    }
+    await queue.addAll(items.map((item, index) => {
+        return async () => {
+            try {
+                if (item.track) {
+                    const track = await (0, deezer_1.isrc2deezer)(item.track.name, item.track.external_ids.isrc);
+                    track.TRACK_POSITION = index + 1;
+                    tracks.push(track);
+                }
+            }
+            catch (err) {
+                if (onError) {
+                    onError(item, index, err);
+                }
+            }
+        };
+    }));
+    const dateCreated = new Date().toISOString();
+    const playlistInfoData = {
+        PLAYLIST_ID: body.id,
+        PARENT_USERNAME: body.owner.id,
+        PARENT_USER_ID: body.owner.id,
+        PICTURE_TYPE: 'cover',
+        PLAYLIST_PICTURE: body.images[0].url,
+        TITLE: body.name,
+        TYPE: '0',
+        STATUS: '0',
+        USER_ID: body.owner.id,
+        DATE_ADD: dateCreated,
+        DATE_MOD: dateCreated,
+        DATE_CREATE: dateCreated,
+        NB_SONG: body.tracks.total,
+        NB_FAN: 0,
+        CHECKSUM: body.id,
+        HAS_ARTIST_LINKED: false,
+        IS_SPONSORED: false,
+        IS_EDITO: false,
+        __TYPE__: 'playlist',
+    };
+    return [playlistInfoData, tracks];
+};
+exports.playlist2Deezer = playlist2Deezer;
+/**
+ * Convert artist songs to deezer. Maxium of 10 tracks.
+ * @param {String} id Spotify track id
+ */
+const artist2Deezer = async (id, onError) => {
+    // Artist tracks are limited to 10 items
+    const { body } = await exports.spotifyApi.getArtistTopTracks(id, 'GB');
+    const tracks = [];
+    await queue.addAll(body.tracks.map((item, index) => {
+        return async () => {
+            try {
+                const track = await (0, deezer_1.isrc2deezer)(item.name, item.external_ids.isrc);
+                tracks.push(track);
+            }
+            catch (err) {
+                if (onError) {
+                    onError(item, index, err);
+                }
+            }
+        };
+    }));
+    return tracks;
+};
+exports.artist2Deezer = artist2Deezer;