10549808448

Committed 25 Aug 2024 08:15PM UTC coverage: 87.115% (-4.1%) from 91.214%

Build # 10549808448

Build Type

Pull #968

github

Committed by

Borewit

Commit Message

Replace "got" HTTP-client with fetch API

Pull Request Pull Request #968: Replace "got" HTTP-client with fetch API, improving browser compatibility

Run Details

40 of 47 branches covered (85.11%)

Branch coverage included in aggregate %.

103 of 139 new or added lines in 4 files covered. (74.1%)

67 existing lines in 2 files now uncovered.

1373 of 1575 relevant lines covered (87.17%)

7.78 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

75.09

/lib/musicbrainz-api.ts

import { StatusCodes as HttpStatus } from 'http-status-codes';
import Debug from 'debug';

export { XmlMetadata } from './xml/xml-metadata.js';
export { XmlIsrc } from './xml/xml-isrc.js';
export { XmlIsrcList } from './xml/xml-isrc-list.js';
export { XmlRecording } from './xml/xml-recording.js';

import type { XmlMetadata } from './xml/xml-metadata.js';
import { DigestAuth } from './digest-auth.js';

import { RateLimitThreshold } from 'rate-limit-threshold';
import * as mb from './musicbrainz.types.js';
import {HttpClient, type HttpFormData} from "./httpClient.js";

export * from './musicbrainz.types.js';

/*
 * https://musicbrainz.org/doc/Development/XML_Web_Service/Version_2#Subqueries
 */

export type RelationsIncludes =
  'area-rels'
  | 'artist-rels'
  | 'event-rels'
  | 'instrument-rels'
  | 'label-rels'
  | 'place-rels'
  | 'recording-rels'
  | 'release-rels'
  | 'release-group-rels'
  | 'series-rels'
  | 'url-rels'
  | 'work-rels';

export type SubQueryIncludes =
  /**
   * include discids for all media in the releases
   */
  'discids'
  /**
   * include media for all releases, this includes the # of tracks on each medium and its format.
   */
  | 'media'
  /**
   * include isrcs for all recordings
   */
  | 'isrcs'
  /**
   * include artists credits for all releases and recordings
   */
  | 'artist-credits'
  /**
   * include only those releases where the artist appears on one of the tracks, only valid on artists in combination with `releases`
   */
  | 'various-artists';

export type MiscIncludes =
  'aliases'
  | 'annotation'
  | 'tags'
  | 'genres'
  | 'ratings'
  | 'media';

export type AreaIncludes = MiscIncludes | RelationsIncludes;

export type ArtistIncludes =
  MiscIncludes
  | RelationsIncludes
  | 'recordings'
  | 'releases'
  | 'release-groups'
  | 'works';

export type CollectionIncludes =
  MiscIncludes
  | RelationsIncludes
  | 'user-collections';

export type EventIncludes = MiscIncludes | RelationsIncludes;

export type GenreIncludes = MiscIncludes;

export type InstrumentIncludes = MiscIncludes | RelationsIncludes;

export type LabelIncludes =
  MiscIncludes
  | RelationsIncludes
  | 'releases';

export type PlaceIncludes = MiscIncludes | RelationsIncludes;

export type RecordingIncludes =
  MiscIncludes
  | RelationsIncludes
  | SubQueryIncludes
  | 'artists'
  | 'releases'
  | 'isrcs';

export type ReleaseIncludes =
  MiscIncludes
  | SubQueryIncludes
  | RelationsIncludes
  | 'artists'
  | 'collections'
  | 'labels'
  | 'recordings'
  | 'release-groups';

export type ReleaseGroupIncludes =
  MiscIncludes
  | SubQueryIncludes
  | RelationsIncludes
  | 'artists'
  | 'releases';

export type SeriesIncludes = MiscIncludes | RelationsIncludes;

export type WorkIncludes = MiscIncludes | RelationsIncludes;

export type UrlIncludes = RelationsIncludes;

export type IFormData = {[key: string]: string | number};

const debug = Debug('musicbrainz-api');

export interface IMusicBrainzConfig {
  botAccount?: {
    username?: string,
    password?: string
  },
  baseUrl: string,

  appName?: string,
  appVersion?: string,

  /**
   * HTTP Proxy
   */
  proxy?: string,

  /**
   * User e-mail address or application URL
   */
  appContactInfo?: string,

  disableRateLimiting?: boolean
}

export interface ICsrfSession {
  sessionKey: string;
  token: string;
}

export interface ISessionInformation {
  csrf: ICsrfSession,
  loggedIn?: boolean;
}

export class MusicBrainzApi {

  public readonly config: IMusicBrainzConfig = {
    baseUrl: 'https://musicbrainz.org'
  };

  private rateLimiter: RateLimitThreshold;
  private httpClient: HttpClient;
  private session?: ISessionInformation;

  public static fetchCsrf(html: string): ICsrfSession {
    return {
      sessionKey: MusicBrainzApi.fetchValue(html, 'csrf_session_key') as string,
      token: MusicBrainzApi.fetchValue(html, 'csrf_token') as string
    };
  }

  private static fetchValue(html: string, key: string): string | undefined{
    let pos = html.indexOf(`name="${key}"`);
    if (pos >= 0) {
      pos = html.indexOf('value="', pos + key.length + 7);
      if (pos >= 0) {
        pos += 7;
        const endValuePos = html.indexOf('"', pos);
        return html.substring(pos, endValuePos);
      }
    }
  }

