musicbrainz-api 0.23.0 → 0.23.1

package/lib/coverartarchive-api.d.ts

@@ -0,0 +1,74 @@
+export type CovertType = 'Front' | 'Back' | 'Booklet' | 'Medium' | 'Obi' | 'Spine' | 'Track' | 'Tray' | 'Sticker' | 'Poster' | 'Liner' | 'Watermark' | 'Raw/Unedited' | 'Matrix/Runout' | 'Top' | 'Bottom' | 'Other';
+export interface IImage {
+    types: CovertType[];
+    front: boolean;
+    back: boolean;
+    edit: number;
+    image: string;
+    comment: string;
+    approved: boolean;
+    id: string;
+    thumbnails: {
+        large: string;
+        small: string;
+        '250': string;
+        '500'?: string;
+        '1200'?: string;
+    };
+}
+export type CoverType = 'front' | 'back';
+export interface ICoversInfo {
+    images: IImage[];
+    release: string;
+}
+export interface ICoverInfo {
+    url: string | null;
+}
+export declare class CoverArtArchiveApi {
+    private httpClient;
+    private getJson;
+    private getCoverRedirect;
+    /**
+     * Fetch release
+     * @releaseId Release MBID
+     * @param releaseId MusicBrainz Release MBID
+     */
+    getReleaseCovers(releaseId: string): Promise<ICoversInfo>;
+    /**
+     * Fetch release-group
+     * @releaseGroupId Release-group MBID
+     * @param releaseGroupId MusicBrainz Release Group MBID
+     */
+    getReleaseGroupCovers(releaseGroupId: string): Promise<ICoversInfo>;
+    /**
+     * Fetch release cover
+     * @releaseId Release MBID
+     * @param releaseId MusicBrainz Release MBID
+     * @param coverType Front or back cover
+     */
+    getReleaseCover(releaseId: string, coverType: CoverType): Promise<ICoverInfo>;
+    /**
+     * Fetch release-group cover
+     * @releaseId Release-group MBID
+     * @param releaseGroupId MusicBrainz Release-group MBID
+     * @param coverType Front or back cover
+     */
+    getReleaseGroupCover(releaseGroupId: string, coverType: CoverType): Promise<ICoverInfo>;
+    private static makePath;
+    /**
+     * Fetch covers
+     * @releaseId MBID
+     * @param releaseId MusicBrainz Release Group MBID
+     * @param releaseType Fetch covers for specific release or release-group
+     * @param coverType Cover type
+     */
+    private getCovers;
+    /**
+     * Fetch covers
+     * @releaseId MBID
+     * @param releaseId MusicBrainz Release Group MBID
+     * @param releaseType Fetch covers for specific release or release-group
+     * @param coverType Cover type
+     */
+    private getCover;
+}

package/lib/coverartarchive-api.js

