discord-player-deezer 2.0.0-beta.2 → 2.0.0-beta.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.ts +25 -3
- package/dist/index.js +60 -14
- package/package.json +2 -3
- package/readme.md +23 -45
package/dist/index.d.ts
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { Track, ExtractorStreamable, BaseExtractor, ExtractorSearchContext, Playlist as Playlist$1, ExtractorInfo } from 'discord-player';
|
|
1
|
+
import { Track, ExtractorStreamable, BaseExtractor, ExtractorSearchContext, Playlist as Playlist$1, ExtractorInfo, Player } from 'discord-player';
|
|
2
2
|
import { Playlist, Track as Track$1 } from '@mithron/deezer-music-metadata';
|
|
3
3
|
import * as crypto from 'crypto';
|
|
4
4
|
import { PassThrough } from 'stream';
|
|
@@ -28,11 +28,33 @@ declare class DeezerExtractor extends BaseExtractor<DeezerExtractorOptions> {
|
|
|
28
28
|
validate(query: string): Promise<boolean>;
|
|
29
29
|
buildPlaylistData(data: Playlist, handleContext: ExtractorSearchContext): Playlist$1;
|
|
30
30
|
handle(query: string, context: ExtractorSearchContext): Promise<ExtractorInfo>;
|
|
31
|
-
buildTrack(track: Track$1,
|
|
31
|
+
buildTrack(track: Track$1, { requestedBy }: ExtractorSearchContext): Track<unknown>;
|
|
32
|
+
bridge(track: Track): Promise<ExtractorStreamable | null>;
|
|
32
33
|
stream(info: Track): Promise<ExtractorStreamable>;
|
|
33
34
|
}
|
|
34
35
|
|
|
35
36
|
declare function getCrypto(): Promise<typeof crypto>;
|
|
37
|
+
type ArrayOrObject<T> = T | T[];
|
|
38
|
+
interface DeezerSearchTrackResponse {
|
|
39
|
+
data: {
|
|
40
|
+
link: string;
|
|
41
|
+
title: string;
|
|
42
|
+
album: {
|
|
43
|
+
cover_xl?: string;
|
|
44
|
+
cover_medium?: string;
|
|
45
|
+
cover_small?: string;
|
|
46
|
+
cover?: string;
|
|
47
|
+
};
|
|
48
|
+
artist: {
|
|
49
|
+
name: string;
|
|
50
|
+
};
|
|
51
|
+
duration: number;
|
|
52
|
+
type: "track";
|
|
53
|
+
}[];
|
|
54
|
+
}
|
|
55
|
+
declare function buildTrackFromSearch(track: DeezerSearchTrackResponse, player: Player, requestedBy?: Track['requestedBy']): Track<unknown>[];
|
|
56
|
+
declare function extractTrackId(query: string): string;
|
|
57
|
+
declare function searchOneTrack(query: string): Promise<DeezerSearchTrackResponse | undefined>;
|
|
36
58
|
declare function streamTrack(track: Track, ext: DeezerExtractor): Promise<PassThrough>;
|
|
37
59
|
declare const deezerRegex: {
|
|
38
60
|
readonly track: RegExp;
|
|
@@ -41,4 +63,4 @@ declare const deezerRegex: {
|
|
|
41
63
|
};
|
|
42
64
|
declare function validate(query: string): boolean;
|
|
43
65
|
|
|
44
|
-
export { DeezerExtractor, type DeezerExtractorOptions, type DeezerUserInfo, deezerRegex, getCrypto, streamTrack, validate };
|
|
66
|
+
export { type ArrayOrObject, DeezerExtractor, type DeezerExtractorOptions, type DeezerSearchTrackResponse, type DeezerUserInfo, buildTrackFromSearch, deezerRegex, extractTrackId, getCrypto, searchOneTrack, streamTrack, validate };
|
package/dist/index.js
CHANGED
|
@@ -31,18 +31,22 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
|
|
|
31
31
|
var src_exports = {};
|
|
32
32
|
__export(src_exports, {
|
|
33
33
|
DeezerExtractor: () => DeezerExtractor,
|
|
34
|
+
buildTrackFromSearch: () => buildTrackFromSearch,
|
|
34
35
|
deezerRegex: () => deezerRegex,
|
|
36
|
+
extractTrackId: () => extractTrackId,
|
|
35
37
|
getCrypto: () => getCrypto,
|
|
38
|
+
searchOneTrack: () => searchOneTrack,
|
|
36
39
|
streamTrack: () => streamTrack,
|
|
37
40
|
validate: () => validate
|
|
38
41
|
});
|
|
39
42
|
module.exports = __toCommonJS(src_exports);
|
|
40
43
|
|
|
41
44
|
// src/DeezerExtractor.ts
|
|
42
|
-
var
|
|
45
|
+
var import_discord_player2 = require("discord-player");
|
|
43
46
|
var import_deezer_music_metadata = require("@mithron/deezer-music-metadata");
|
|
44
47
|
|
|
45
48
|
// src/utils/util.ts
|
|
49
|
+
var import_discord_player = require("discord-player");
|
|
46
50
|
var import_stream = require("stream");
|
|
47
51
|
var IV = Buffer.from(Array.from({ length: 8 }, (_, x) => x));
|
|
48
52
|
var rawCrypto;
|
|
@@ -53,13 +57,43 @@ async function getCrypto() {
|
|
|
53
57
|
}
|
|
54
58
|
return rawCrypto;
|
|
55
59
|
}
|
|
60
|
+
var DeezerAPIRoutes = {
|
|
61
|
+
searchTrack(query, limit) {
|
|
62
|
+
const url = `https://api.deezer.com/search/track?q=${encodeURIComponent(query)}&${limit ? `limit=${limit}` : ""}`;
|
|
63
|
+
return url;
|
|
64
|
+
}
|
|
65
|
+
};
|
|
66
|
+
function buildTrackFromSearch(track, player, requestedBy) {
|
|
67
|
+
return track.data.map((v) => new import_discord_player.Track(player, {
|
|
68
|
+
source: "arbitrary",
|
|
69
|
+
duration: import_discord_player.Util.buildTimeCode(import_discord_player.Util.parseMS(v.duration * 1e3)),
|
|
70
|
+
author: Array.isArray(v.artist) ? v.artist.map((a) => a.name).join(", ") : v.artist.name,
|
|
71
|
+
url: v.link,
|
|
72
|
+
title: v.title,
|
|
73
|
+
thumbnail: v.album.cover_xl || v.album.cover_medium || v.album.cover || v.album.cover_small || "https://play-lh.googleusercontent.com/xtIOV8iPeAY4GrldTDo3CbLAEpbea2DqnfxaB4Nn2p5qz6KAiumY74qH86pgu1HA1A",
|
|
74
|
+
live: false,
|
|
75
|
+
requestedBy
|
|
76
|
+
}));
|
|
77
|
+
}
|
|
78
|
+
function extractTrackId(query) {
|
|
79
|
+
if (!validate(query)) throw new Error("Invalid track url");
|
|
80
|
+
const trackIdWithUrlParams = query.split("/").at(-1);
|
|
81
|
+
if (!trackIdWithUrlParams) throw new Error("Cannot find track ID");
|
|
82
|
+
return trackIdWithUrlParams.split("?")[0];
|
|
83
|
+
}
|
|
84
|
+
async function searchOneTrack(query) {
|
|
85
|
+
const url = DeezerAPIRoutes.searchTrack(query, 1);
|
|
86
|
+
const trackRes = await fetch(url);
|
|
87
|
+
if (trackRes.status !== 200) throw new Error("Fetch failed");
|
|
88
|
+
const trackData = await trackRes.json();
|
|
89
|
+
const track = trackData;
|
|
90
|
+
return track;
|
|
91
|
+
}
|
|
56
92
|
async function streamTrack(track, ext) {
|
|
57
|
-
const trackIdWithUrlParams = track.url.split("/").at(-1);
|
|
58
|
-
if (!trackIdWithUrlParams || !validate(track.url)) throw new Error("INVALID TRACK");
|
|
59
93
|
const decryptionKey = ext.options.decryptionKey;
|
|
60
94
|
if (!decryptionKey) throw new Error("MISSING DEEZER DECRYPTION KEY");
|
|
61
95
|
const crypto = await getCrypto();
|
|
62
|
-
const trackId =
|
|
96
|
+
const trackId = extractTrackId(track.url);
|
|
63
97
|
const trackHash = crypto.createHash("md5").update(trackId, "ascii").digest("hex");
|
|
64
98
|
const trackKey = Buffer.alloc(16);
|
|
65
99
|
for (let iter = 0; iter < 16; iter++)
|
|
@@ -153,7 +187,7 @@ function validate(query) {
|
|
|
153
187
|
}
|
|
154
188
|
|
|
155
189
|
// src/DeezerExtractor.ts
|
|
156
|
-
var DeezerExtractor = class extends
|
|
190
|
+
var DeezerExtractor = class extends import_discord_player2.BaseExtractor {
|
|
157
191
|
async activate() {
|
|
158
192
|
if (!this.options.decryptionKey) process.emitWarning("Decryption Key missing! This is needed for extracting streams.");
|
|
159
193
|
else {
|
|
@@ -161,15 +195,17 @@ var DeezerExtractor = class extends import_discord_player.BaseExtractor {
|
|
|
161
195
|
const randomToken = crypto.randomBytes(16).toString("hex");
|
|
162
196
|
const deezerUsrDataUrl = `https://www.deezer.com/ajax/gw-light.php?method=deezer.getUserData&input=3&api_version=1.0&api_token=${randomToken}`;
|
|
163
197
|
const usrDataRes = await fetch(deezerUsrDataUrl);
|
|
164
|
-
const cookie = usrDataRes.headers.get("set-cookie");
|
|
165
|
-
this.userInfo.cookie = cookie;
|
|
166
198
|
const usrData = await usrDataRes.json();
|
|
167
199
|
const licenseToken = usrData.results.USER.OPTIONS.license_token;
|
|
168
200
|
if (typeof licenseToken !== "string") throw new Error("Unable to get licenseToken");
|
|
169
|
-
this.userInfo.licenseToken = licenseToken;
|
|
170
201
|
const csrfToken = usrData.results.checkForm;
|
|
171
202
|
if (typeof csrfToken !== "string") throw new Error("Unable to get csrf token which is required for decryption");
|
|
172
|
-
this.userInfo
|
|
203
|
+
this.userInfo = {
|
|
204
|
+
mediaUrl: usrData.results.URL_MEDIA || "https://media.deezer.com",
|
|
205
|
+
cookie: usrDataRes.headers.get("set-cookie"),
|
|
206
|
+
licenseToken,
|
|
207
|
+
csrfToken
|
|
208
|
+
};
|
|
173
209
|
}
|
|
174
210
|
}
|
|
175
211
|
async validate(query) {
|
|
@@ -178,7 +214,7 @@ var DeezerExtractor = class extends import_discord_player.BaseExtractor {
|
|
|
178
214
|
buildPlaylistData(data, handleContext) {
|
|
179
215
|
const raw = data.url.split("/");
|
|
180
216
|
const identifier = raw[raw.length - 1].split("?")[0];
|
|
181
|
-
return new
|
|
217
|
+
return new import_discord_player2.Playlist(this.context.player, {
|
|
182
218
|
title: data.name,
|
|
183
219
|
thumbnail: data.thumbnail[0].url,
|
|
184
220
|
author: {
|
|
@@ -202,17 +238,24 @@ var DeezerExtractor = class extends import_discord_player.BaseExtractor {
|
|
|
202
238
|
}
|
|
203
239
|
throw new Error("Unable to get data from Deezer");
|
|
204
240
|
}
|
|
205
|
-
buildTrack(track,
|
|
206
|
-
return new
|
|
241
|
+
buildTrack(track, { requestedBy }) {
|
|
242
|
+
return new import_discord_player2.Track(this.context.player, {
|
|
207
243
|
title: track.name,
|
|
208
244
|
author: track.author.map((v) => v.name).join(", "),
|
|
209
245
|
url: track.url,
|
|
210
246
|
source: "arbitrary",
|
|
211
247
|
thumbnail: track.thumbnail[0].url,
|
|
212
|
-
duration:
|
|
213
|
-
requestedBy
|
|
248
|
+
duration: import_discord_player2.Util.buildTimeCode(import_discord_player2.Util.parseMS(track.duration)),
|
|
249
|
+
requestedBy
|
|
214
250
|
});
|
|
215
251
|
}
|
|
252
|
+
async bridge(track) {
|
|
253
|
+
const deezerTrack = await searchOneTrack(`${track.author} ${track.source === "youtube" ? track.cleanTitle : track.title}`);
|
|
254
|
+
if (!deezerTrack || !deezerTrack?.data[0]) return null;
|
|
255
|
+
const dpTrack = buildTrackFromSearch(deezerTrack, this.context.player, track.requestedBy);
|
|
256
|
+
const stream = this.stream(dpTrack[0]);
|
|
257
|
+
return stream;
|
|
258
|
+
}
|
|
216
259
|
stream(info) {
|
|
217
260
|
return streamTrack(info, this);
|
|
218
261
|
}
|
|
@@ -221,8 +264,11 @@ DeezerExtractor.identifier = "com.retrouser955.discord-player.deezr-ext";
|
|
|
221
264
|
// Annotate the CommonJS export names for ESM import in node:
|
|
222
265
|
0 && (module.exports = {
|
|
223
266
|
DeezerExtractor,
|
|
267
|
+
buildTrackFromSearch,
|
|
224
268
|
deezerRegex,
|
|
269
|
+
extractTrackId,
|
|
225
270
|
getCrypto,
|
|
271
|
+
searchOneTrack,
|
|
226
272
|
streamTrack,
|
|
227
273
|
validate
|
|
228
274
|
});
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "discord-player-deezer",
|
|
3
|
-
"version": "2.0.0-beta.
|
|
3
|
+
"version": "2.0.0-beta.4",
|
|
4
4
|
"description": "A custom extractor made for discord-player that enables you to extract from Deezer.",
|
|
5
5
|
"main": "dist/index.js",
|
|
6
6
|
"author": "retro_ig",
|
|
@@ -11,7 +11,6 @@
|
|
|
11
11
|
},
|
|
12
12
|
"devDependencies": {
|
|
13
13
|
"@discord-player/extractor": "^4.5.1",
|
|
14
|
-
"cross-env": "^7.0.3",
|
|
15
14
|
"discord-player": "^6.7.1",
|
|
16
15
|
"prettier": "^3.4.2",
|
|
17
16
|
"tslint": "^6.1.3",
|
|
@@ -22,7 +21,7 @@
|
|
|
22
21
|
"scripts": {
|
|
23
22
|
"build": "yarn lint && tsup",
|
|
24
23
|
"lint": "tslint -p tsconfig.json",
|
|
25
|
-
"npm:publish": "
|
|
24
|
+
"npm:publish": "yarn build && npm publish --access public"
|
|
26
25
|
},
|
|
27
26
|
"repository": {
|
|
28
27
|
"type": "git",
|
package/readme.md
CHANGED
|
@@ -1,65 +1,43 @@
|
|
|
1
|
-
# Discord Player Deezer
|
|
1
|
+
# Discord Player Deezer
|
|
2
2
|
|
|
3
|
-
Discord Player Deezer
|
|
3
|
+
Discord Player Deezer is a Deezer platform plugin for discord-player
|
|
4
4
|
|
|
5
|
-
|
|
5
|
+
# Installation
|
|
6
6
|
|
|
7
7
|
```bash
|
|
8
|
-
npm install discord-player-deezer
|
|
9
|
-
# or
|
|
10
|
-
yarn add discord-player-deezer
|
|
8
|
+
$ npm install discord-player-deezer
|
|
11
9
|
```
|
|
12
10
|
|
|
13
|
-
|
|
11
|
+
# Register the extractor
|
|
14
12
|
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
const player = getMainPlayerSomehow()
|
|
13
|
+
```ts
|
|
14
|
+
import { DeezerExtractor } from "discord-player-deezer"
|
|
15
|
+
import { Player } from "discord-player"
|
|
19
16
|
|
|
20
|
-
player
|
|
21
|
-
```
|
|
17
|
+
const player = new Player(...)
|
|
22
18
|
|
|
23
|
-
|
|
24
|
-
```
|
|
25
|
-
import { default as DeezerExtractor } from "discord-player-deezer"
|
|
19
|
+
await player.extractors.register(DeezerExtractor, {})
|
|
20
|
+
```
|
|
26
21
|
|
|
27
|
-
|
|
22
|
+
# Extracting Streams
|
|
28
23
|
|
|
29
|
-
|
|
30
|
-
```
|
|
24
|
+
As Deezer sends DMCA to repositories containing the hard-coded decryption key, it is not provided. You can find this key in the code of related projects (deezer downloaders) and your client-side JavaScript code.
|
|
31
25
|
|
|
32
|
-
### Typescript
|
|
33
26
|
```ts
|
|
34
|
-
import DeezerExtractor from "discord-player-deezer"
|
|
27
|
+
import { DeezerExtractor } from "discord-player-deezer"
|
|
28
|
+
import { Player } from "discord-player"
|
|
35
29
|
|
|
36
|
-
const player =
|
|
30
|
+
const player = new Player(...)
|
|
37
31
|
|
|
38
|
-
player.extractors.register(DeezerExtractor
|
|
32
|
+
await player.extractors.register(DeezerExtractor, {
|
|
33
|
+
decryptionKey: "master-decryption-key"
|
|
34
|
+
})
|
|
39
35
|
```
|
|
40
36
|
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
That's it! See the magic happen as you bot is now able to play from Deezer URLs
|
|
37
|
+
# Important information
|
|
44
38
|
|
|
45
|
-
|
|
39
|
+
As Node has migrated from openssl for decryption, we must use the `--openssl-legacy-provider` flag when starting our application with stream extraction
|
|
46
40
|
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
interface DeezerOptions {
|
|
50
|
-
forceEngine?: EngineType;
|
|
51
|
-
createStream?: () => Promise<string|Readable>;
|
|
52
|
-
beforeCreateStream?: () => Promise<unknown>|unknown;
|
|
53
|
-
}
|
|
54
|
-
```
|
|
55
|
-
One thing to keep in mind is, while using the two functions, if you want to access track data, you must you `useTrack()` function exported by the library. For example ...
|
|
56
|
-
|
|
57
|
-
```ts
|
|
58
|
-
player.extractors.register(DeezerExtractor, {
|
|
59
|
-
createStream: () => {
|
|
60
|
-
const track = useTrack()
|
|
61
|
-
|
|
62
|
-
return getStreamSomehow(track)
|
|
63
|
-
}
|
|
64
|
-
})
|
|
41
|
+
```bash
|
|
42
|
+
$ node --openssl-legacy-provider yourfile.js
|
|
65
43
|
```
|