lonc/src/api/client.js

import { API_PATHS } from '../app/config.js';
import { resolveApiRequestUrl } from './url.js';

async function parseJsonResponse(response) {
  const text = await response.text();
  if (!text) {
    return null;
  }

  try {
    return JSON.parse(text);
  } catch {
    return text;
  }
}

async function parseResponse(response) {
  if (response.status === 204) {
    return null;
  }

  const contentType = response.headers.get('content-type') || '';

  if (contentType.includes('application/json')) {
    return parseJsonResponse(response);
  }

  if (contentType.includes('image/')) {
    return response.blob();
  }

  const text = await response.text();
  if (!text) {
    return null;
  }

  try {
    return JSON.parse(text);
  } catch {
    return text;
  }
}

function flattenErrorObject(value) {
  if (!value || typeof value !== 'object' || Array.isArray(value)) {
    return null;
  }

  return Object.fromEntries(
    Object.entries(value).map(([key, entry]) => {
      if (Array.isArray(entry)) {
        return [key, entry.join(', ')];
      }

      return [key, String(entry)];
    }),
  );
}

function extractErrorMessage(response, payload) {
  if (typeof payload === 'string' && payload.trim()) {
    return payload;
  }

  if (Array.isArray(payload) && payload.length) {
    return payload.map((entry) => String(entry)).join(', ');
  }

  if (payload && typeof payload === 'object') {
    const directMessage =
      payload.message ||
      payload.error ||
      payload.detail ||
      payload.description ||
      payload.title;

    if (typeof directMessage === 'string' && directMessage.trim()) {
      return directMessage;
    }

    const fieldErrors = flattenErrorObject(payload.errors || payload.details);
    if (fieldErrors) {
      return Object.entries(fieldErrors)
        .map(([field, message]) => `${field}: ${message}`)
        .join(' | ');
    }
  }

  return `Request failed with status ${response.status}.`;
}

function normalizeError(response, payload, request) {
  const details = flattenErrorObject(payload?.errors || payload?.details) || null;
  const payloadMessage = extractErrorMessage(response, payload);
  const statusHint =
    response.status === 404
      ? 'This usually means the request hit the wrong origin, port, or path.'
      : response.status === 401 || response.status === 403
        ? 'Authentication or application-key validation failed.'
        : response.status >= 500
          ? 'The backend reported a server error.'
          : '';
  const message = [
    `${request.method} ${request.resolvedUrl} returned ${response.status}.`,
    statusHint,
    payloadMessage && !payloadMessage.startsWith('Request failed with status')
      ? payloadMessage
      : '',
  ]
    .filter(Boolean)
    .join(' ');

  const error = new Error(message, {
    cause: {
      status: response.status,
      details,
      url: request.resolvedUrl,
      fetchUrl: request.fetchUrl,
      method: request.method,
      payload,
    },
  });

  error.name = 'ApiRequestError';
  error.status = response.status;
  error.url = request.resolvedUrl;
  error.fetchUrl = request.fetchUrl;
  error.method = request.method;
  error.details = details;
  error.payload = payload;

  return error;
}

function logApiFailure(message, context) {
  console.error(message, context);
}

export async function apiRequest(store, path, options = {}) {
  const { config, session, activeKitchen } = store;

  if (!config.database) {
    throw new Error('Database name is required.');
  }

  const method = options.method || 'GET';
  const currentOrigin = typeof window !== 'undefined' ? window.location.origin : '';
  const requestTarget = resolveApiRequestUrl({
    baseUrl: config.baseUrl,
    currentOrigin,
    database: config.database,
    kitchenId: activeKitchen?.id,
    path,
    query: options.query,
    includeKitchen: options.includeKitchen !== false,
  });
  const headers = new Headers(options.headers || {});
  headers.set('Accept', options.accept || 'application/json');

  if (options.body && !options.isFormData) {
    headers.set('Content-Type', 'application/json');
  }

  if (session?.applicationKey) {
    headers.set('Authorization', `Bearer ${session.applicationKey}`);
  }

  let response;
  try {
    response = await fetch(requestTarget.fetchUrl, {
      method,
      headers,
      credentials: options.credentials || 'same-origin',
      body:
        options.body && !options.isFormData
          ? JSON.stringify(options.body)
          : options.body || undefined,
    });
  } catch (error) {
    const networkHint = requestTarget.isCrossOrigin
      ? 'Cross-origin request failed before a usable response was returned. Check nginx CORS/preflight handling and that the configured API origin is reachable.'
      : 'Request failed before a response was returned. Check that the current origin serves the API or configure the Tryton server URL explicitly.';
    const networkError = new Error(
      `${method} ${requestTarget.resolvedUrl} failed before a response was returned. ${networkHint}`,
      {
        cause: {
          url: requestTarget.resolvedUrl,
          fetchUrl: requestTarget.fetchUrl,
          method,
          isCrossOrigin: requestTarget.isCrossOrigin,
          originalError: error,
        },
      },
    );
    networkError.name = 'ApiNetworkError';
    networkError.url = requestTarget.resolvedUrl;
    networkError.fetchUrl = requestTarget.fetchUrl;
    networkError.method = method;
    networkError.isCrossOrigin = requestTarget.isCrossOrigin;
    logApiFailure('API network request failed', {
      url: requestTarget.resolvedUrl,
      fetchUrl: requestTarget.fetchUrl,
      method,
      error,
    });
    throw networkError;
  }

  const payload = await parseResponse(response);
  if (!response.ok) {
    const apiError = normalizeError(response, payload, {
      resolvedUrl: requestTarget.resolvedUrl,
      fetchUrl: requestTarget.fetchUrl,
      method,
    });
    logApiFailure('API request returned an error response', {
      url: requestTarget.resolvedUrl,
      fetchUrl: requestTarget.fetchUrl,
      method,
      status: response.status,
      payload,
    });
    throw apiError;
  }

  return payload;
}

export function getPath(key) {
  return API_PATHS[key];
}

export function buildKitchenApiUrl(store, path, query = {}) {
  return resolveApiRequestUrl({
    baseUrl: store.config.baseUrl,
    currentOrigin: typeof window !== 'undefined' ? window.location.origin : '',
    database: store.config.database,
    kitchenId: store.activeKitchen?.id,
    path,
    query,
    includeKitchen: true,
  }).resolvedUrl;
}