  public constructor(_config?: IMusicBrainzConfig) {

    Object.assign(this.config, _config);

    this.httpClient = new HttpClient({
      baseUrl: this.config.baseUrl,
      timeout: 20 * 1000,
      userAgent: `${this.config.appName}/${this.config.appVersion} ( ${this.config.appContactInfo} )`
    });

    this.rateLimiter = new RateLimitThreshold(15, 18);
  }

  public async restGet<T>(relUrl: string, query: { [key: string]: string; } = {}): Promise<T> {

    query.fmt = 'json';

    await this.applyRateLimiter();

    const response = await this.httpClient.get(`ws/2${relUrl}`, {
      query,
      retryLimit: 10
    });
    return response.json();
  }

  /**
   * Lookup entity
   * @param entity 'area', 'artist', collection', 'instrument', 'label', 'place', 'release', 'release-group', 'recording', 'series', 'work', 'url' or 'event'
   * @param mbid Entity MBID
   * @param inc Query, like: {<entity>: <MBID:}
   */
  public lookup(entity: 'area', mbid: string, inc?: AreaIncludes[]): Promise<mb.IArea>;
  public lookup(entity: 'artist', mbid: string, inc?: ArtistIncludes[]): Promise<mb.IArtist>;
  public lookup(entity: 'collection', mbid: string, inc?: CollectionIncludes[]): Promise<mb.ICollection>;
  public lookup(entity: 'instrument', mbid: string, inc?: InstrumentIncludes[]): Promise<mb.IInstrument>;
  public lookup(entity: 'label', mbid: string, inc?: LabelIncludes[]): Promise<mb.ILabel>;
  public lookup(entity: 'place', mbid: string, inc?: PlaceIncludes[]): Promise<mb.IPlace>;
  public lookup(entity: 'release', mbid: string, inc?: ReleaseIncludes[]): Promise<mb.IRelease>;
  public lookup(entity: 'release-group', mbid: string, inc?: ReleaseGroupIncludes[]): Promise<mb.IReleaseGroup>;
  public lookup(entity: 'recording', mbid: string, inc?: RecordingIncludes[]): Promise<mb.IRecording>;
  public lookup(entity: 'series', mbid: string, inc?: SeriesIncludes[]): Promise<mb.ISeries>;
  public lookup(entity: 'work', mbid: string, inc?: WorkIncludes[]): Promise<mb.IWork>;
  public lookup(entity: 'url', mbid: string, inc?: UrlIncludes[]): Promise<mb.IUrl>;
  public lookup(entity: 'event', mbid: string, inc?: EventIncludes[]): Promise<mb.IEvent>;
  public lookup<T, I extends string = never>(entity: mb.EntityType, mbid: string, inc: I[] = []): Promise<T> {
    return this.restGet<T>(`/${entity}/${mbid}`, {inc: inc.join(' ')});
  }

  /**
   * Browse entity
   * https://wiki.musicbrainz.org/MusicBrainz_API#Browse
   * https://wiki.musicbrainz.org/MusicBrainz_API#Linked_entities
   * https://wiki.musicbrainz.org/Development/JSON_Web_Service#Browse_Requests
   * For example: http://musicbrainz.org/ws/2/release?label=47e718e1-7ee4-460c-b1cc-1192a841c6e5&offset=12&limit=2
   * @param entity MusicBrainz entity
   * @param query Query, like: {<entity>: <MBID:}
   */
  public browse(entity: 'area', query?: mb.IBrowseAreasQuery): Promise<mb.IBrowseAreasResult>;
  public browse(entity: 'artist', query?: mb.IBrowseArtistsQuery): Promise<mb.IBrowseArtistsResult>;
  public browse(entity: 'collection', query?: mb.IBrowseCollectionsQuery): Promise<mb.IBrowseCollectionsResult> ;
  public browse(entity: 'event', query?: mb.IBrowseEventsQuery): Promise<mb.IBrowseEventsResult>;
  public browse(entity: 'label', query?: mb.IBrowseLabelsQuery): Promise<mb.IBrowseLabelsResult>;
  public browse(entity: 'instrument', query?: mb.IBrowseInstrumentsQuery): Promise<mb.IBrowseInstrumentsResult>;
  public browse(entity: 'place', query?: mb.IBrowsePlacesQuery): Promise<mb.IBrowsePlacesResult>;
  public browse(entity: 'recording', query?: mb.IBrowseRecordingsQuery): Promise<mb.IBrowseRecordingsResult>;
  public browse(entity: 'release', query?: mb.IBrowseReleasesQuery): Promise<mb.IBrowseReleasesResult>;
  public browse(entity: 'release-group', query?: mb.IBrowseReleaseGroupsQuery): Promise<mb.IBrowseReleaseGroupsResult>;
  public browse(entity: 'series', query?: mb.IBrowseSeriesQuery): Promise<mb.IBrowseSeriesResult>;
  public browse(entity: 'url', query?: mb.IBrowseUrlsQuery): Promise<mb.IUrl>;
  public browse(entity: 'work', query?: mb.IBrowseWorksQuery): Promise<mb.IBrowseWorksResult>;
  public browse<T>(entity: mb.EntityType, query?: { [key: string]: any; }): Promise<T> {
    return this.restGet<T>(`/${entity}`, query);
  }

  // -----------------------------------------------------------------------------------------------------------------
  // Query functions
  // -----------------------------------------------------------------------------------------------------------------

