api.js

Go to the documentation of this file.

// src/lib/api.js
// Robust API helper that automatically detects environment and constructs proper absolute URLs
 
// Detect the API base dynamically or via .env
export const API_BASE = (() => {
  // 1️⃣ Prefer explicit env setting (for production)
  if (import.meta.env.VITE_API_URL?.trim()) {
    return import.meta.env.VITE_API_URL.trim().replace(/\/$/, '') || 'https://everydaytech.au/api';
  }
 
  // 2️⃣ Fallback: if we’re on localhost (vite dev), point to backend port 3000
  if (window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1') {
    return 'http://localhost:3000/api';
  }
 
  // 3️⃣ Otherwise, build automatically from current domain + /api
  return `${window.location.origin.replace(/\/$/, '')}/api`;
})();
 
console.log('[api.js] Resolved API_BASE:', API_BASE);
 
// Helper to get clean base (used by apiUrl)
const getAbsoluteBase = () => {
  let base = API_BASE;
 
  // If it's an absolute URL, ensure it ends with a slash
  if (base.startsWith('http://') || base.startsWith('https://')) {
    return base.replace(/\/?$/, '/');
  }
 
  // Otherwise build from origin and ensure trailing slash
  const origin = window.location.origin.replace(/\/$/, '');
  const clean = base.startsWith('/') ? base : `/${base}`;
  return `${origin}${clean}`.replace(/\/?$/, '/');
};
 
 
// Build a full API URL from relative path (e.g. '/tickets' → https://demo.everydayoffice.au/api/tickets)
export const apiUrl = (path = '/') => {
  // Always produce a valid URL, even for empty or malformed paths
  if (!path || typeof path !== 'string' || path.trim() === '') {
    return new URL('/', getAbsoluteBase());
  }
  let cleanPath = String(path).replace(/^\//, '');
  const absBase = getAbsoluteBase();
  // If path is only a query string (e.g. '?search=foo'), prepend a slash
  if (cleanPath.startsWith('?')) {
    cleanPath = '/' + cleanPath;
  }
  try {
    const full = new URL(cleanPath, absBase);
    return full;
  } catch (err) {
    console.error('[apiUrl] Failed to construct URL:', cleanPath, absBase, err);
    return new URL('/', absBase);
  }
};
 
// Centralized fetch helper — automatically attaches JWT and handles JSON
export const apiFetch = async (path, options = {}) => {
  const token = localStorage.getItem('token');
  const headers = {
    ...(options.headers || {}),
    ...(token ? { Authorization: `Bearer ${token}` } : {}),
  };
 
  // If body is present and it's a string (JSON), automatically add Content-Type
  if (options.body && typeof options.body === 'string') {
    headers['Content-Type'] = headers['Content-Type'] || 'application/json';
  }
 
  // Decode JWT to check if we're impersonating
  let isImpersonating = false;
  let jwtTenantId = null;
  if (token) {
    try {
      const payload = token.split('.')[1];
      const decoded = JSON.parse(atob(payload.replace(/-/g, '+').replace(/_/g, '/')));
      isImpersonating = !!decoded.impersonated;
      jwtTenantId = decoded.tenant_id || decoded.tenantId || null;
    } catch (err) {
      console.warn('[apiFetch] Failed to decode JWT:', err);
    }
  }
 
  let urlObj = apiUrl(path);
  
  // Do NOT add tenant_id query param when impersonating - backend reads it from JWT
  // Only add tenant_id for global/root-only endpoints that need explicit tenant override
  const pathNoQuery = String(path).split('?')[0].replace(/\\/g, '/');
  const isGlobalEndpoint = (
    pathNoQuery === 'tenants' ||
    pathNoQuery === '/tenants' ||
    pathNoQuery === 'tenants/' ||
    pathNoQuery === '/tenants/' ||
    pathNoQuery === 'tenants/current' ||
    pathNoQuery === '/tenants/current' ||
    pathNoQuery === 'auth/impersonate' ||
    pathNoQuery === '/auth/impersonate' ||
    pathNoQuery === 'auth/exit-impersonation' ||
    pathNoQuery === '/auth/exit-impersonation'
  );
 
  // Legacy support: Only use localStorage tenant selection if NOT impersonating
  let selectedTenantId = (localStorage.getItem('selectedTenantId') || '').trim().replace(/['"]/g, '');
  if (!isImpersonating && selectedTenantId && selectedTenantId !== '' && !isGlobalEndpoint) {
    urlObj.searchParams.set('tenant_id', selectedTenantId);
  }
 
  // Logging request details
  console.log('[apiFetch] Request:', {
    url: urlObj.toString(),
    method: options.method || 'GET',
    isImpersonating,
    jwtTenantId,
    selectedTenantId: isImpersonating ? null : selectedTenantId,
    headers: { ...headers, Authorization: token ? 'Bearer <redacted>' : undefined },
    options
  });
 
  let res;
  try {
    res = await fetch(urlObj.toString(), {
      ...options,
      headers,
      credentials: 'include',
    });
  } catch (err) {
    console.error('[apiFetch] Network error:', err, {
      url: urlObj.toString(),
      method: options.method || 'GET',
      isImpersonating,
      jwtTenantId
    });
    throw err;
  }
 
  if (!res.ok) {
    console.warn('[apiFetch] Request failed:', {
      url: urlObj.toString(),
      status: res.status,
      statusText: res.statusText,
      method: options.method || 'GET',
      isImpersonating,
      jwtTenantId
    });
  }
 
  return res;
};