call-sdk/packages/common/lib/utils/apiHelper.ts

import { RequestKeys } from "@universal-call-sdk/adapter-ameyo/lib/types";
import { ContentType, METHODS, Request, RequestType } from "../types/Request";

const getFetchResponse = async(
  url: string,
  method: string,
  data: any,
  requestType: RequestType,
  headers: Record<string, string>
): Promise<any> => {
  const fetchOptions: RequestInit = {
    method,
    headers: {
      "Content-Type":
        requestType === RequestType.JSON ? ContentType.JSON : ContentType.TEXT,
      ...headers,
    },
    ...(method !== METHODS.GET && { body: data }),
  };

  try {
    const res = await fetch(url, fetchOptions);

    if (!res.ok) {
      return {
        error: res,
      };
    }

    const contentType = res.headers.get("Content-Type") || "";

    if (contentType.includes(ContentType.JSON)) {
      return await res.json();
    } else if (contentType.includes(ContentType.TEXT)) {
      return await res.text();
    } else {
      throw new Error(`Unsupported Content-Type: ${contentType}`);
    }
  } catch (err) {
    console.error("Fetch error:", err);
    return {
      error: err,
    };
  }
};

export const apiHelper = async({
  url,
  method,
  requestKey,
  requestType = RequestType.JSON,
  headers = {},
  data = {},
}: Request) => {
  const requestPayload =
    requestType === RequestType.RAW ? data : JSON.stringify(data);

  try {
    if (requestKey === RequestKeys.GET_AGENTS_FOR_CALL_TRANSFER) {
      return getFetchResponse(
        url,
        method,
        requestPayload,
        requestType,
        headers || {}
      );
    }

    const requestStartTime = Date.now();
    const response = await getFetchResponse(
      url,
      method,
      requestPayload,
      requestType,
      headers || {}
    );
    const requestEndTime = Date.now();
    if (response?.error) {
      return {
        data: {
          requestKey,
          err: response,
        }
      };
    }

    return {
      data: {
        requestKey,
        response,
        time: requestEndTime - requestStartTime,
      }
    };
  } catch (error) {
    console.error("Response error:", error);
    return {
      data: {
        requestKey,
        err: error,
      }
    };
  }
};

export default apiHelper;