@@ -0,0 +1,110 @@
+/* eslint-disable-next-line */
+import { HttpClient } from "./http-client.js";
+export class CoverArtArchiveApi {
+    constructor() {
+        this.httpClient = new HttpClient({ baseUrl: 'https://coverartarchive.org', userAgent: 'Node.js musicbrains-api', timeout: 20000, followRedirects: false });
+    }
+    async getJson(path) {
+        const response = await this.httpClient.get(path, {
+            headers: {
+                Accept: "application/json"
+            }
+        });
+        const contentType = response.headers.get("Content-Type");
+        if (response.status === 404 && contentType?.toLowerCase() !== "application/json") {
+            return {
+                "error": "Not Found",
+                "help": "For usage, please see: https://musicbrainz.org/development/mmd"
+            };
+        }
+        return response.json();
+    }
+    async getCoverRedirect(path) {
+        const response = await this.httpClient.get(path, {
+            followRedirects: false
+        });
+        switch (response.status) {
+            case 307:
+                return response.headers.get('LOCATION');
+            case 400:
+                throw new Error('Invalid UUID');
+            case 404:
+                // No release with this MBID
+                return null;
+            case 405:
+                throw new Error('Invalid HTTP method');
+            case 503:
+                return null;
+            default:
+                throw new Error(`Unexpected HTTP-status response: ${response.status}`);
+        }
+    }
+    /**
+     * Fetch release
+     * @releaseId Release MBID
+     * @param releaseId MusicBrainz Release MBID
+     */
+    getReleaseCovers(releaseId) {
+        return this.getCovers(releaseId, 'release');
+    }
+    /**
+     * Fetch release-group
+     * @releaseGroupId Release-group MBID
+     * @param releaseGroupId MusicBrainz Release Group MBID
+     */
+    getReleaseGroupCovers(releaseGroupId) {
+        return this.getCovers(releaseGroupId, 'release-group');
+    }
+    /**
+     * Fetch release cover
+     * @releaseId Release MBID
+     * @param releaseId MusicBrainz Release MBID
+     * @param coverType Front or back cover
+     */
+    getReleaseCover(releaseId, coverType) {
+        return this.getCover(releaseId, 'release', coverType);
+    }
+    /**
+     * Fetch release-group cover
+     * @releaseId Release-group MBID
+     * @param releaseGroupId MusicBrainz Release-group MBID
+     * @param coverType Front or back cover
+     */
+    getReleaseGroupCover(releaseGroupId, coverType) {
+        return this.getCover(releaseGroupId, 'release-group', coverType);
+    }
+    static makePath(releaseId, releaseType = 'release', coverType) {
+        const path = [releaseType, releaseId];
+        if (coverType) {
+            path.push(coverType);
+        }
+        return `/${path.join('/')}`;
+    }
+    /**
+     * Fetch covers
+     * @releaseId MBID
+     * @param releaseId MusicBrainz Release Group MBID
+     * @param releaseType Fetch covers for specific release or release-group
+     * @param coverType Cover type
+     */
+    async getCovers(releaseId, releaseType = 'release') {
+        const info = await this.getJson(CoverArtArchiveApi.makePath(releaseId, releaseType));
+        // Hack to correct http addresses into https
+        if (info.release?.startsWith('http:')) {
+            info.release = `https${info.release.substring(4)}`;
+        }
+        return info;
+    }
+    /**
+     * Fetch covers
+     * @releaseId MBID
+     * @param releaseId MusicBrainz Release Group MBID
+     * @param releaseType Fetch covers for specific release or release-group
+     * @param coverType Cover type
+     */
+    async getCover(releaseId, releaseType = 'release', coverType) {
+        const url = await this.getCoverRedirect(CoverArtArchiveApi.makePath(releaseId, releaseType, coverType));
+        return { url: url };
+    }
+}
+//# sourceMappingURL=coverartarchive-api.js.map

package/lib/digest-auth.d.ts

@@ -0,0 +1,21 @@
+export interface ICredentials {
+    username: string;
+    password: string;
+}
+export declare class DigestAuth {
+    private credentials;
+    /**
+     * RFC 2617: handle both MD5 and MD5-sess algorithms.
+     *
+     * If the algorithm directive's value is "MD5" or unspecified, then HA1 is
+     *   HA1=MD5(username:realm:password)
+     * If the algorithm directive's value is "MD5-sess", then HA1 is
+     *   HA1=MD5(MD5(username:realm:password):nonce:cnonce)
+     */
+    static ha1Compute(algorithm: string, user: string, realm: string, pass: string, nonce: string, cnonce: string): string;
+    hasAuth: boolean;
+    sentAuth: boolean;
+    bearerToken: string | null;
+    constructor(credentials: ICredentials);
+    digest(method: string, path: string, authHeader: string): string;
+}

package/lib/digest-auth.js

