122 lines
4.3 KiB
TypeScript
122 lines
4.3 KiB
TypeScript
/**
|
|
* MusicBrainz API integration for fetching release years
|
|
* API Documentation: https://musicbrainz.org/doc/MusicBrainz_API
|
|
* Rate Limiting: 50 requests per second for meaningful User-Agent strings
|
|
*/
|
|
|
|
const MUSICBRAINZ_API_BASE = 'https://musicbrainz.org/ws/2';
|
|
const USER_AGENT = 'hoerdle/0.1.0 ( elpatron@mailbox.org )';
|
|
const RATE_LIMIT_DELAY = 25; // 25ms between requests = ~40 req/s (safe margin)
|
|
|
|
/**
|
|
* Sleep utility for rate limiting
|
|
*/
|
|
function sleep(ms: number): Promise<void> {
|
|
return new Promise(resolve => setTimeout(resolve, ms));
|
|
}
|
|
|
|
/**
|
|
* Fetch with retry logic for HTTP 503 (rate limit exceeded)
|
|
*/
|
|
async function fetchWithRetry(url: string, maxRetries = 5): Promise<Response> {
|
|
let lastError: Error | null = null;
|
|
|
|
for (let attempt = 0; attempt < maxRetries; attempt++) {
|
|
try {
|
|
const response = await fetch(url, {
|
|
headers: {
|
|
'User-Agent': USER_AGENT,
|
|
'Accept': 'application/json'
|
|
}
|
|
});
|
|
|
|
// If rate limited (503), wait with exponential backoff
|
|
if (response.status === 503) {
|
|
const waitTime = Math.pow(2, attempt) * 1000; // 1s, 2s, 4s, 8s, 16s
|
|
console.log(`Rate limited (503), waiting ${waitTime}ms before retry ${attempt + 1}/${maxRetries}...`);
|
|
await sleep(waitTime);
|
|
continue;
|
|
}
|
|
|
|
return response;
|
|
} catch (error) {
|
|
lastError = error as Error;
|
|
if (attempt < maxRetries - 1) {
|
|
const waitTime = Math.pow(2, attempt) * 1000;
|
|
console.log(`Network error, waiting ${waitTime}ms before retry ${attempt + 1}/${maxRetries}...`);
|
|
await sleep(waitTime);
|
|
}
|
|
}
|
|
}
|
|
|
|
throw lastError || new Error('Max retries exceeded');
|
|
}
|
|
|
|
/**
|
|
* Get the earliest release year for a song from MusicBrainz
|
|
* @param artist Artist name
|
|
* @param title Song title
|
|
* @returns Release year or null if not found
|
|
*/
|
|
export async function getReleaseYear(artist: string, title: string): Promise<number | null> {
|
|
try {
|
|
// Build search query using Lucene syntax
|
|
const query = `artist:"${artist}" AND recording:"${title}"`;
|
|
const url = `${MUSICBRAINZ_API_BASE}/recording?query=${encodeURIComponent(query)}&fmt=json&limit=10`;
|
|
|
|
// Add rate limiting delay
|
|
await sleep(RATE_LIMIT_DELAY);
|
|
|
|
const response = await fetchWithRetry(url);
|
|
|
|
if (!response.ok) {
|
|
console.error(`MusicBrainz API error: ${response.status} ${response.statusText}`);
|
|
return null;
|
|
}
|
|
|
|
const data = await response.json();
|
|
|
|
if (!data.recordings || data.recordings.length === 0) {
|
|
console.log(`No recordings found for "${title}" by "${artist}"`);
|
|
return null;
|
|
}
|
|
|
|
// Find the earliest release year from all recordings
|
|
let earliestYear: number | null = null;
|
|
|
|
for (const recording of data.recordings) {
|
|
// Check if recording has releases
|
|
if (recording.releases && recording.releases.length > 0) {
|
|
for (const release of recording.releases) {
|
|
if (release.date) {
|
|
// Extract year from date (format: YYYY-MM-DD or YYYY)
|
|
const year = parseInt(release.date.split('-')[0]);
|
|
if (!isNaN(year) && (earliestYear === null || year < earliestYear)) {
|
|
earliestYear = year;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Also check first-release-date on the recording itself
|
|
if (recording['first-release-date']) {
|
|
const year = parseInt(recording['first-release-date'].split('-')[0]);
|
|
if (!isNaN(year) && (earliestYear === null || year < earliestYear)) {
|
|
earliestYear = year;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (earliestYear) {
|
|
console.log(`Found release year ${earliestYear} for "${title}" by "${artist}"`);
|
|
} else {
|
|
console.log(`No release year found for "${title}" by "${artist}"`);
|
|
}
|
|
|
|
return earliestYear;
|
|
} catch (error) {
|
|
console.error(`Error fetching release year for "${title}" by "${artist}":`, error);
|
|
return null;
|
|
}
|
|
}
|