Hold one socket, hear every change

// live.ts: a merged, self-healing view of every match in play.
// Runs on Node 22+, Deno and Bun, which ship a global WebSocket.
const API = "https://api.datasportsapi.com";
const KEY = process.env.DATASPORTSAPI_API_KEY!;
const CHANNELS = ["livescores"];

type Json = Record<string, unknown>;
type Fixture = Json & { id: number };
type Frame = Json & { type: string; channel?: string; seq?: number; ts: number };

const fixtures = new Map<number, Fixture>(); // what your UI renders
const lastSeq = new Map<string, number>(); // per channel: gap checks and replay
const resyncing = new Set<string>(); // channels waiting for a fresh snapshot
let backoff = 1_000;

const isObject = (v: unknown): v is Json => typeof v === "object" && v !== null && !Array.isArray(v);

/** Plain objects are merged field by field; anything else (null and arrays too) overwrites. */
function merge(target: Json, patch: Json) {
  for (const [key, value] of Object.entries(patch)) {
    const current = target[key];
    if (isObject(value) && isObject(current)) merge(current, value);
    else target[key] = value;
  }
}

async function mintTicket(): Promise<string> {
  const res = await fetch(`${API}/v2/stream/ticket`, {
    method: "POST",
    headers: { Authorization: `Bearer ${KEY}` },
  });
  const body = await res.json();
  if (!res.ok) throw new Error(`ticket refused: ${res.status} ${body.error.code}`);
  return body.data.url; // wss://api.datasportsapi.com/?ticket=…, single use, valid for 30 seconds
}

function send(ws: WebSocket, frame: Json) {
  ws.send(JSON.stringify(frame));
}

function onFrame(ws: WebSocket, f: Frame) {
  // Frames after the baseline must arrive as seq + 1 on their channel.
  const ordered = f.channel && f.seq !== undefined && f.type !== "snapshot" && f.type !== "subscribed";
  if (ordered) {
    if (resyncing.has(f.channel!)) return; // a snapshot is on its way
    const prev = lastSeq.get(f.channel!);
    if (prev !== undefined && f.seq !== prev + 1) {
      resyncing.add(f.channel!);
      send(ws, { type: "resync", channel: f.channel });
      return;
    }
  }
  if (f.channel && f.seq !== undefined) lastSeq.set(f.channel, f.seq);

  switch (f.type) {
    case "welcome":
      backoff = 1_000;
      for (const channel of CHANNELS) {
        const seq = lastSeq.get(channel);
        // After a drop, lastSeq asks for the missed frames instead of a new snapshot.
        send(ws, seq === undefined ? { type: "subscribe", channel } : { type: "subscribe", channel, lastSeq: seq });
      }
      break;
    case "snapshot": // one channel here, so the snapshot is the whole picture
      resyncing.delete(f.channel!);
      fixtures.clear();
      for (const fx of f.data as Fixture[]) fixtures.set(fx.id, fx);
      break;
    case "fixture": // a match kicked off, or the server saw it for the first time
      fixtures.set(f.id as number, f.data as Fixture);
      break;
    case "delta": {
      const fx = fixtures.get(f.id as number);
      if (!fx) break;
      merge(fx, f.changes as Json);
      // The last delta of a match that leaves the channel says why.
      const status = fx.status as { type?: string } | undefined;
      if (status?.type === "finished" || status?.type === "canceled") fixtures.delete(fx.id);
      break;
    }
    case "error":
      console.warn(`stream error ${f.code}: ${f.message}`);
      if (f.code === "snapshot_failed" && f.channel) send(ws, { type: "resync", channel: f.channel });
      break;
  }
}

function retry(wait = backoff) {
  backoff = Math.min(backoff * 2, 30_000);
  setTimeout(start, wait);
}

async function connect() {
  const ws = new WebSocket(await mintTicket());
  ws.onmessage = (ev) => onFrame(ws, JSON.parse(String(ev.data)));
  ws.onclose = (ev) => {
    // 1013: every connection your account may hold is open. Wait longer.
    // 1008: bad ticket, or the key or plan changed; ev.reason says which.
    resyncing.clear();
    retry(ev.code === 1013 ? 60_000 : backoff);
  };
}

function start() {
  connect().catch((err) => {
    console.error(err); // a 401 or 403 on the ticket will not heal itself: alert a human
    retry();
  });
}

start();