Walking a Label's Full Discography Programmatically

import fs from "node:fs";

const API_KEY = process.env.SONOVAULT_API_KEY!;
const BASE    = "https://api.sonovault.now/v1";

interface Release {
  id: number; title: string;
  artist: { id: number; name: string };
  label:  { id: number; name: string } | null;
  release_date: string;
  catalog_no:   string | null;
  track_count:  number;
}

async function walkLabel(labelId: number): Promise<Release[]> {
  const out: Release[] = [];
  let cursor: string | null = null;

  while (true) {
    const qs: Record<string, string> = { limit: "100" };
    if (cursor) qs.cursor = cursor;
    const u   = `${BASE}/labels/${labelId}/releases?${new URLSearchParams(qs)}`;
    const res = await fetch(u, { headers: { "x-api-key": API_KEY } });
    if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);

    const page = await res.json();
    out.push(...page.results);
    console.log(`  fetched ${out.length} so far…`);

    if (!page.next_cursor) break;
    cursor = page.next_cursor;
  }
  return out;
}

const labelId  = 1;
const releases = await walkLabel(labelId);
console.log(`Walked ${releases.length} releases`);
fs.writeFileSync(`./label-${labelId}.json`, JSON.stringify(releases, null, 2));

interface ReleaseFull extends Release {
  tracks: { id: number; title: string; isrc: string; duration: number; genre: string[]; subgenre: string[] }[];
}

async function withTracks(release: Release): Promise<ReleaseFull> {
  const res  = await fetch(`${BASE}/releases/${release.id}`, {
    headers: { "x-api-key": API_KEY },
  });
  const full = await res.json();
  return { ...release, tracks: full.tracks };
}

// Modest concurrency — 4 in flight at a time.
// (For real production use, swap for p-limit or a proper queue.)
async function enrichAll(releases: Release[]): Promise<ReleaseFull[]> {
  const out: ReleaseFull[] = [];
  const CONCURRENCY = 4;

  for (let i = 0; i < releases.length; i += CONCURRENCY) {
    const batch = await Promise.all(
      releases.slice(i, i + CONCURRENCY).map(withTracks),
    );
    out.push(...batch);
  }
  return out;
}

const full = await enrichAll(releases);
fs.writeFileSync(`./label-${labelId}-full.json`, JSON.stringify(full, null, 2));

import fs from "node:fs/promises";

async function incrementalWalk(labelId: number, sinceFile: string): Promise<Release[]> {
  let since = "";
  try   { since = (await fs.readFile(sinceFile, "utf-8")).trim(); }
  catch { /* first run; full walk */ }

  const out: Release[] = [];
  let cursor: string | null = null;
  let newest: string = since;

  walking: while (true) {
    const qs: Record<string, string> = { limit: "100" };
    if (cursor) qs.cursor = cursor;
    const u    = `${BASE}/labels/${labelId}/releases?${new URLSearchParams(qs)}`;
    const page = await (await fetch(u, { headers: { "x-api-key": API_KEY } })).json();

    for (const r of page.results as Release[]) {
      if (since && r.release_date <= since) break walking; // caught up
      out.push(r);
      if (r.release_date > newest) newest = r.release_date;
    }
    if (!page.next_cursor) break;
    cursor = page.next_cursor;
  }

  if (newest) await fs.writeFile(sinceFile, newest);
  return out;
}