@@ -0,0 +1,77 @@
+import { v4 as uuidv4 } from 'uuid';
+import sparkMd5 from 'spark-md5';
+const md5 = sparkMd5.hash;
+export class DigestAuth {
+    /**
+     * RFC 2617: handle both MD5 and MD5-sess algorithms.
+     *
+     * If the algorithm directive's value is "MD5" or unspecified, then HA1 is
+     *   HA1=MD5(username:realm:password)
+     * If the algorithm directive's value is "MD5-sess", then HA1 is
+     *   HA1=MD5(MD5(username:realm:password):nonce:cnonce)
+     */
+    static ha1Compute(algorithm, user, realm, pass, nonce, cnonce) {
+        const ha1 = md5(`${user}:${realm}:${pass}`); // lgtm [js/insufficient-password-hash]
+        return algorithm && algorithm.toLowerCase() === 'md5-sess' ? md5(`${ha1}:${nonce}:${cnonce}`) : ha1;
+    }
+    constructor(credentials) {
+        this.credentials = credentials;
+        this.hasAuth = false;
+        this.sentAuth = false;
+        this.bearerToken = null;
+    }
+    digest(method, path, authHeader) {
+        // TODO: More complete implementation of RFC 2617.
+        //   - support qop="auth-int" only
+        //   - handle Authentication-Info (not necessarily?)
+        //   - check challenge.stale (not necessarily?)
+        //   - increase nc (not necessarily?)
+        // For reference:
+        // http://tools.ietf.org/html/rfc2617#section-3
+        // https://github.com/bagder/curl/blob/master/lib/http_digest.c
+        const challenge = {};
+        const re = /([a-z0-9_-]+)=(?:"([^"]+)"|([a-z0-9_-]+))/gi;
+        while (true) {
+            const match = re.exec(authHeader);
+            if (!match) {
+                break;
+            }
+            challenge[match[1]] = match[2] || match[3];
+        }
+        const qop = /(^|,)\s*auth\s*($|,)/.test(challenge.qop) && 'auth';
+        const nc = qop && '00000001';
+        const cnonce = qop && uuidv4().replace(/-/g, '');
+        const ha1 = DigestAuth.ha1Compute(challenge.algorithm, this.credentials.username, challenge.realm, this.credentials.password, challenge.nonce, cnonce);
+        const ha2 = md5(`${method}:${path}`); // lgtm [js/insufficient-password-hash]
+        const digestResponse = qop
+            ? md5(`${ha1}:${challenge.nonce}:${nc}:${cnonce}:${qop}:${ha2}`) // lgtm [js/insufficient-password-hash]
+            : md5(`${ha1}:${challenge.nonce}:${ha2}`); // lgtm [js/insufficient-password-hash]
+        const authValues = {
+            username: this.credentials.username,
+            realm: challenge.realm,
+            nonce: challenge.nonce,
+            uri: path,
+            qop,
+            response: digestResponse,
+            nc,
+            cnonce,
+            algorithm: challenge.algorithm,
+            opaque: challenge.opaque
+        };
+        const parts = [];
+        Object.entries(authValues).forEach(([key, value]) => {
+            if (value) {
+                if (key === 'qop' || key === 'nc' || key === 'algorithm') {
+                    parts.push(`${key}=${value}`);
+                }
+                else {
+                    parts.push(`${key}="${value}"`);
+                }
+            }
+        });
+        const digest = `Digest ${parts.join(', ')}`;
+        this.sentAuth = true;
+        return digest;
+    }
+}
+//# sourceMappingURL=digest-auth.js.map

package/lib/entry-default.d.ts

@@ -0,0 +1,2 @@
+export * from './coverartarchive-api.js';
+export * from './musicbrainz-api.js';

package/lib/entry-default.js

@@ -0,0 +1,3 @@
+export * from './coverartarchive-api.js';
+export * from './musicbrainz-api.js';
+//# sourceMappingURL=entry-default.js.map

package/lib/entry-node.d.ts

@@ -0,0 +1,2 @@
+export * from './coverartarchive-api.js';
+export * from './musicbrainz-api-node.js';

package/lib/entry-node.js

@@ -0,0 +1,3 @@
+export * from './coverartarchive-api.js';
+export * from './musicbrainz-api-node.js';
+//# sourceMappingURL=entry-node.js.map

package/lib/http-client-node.d.ts

@@ -0,0 +1,11 @@
+import { type Cookie } from "tough-cookie";
+import { HttpClient, type IHttpClientOptions } from "./http-client.js";
+export type HttpFormData = {
+    [key: string]: string;
+};
+export declare class HttpClientNode extends HttpClient {
+    private cookieJar;
+    constructor(options: IHttpClientOptions);
+    protected registerCookies(response: Response): Promise<Cookie | undefined>;
+    getCookies(): Promise<string | null>;
+}

package/lib/http-client-node.js

@@ -0,0 +1,19 @@
+import { CookieJar } from "tough-cookie";
+import { HttpClient } from "./http-client.js";
+export class HttpClientNode extends HttpClient {
+    constructor(options) {
+        super(options);
+        this.cookieJar = new CookieJar();
+    }
+    registerCookies(response) {
+        const cookie = response.headers.get('set-cookie');
+        if (cookie) {
+            return this.cookieJar.setCookie(cookie, response.url);
+        }
+        return Promise.resolve(undefined);
+    }
+    getCookies() {
+        return this.cookieJar.getCookieString(this.options.baseUrl); // Get cookies for the request
+    }
+}
+//# sourceMappingURL=http-client-node.js.map

package/lib/http-client.d.ts

