Online booking widget

// practicehub.ts
const BASE = process.env.PRACTICEHUB_BASE_URL!;   // https://your-clinic.your-region.practicehub.io/v3/api
const KEY  = process.env.PRACTICEHUB_API_KEY!;

export class ApiError extends Error {
  constructor(public status: number, public code: string, message: string, public errors?: Record<string, string[]>) {
    super(message);
  }
}

export async function api<T>(method: string, path: string, body?: unknown, headers: Record<string, string> = {}): Promise<T> {
  for (let attempt = 0; ; attempt++) {
    const res = await fetch(`${BASE}${path}`, {
      method,
      headers: { Authorization: `Bearer ${KEY}`, Accept: 'application/json', 'Content-Type': 'application/json', ...headers },
      body: body === undefined ? undefined : JSON.stringify(body),
    });

    if (res.status === 204) return undefined as T;
    if (res.ok) return (await res.json()) as T;

    const retryable = res.status === 429 || res.status >= 500;
    if (retryable && attempt < 4) {
      const retryAfter = Number(res.headers.get('Retry-After') ?? 0);
      await new Promise(r => setTimeout(r, (retryAfter || 2 ** attempt) * 1000));
      continue;
    }

    const err = (await res.json().catch(() => ({}))) as { message?: string; code?: string; errors?: Record<string, string[]> };
    throw new ApiError(res.status, err.code ?? 'unknown', err.message ?? res.statusText, err.errors);
  }
}

type Row<T> = { data: T[] };
type Location = { id: number; name: string; online_booking: boolean };
type AppointmentType = { id: number; name: string; duration: number; online_booking: boolean; active: boolean };

const [locations, types] = await Promise.all([
  api<Row<Location>>('GET', '/locations?online_booking=eq:1'),
  api<Row<AppointmentType>>('GET', '/appointment_types?active=eq:1&online_booking=eq:1'),
]);

type Slot = {
  start: string; end: string;                // clinic-local "YYYY-MM-DD HH:MM:SS"
  practitioner_id: number; practitioner_name: string;
  location_id: number; appointment_type_id: number; resource_id: number | null;
  type: 'individual' | 'group'; group_master_id: number | null; online_fee: number | null;
};
type Availability = { data: Slot[]; meta: { timezone: string; from: string; to: string; visibility: string; unavailable_dates: string[] } };

const q = new URLSearchParams({ location_id: '81', appointment_type_id: '1', from: '2026-09-01', to: '2026-09-07' });
const { data: slots, meta } = await api<Availability>('GET', `/availability?${q}`);

type Patient = { id: number; first_name: string; last_name: string | null; email: string | null; metadata: Record<string, unknown> };

async function findOrCreatePatient(v: { firstName: string; lastName: string; email: string; mobile: string }): Promise<number> {
  const found = await api<Row<Patient>>('GET', `/patients?email=eq:${encodeURIComponent(v.email)}&page_size=1`);
  if (found.data.length) return found.data[0].id;

  const created = await api<{ data: Patient }>('POST', '/patients', {
    first_name: v.firstName,
    last_name: v.lastName,
    email: v.email,
    numbers: [{ number: v.mobile, country_code: '44', iso2: 'GB', type: 'mobile' }],
    metadata: { source: 'website-widget' },
  });
  return created.data.id;
}

type Appointment = { id: number; status: string; start: string; end: string; practitioner_id: number; patient_id: number };

async function book(patientId: number, slot: Slot, bookingRef: string) {
  const body = slot.type === 'group'
    ? { patient_id: patientId, appointment_type_id: slot.appointment_type_id, group_master_id: slot.group_master_id, note: 'Booked from the website' }
    : {
        patient_id: patientId,
        location_id: slot.location_id,
        appointment_type_id: slot.appointment_type_id,
        practitioner_id: slot.practitioner_id,
        resource_id: slot.resource_id,
        start: slot.start,
        end: slot.end,
        note: 'Booked from the website',
        metadata: { widget_ref: bookingRef },
      };

  try {
    const { data } = await api<{ data: Appointment }>('POST', '/appointments', body, { 'Idempotency-Key': `widget-${bookingRef}` });
    return { ok: true as const, appointment: data };
  } catch (e) {
    if (e instanceof ApiError && (e.code === 'slot_unavailable' || e.code === 'group_full')) {
      return { ok: false as const, reason: 'taken' };          // re-query availability, offer the next slot
    }
    if (e instanceof ApiError && e.status === 422) {
      return { ok: false as const, reason: 'invalid', errors: e.errors };
    }
    throw e;
  }
}

// Cancel (a real cancellation: same side effects as staff cancelling)
await api('PATCH', `/appointments/${id}`, { status: 'cancelled', cancel_note: 'Cancelled by patient via website' });

// Move: re-run availability with rescheduled_appointment_id so the current booking's own time
// is not counted as busy, then PATCH the new start/end (and practitioner if it changed)
const q = new URLSearchParams({ location_id, appointment_type_id, from, to, rescheduled_appointment_id: String(id) });
const { data: slots } = await api<Availability>('GET', `/availability?${q}`);
await api('PATCH', `/appointments/${id}`, { start: slot.start, end: slot.end, practitioner_id: slot.practitioner_id });