http-instance.ts

type HttpInterceptor = (
  options: FetchOptions,
) => Promise<FetchOptions> | FetchOptions;

type HttpInstance = {
  baseURL: string;
  headers: Record<string, string>;
};
export const HTTP_INSTANCE: HttpInstance = {
  baseURL: '',
  headers: {},
};

export type FetchOptions = {
  baseURL?: string;
  headers?: Record<string, string>;
  url: string;
  method:
    | 'get'
    | 'post'
    | 'put'
    | 'delete'
    | 'patch'
    | 'GET'
    | 'POST'
    | 'PUT'
    | 'DELETE'
    | 'PATCH';
  params?: any;
  data?: any;
  responseType?: string;
  signal?: AbortSignal;
};

export type FetchResponse<T = unknown> = {
  data: T;
  headers: {
    authorization?: string | null;
  };
};

export type FetchError<T = unknown> = {
  data: T;
  status: number;
};

export const getResponseBody = <T>(response: Response): Promise<T> => {
  const contentType = response.headers.get('content-type');

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

  if (contentType && contentType.includes('application/pdf')) {
    return response.blob() as Promise<T>;
  }

  return response.text() as Promise<T>;
};

export const fetchInstance = async <T>(
  config: FetchOptions,
  init?: ResponseInit
): Promise<FetchResponse<T>> => {
  const isFormData = config.headers?.['Content-Type'] === 'multipart/form-data';
  const isJson = config.headers?.['Content-Type'] === 'application/json';

  const baseUrl = config.baseURL;

  const headers = {
    ...config.headers,
    ...(isJson ? { 'Content-Type': 'application/json' } : {}),
  };

  // Remove Content-Type header if it's not needed to avoid issues
  if (!isJson) {
    delete headers['Content-Type'];
  }

  const response = await fetch(
    `${baseUrl}${config.url}` +
      (config.params ? `?${new URLSearchParams(config.params)}` : ''),
    {
      method: config.method,
      ...(config.data
        ? { body: !isFormData ? JSON.stringify(config.data) : config.data }
        : {}),
      headers,
      signal: config.signal,
    },
  );

  const data = await getResponseBody<T>(response);

  if (!response.ok) {
    throw {
      status: response.status,
      data,
    };
  }

  return {
    headers: {
      authorization: response.headers.get('authorization'),
    },
    data,
  };
};