  /**
   * Search an entity using a search query
   * @param query e.g.: '" artist: Madonna, track: Like a virgin"' or object with search terms: {artist: Madonna}
   * @param entity e.g. 'recording'
   * @param query Arguments
   */
  public search(entity:'area', query: mb.ISearchQuery<AreaIncludes> & mb.ILinkedEntitiesArea): Promise<mb.IAreaList>;
  public search(artist:'artist', query: mb.ISearchQuery<ArtistIncludes> & mb.ILinkedEntitiesArea): Promise<mb.IArtistList>;
  public search(artist:'recording', query: mb.ISearchQuery<AreaIncludes> & mb.ILinkedEntitiesArea): Promise<mb.IRecordingList>;
  public search(artist:'release', query: mb.ISearchQuery<ReleaseIncludes> & mb.ILinkedEntitiesArea): Promise<mb.IReleaseList>;
  public search(artist:'release-group', query: mb.ISearchQuery<ReleaseGroupIncludes> & mb.ILinkedEntitiesArea): Promise<mb.IReleaseGroupList>;
  public search(artist:'url', query: mb.ISearchQuery<UrlIncludes> & mb.ILinkedEntitiesArea): Promise<mb.IUrlList>;
  public search<T extends mb.ISearchResult, I extends string = never>(entity: mb.EntityType, query: mb.ISearchQuery<I>): Promise<T> {
    const urlQuery: any = {...query};
    if (typeof query.query === 'object') {
      urlQuery.query = makeAndQueryString(query.query);
    }
    if (Array.isArray(query.inc)) {
      urlQuery.inc = urlQuery.inc.join(' ');
    }
    return this.restGet<T>(`/${entity}/`, urlQuery);
  }

  // ---------------------------------------------------------------------------

  public async postRecording(xmlMetadata: XmlMetadata): Promise<void> {
    return this.post('recording', xmlMetadata);
  }

  public async post(entity: mb.EntityType, xmlMetadata: XmlMetadata): Promise<void> {

    if (!this.config.appName || !this.config.appVersion) {
      throw new Error("XML-Post requires the appName & appVersion to be defined");
    }

    const clientId = `${this.config.appName.replace(/-/g, '.')}-${this.config.appVersion}`;

    const path = `ws/2/${entity}/`;
    // Get digest challenge

    let digest = '';
    let n = 1;
    const postData = xmlMetadata.toXml();

    do {
      await this.applyRateLimiter();
      const response: any = await this.httpClient.post(path, {
        query: {client: clientId},
        headers: {
          authorization: digest,
          'Content-Type': 'application/xml'
        },
        body: postData
      });

      if (response.statusCode === HttpStatus.UNAUTHORIZED) {
        // Respond to digest challenge
        const auth = new DigestAuth(this.config.botAccount as {username: string, password: string});
        const relPath = response.requestUrl.pathname; // Ensure path is relative
        digest = auth.digest(response.request.method, relPath as string, response.headers['www-authenticate']);
        ++n;
      } else {
        break;
      }
    } while (n++ < 5);
  }

  public async login(): Promise<boolean> {

    if(!this.config.botAccount?.username) throw new Error('bot username should be set');
    if(!this.config.botAccount?.password) throw new Error('bot password should be set');

    if (this.session?.loggedIn) {
      const cookies = await this.httpClient.getCookies();
      return cookies.indexOf('musicbrainz_server_session') !== -1;
    }
    this.session = await this.getSession();

    const redirectUri = '/success';

    const formData: HttpFormData = {
      username: this.config.botAccount.username,
      password: this.config.botAccount.password,
      csrf_session_key: this.session.csrf.sessionKey,
      csrf_token: this.session.csrf.token,
      remember_me: '1'
    };

    const response = await this.httpClient.postForm('login', formData, {
        query: {
          returnto: redirectUri
        },
        followRedirects: false
    });

    const success = response.status === HttpStatus.MOVED_TEMPORARILY && response.headers.get('location') === redirectUri;
    if (success) {
      this.session.loggedIn = true;
    }
    return success;
  }

  /**
   * Logout
   */
  public async logout(): Promise<boolean> {
    const redirectUri = '/success';

    const response = await this.httpClient.post('logout', {
      followRedirects: false,
      query: {
        returnto: redirectUri
      }
    });
    const success = response.status === HttpStatus.MOVED_TEMPORARILY && response.headers.get('location') === redirectUri;
    if (success && this.session) {
      this.session.loggedIn = true;
    }
    return success;
  }

  /**
   * Submit entity
   * @param entity Entity type e.g. 'recording'
   * @param mbid
   * @param formData
   */
  public async editEntity(entity: mb.EntityType, mbid: string, formData: Record<string, any>): Promise<void> {

    await this.applyRateLimiter();

    this.session = await this.getSession();

    formData.csrf_session_key = this.session.csrf.sessionKey;
    formData.csrf_token = this.session.csrf.token;
    formData.username = this.config.botAccount?.username;
    formData.password = this.config.botAccount?.password;
    formData.remember_me = 1;

    const response = await this.httpClient.postForm(`${entity}/${mbid}/edit`, formData, {
      followRedirects: false
    });
    if (response.status === HttpStatus.OK)
      throw new Error("Failed to submit form data");
    if (response.status === HttpStatus.MOVED_TEMPORARILY)
      return;
    throw new Error(`Unexpected status code: ${response.status}`);
  }

  /**
   * Set URL to recording
   * @param recording Recording to update
   * @param url2add URL to add to the recording
   * @param editNote Edit note
   */
  public async addUrlToRecording(recording: mb.IRecording, url2add: { linkTypeId: mb.LinkType, text: string }, editNote = '') {

    const formData: {[key: string]: string | boolean | number} = {};

    formData['edit-recording.name'] = recording.title; // Required
    formData['edit-recording.comment'] = recording.disambiguation;
    formData['edit-recording.make_votable'] = true;

    formData['edit-recording.url.0.link_type_id'] = url2add.linkTypeId;
    formData['edit-recording.url.0.text'] = url2add.text;

    recording.isrcs?.forEach((isrcs, i) => {
      formData[`edit-recording.isrcs.${i}`] = isrcs;
    });

    formData['edit-recording.edit_note'] = editNote;

    return this.editEntity('recording', recording.id, formData);
  }

