aqualink 2.19.0 → 2.20.0

package/build/structures/Rest.js

@@ -1,9 +1,7 @@
-'use strict'
-
-const { Buffer } = require('buffer')
-const { Agent: HttpsAgent, request: httpsRequest } = require('https')
-const { Agent: HttpAgent, request: httpRequest } = require('http')
-const http2 = require('http2')
+const { Buffer } = require('node:buffer')
+const { Agent: HttpsAgent, request: httpsRequest } = require('node:https')
+const { Agent: HttpAgent, request: httpRequest } = require('node:http')
+const http2 = require('node:http2')
 const {
   createBrotliDecompress,
   createUnzip,
@@ -11,7 +9,12 @@ const {
   unzipSync,
   createZstdDecompress,
   zstdDecompressSync
-} = require('zlib')
+} = require('node:zlib')
+
+let autoplayModule = null
+try {
+  autoplayModule = require('../handlers/autoplay')
+} catch {}
 
 const unrefTimer = (t) => {
   try {
@@ -147,7 +150,7 @@ class Rest {
       decodetracks: `${this._apiBase}/decodetracks`,
       stats: `${this._apiBase}/stats`,
       info: `${this._apiBase}/info`,
-      version: `${this._apiBase}/version`,
+      version: `/version`,
       routeplanner: Object.freeze({
         status: `${this._apiBase}/routeplanner/status`,
         freeAddress: `${this._apiBase}/routeplanner/free/address`,
@@ -173,6 +176,7 @@ class Rest {
     this.useHttp2 = !!aqua?.options?.useHttp2
     this._h2 = null
     this._h2Timer = null
+    this.calls = 0
   }
 
   _setupAgent(node) {
@@ -203,6 +207,10 @@ class Rest {
     this.agent = new (node.ssl ? HttpsAgent : HttpAgent)(opts)
     this.request = node.ssl ? httpsRequest : httpRequest
 
+    if (node.ssl && autoplayModule?.setSharedAgent) {
+      autoplayModule.setSharedAgent(this.agent)
+    }
+
     const origCreate = this.agent.createConnection.bind(this.agent)
     this.agent.createConnection = (options, cb) => {
       const socket = origCreate(options, cb)
@@ -249,6 +257,88 @@ class Rest {
     }
   }
 
+  _collectBody(stream, preallocSize = 0) {
+    return new Promise((resolve, reject) => {
+      let done = false
+      let size = 0
+      let prealloc =
+        preallocSize > 0 && preallocSize <= MAX_RESPONSE_SIZE
+          ? Buffer.allocUnsafe(preallocSize)
+          : null
+      let chunks = prealloc ? null : []
+
+      const finish = (ok, val) => {
+        if (done) return
+        done = true
+        prealloc = null
+        chunks = null
+        ok ? resolve(val) : reject(val)
+      }
+
+      stream.on('data', (chunk) => {
+        if (done) return
+        if (prealloc) {
+          if (size + chunk.length <= prealloc.length) {
+            chunk.copy(prealloc, size)
+            size += chunk.length
+          } else {
+            chunks = [prealloc.slice(0, size), chunk]
+            size += chunk.length
+            prealloc = null
+          }
+        } else {
+          size += chunk.length
+          chunks.push(chunk)
+        }
+        if (size > MAX_RESPONSE_SIZE) finish(false, ERRORS.RESPONSE_TOO_LARGE)
+      })
+
+      stream.once('error', (e) => finish(false, e))
+      stream.once('end', () => {
+        if (done) return
+        if (size === 0) return finish(true, null)
+        finish(
+          true,
+          prealloc
+            ? prealloc.slice(0, size)
+            : chunks.length === 1
+              ? chunks[0]
+              : Buffer.concat(chunks, size)
+        )
+      })
+    })
+  }
+
+  _parseResponseBuffer(
+    buffer,
+    status,
+    method,
+    url,
+    headers,
+    contentType,
+    statusMessage
+  ) {
+    if (!buffer) return null
+    if (buffer.length > MAX_RESPONSE_SIZE) throw ERRORS.RESPONSE_TOO_LARGE
+    let result
+    try {
+      result = _functions.parseBody(buffer, contentType, false)
+    } catch (e) {
+      throw new Error(`JSON parse error: ${e.message}`)
+    }
+    if (status >= 400) {
+      throw _functions.createHttpError(
+        status,
+        method,
+        url,
+        headers,
+        result,
+        statusMessage
+      )
+    }
+    return result
+  }
+
   async makeRequest(method, endpoint, body) {
     const url = `${this.baseUrl}${endpoint}`
     const payload =
@@ -259,6 +349,7 @@ class Rest {
           : JSON.stringify(body)
     const payloadLen = payload ? Buffer.byteLength(payload, UTF8) : 0
     const headers = this._buildHeaders(!!payload, payloadLen)
+    this.calls++
 
     try {
       const resp =
@@ -267,6 +358,7 @@ class Rest {
           : await this._h1Request(method, url, headers, payload)
       return resp
     } finally {
+      if (this.calls > 0) this.calls--
       this._returnHeaders(headers)
     }
   }
@@ -276,9 +368,6 @@ class Rest {
       let req,
         timer,
         done = false
-      let chunks = null,
-        size = 0,
-        prealloc = null
 
       const finish = (ok, val) => {
         if (done) return
@@ -287,7 +376,6 @@ class Rest {
           clearTimeout(timer)
           timer = null
         }
-        chunks = prealloc = null
         if (req && !ok) req.destroy()
         ok ? resolve(val) : reject(val)
       }
@@ -319,104 +407,63 @@ class Rest {
           const encoding = _functions.getEncodingType(
             res.headers['content-encoding']
           )
-
-          const handleResponse = (buffer) => {
-            if (buffer.length > MAX_RESPONSE_SIZE)
-              return finish(false, ERRORS.RESPONSE_TOO_LARGE)
-
+          const finalize = (buffer) => {
             try {
-              const result = _functions.parseBody(buffer, contentType, false)
-              if (status >= 400) {
-                finish(
-                  false,
-                  _functions.createHttpError(
-                    status,
-                    method,
-                    url,
-                    res.headers,
-                    result,
-                    res.statusMessage
-                  )
-                )
-              } else {
-                finish(true, result)
-              }
+              const result = this._parseResponseBuffer(
+                buffer,
+                status,
+                method,
+                url,
+                res.headers,
+                contentType,
+                res.statusMessage
+              )
+              finish(true, result)
             } catch (e) {
-              finish(false, new Error(`JSON parse error: ${e.message}`))
+              finish(false, e)
             }
           }
 
+          res.once('aborted', () => finish(false, ERRORS.RESPONSE_ABORTED))
+          res.once('error', (e) => finish(false, e))
+
           if (
             encoding !== ENCODING_NONE &&
             clInt > 0 &&
             clInt < COMPRESSION_MIN_SIZE
           ) {
-            const compressed = []
-            let csize = 0
-
-            res.on('data', (c) => {
-              csize += c.length
-              if (csize > MAX_RESPONSE_SIZE)
-                return finish(false, ERRORS.RESPONSE_TOO_LARGE)
-              compressed.push(c)
-            })
-            res.once('end', () => {
-              try {
-                handleResponse(
-                  _functions.decompressSync(Buffer.concat(compressed), encoding)
+            this._collectBody(res)
+              .then((compressed) => {
+                if (!compressed) return finish(true, null)
+                const decompressed = _functions.decompressSync(
+                  compressed,
+                  encoding
                 )
-              } catch (e) {
+                finalize(decompressed)
+              })
+              .catch((e) => {
                 finish(false, e)
-              }
-            })
-            res.once('aborted', () => finish(false, ERRORS.RESPONSE_ABORTED))
-            res.once('error', (e) => finish(false, e))
+              })
             return
           }
 
-          if (
-            encoding === ENCODING_NONE &&
-            clInt > 0 &&
-            clInt <= MAX_RESPONSE_SIZE
-          ) {
-            prealloc = Buffer.allocUnsafe(clInt)
-          } else {
-            chunks = []
-          }
-
           let stream = res
+          let preallocSize = 0
           if (encoding !== ENCODING_NONE) {
             const decomp = _functions.createDecompressor(encoding)
             decomp.once('error', (e) => finish(false, e))
             res.pipe(decomp)
             stream = decomp
+          } else if (clInt > 0 && clInt <= MAX_RESPONSE_SIZE) {
+            preallocSize = clInt
           }
 
-          res.once('aborted', () => finish(false, ERRORS.RESPONSE_ABORTED))
-          res.once('error', (e) => finish(false, e))
-
-          stream.on('data', (chunk) => {
-            if (prealloc) {
-              chunk.copy(prealloc, size)
-              size += chunk.length
-            } else {
-              size += chunk.length
-              if (size > MAX_RESPONSE_SIZE)
-                return finish(false, ERRORS.RESPONSE_TOO_LARGE)
-              chunks.push(chunk)
-            }
-          })
-
-          stream.once('end', () => {
-            if (size === 0) return finish(true, null)
-            handleResponse(
-              prealloc
-                ? prealloc.slice(0, size)
-                : chunks.length === 1
-                  ? chunks[0]
-                  : Buffer.concat(chunks, size)
-            )
-          })
+          this._collectBody(stream, preallocSize)
+            .then((buffer) => {
+              if (!buffer) return finish(true, null)
+              finalize(buffer)
+            })
+            .catch((e) => finish(false, e))
         }
       )
 
@@ -483,9 +530,6 @@ class Rest {
       let req,
         timer,
         done = false
-      let chunks = null,
-        size = 0,
-        prealloc = null
 
       const finish = (ok, val) => {
         if (done) return
@@ -494,7 +538,6 @@ class Rest {
           clearTimeout(timer)
           timer = null
         }
-        chunks = prealloc = null
         if (req && !ok) req.close(http2.constants.NGHTTP2_CANCEL)
         ok ? resolve(val) : reject(val)
       }
@@ -536,15 +579,20 @@ class Rest {
         }
 
         const encoding = _functions.getEncodingType(rh['content-encoding'])
-
-        if (
-          encoding === ENCODING_NONE &&
-          clInt > 0 &&
-          clInt <= MAX_RESPONSE_SIZE
-        ) {
-          prealloc = Buffer.allocUnsafe(clInt)
-        } else {
-          chunks = []
+        const finalize = (buffer) => {
+          try {
+            const result = this._parseResponseBuffer(
+              buffer,
+              status,
+              method,
+              this.baseUrl + path,
+              rh,
+              contentType
+            )
+            finish(true, result)
+          } catch (e) {
+            finish(false, e)
+          }
         }
 
         const decomp =
@@ -552,51 +600,19 @@ class Rest {
             ? _functions.createDecompressor(encoding)
             : null
         const stream = decomp ? req.pipe(decomp) : req
+        const preallocSize =
+          encoding === ENCODING_NONE && clInt > 0 && clInt <= MAX_RESPONSE_SIZE
+            ? clInt
+            : 0
 
         if (decomp) decomp.once('error', (e) => finish(false, e))
         req.once('error', (e) => finish(false, e))
-
-        stream.on('data', (chunk) => {
-          if (prealloc) {
-            chunk.copy(prealloc, size)
-            size += chunk.length
-          } else {
-            size += chunk.length
-            if (size > MAX_RESPONSE_SIZE)
-              return finish(false, ERRORS.RESPONSE_TOO_LARGE)
-            chunks.push(chunk)
-          }
-        })
-
-        stream.once('end', () => {
-          if (size === 0) return finish(true, null)
-
-          const buffer = prealloc
-            ? prealloc.slice(0, size)
-            : chunks.length === 1
-              ? chunks[0]
-              : Buffer.concat(chunks, size)
-
-          try {
-            const result = _functions.parseBody(buffer, contentType, false)
-            if (status >= 400) {
-              finish(
-                false,
-                _functions.createHttpError(
-                  status,
-                  method,
-                  this.baseUrl + path,
-                  rh,
-                  result
-                )
-              )
-            } else {
-              finish(true, result)
-            }
-          } catch (e) {
-            finish(false, new Error(`JSON parse error: ${e.message}`))
-          }
-        })
+        this._collectBody(stream, preallocSize)
+          .then((buffer) => {
+            if (!buffer) return finish(true, null)
+            finalize(buffer)
+          })
+          .catch((e) => finish(false, e))
       })
 
       timer = setTimeout(
@@ -844,6 +860,7 @@ class Rest {
       this.defaultHeaders =
       this._endpoints =
         null
+    this.calls = 0
   }
 }
 

package/build/structures/Track.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const YT_ID_REGEX =
   /(?:[?&]v=|youtu\.be\/|\/embed\/|\/shorts\/)([A-Za-z0-9_-]{11})/
 
@@ -30,10 +28,12 @@ class Track {
     this.nodes = data.nodes || null
     this.requester = requester || null
     this._infoCache = null
+    this._artworkCache = undefined // undefined = not computed, null = computed but no artwork
   }
 
   get info() {
-    return (this._infoCache ||= Object.freeze({
+    if (this._infoCache) return this._infoCache
+    this._infoCache = Object.freeze({
       identifier: this.identifier,
       isSeekable: this.isSeekable,
       position: this.position,
@@ -44,7 +44,8 @@ class Track {
       uri: this.uri,
       sourceName: this.sourceName,
       artworkUrl: this.artworkUrl || this._computeArtwork()
-    }))
+    })
+    return this._infoCache
   }
 
   get length() {
@@ -52,7 +53,10 @@ class Track {
   }
 
   get thumbnail() {
-    return this.artworkUrl || this._computeArtwork()
+    if (this.artworkUrl) return this.artworkUrl
+    if (this._artworkCache !== undefined) return this._artworkCache
+    this._artworkCache = this._computeArtwork()
+    return this._artworkCache
   }
 
   async resolve(aqua, opts = {}) {
@@ -140,10 +144,13 @@ class Track {
 
   _computeArtwork() {
     if (this.artworkUrl) return this.artworkUrl
+    if (this._artworkCache !== undefined) return this._artworkCache
     const id = this.identifier || (this.uri && YT_ID_REGEX.exec(this.uri)?.[1])
     if (id && this.sourceName?.includes('youtube')) {
-      return `https://i.ytimg.com/vi/${id}/hqdefault.jpg`
+      this._artworkCache = `https://i.ytimg.com/vi/${id}/hqdefault.jpg`
+      return this._artworkCache
     }
+    this._artworkCache = null
     return null
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "2.19.0",
+  "version": "2.20.0",
   "description": "An Lavalink/Nodelink client, focused in pure performance and features",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -45,8 +45,7 @@
   },
   "homepage": "https://aqualink-6006388d.mintlify.app/",
   "dependencies": {
-    "ws": "^8.19.0",
-    "tseep": "^1.3.1"
+    "ws": "^8.19.0"
   },
   "contributors": [
     {
@@ -68,4 +67,4 @@
       "url": "https://github.com/ToddyTheNoobDud"
     }
   ]
-}
+}