scoreko-dev/src/extension/nodecg-bindings/challonge.ts

import { nodecg } from '../util/nodecg.js';
import { getStringProp, normalizeTournamentSlug } from '../../shared/utils/string.js';
import { challongeOAuthServer, getOAuthMode } from '../oauth/challonge.js';
import { fetchRecentTournaments, fetchTournamentPlayers } from '../services/challonge.js';
import type { OAuthConfig } from '../util/oauth-server.js';

const sendAck = (ack: unknown, error: string | null, response?: unknown) => {
  if (typeof ack === 'function') ack(error, response);
};

nodecg.listenFor('challonge:createOAuthSession', async (_payload: unknown, ack) => {
  const mode = getOAuthMode();
  let serverConfig: OAuthConfig;

  if (mode.type === 'dev') {
    serverConfig = {
      clientId: mode.clientId,
      callbackPort: mode.callbackPort,
    };
  } else {
    try {
      const res = await fetch(`${mode.proxyBaseUrl}/oauth/challonge/client-id`);
      if (!res.ok) throw new Error(`Proxy responded with ${res.status}`);
      const data = await res.json() as { clientId?: string };
      const clientId = String(data.clientId ?? '').trim();
      if (!clientId) throw new Error('Proxy did not return a clientId');
      serverConfig = { clientId, callbackPort: mode.callbackPort };
    } catch (err) {
      sendAck(
        ack,
        err instanceof Error ? err.message : 'Could not fetch OAuth config from proxy',
      );
      return;
    }
  }

  try {
    await challongeOAuthServer.ensureServer(serverConfig);
  } catch (err) {
    sendAck(ack, err instanceof Error ? err.message : 'Could not start the OAuth callback server');
    return;
  }

  sendAck(ack, null, challongeOAuthServer.createSession(serverConfig));
});

nodecg.listenFor('challonge:getOAuthSessionStatus', (payload: unknown, ack) => {
  const sessionId = getStringProp(payload, 'sessionId');
  if (!sessionId) {
    sendAck(ack, 'Missing OAuth session id');
    return;
  }

  const status = challongeOAuthServer.getSessionStatus(sessionId);
  if (!status) {
    sendAck(ack, 'OAuth session not found');
    return;
  }

  sendAck(ack, null, status);
});

nodecg.listenFor('challonge:fetchRecentTournaments', async (payload: unknown, ack) => {
  const token = getStringProp(payload, 'token');
  if (!token) {
    sendAck(ack, 'Missing Challonge API token');
    return;
  }

  try {
    const tournaments = await fetchRecentTournaments(token);
    sendAck(ack, null, tournaments);
  } catch (error) {
    sendAck(ack, error instanceof Error ? error.message : 'Unknown error while loading tournaments');
  }
});

nodecg.listenFor('challonge:fetchTournamentPlayers', async (payload: unknown, ack) => {
  const token = getStringProp(payload, 'token');
  const slug = normalizeTournamentSlug(getStringProp(payload, 'slug'));

  if (!token) { sendAck(ack, 'Missing Challonge API token'); return; }
  if (!slug) { sendAck(ack, 'Missing tournament slug'); return; }

  try {
    const players = await fetchTournamentPlayers(slug, token);
    sendAck(ack, null, players);
  } catch (error) {
    sendAck(ack, error instanceof Error ? error.message : 'Unknown error while importing players');
  }
});