  /**
   * Add ISRC to recording
   * @param recording Recording to update
   * @param isrc ISRC code to add
   */
  public async addIsrc(recording: mb.IRecording, isrc: string) {

    const formData: IFormData = {};

    formData["edit-recording.name"] = recording.title; // Required

    if (!recording.isrcs) {
      throw new Error('You must retrieve recording with existing ISRC values');
    }

    if (recording.isrcs.indexOf(isrc) === -1) {
      recording.isrcs.push(isrc);

      for (const i in recording.isrcs) {
        formData[`edit-recording.isrcs.${i}`] = recording.isrcs[i];
      }
      return this.editEntity('recording', recording.id, formData);
    }
  }


  // -----------------------------------------------------------------------------------------------------------------
  // Helper functions
  // -----------------------------------------------------------------------------------------------------------------

  /**
   * Add Spotify-ID to MusicBrainz recording.
   * This function will automatically lookup the recording title, which is required to submit the recording URL
   * @param recording MBID of the recording
   * @param spotifyId Spotify ID
   * @param editNote Comment to add.
   */
  public addSpotifyIdToRecording(recording: mb.IRecording, spotifyId: string, editNote: string) {

    if (spotifyId.length !== 22) {
      throw new Error('Invalid Spotify ID length');
    }

    return this.addUrlToRecording(recording, {
      linkTypeId: mb.LinkType.stream_for_free,
      text: `https://open.spotify.com/track/${spotifyId}`
    }, editNote);
  }

  private async getSession(): Promise<ISessionInformation> {

    const response = await this.httpClient.get('login', {
      followRedirects: false
    });
    return {
      csrf: MusicBrainzApi.fetchCsrf(await response.text())
    };
  }

  private async applyRateLimiter() {
    if (!this.config.disableRateLimiting) {
      const delay = await this.rateLimiter.limit();
      debug(`Client side rate limiter activated: cool down for ${Math.round(delay / 100)/10} s...`);
    }
  }
}

export function makeAndQueryString(keyValuePairs: IFormData): string {
  return Object.keys(keyValuePairs).map(key => `${key}:"${keyValuePairs[key]}"`).join(' AND ');
}

