discord-player-deezer 2.0.0-dev.9 → 2.1.0

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 CHANGED
@@ -21,6 +21,10 @@ type DeezerUserInfo = {
21
21
  csrfToken: string;
22
22
  mediaUrl: string;
23
23
  };
24
+ declare const Warnings: {
25
+ readonly MissingDecryption: "Decryption Key missing! This is needed for extracting streams.";
26
+ };
27
+ type Warnings = (typeof Warnings)[keyof typeof Warnings];
24
28
  declare class DeezerExtractor extends BaseExtractor<DeezerExtractorOptions> {
25
29
  static identifier: string;
26
30
  userInfo: DeezerUserInfo;
@@ -63,4 +67,4 @@ declare const deezerRegex: {
63
67
  };
64
68
  declare function validate(query: string): boolean;
65
69
 
66
- export { type ArrayOrObject, DeezerExtractor, type DeezerExtractorOptions, type DeezerSearchTrackResponse, type DeezerUserInfo, buildTrackFromSearch, deezerRegex, extractTrackId, getCrypto, searchOneTrack, streamTrack, validate };
70
+ export { type ArrayOrObject, DeezerExtractor, type DeezerExtractorOptions, type DeezerSearchTrackResponse, type DeezerUserInfo, Warnings, buildTrackFromSearch, deezerRegex, extractTrackId, getCrypto, searchOneTrack, streamTrack, validate };
package/dist/index.js CHANGED
@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
31
31
  var src_exports = {};
32
32
  __export(src_exports, {
33
33
  DeezerExtractor: () => DeezerExtractor,
34
+ Warnings: () => Warnings,
34
35
  buildTrackFromSearch: () => buildTrackFromSearch,
35
36
  deezerRegex: () => deezerRegex,
36
37
  extractTrackId: () => extractTrackId,
@@ -48,6 +49,7 @@ var import_deezer_music_metadata = require("@mithron/deezer-music-metadata");
48
49
  // src/utils/util.ts
49
50
  var import_discord_player = require("discord-player");
50
51
  var import_stream = require("stream");
52
+ var import_blowfish_node = __toESM(require("blowfish-node"));
51
53
  var IV = Buffer.from(Array.from({ length: 8 }, (_, x) => x));
52
54
  var rawCrypto;
53
55
  async function getCrypto() {
@@ -155,16 +157,13 @@ async function streamTrack(track, ext) {
155
157
  } else {
156
158
  buffer = Buffer.concat([buffer, chunk]);
157
159
  }
160
+ const blowfishDecrypter = new import_blowfish_node.default(new Uint8Array(trackKey), import_blowfish_node.default.MODE.CBC, import_blowfish_node.default.PADDING.NULL);
161
+ blowfishDecrypter.setIv(new Uint8Array(IV));
158
162
  while (buffer.length >= bufferSize) {
159
163
  const bufferSized = buffer.subarray(0, bufferSize);
160
164
  if (i % 3 === 0) {
161
- const decipher = crypto.createDecipheriv(
162
- "bf-cbc",
163
- trackKey,
164
- IV
165
- ).setAutoPadding(false);
166
- passThrough.write(decipher.update(bufferSized));
167
- passThrough.write(decipher.final());
165
+ const decipher = Buffer.from(blowfishDecrypter.decode(new Uint8Array(bufferSized), import_blowfish_node.default.TYPE.UINT8_ARRAY));
166
+ passThrough.write(decipher);
168
167
  } else {
169
168
  passThrough.write(bufferSized);
170
169
  }
@@ -185,9 +184,12 @@ function validate(query) {
185
184
  }
186
185
 
187
186
  // src/DeezerExtractor.ts
187
+ var Warnings = {
188
+ MissingDecryption: "Decryption Key missing! This is needed for extracting streams."
189
+ };
188
190
  var DeezerExtractor = class extends import_discord_player2.BaseExtractor {
189
191
  async activate() {
190
- if (!this.options.decryptionKey) process.emitWarning("Decryption Key missing! This is needed for extracting streams.");
192
+ if (!this.options.decryptionKey) process.emitWarning(Warnings.MissingDecryption);
191
193
  else {
192
194
  const crypto = await getCrypto();
193
195
  const randomToken = crypto.randomBytes(16).toString("hex");
@@ -229,6 +231,10 @@ var DeezerExtractor = class extends import_discord_player2.BaseExtractor {
229
231
  });
230
232
  }
231
233
  async handle(query, context) {
234
+ if (deezerRegex.share.test(query)) {
235
+ const redirect = await fetch(query);
236
+ query = redirect.url;
237
+ }
232
238
  const metadata = await (0, import_deezer_music_metadata.getData)(query);
233
239
  if (metadata?.type === "song") return this.createResponse(null, [this.buildTrack(metadata, context)]);
234
240
  if (metadata?.type === "playlist" || metadata?.type === "album") {
@@ -263,6 +269,7 @@ DeezerExtractor.identifier = "com.retrouser955.discord-player.deezr-ext";
263
269
  // Annotate the CommonJS export names for ESM import in node:
264
270
  0 && (module.exports = {
265
271
  DeezerExtractor,
272
+ Warnings,
266
273
  buildTrackFromSearch,
267
274
  deezerRegex,
268
275
  extractTrackId,
package/package.json CHANGED
@@ -1,13 +1,14 @@
1
1
  {
2
2
  "name": "discord-player-deezer",
3
- "version": "2.0.0-dev.9",
3
+ "version": "2.1.0",
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",
7
7
  "license": "MIT",
8
8
  "private": false,
9
9
  "dependencies": {
10
- "@mithron/deezer-music-metadata": "^1.0.3"
10
+ "@mithron/deezer-music-metadata": "^1.0.3",
11
+ "blowfish-node": "^1.1.4"
11
12
  },
12
13
  "devDependencies": {
13
14
  "@discord-player/extractor": "^4.5.1",
@@ -21,7 +22,8 @@
21
22
  "scripts": {
22
23
  "build": "yarn lint && tsup",
23
24
  "lint": "tslint -p tsconfig.json",
24
- "npm:publish": "yarn build && npm publish --access public"
25
+ "npm:publish": "yarn build && npm publish --access public",
26
+ "prepare": "tsup"
25
27
  },
26
28
  "repository": {
27
29
  "type": "git",
package/readme.md CHANGED
@@ -32,12 +32,4 @@ const player = new Player(...)
32
32
  await player.extractors.register(DeezerExtractor, {
33
33
  decryptionKey: "master-decryption-key"
34
34
  })
35
- ```
36
-
37
- # Important information
38
-
39
- As Node has migrated from openssl for decryption, we must use the `--openssl-legacy-provider` flag when starting our application with stream extraction
40
-
41
- ```bash
42
- $ node --openssl-legacy-provider yourfile.js
43
35
  ```
@@ -0,0 +1,131 @@
1
+ import { BaseExtractor, ExtractorSearchContext, ExtractorStreamable, Track, Playlist, Util as DPUtil, ExtractorInfo } from "discord-player"
2
+ import { Playlist as DeezerPlaylist, Track as DeezerTrack, getData } from "@mithron/deezer-music-metadata";
3
+ import { buildTrackFromSearch, deezerRegex, getCrypto, searchOneTrack, streamTrack, validate } from "./utils/util";
4
+
5
+ /**
6
+ * -------------------------------NOTICE-------------------------------------
7
+ * STREAMING CODE IS MAINLY TAKEN FROM https://github.com/PerformanC/NodeLink
8
+ * WHICH HAS THE "BSD 2-Clause "Simplified" License"
9
+ *
10
+ * PLEASE SHOW THE ORIGINAL AUTHOR SUPPORT BY STARING HIS GITHUB REPO
11
+ * --------------------------------------------------------------------------
12
+ */
13
+
14
+ export type DeezerExtractorOptions = {
15
+ decryptionKey?: string; // needed for decrypting deezer songs
16
+ createStream?: (track: Track, ext: DeezerExtractor) => Promise<ExtractorStreamable>
17
+ }
18
+
19
+ export type DeezerUserInfo = {
20
+ cookie: string;
21
+ licenseToken: string;
22
+ csrfToken: string;
23
+ mediaUrl: string;
24
+ }
25
+
26
+ export const Warnings = {
27
+ MissingDecryption: "Decryption Key missing! This is needed for extracting streams."
28
+ } as const
29
+ export type Warnings = (typeof Warnings)[keyof typeof Warnings]
30
+
31
+ export class DeezerExtractor extends BaseExtractor<DeezerExtractorOptions> {
32
+ static identifier: string = "com.retrouser955.discord-player.deezr-ext"
33
+ userInfo!: DeezerUserInfo
34
+
35
+ async activate(): Promise<void> {
36
+ if(!this.options.decryptionKey) process.emitWarning(Warnings.MissingDecryption)
37
+ else {
38
+ // extract deezer username
39
+ // dynamically load crypto because some might not want streaming
40
+ const crypto = await getCrypto()
41
+ const randomToken = crypto.randomBytes(16).toString("hex")
42
+ const deezerUsrDataUrl = `https://www.deezer.com/ajax/gw-light.php?method=deezer.getUserData&input=3&api_version=1.0&api_token=${randomToken}`
43
+
44
+ const usrDataRes = await fetch(deezerUsrDataUrl)
45
+ const usrData = await usrDataRes.json()
46
+
47
+ const licenseToken = usrData.results.USER.OPTIONS.license_token
48
+ if(typeof licenseToken !== "string") throw new Error("Unable to get licenseToken")
49
+
50
+ const csrfToken = usrData.results.checkForm
51
+ if(typeof csrfToken !== "string") throw new Error("Unable to get csrf token which is required for decryption")
52
+
53
+ this.userInfo = {
54
+ mediaUrl: usrData.results.URL_MEDIA || "https://media.deezer.com",
55
+ cookie: usrDataRes.headers.get("set-cookie")!,
56
+ licenseToken,
57
+ csrfToken
58
+ }
59
+
60
+ this.context.player.debug('USER INFO EXT: ' + JSON.stringify(this.userInfo))
61
+ }
62
+ }
63
+
64
+ async validate(query: string): Promise<boolean> {
65
+ return validate(query)
66
+ }
67
+
68
+ buildPlaylistData(data: DeezerPlaylist, handleContext: ExtractorSearchContext) {
69
+ const raw: string[] = data.url.split("/")
70
+ const identifier: string = raw[raw.length - 1].split("?")[0]
71
+
72
+ return new Playlist(this.context.player, {
73
+ title: data.name,
74
+ thumbnail: data.thumbnail[0].url,
75
+ author: {
76
+ name: data.artist.name,
77
+ url: data.artist.url
78
+ },
79
+ type: data.type,
80
+ tracks: data.tracks.map((v) => this.buildTrack(v, handleContext)),
81
+ description: "",
82
+ source: "arbitrary",
83
+ id: identifier,
84
+ url: data.url
85
+ })
86
+ }
87
+
88
+ async handle(query: string, context: ExtractorSearchContext): Promise<ExtractorInfo> {
89
+ if (deezerRegex.share.test(query)) {
90
+ const redirect = await fetch(query);
91
+ query = redirect.url; // follow the redirect of deezer page links
92
+ }
93
+ const metadata = await getData(query)
94
+
95
+ if(metadata?.type === "song") return this.createResponse(null, [this.buildTrack(metadata, context)])
96
+ if(metadata?.type === "playlist" || metadata?.type === "album") {
97
+ const playlist = this.buildPlaylistData(metadata, context)
98
+
99
+ return this.createResponse(playlist, playlist.tracks)
100
+ }
101
+
102
+ throw new Error("Unable to get data from Deezer")
103
+ }
104
+
105
+ buildTrack(track: DeezerTrack, { requestedBy }: ExtractorSearchContext) {
106
+ return new Track(this.context.player, {
107
+ title: track.name,
108
+ author: track.author.map((v) => v.name).join(", "),
109
+ url: track.url,
110
+ source: "arbitrary",
111
+ thumbnail: track.thumbnail[0].url,
112
+ duration: DPUtil.buildTimeCode(DPUtil.parseMS(track.duration)),
113
+ requestedBy
114
+ })
115
+ }
116
+
117
+ async bridge(track: Track): Promise<ExtractorStreamable | null> {
118
+ const deezerTrack = await searchOneTrack(`${track.author} ${track.source === "youtube" ? track.cleanTitle : track.title}`)
119
+
120
+ if(!deezerTrack) return null
121
+ const dpTrack = buildTrackFromSearch(deezerTrack, this.context.player, track.requestedBy)
122
+
123
+ const stream = this.stream(dpTrack[0])
124
+
125
+ return stream
126
+ }
127
+
128
+ stream(info: Track): Promise<ExtractorStreamable> {
129
+ return streamTrack(info, this)
130
+ }
131
+ }
package/src/index.ts ADDED
@@ -0,0 +1,2 @@
1
+ export * from "./DeezerExtractor"
2
+ export * from "./utils/util"
@@ -0,0 +1,194 @@
1
+ import { type Player, Track, Util } from "discord-player";
2
+ import type { DeezerExtractor } from "../DeezerExtractor";
3
+ import { Readable, PassThrough } from 'stream'
4
+ import type { BinaryLike, CipherGCMTypes, CipherKey, Decipher } from "crypto";
5
+ import Blowfish from "blowfish-node";
6
+
7
+ const IV = Buffer.from(Array.from({ length: 8 }, (_, x) => x))
8
+
9
+ let rawCrypto: typeof import("crypto")
10
+
11
+ export async function getCrypto() {
12
+ if (!rawCrypto) {
13
+ rawCrypto = await import("crypto")
14
+ return rawCrypto
15
+ }
16
+
17
+ return rawCrypto
18
+ }
19
+
20
+ const DeezerAPIRoutes = {
21
+ searchTrack(query: string, limit?: number) {
22
+ const url = `https://api.deezer.com/search/track?q=${encodeURIComponent(query)}&${limit ? `limit=${limit}` : ""}`
23
+
24
+ return url
25
+ }
26
+ } as const
27
+
28
+ export type ArrayOrObject<T> = T | T[]
29
+
30
+ export interface DeezerSearchTrackResponse {
31
+ data: {
32
+ link: string,
33
+ title: string,
34
+ album: {
35
+ cover_xl?: string,
36
+ cover_medium?: string,
37
+ cover_small?: string,
38
+ cover?: string
39
+ },
40
+ artist: {
41
+ name: string
42
+ },
43
+ duration: number, // in seconds
44
+ type: "track"
45
+ }[]
46
+ }
47
+
48
+ export function buildTrackFromSearch(track: DeezerSearchTrackResponse, player: Player, requestedBy?: Track['requestedBy']) {
49
+ const tracks = track.data.map((v) => new Track(player, {
50
+ source: "arbitrary",
51
+ duration: Util.buildTimeCode(Util.parseMS(v.duration * 1000)),
52
+ author: Array.isArray(v.artist) ? v.artist.map(a => a.name).join(", ") : v.artist.name,
53
+ url: v.link,
54
+ title: v.title,
55
+ thumbnail: v.album.cover_xl || v.album.cover_medium || v.album.cover || v.album.cover_small || "https://play-lh.googleusercontent.com/xtIOV8iPeAY4GrldTDo3CbLAEpbea2DqnfxaB4Nn2p5qz6KAiumY74qH86pgu1HA1A",
56
+ live: false,
57
+ requestedBy
58
+ }))
59
+
60
+ return tracks
61
+ }
62
+
63
+ export function extractTrackId(query: string) {
64
+ if (!validate(query)) throw new Error("Invalid track url")
65
+ const trackIdWithUrlParams = query.split("/").at(-1)
66
+ if (!trackIdWithUrlParams) throw new Error("Cannot find track ID")
67
+ return trackIdWithUrlParams.split("?")[0]
68
+ }
69
+
70
+ // used for bridging
71
+ export async function searchOneTrack(query: string) {
72
+ const url = DeezerAPIRoutes.searchTrack(query, 1)
73
+
74
+ const trackRes = await fetch(url)
75
+ if (trackRes.status !== 200) throw new Error("Fetch failed")
76
+
77
+ const trackData = await trackRes.json() as DeezerSearchTrackResponse | undefined
78
+ return trackData
79
+ }
80
+
81
+ export async function streamTrack(track: Track, ext: DeezerExtractor) {
82
+ const decryptionKey = ext.options.decryptionKey
83
+ if (!decryptionKey) throw new Error("MISSING DEEZER DECRYPTION KEY") // cant decrypt due to missing key
84
+
85
+ const crypto = await getCrypto()
86
+ const trackId = extractTrackId(track.url)
87
+
88
+ const trackHash = crypto.createHash("md5").update(trackId, "ascii").digest("hex")
89
+ const trackKey = Buffer.alloc(16)
90
+
91
+ for (let iter = 0; iter < 16; iter++)
92
+ /* tslint:disable-next-line no-bitwise */
93
+ trackKey.writeInt8(trackHash[iter].charCodeAt(0) ^ trackHash[iter + 16].charCodeAt(0) ^ decryptionKey[iter].charCodeAt(0), iter)
94
+
95
+ const trackInfoRes = await fetch(`https://www.deezer.com/ajax/gw-light.php?method=song.getListData&input=3&api_version=1.0&api_token=${ext.userInfo.csrfToken}`, {
96
+ method: "POST",
97
+ headers: {
98
+ Cookie: ext.userInfo.cookie,
99
+ 'User-Agent': "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:120.0) Gecko/20100101 Firefox/120.0",
100
+ 'DNT': '1'
101
+ },
102
+ body: JSON.stringify({
103
+ sng_ids: [trackId]
104
+ })
105
+ })
106
+
107
+ const songInfo = (await trackInfoRes.json()).results.data[0]
108
+
109
+ const streamInfoRes = await fetch('https://media.deezer.com/v1/get_url', {
110
+ method: "POST",
111
+ body: JSON.stringify({
112
+ license_token: ext.userInfo.licenseToken,
113
+ media: [{
114
+ type: 'FULL',
115
+ formats: [{
116
+ cipher: 'BF_CBC_STRIPE',
117
+ format: 'FLAC'
118
+ }, {
119
+ cipher: 'BF_CBC_STRIPE',
120
+ format: 'MP3_256'
121
+ }, {
122
+ cipher: 'BF_CBC_STRIPE',
123
+ format: 'MP3_128'
124
+ }, {
125
+ cipher: 'BF_CBC_STRIPE',
126
+ format: 'MP3_MISC'
127
+ }]
128
+ }],
129
+ track_tokens: [songInfo.TRACK_TOKEN]
130
+ })
131
+ })
132
+ const streamInfo = await streamInfoRes.json()
133
+
134
+ const trackMediaUrl = streamInfo.data[0].media[0].sources[0].url
135
+
136
+ ext.context.player.debug("DEEZER FOUND MEDIA URL " + trackMediaUrl)
137
+
138
+ const trackReq = await fetch(trackMediaUrl)
139
+ // @ts-ignore
140
+ const readable = Readable.fromWeb(trackReq.body)
141
+ let buffer = Buffer.alloc(0)
142
+ let i = 0
143
+
144
+ const bufferSize = 2048 // 2mb
145
+
146
+ const passThrough = new PassThrough()
147
+
148
+ readable.on("readable", () => {
149
+ let chunk = null;
150
+ while (true) {
151
+ chunk = readable.read(bufferSize)
152
+
153
+ if (!chunk) {
154
+ if (readable.readableLength) {
155
+ chunk = readable.read(readable.readableLength)
156
+ buffer = Buffer.concat([buffer, chunk])
157
+ }
158
+ break;
159
+ } else {
160
+ buffer = Buffer.concat([buffer, chunk])
161
+ }
162
+
163
+ const blowfishDecrypter = new Blowfish(new Uint8Array(trackKey), Blowfish.MODE.CBC, Blowfish.PADDING.NULL)
164
+ blowfishDecrypter.setIv(new Uint8Array(IV))
165
+
166
+ while (buffer.length >= bufferSize) {
167
+ const bufferSized = buffer.subarray(0, bufferSize)
168
+
169
+ if (i % 3 === 0) {
170
+ const decipher = Buffer.from(blowfishDecrypter.decode(new Uint8Array(bufferSized), Blowfish.TYPE.UINT8_ARRAY))
171
+ passThrough.write(decipher)
172
+ } else {
173
+ passThrough.write(bufferSized)
174
+ }
175
+
176
+ i++
177
+
178
+ buffer = buffer.subarray(bufferSize)
179
+ }
180
+ }
181
+ })
182
+
183
+ return passThrough
184
+ }
185
+
186
+ export const deezerRegex = {
187
+ track: /(^https:)\/\/(www\.)?deezer.com\/([a-zA-Z]+\/)?track\/[0-9]+/,
188
+ playlistNalbums: /(^https:)\/\/(www\.)?deezer.com\/[a-zA-Z]+\/(playlist|album)\/[0-9]+(\?)?(.*)/,
189
+ share: /(^https:)\/\/deezer\.page\.link\/[A-Za-z0-9]+/
190
+ } as const;
191
+
192
+ export function validate(query: string) {
193
+ return deezerRegex.track.test(query) ?? deezerRegex.playlistNalbums.test(query) ?? deezerRegex.share.test(query)
194
+ }