@@ -0,0 +1,34 @@
+import type { Cookie } from "tough-cookie";
+export type HttpFormData = {
+    [key: string]: string;
+};
+/**
+ * Allows multiple entries for the same key
+ */
+export type MultiQueryFormData = {
+    [key: string]: string | string[];
+};
+export interface IHttpClientOptions {
+    baseUrl: string;
+    timeout: number;
+    userAgent: string;
+    followRedirects?: boolean;
+}
+export interface IFetchOptions {
+    query?: MultiQueryFormData;
+    retryLimit?: number;
+    body?: string;
+    headers?: HeadersInit;
+    followRedirects?: boolean;
+}
+export declare class HttpClient {
+    protected options: IHttpClientOptions;
+    constructor(options: IHttpClientOptions);
+    get(path: string, options?: IFetchOptions): Promise<Response>;
+    post(path: string, options?: IFetchOptions): Promise<Response>;
+    postForm(path: string, formData: HttpFormData, options?: IFetchOptions): Promise<Response>;
+    postJson(path: string, json: Object, options?: IFetchOptions): Promise<Response>;
+    private _fetch;
+    protected registerCookies(response: Response): Promise<Cookie | undefined>;
+    getCookies(): Promise<string | null>;
+}

package/lib/http-client.js

@@ -0,0 +1,57 @@
+export class HttpClient {
+    constructor(options) {
+        this.options = options;
+    }
+    get(path, options) {
+        return this._fetch('get', path, options);
+    }
+    post(path, options) {
+        return this._fetch('post', path, options);
+    }
+    postForm(path, formData, options) {
+        const encodedFormData = new URLSearchParams(formData).toString();
+        return this._fetch('post', path, { ...options, body: encodedFormData, headers: { 'Content-Type': 'application/x-www-form-urlencoded' } });
+    }
+    // biome-ignore lint/complexity/noBannedTypes:
+    postJson(path, json, options) {
+        const encodedJson = JSON.stringify(json);
+        return this._fetch('post', path, { ...options, body: encodedJson, headers: { 'Content-Type': 'application/json.' } });
+    }
+    async _fetch(method, path, options) {
+        if (!options)
+            options = {};
+        let url = path.startsWith('/') ? `${this.options.baseUrl}${path}` : `${this.options.baseUrl}/${path}`;
+        if (options.query) {
+            const urlSearchParams = new URLSearchParams();
+            for (const key of Object.keys(options.query)) {
+                const value = options.query[key];
+                (Array.isArray(value) ? value : [value]).forEach(value => {
+                    urlSearchParams.append(key, value);
+                });
+            }
+            url += `?${urlSearchParams.toString()}`;
+        }
+        const cookies = await this.getCookies();
+        const headers = new Headers(options.headers);
+        headers.set('User-Agent', this.options.userAgent);
+        if (cookies !== null) {
+            headers.set('Cookie', cookies);
+        }
+        const response = await fetch(url, {
+            method,
+            ...options,
+            headers,
+            body: options.body,
+            redirect: options.followRedirects === false ? 'manual' : 'follow'
+        });
+        await this.registerCookies(response);
+        return response;
+    }
+    registerCookies(response) {
+        return Promise.resolve(undefined);
+    }
+    async getCookies() {
+        return Promise.resolve(null);
+    }
+}
+//# sourceMappingURL=http-client.js.map

package/lib/musicbrainz-api-node.d.ts

@@ -0,0 +1,16 @@
+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 { HttpClientNode } from "./http-client-node.js";
+import { MusicBrainzApi as MusicBrainzApiDefault } from "./musicbrainz-api.js";
+export * from './musicbrainz.types.js';
+export * from './http-client.js';
+export declare class MusicBrainzApi extends MusicBrainzApiDefault {
+    protected initHttpClient(): HttpClientNode;
+    login(): Promise<boolean>;
+    /**
+     * Logout
+     */
+    logout(): Promise<boolean>;
+}

package/lib/musicbrainz-api-node.js

@@ -0,0 +1,71 @@
+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 { HttpClientNode } from "./http-client-node.js";
+import { MusicBrainzApi as MusicBrainzApiDefault } from "./musicbrainz-api.js";
+export * from './musicbrainz.types.js';
+export * from './http-client.js';
+/*
+ * https://musicbrainz.org/doc/Development/XML_Web_Service/Version_2#Subqueries
+ */
+const debug = Debug('musicbrainz-api-node');
+export class MusicBrainzApi extends MusicBrainzApiDefault {
+    initHttpClient() {
+        return new HttpClientNode({
+            baseUrl: this.config.baseUrl,
+            timeout: 20 * 1000,
+            userAgent: `${this.config.appName}/${this.config.appVersion} ( ${this.config.appContactInfo} )`
+        });
+    }
+    async login() {
+        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 = {
+            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
+     */
+    async logout() {
+        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;
+    }
+}
+//# sourceMappingURL=musicbrainz-api-node.js.map