1	import { StatusCodes as HttpStatus } from 'http-status-codes';	2✔
2	import Debug from 'debug';	2✔
3		2✔
4	export { XmlMetadata } from './xml/xml-metadata.js';	2✔
5	export { XmlIsrc } from './xml/xml-isrc.js';	2✔
6	export { XmlIsrcList } from './xml/xml-isrc-list.js';	2✔
7	export { XmlRecording } from './xml/xml-recording.js';	2✔
8		2✔
9	import type { XmlMetadata } from './xml/xml-metadata.js';	2✔
10	import { DigestAuth } from './digest-auth.js';	2✔
11		2✔
12	import { RateLimitThreshold } from 'rate-limit-threshold';	2✔
13	import * as mb from './musicbrainz.types.js';	2✔
14	import {HttpClient, type HttpFormData} from "./httpClient.js";	2✔
15		2✔
16	export * from './musicbrainz.types.js';	2✔
17		2✔
18	/*	2✔
19	* https://musicbrainz.org/doc/Development/XML_Web_Service/Version_2#Subqueries	2✔
20	*/	2✔
21		2✔
22	export type RelationsIncludes =	2✔
23	'area-rels'	2✔
24	\| 'artist-rels'	2✔
25	\| 'event-rels'	2✔
26	\| 'instrument-rels'	2✔
27	\| 'label-rels'	2✔
28	\| 'place-rels'	2✔
29	\| 'recording-rels'	2✔
30	\| 'release-rels'	2✔
31	\| 'release-group-rels'	2✔
32	\| 'series-rels'	2✔
33	\| 'url-rels'	2✔
34	\| 'work-rels';	2✔
35		2✔
36	export type SubQueryIncludes =	2✔
37	/**	2✔
38	* include discids for all media in the releases	2✔
39	*/	2✔
40	'discids'	2✔
41	/**	2✔
42	* include media for all releases, this includes the # of tracks on each medium and its format.	2✔
43	*/	2✔
44	\| 'media'	2✔
45	/**	2✔
46	* include isrcs for all recordings	2✔
47	*/	2✔
48	\| 'isrcs'	2✔
49	/**	2✔
50	* include artists credits for all releases and recordings	2✔
51	*/	2✔
52	\| 'artist-credits'	2✔
53	/**	2✔
54	* include only those releases where the artist appears on one of the tracks, only valid on artists in combination with `releases`	2✔
55	*/	2✔
56	\| 'various-artists';	2✔
57		2✔
58	export type MiscIncludes =	2✔
59	'aliases'	2✔
60	\| 'annotation'	2✔
61	\| 'tags'	2✔
62	\| 'genres'	2✔
63	\| 'ratings'	2✔
64	\| 'media';	2✔
65		2✔
66	export type AreaIncludes = MiscIncludes \| RelationsIncludes;	2✔
67		2✔
68	export type ArtistIncludes =	2✔
69	MiscIncludes	2✔
70	\| RelationsIncludes	2✔
71	\| 'recordings'	2✔
72	\| 'releases'	2✔
73	\| 'release-groups'	2✔
74	\| 'works';	2✔
75		2✔
76	export type CollectionIncludes =	2✔
77	MiscIncludes	2✔
78	\| RelationsIncludes	2✔
79	\| 'user-collections';	2✔
80		2✔
81	export type EventIncludes = MiscIncludes \| RelationsIncludes;	2✔
82		2✔
83	export type GenreIncludes = MiscIncludes;	2✔
84		2✔
85	export type InstrumentIncludes = MiscIncludes \| RelationsIncludes;	2✔
86		2✔
87	export type LabelIncludes =	2✔
88	MiscIncludes	2✔
89	\| RelationsIncludes	2✔
90	\| 'releases';	2✔
91		2✔
92	export type PlaceIncludes = MiscIncludes \| RelationsIncludes;	2✔
93		2✔
94	export type RecordingIncludes =	2✔
95	MiscIncludes	2✔
96	\| RelationsIncludes	2✔
97	\| SubQueryIncludes	2✔
98	\| 'artists'	2✔
99	\| 'releases'	2✔
100	\| 'isrcs';	2✔
101		2✔
102	export type ReleaseIncludes =	2✔
103	MiscIncludes	2✔
104	\| SubQueryIncludes	2✔
105	\| RelationsIncludes	2✔
106	\| 'artists'	2✔
107	\| 'collections'	2✔
108	\| 'labels'	2✔
109	\| 'recordings'	2✔
110	\| 'release-groups';	2✔
111		2✔
112	export type ReleaseGroupIncludes =	2✔
113	MiscIncludes	2✔
114	\| SubQueryIncludes	2✔
115	\| RelationsIncludes	2✔
116	\| 'artists'	2✔
117	\| 'releases';	2✔
118		2✔
119	export type SeriesIncludes = MiscIncludes \| RelationsIncludes;	2✔
120		2✔
121	export type WorkIncludes = MiscIncludes \| RelationsIncludes;	2✔
122		2✔
123	export type UrlIncludes = RelationsIncludes;	2✔
124		2✔
125	export type IFormData = {[key: string]: string \| number};	2✔
126		2✔
127	const debug = Debug('musicbrainz-api');	2✔
128		2✔
129	export interface IMusicBrainzConfig {	2✔
130	botAccount?: {	2✔
131	username?: string,	2✔
132	password?: string	2✔
133	},	2✔
134	baseUrl: string,	2✔
135		2✔
136	appName?: string,	2✔
137	appVersion?: string,	2✔
138		2✔
139	/**	2✔
140	* HTTP Proxy	2✔
141	*/	2✔
142	proxy?: string,	2✔
143		2✔
144	/**	2✔
145	* User e-mail address or application URL	2✔
146	*/	2✔
147	appContactInfo?: string,	2✔
148		2✔
149	disableRateLimiting?: boolean	2✔
150	}	2✔
151		2✔
152	export interface ICsrfSession {	2✔
153	sessionKey: string;	2✔
154	token: string;	2✔
155	}	2✔
156		2✔
157	export interface ISessionInformation {	2✔
158	csrf: ICsrfSession,	2✔
159	loggedIn?: boolean;	2✔
160	}	2✔
161		2✔
162	export class MusicBrainzApi {	2✔
163		2✔
164	public readonly config: IMusicBrainzConfig = {	2✔
165	baseUrl: 'https://musicbrainz.org'	2✔
166	};	2✔
167		2✔
168	private rateLimiter: RateLimitThreshold;	2✔
169	private httpClient: HttpClient;	2✔
170	private session?: ISessionInformation;	2✔
171		2✔
172	public static fetchCsrf(html: string): ICsrfSession {	2✔
173	return {	2✔
174	sessionKey: MusicBrainzApi.fetchValue(html, 'csrf_session_key') as string,	2✔
175	token: MusicBrainzApi.fetchValue(html, 'csrf_token') as string	2✔
176	};	2✔
177	}	2✔
178		2✔
179	private static fetchValue(html: string, key: string): string \| undefined{	2✔
180	let pos = html.indexOf(`name="${key}"`);	4✔
181	if (pos >= 0) {	4✔
182	pos = html.indexOf('value="', pos + key.length + 7);	4✔
183	if (pos >= 0) {	4✔
184	pos += 7;	4✔
185	const endValuePos = html.indexOf('"', pos);	4✔
186	return html.substring(pos, endValuePos);	4✔
187	}	4✔
188	}	4✔
189	}	4✔
190		2✔
191	public constructor(_config?: IMusicBrainzConfig) {	2✔
192		12✔
193	Object.assign(this.config, _config);	12✔
194		12✔
195	this.httpClient = new HttpClient({	12✔
196	baseUrl: this.config.baseUrl,	12✔
197	timeout: 20 * 1000,	12✔
198	userAgent: `${this.config.appName}/${this.config.appVersion} ( ${this.config.appContactInfo} )`	12✔
199	});	12✔
200		12✔
201	this.rateLimiter = new RateLimitThreshold(15, 18);	12✔
202	}	12✔
203		2✔
204	public async restGet<T>(relUrl: string, query: { [key: string]: string; } = {}): Promise<T> {	2✔
205		166✔
206	query.fmt = 'json';	166✔
207		166✔
208	await this.applyRateLimiter();	166✔
209		166✔
210	const response = await this.httpClient.get(`ws/2${relUrl}`, {	166✔
211	query,	166✔
212	retryLimit: 10	166✔
213	});	166✔
214	return response.json();	166✔
215	}	166✔
216		2✔
217	/**	2✔
218	* Lookup entity	2✔
219	* @param entity 'area', 'artist', collection', 'instrument', 'label', 'place', 'release', 'release-group', 'recording', 'series', 'work', 'url' or 'event'	2✔
220	* @param mbid Entity MBID	2✔
221	* @param inc Query, like: {<entity>: <MBID:}	2✔
222	*/	2✔
223	public lookup(entity: 'area', mbid: string, inc?: AreaIncludes[]): Promise<mb.IArea>;	2✔
224	public lookup(entity: 'artist', mbid: string, inc?: ArtistIncludes[]): Promise<mb.IArtist>;	2✔
225	public lookup(entity: 'collection', mbid: string, inc?: CollectionIncludes[]): Promise<mb.ICollection>;	2✔
226	public lookup(entity: 'instrument', mbid: string, inc?: InstrumentIncludes[]): Promise<mb.IInstrument>;	2✔
227	public lookup(entity: 'label', mbid: string, inc?: LabelIncludes[]): Promise<mb.ILabel>;	2✔
228	public lookup(entity: 'place', mbid: string, inc?: PlaceIncludes[]): Promise<mb.IPlace>;	2✔
229	public lookup(entity: 'release', mbid: string, inc?: ReleaseIncludes[]): Promise<mb.IRelease>;	2✔
230	public lookup(entity: 'release-group', mbid: string, inc?: ReleaseGroupIncludes[]): Promise<mb.IReleaseGroup>;	2✔
231	public lookup(entity: 'recording', mbid: string, inc?: RecordingIncludes[]): Promise<mb.IRecording>;	2✔
232	public lookup(entity: 'series', mbid: string, inc?: SeriesIncludes[]): Promise<mb.ISeries>;	2✔
233	public lookup(entity: 'work', mbid: string, inc?: WorkIncludes[]): Promise<mb.IWork>;	2✔
234	public lookup(entity: 'url', mbid: string, inc?: UrlIncludes[]): Promise<mb.IUrl>;	2✔
235	public lookup(entity: 'event', mbid: string, inc?: EventIncludes[]): Promise<mb.IEvent>;	2✔
236	public lookup<T, I extends string = never>(entity: mb.EntityType, mbid: string, inc: I[] = []): Promise<T> {	2✔
237	return this.restGet<T>(`/${entity}/${mbid}`, {inc: inc.join(' ')});	62✔
238	}	62✔
239		2✔
240	/**	2✔
241	* Browse entity	2✔
242	* https://wiki.musicbrainz.org/MusicBrainz_API#Browse	2✔
243	* https://wiki.musicbrainz.org/MusicBrainz_API#Linked_entities	2✔
244	* https://wiki.musicbrainz.org/Development/JSON_Web_Service#Browse_Requests	2✔
245	* For example: http://musicbrainz.org/ws/2/release?label=47e718e1-7ee4-460c-b1cc-1192a841c6e5&offset=12&limit=2	2✔
246	* @param entity MusicBrainz entity	2✔
247	* @param query Query, like: {<entity>: <MBID:}	2✔
248	*/	2✔
249	public browse(entity: 'area', query?: mb.IBrowseAreasQuery): Promise<mb.IBrowseAreasResult>;	2✔
250	public browse(entity: 'artist', query?: mb.IBrowseArtistsQuery): Promise<mb.IBrowseArtistsResult>;	2✔
251	public browse(entity: 'collection', query?: mb.IBrowseCollectionsQuery): Promise<mb.IBrowseCollectionsResult> ;	2✔
252	public browse(entity: 'event', query?: mb.IBrowseEventsQuery): Promise<mb.IBrowseEventsResult>;	2✔
253	public browse(entity: 'label', query?: mb.IBrowseLabelsQuery): Promise<mb.IBrowseLabelsResult>;	2✔
254	public browse(entity: 'instrument', query?: mb.IBrowseInstrumentsQuery): Promise<mb.IBrowseInstrumentsResult>;	2✔
255	public browse(entity: 'place', query?: mb.IBrowsePlacesQuery): Promise<mb.IBrowsePlacesResult>;	2✔
256	public browse(entity: 'recording', query?: mb.IBrowseRecordingsQuery): Promise<mb.IBrowseRecordingsResult>;	2✔
257	public browse(entity: 'release', query?: mb.IBrowseReleasesQuery): Promise<mb.IBrowseReleasesResult>;	2✔
258	public browse(entity: 'release-group', query?: mb.IBrowseReleaseGroupsQuery): Promise<mb.IBrowseReleaseGroupsResult>;	2✔
259	public browse(entity: 'series', query?: mb.IBrowseSeriesQuery): Promise<mb.IBrowseSeriesResult>;	2✔
260	public browse(entity: 'url', query?: mb.IBrowseUrlsQuery): Promise<mb.IUrl>;	2✔
261	public browse(entity: 'work', query?: mb.IBrowseWorksQuery): Promise<mb.IBrowseWorksResult>;	2✔
262	public browse<T>(entity: mb.EntityType, query?: { [key: string]: any; }): Promise<T> {	2✔
263	return this.restGet<T>(`/${entity}`, query);	72✔
264	}	72✔
265		2✔
266	// -----------------------------------------------------------------------------------------------------------------	2✔
267	// Query functions	2✔
268	// -----------------------------------------------------------------------------------------------------------------	2✔
269		2✔
270	/**	2✔
271	* Search an entity using a search query	2✔
272	* @param query e.g.: '" artist: Madonna, track: Like a virgin"' or object with search terms: {artist: Madonna}	2✔
273	* @param entity e.g. 'recording'	2✔
274	* @param query Arguments	2✔
275	*/	2✔
276	public search(entity:'area', query: mb.ISearchQuery<AreaIncludes> & mb.ILinkedEntitiesArea): Promise<mb.IAreaList>;	2✔
277	public search(artist:'artist', query: mb.ISearchQuery<ArtistIncludes> & mb.ILinkedEntitiesArea): Promise<mb.IArtistList>;	2✔
278	public search(artist:'recording', query: mb.ISearchQuery<AreaIncludes> & mb.ILinkedEntitiesArea): Promise<mb.IRecordingList>;	2✔
279	public search(artist:'release', query: mb.ISearchQuery<ReleaseIncludes> & mb.ILinkedEntitiesArea): Promise<mb.IReleaseList>;	2✔
280	public search(artist:'release-group', query: mb.ISearchQuery<ReleaseGroupIncludes> & mb.ILinkedEntitiesArea): Promise<mb.IReleaseGroupList>;	2✔
281	public search(artist:'url', query: mb.ISearchQuery<UrlIncludes> & mb.ILinkedEntitiesArea): Promise<mb.IUrlList>;	2✔
282	public search<T extends mb.ISearchResult, I extends string = never>(entity: mb.EntityType, query: mb.ISearchQuery<I>): Promise<T> {	2✔
283	const urlQuery: any = {...query};	26✔
284	if (typeof query.query === 'object') {	26✔
285	urlQuery.query = makeAndQueryString(query.query);	14✔
286	}	14✔
287	if (Array.isArray(query.inc)) {	26✔
288	urlQuery.inc = urlQuery.inc.join(' ');	2✔
289	}	2✔
290	return this.restGet<T>(`/${entity}/`, urlQuery);	26✔
291	}	26✔
292		2✔
293	// ---------------------------------------------------------------------------	2✔
294		2✔
295	public async postRecording(xmlMetadata: XmlMetadata): Promise<void> {	2✔
296	return this.post('recording', xmlMetadata);	×
297	}	×
298		2✔
299	public async post(entity: mb.EntityType, xmlMetadata: XmlMetadata): Promise<void> {	2✔
300		8✔
301	if (!this.config.appName \|\| !this.config.appVersion) {	8!
302	throw new Error("XML-Post requires the appName & appVersion to be defined");	×
303	}	×
304		8✔
305	const clientId = `${this.config.appName.replace(/-/g, '.')}-${this.config.appVersion}`;	8✔
306		8✔
307	const path = `ws/2/${entity}/`;	8✔
308	// Get digest challenge	8✔
309		8✔
310	let digest = '';	8✔
311	let n = 1;	8✔
312	const postData = xmlMetadata.toXml();	8✔
313		8✔
314	do {	8✔
315	await this.applyRateLimiter();	8✔
316	const response: any = await this.httpClient.post(path, {	8✔
317	query: {client: clientId},	8✔
318	headers: {	8✔
319	authorization: digest,	8✔
320	'Content-Type': 'application/xml'	8✔
321	},	8✔
322	body: postData	8✔
323	});	8✔
324		8✔
325	if (response.statusCode === HttpStatus.UNAUTHORIZED) {	8!
UNCOV 326	// Respond to digest challenge	×
UNCOV 327	const auth = new DigestAuth(this.config.botAccount as {username: string, password: string});	×
UNCOV 328	const relPath = response.requestUrl.pathname; // Ensure path is relative	×
UNCOV 329	digest = auth.digest(response.request.method, relPath as string, response.headers['www-authenticate']);	×
UNCOV 330	++n;	×
331	} else {	8✔
332	break;	8✔
333	}	8✔
334	} while (n++ < 5);	8✔
335	}	8✔
336		2✔
337	public async login(): Promise<boolean> {	2✔
338		×
NEW 339	if(!this.config.botAccount?.username) throw new Error('bot username should be set');	×
NEW 340	if(!this.config.botAccount?.password) throw new Error('bot password should be set');	×
341		×
342	if (this.session?.loggedIn) {	×
NEW 343	const cookies = await this.httpClient.getCookies();	×
NEW 344	return cookies.indexOf('musicbrainz_server_session') !== -1;	×
345	}	×
346	this.session = await this.getSession();	×
347		×
348	const redirectUri = '/success';	×
349		×
NEW 350	const formData: HttpFormData = {	×
351	username: this.config.botAccount.username,	×
352	password: this.config.botAccount.password,	×
353	csrf_session_key: this.session.csrf.sessionKey,	×
354	csrf_token: this.session.csrf.token,	×
NEW 355	remember_me: '1'	×
356	};	×
357		×
NEW 358	const response = await this.httpClient.postForm('login', formData, {	×
NEW 359	query: {	×
NEW 360	returnto: redirectUri	×
NEW 361	},	×
NEW 362	followRedirects: false	×
363	});	×
NEW 364		×
NEW 365	const success = response.status === HttpStatus.MOVED_TEMPORARILY && response.headers.get('location') === redirectUri;	×
366	if (success) {	×
367	this.session.loggedIn = true;	×
368	}	×
369	return success;	×
370	}	×
371		2✔
372	/**	2✔
373	* Logout	2✔
374	*/	2✔
375	public async logout(): Promise<boolean> {	2✔
376	const redirectUri = '/success';	×
377		×
NEW 378	const response = await this.httpClient.post('logout', {	×
NEW 379	followRedirects: false,	×
NEW 380	query: {	×
381	returnto: redirectUri	×
382	}	×
383	});	×
NEW 384	const success = response.status === HttpStatus.MOVED_TEMPORARILY && response.headers.get('location') === redirectUri;	×
385	if (success && this.session) {	×
386	this.session.loggedIn = true;	×
387	}	×
388	return success;	×
389	}	×
390		2✔
391	/**	2✔
392	* Submit entity	2✔
393	* @param entity Entity type e.g. 'recording'	2✔
394	* @param mbid	2✔
395	* @param formData	2✔
396	*/	2✔
397	public async editEntity(entity: mb.EntityType, mbid: string, formData: Record<string, any>): Promise<void> {	2✔
398		×
399	await this.applyRateLimiter();	×
400		×
401	this.session = await this.getSession();	×
402		×
403	formData.csrf_session_key = this.session.csrf.sessionKey;	×
404	formData.csrf_token = this.session.csrf.token;	×
405	formData.username = this.config.botAccount?.username;	×
406	formData.password = this.config.botAccount?.password;	×
407	formData.remember_me = 1;	×
408		×
NEW 409	const response = await this.httpClient.postForm(`${entity}/${mbid}/edit`, formData, {	×
NEW 410	followRedirects: false	×
411	});	×
NEW 412	if (response.status === HttpStatus.OK)	×
413	throw new Error("Failed to submit form data");	×
NEW 414	if (response.status === HttpStatus.MOVED_TEMPORARILY)	×
415	return;	×
NEW 416	throw new Error(`Unexpected status code: ${response.status}`);	×
417	}	×
418		2✔
419	/**	2✔
420	* Set URL to recording	2✔
421	* @param recording Recording to update	2✔
422	* @param url2add URL to add to the recording	2✔
423	* @param editNote Edit note	2✔
424	*/	2✔
425	public async addUrlToRecording(recording: mb.IRecording, url2add: { linkTypeId: mb.LinkType, text: string }, editNote = '') {	2✔
426		×
427	const formData: {[key: string]: string \| boolean \| number} = {};	×
428		×
429	formData['edit-recording.name'] = recording.title; // Required	×
430	formData['edit-recording.comment'] = recording.disambiguation;	×
431	formData['edit-recording.make_votable'] = true;	×
432		×
433	formData['edit-recording.url.0.link_type_id'] = url2add.linkTypeId;	×
434	formData['edit-recording.url.0.text'] = url2add.text;	×
435		×
436	recording.isrcs?.forEach((isrcs, i) => {	×
437	formData[`edit-recording.isrcs.${i}`] = isrcs;	×
438	});	×
439		×
440	formData['edit-recording.edit_note'] = editNote;	×
441		×
442	return this.editEntity('recording', recording.id, formData);	×
443	}	×
444		2✔
445	/**	2✔
446	* Add ISRC to recording	2✔
447	* @param recording Recording to update	2✔
448	* @param isrc ISRC code to add	2✔
449	*/	2✔
450	public async addIsrc(recording: mb.IRecording, isrc: string) {	2✔
451		×
452	const formData: IFormData = {};	×
453		×
454	formData["edit-recording.name"] = recording.title; // Required	×
455		×
456	if (!recording.isrcs) {	×
457	throw new Error('You must retrieve recording with existing ISRC values');	×
458	}	×
459		×
460	if (recording.isrcs.indexOf(isrc) === -1) {	×
461	recording.isrcs.push(isrc);	×
462		×
463	for (const i in recording.isrcs) {	×
464	formData[`edit-recording.isrcs.${i}`] = recording.isrcs[i];	×
465	}	×
466	return this.editEntity('recording', recording.id, formData);	×
467	}	×
468	}	×
469		2✔
470		2✔
471	// -----------------------------------------------------------------------------------------------------------------	2✔
472	// Helper functions	2✔
473	// -----------------------------------------------------------------------------------------------------------------	2✔
474		2✔
475	/**	2✔
476	* Add Spotify-ID to MusicBrainz recording.	2✔
477	* This function will automatically lookup the recording title, which is required to submit the recording URL	2✔
478	* @param recording MBID of the recording	2✔
479	* @param spotifyId Spotify ID	2✔
480	* @param editNote Comment to add.	2✔
481	*/	2✔
482	public addSpotifyIdToRecording(recording: mb.IRecording, spotifyId: string, editNote: string) {	2✔
483		×
NEW 484	if (spotifyId.length !== 22) {	×
NEW 485	throw new Error('Invalid Spotify ID length');	×
NEW 486	}	×
487		×
488	return this.addUrlToRecording(recording, {	×
489	linkTypeId: mb.LinkType.stream_for_free,	×
490	text: `https://open.spotify.com/track/${spotifyId}`	×
491	}, editNote);	×
492	}	×
493		2✔
494	private async getSession(): Promise<ISessionInformation> {	2✔
495		×
NEW 496	const response = await this.httpClient.get('login', {	×
NEW 497	followRedirects: false	×
498	});	×
499	return {	×
NEW 500	csrf: MusicBrainzApi.fetchCsrf(await response.text())	×
501	};	×
502	}	×
503		2✔
504	private async applyRateLimiter() {	2✔
505	if (!this.config.disableRateLimiting) {	174✔
506	const delay = await this.rateLimiter.limit();	170✔
507	debug(`Client side rate limiter activated: cool down for ${Math.round(delay / 100)/10} s...`);	170✔
508	}	170✔
509	}	174✔
510	}	2✔
511		2✔
512	export function makeAndQueryString(keyValuePairs: IFormData): string {	2✔
513	return Object.keys(keyValuePairs).map(key => `${key}:"${keyValuePairs[key]}"`).join(' AND ');	14✔
514	}	14✔

Borewit / musicbrainz-api / 10549808448

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous