HttpUtils.ts

import { fetch } from 'cross-fetch';
import Debug from 'debug';

import { ContentType, SIOPErrors, SIOPResonse } from '../types';

const debug = Debug('sphereon:siopv2:http');

export const getJson = async <T>(
  URL: string,
  opts?: {
    bearerToken?: string;
    contentType?: string | ContentType;
    accept?: string;
    customHeaders?: HeadersInit;
    exceptionOnHttpErrorStatus?: boolean;
  }
): Promise<SIOPResonse<T>> => {
  return await siopFetch(URL, undefined, { method: 'GET', ...opts });
};

export const formPost = async <T>(
  url: string,
  body: BodyInit,
  opts?: {
    bearerToken?: string;
    contentType?: string | ContentType;
    accept?: string;
    customHeaders?: HeadersInit;
    exceptionOnHttpErrorStatus?: boolean;
  }
): Promise<SIOPResonse<T>> => {
  return await post(url, body, opts?.contentType ? { ...opts } : { contentType: ContentType.FORM_URL_ENCODED, ...opts });
};

export const post = async <T>(
  url: string,
  body?: BodyInit,
  opts?: {
    bearerToken?: string;
    contentType?: string | ContentType;
    accept?: string;
    customHeaders?: HeadersInit;
    exceptionOnHttpErrorStatus?: boolean;
  }
): Promise<SIOPResonse<T>> => {
  return await siopFetch(url, body, { method: 'POST', ...opts });
};

const siopFetch = async <T>(
  url: string,
  body?: BodyInit,
  opts?: {
    method?: string;
    bearerToken?: string;
    contentType?: string | ContentType;
    accept?: string;
    customHeaders?: HeadersInit;
    exceptionOnHttpErrorStatus?: boolean;
  }
): Promise<SIOPResonse<T>> => {
  if (!url || url.toLowerCase().startsWith('did:')) {
    throw Error(`Invalid URL supplied. Expected a http(s) URL. Recieved: ${url}`);
  }
  const headers = opts?.customHeaders ? opts.customHeaders : {};
  if (opts?.bearerToken) {
    headers['Authorization'] = `Bearer ${opts.bearerToken}`;
  }
  const method = opts?.method ? opts.method : body ? 'POST' : 'GET';
  const accept = opts?.accept ? opts.accept : 'application/json';
  headers['Content-Type'] = opts?.contentType ? opts.contentType : method !== 'GET' ? 'application/json' : undefined;
  headers['Accept'] = accept;

  const payload: RequestInit = {
    method,
    headers,
    body,
  };

  debug(`START fetching url: ${url}`);
  if (body) {
    debug(`Body:\r\n${JSON.stringify(body)}`);
  }
  debug(`Headers:\r\n${JSON.stringify(payload.headers)}`);
  const origResponse = await fetch(url, payload);
  const clonedResponse = origResponse.clone();
  const success = origResponse && origResponse.status >= 200 && origResponse.status < 400;
  const textResponseBody = await clonedResponse.text();

  const isJSONResponse =
    (accept === 'application/json' || origResponse.headers['Content-Type'] === 'application/json') && textResponseBody.trim().startsWith('{');
  const responseBody = isJSONResponse ? JSON.parse(textResponseBody) : textResponseBody;

  if (success || opts?.exceptionOnHttpErrorStatus) {
    debug(`${success ? 'success' : 'error'} status: ${clonedResponse.status}, body:\r\n${JSON.stringify(responseBody)}`);
  } else {
    console.warn(`${success ? 'success' : 'error'} status: ${clonedResponse.status}, body:\r\n${JSON.stringify(responseBody)}`);
  }

  if (!success && opts?.exceptionOnHttpErrorStatus) {
    const error = JSON.stringify(responseBody);
    throw new Error(error === '{}' ? '{"error": "not found"}' : error);
  }
  debug(`END fetching url: ${url}`);

  return {
    origResponse,
    successBody: success ? responseBody : undefined,
    errorBody: !success ? responseBody : undefined,
  };
};

export const getWithUrl = async <T>(url: string, textResponse?: boolean): Promise<T> => {
  // try {
  const response = await fetch(url);
  if (response.status >= 400) {
    return Promise.reject(Error(`${SIOPErrors.RESPONSE_STATUS_UNEXPECTED} ${response.status}:${response.statusText} URL: ${url}`));
  }
  if (textResponse === true) {
    return (await response.text()) as unknown as T;
  }
  return await response.json();
  /*} catch (e) {
    return Promise.reject(Error(`${(e as Error).message}`));
  }*/
};

export const fetchByReferenceOrUseByValue = async <T>(referenceURI: string, valueObject: T, textResponse?: boolean): Promise<T> => {
  let response: T = valueObject;
  if (referenceURI) {
    try {
      response = await getWithUrl(referenceURI, textResponse);
    } catch (e) {
      console.log(e);
      throw new Error(`${SIOPErrors.REG_PASS_BY_REFERENCE_INCORRECTLY}: ${e.message}, URL: ${referenceURI}`);
    }
  }
  return response;
};