@doitian/dsh-music 0.1.1 → 0.1.4

package/lib/netease.js

@@ -14,6 +14,8 @@
  *   - `api/toplist`                   anonymous OK
  *   - `api/discovery/simiSong`        anonymous OK
  *   - `api/personalized/newsong`      anonymous OK
+ *   - `api/song/like`                 POST: like / un-like, needs a session
+ *   - `api/song/like/check`           which of these ids the account liked
  *   - `api/login/qrcode/*`            QR login handshake
  *
  * @module dsh-music/netease
@@ -294,21 +296,37 @@ export class Netease {
 
   /**
    * Raw streaming fetch, used by the audio proxy. The caller owns the body.
+   *
+   * The deadline covers only the connect and the response headers. The body
+   * then streams for as long as the browser keeps reading — potentially the
+   * whole track, because the element pauses and resumes its reads as its
+   * buffer fills and drains. A whole-request timeout here (`AbortSignal`
+   * watches the body too) used to cut every stream still open at that point;
+   * the panel read the truncation as a failed track and skipped mid-song. A
+   * body that stops flowing is still bounded by undici's own idle timeout.
+   *
    * @returns {Promise<Response>}
    */
-  async fetchAudio(url, { range, method = 'GET' } = {}) {
+  async fetchAudio(url, { range, method = 'GET', headerTimeoutMs = 30_000 } = {}) {
     const headers = {
       Referer: `${API_ORIGIN}/`,
       'User-Agent': UA,
       Cookie: this.jar.header(),
     };
     if (range) headers.Range = range;
-    const response = await fetch(url, {
-      method,
-      headers,
-      redirect: 'follow',
-      signal: AbortSignal.timeout(30_000),
-    });
+    const controller = new AbortController();
+    const deadline = setTimeout(() => controller.abort(), headerTimeoutMs);
+    let response;
+    try {
+      response = await fetch(url, {
+        method,
+        headers,
+        redirect: 'follow',
+        signal: controller.signal,
+      });
+    } finally {
+      clearTimeout(deadline);
+    }
     this.jar.absorb(response);
     return response;
   }
@@ -528,6 +546,78 @@ export class Netease {
     return normalizeTracks(data?.data);
   }
 
+  // ------------------------------------------------------------------ likes
+
+  /**
+   * Like or un-like one track on the account.
+   *
+   * `/api/song/like` is one of the few *write* endpoints the plain web API
+   * still serves unencrypted — it answers `{playlistId, code: 200}` and puts the
+   * track in (or takes it out of) the account's 我喜欢的音乐 playlist. It takes
+   * the direction rather than toggling, so the caller must know which one it
+   * means; ask {@link likedIds} when it does not.
+   *
+   * A refusal is reported, not thrown: an anonymous session answers `code: 301`
+   * and a delisted track answers `code: 400` with NetEase's own reason
+   * ("歌曲已经下架了"), and both are ordinary outcomes of a click. Only a
+   * transport failure throws.
+   *
+   * @param {number|string} id track id.
+   * @param {boolean} like `true` to like, `false` to remove the like.
+   */
+  async likeSong(id, like = true) {
+    const trackId = Number(id);
+    if (!Number.isFinite(trackId)) {
+      return { ok: false, id, code: 'BAD_ID', reason: `invalid track id "${id}"` };
+    }
+    const data = await this.call('/api/song/like', {
+      method: 'POST',
+      query: { trackId, like: Boolean(like) },
+    });
+    if (Number(data?.code) !== 200) {
+      return {
+        ok: false,
+        id: trackId,
+        code: data?.code ?? 'UNKNOWN',
+        reason:
+          data?.message ||
+          data?.msg ||
+          (this.authenticated ? 'NetEase refused the change' : 'sign in to NetEase first'),
+      };
+    }
+    return { ok: true, id: trackId, liked: Boolean(like), playlistId: data?.playlistId ?? null };
+  }
+
+  /**
+   * Which of these tracks the account has liked.
+   *
+   * `/api/song/like/check` answers `{ids: [...the liked subset...]}`, so one
+   * request covers a whole queue. An anonymous session answers `code: 301` for
+   * every id — a refusal, not "nothing is liked" — and comes back as
+   * `ok: false` so a caller never caches it as an answer.
+   *
+   * @param {Iterable<number|string>} ids
+   * @returns {Promise<{ok: boolean, ids: number[], code?: number|string, reason?: string}>}
+   */
+  async likedIds(ids) {
+    const list = [...new Set([...ids].map(Number).filter(Number.isFinite))];
+    // NetEase answers an empty batch with `code: 400`, and an empty question has
+    // no answer to fetch anyway.
+    if (list.length === 0) return { ok: true, ids: [] };
+    const data = await this.call('/api/song/like/check', {
+      query: { trackIds: JSON.stringify(list) },
+    });
+    if (Number(data?.code) !== 200 || !Array.isArray(data?.ids)) {
+      return {
+        ok: false,
+        ids: [],
+        code: data?.code ?? 'UNKNOWN',
+        reason: data?.message || data?.msg || 'NetEase refused the like check',
+      };
+    }
+    return { ok: true, ids: data.ids.map(Number) };
+  }
+
   // -------------------------------------------------------------- account
 
   /** Account summary; `null` when the session is anonymous or expired. */
@@ -561,9 +651,32 @@ export class Netease {
       cover: resizeImage(item.coverImgUrl, 300),
       trackCount: item.trackCount ?? 0,
       subscribed: Boolean(item.subscribed),
+      /** `5` marks 我喜欢的音乐 — the account's likes, as a playlist. */
+      specialType: item.specialType ?? 0,
     }));
   }
 
+  /**
+   * Every track id in the account's 我喜欢的音乐 playlist, or `null` when there
+   * is no account or no such playlist.
+   *
+   * This is the whole like state in one read, which is what makes it useful for
+   * reconciling a local mirror; use {@link likedIds} to ask about specific
+   * tracks. The playlist's length is not capped by `n` — NetEase returns the
+   * complete `trackIds` list — so one request covers a library of any size.
+   *
+   * @param {number|string} [uid] owner; defaults to the fetched account.
+   */
+  async likedPlaylistIds(uid) {
+    const owner = Number(uid ?? this.account?.uid);
+    if (!Number.isFinite(owner)) return null;
+    const playlists = await this.userPlaylists(owner, { limit: 1000 });
+    const liked = playlists.find((playlist) => playlist.specialType === 5);
+    if (!liked) return null;
+    const detail = await this.call('/api/v6/playlist/detail', { query: { id: liked.id, n: 1 } });
+    return (detail?.playlist?.trackIds ?? []).map((entry) => entry.id).filter(Number.isFinite);
+  }
+
   // ------------------------------------------------------------ QR login
 
   /**