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

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

const handleError = (context: string, error: unknown): void => {
  console.error(`[${context}]`, error);
};

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 ? "application/json" : "text/plain",
      ...headers,
    },
    ...(method !== METHODS.GET && { body: data }),
  };

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

    if (!res.ok) {
      throw new Error(`HTTP error! Status: ${res.status} ${res.statusText}`);
    }

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

    if (contentType.includes("application/json")) {
      return await res.json();
    } else if (contentType.includes("text/plain")) {
      return await res.text();
    } else {
      throw new Error(`Unsupported Content-Type: ${contentType}`);
    }
  } catch (err) {
    handleError("Fetch error:", err);
    return null;
  }
};

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 response = await getFetchResponse(
      url,
      method,
      requestPayload,
      requestType,
      headers || {}
    );

    return {
      data: {
        requestKey,
        response,
      },
    };
  } catch (error) {
    handleError("Response error:", error);
    return null;
  }
};

export default apiHelper;