duty-teller/webapp/js/api.js

/**
 * Network requests: duties and calendar events.
 */

import { FETCH_TIMEOUT_MS } from "./constants.js";
import { getInitData } from "./auth.js";
import { state } from "./dom.js";
import { t } from "./i18n.js";

/**
 * Build fetch options with init data header, Accept-Language and timeout abort.
 * Optional external signal (e.g. from loadMonth) aborts this request when triggered.
 * @param {string} initData - Telegram init data
 * @param {AbortSignal} [externalSignal] - when aborted, cancels this request
 * @returns {{ headers: object, signal: AbortSignal, cleanup: () => void }}
 */
export function buildFetchOptions(initData, externalSignal) {
  const headers = {};
  if (initData) headers["X-Telegram-Init-Data"] = initData;
  headers["Accept-Language"] = state.lang || "ru";
  const controller = new AbortController();
  const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
  const onAbort = () => controller.abort();
  const cleanup = () => {
    clearTimeout(timeoutId);
    if (externalSignal) externalSignal.removeEventListener("abort", onAbort);
  };
  if (externalSignal) {
    if (externalSignal.aborted) {
      cleanup();
      controller.abort();
    } else {
      externalSignal.addEventListener("abort", onAbort);
    }
  }
  return { headers, signal: controller.signal, cleanup };
}

/**
 * GET request to API with init data, Accept-Language, timeout.
 * Caller checks res.ok, res.status, res.json().
 * @param {string} path - e.g. "/api/duties"
 * @param {{ from?: string, to?: string }} params - query params
 * @param {{ signal?: AbortSignal }} [options] - optional abort signal for request cancellation
 * @returns {Promise<Response>} - raw response
 */
export async function apiGet(path, params = {}, options = {}) {
  const base = window.location.origin;
  const query = new URLSearchParams(params).toString();
  const url = query ? `${base}${path}?${query}` : `${base}${path}`;
  const initData = getInitData();
  const opts = buildFetchOptions(initData, options.signal);
  try {
    const res = await fetch(url, { headers: opts.headers, signal: opts.signal });
    return res;
  } finally {
    opts.cleanup();
  }
}

/**
 * Fetch duties for date range. Throws ACCESS_DENIED error on 403.
 * AbortError is rethrown when the request is cancelled (e.g. stale loadMonth).
 * @param {string} from - YYYY-MM-DD
 * @param {string} to - YYYY-MM-DD
 * @param {AbortSignal} [signal] - optional signal to cancel the request
 * @returns {Promise<object[]>}
 */
export async function fetchDuties(from, to, signal) {
  try {
    const res = await apiGet("/api/duties", { from, to }, { signal });
    if (res.status === 403) {
      let detail = t(state.lang, "access_denied");
      try {
        const body = await res.json();
        if (body && body.detail !== undefined) {
          detail =
            typeof body.detail === "string"
              ? body.detail
              : (body.detail.msg || JSON.stringify(body.detail));
        }
      } catch (parseErr) {
        /* ignore */
      }
      const err = new Error("ACCESS_DENIED");
      err.serverDetail = detail;
      throw err;
    }
    if (!res.ok) throw new Error(t(state.lang, "error_load_failed"));
    return res.json();
  } catch (e) {
    if (e.name === "AbortError") throw e;
    throw e;
  }
}

/**
 * Fetch calendar events for range. Returns [] on non-200 or error. Does not throw for 403.
 * Rethrows AbortError when the request is cancelled (e.g. stale loadMonth).
 * @param {string} from - YYYY-MM-DD
 * @param {string} to - YYYY-MM-DD
 * @param {AbortSignal} [signal] - optional signal to cancel the request
 * @returns {Promise<object[]>}
 */
export async function fetchCalendarEvents(from, to, signal) {
  try {
    const res = await apiGet("/api/calendar-events", { from, to }, { signal });
    if (!res.ok) return [];
    return res.json();
  } catch (e) {
    if (e.name === "AbortError") throw e;
    return [];
  }
}