export async function armRequestWithoutPolling()

in src/Utils/arm/request.ts [53:107]
49 lines of code
17 McCabe index (conditional complexity)

export async function armRequestWithoutPolling<T>({
  host,
  path,
  apiVersion,
  method,
  body: requestBody,
  queryParams,
  contentType,
  customHeaders,
}: Options): Promise<{ result: T; operationStatusUrl: string }> {
  const url = new URL(path, host);
  url.searchParams.append("api-version", configContext.armAPIVersion || apiVersion);
  if (queryParams) {
    queryParams.filter && url.searchParams.append("$filter", queryParams.filter);
    queryParams.metricNames && url.searchParams.append("metricnames", queryParams.metricNames);
  }

  if (!userContext?.authorizationToken && !customHeaders?.["Authorization"]) {
    throw new Error("No authority token provided");
  }

  const headers: Record<string, string> = {
    Authorization: userContext.authorizationToken || customHeaders?.["Authorization"] || "",
    [HttpHeaders.contentType]: contentType || "application/json",
    ...(customHeaders || {}),
  };

  const response = await window.fetch(url.href, {
    method,
    headers,
    body: requestBody ? JSON.stringify(requestBody) : undefined,
  });

  if (!response.ok) {
    let error: ARMError;
    try {
      const errorResponse = (await response.json()) as ParsedErrorResponse;
      if ("error" in errorResponse) {
        error = new ARMError(errorResponse.error.message);
        error.code = errorResponse.error.code;
      } else {
        error = new ARMError(errorResponse.message);
        error.code = errorResponse.code;
      }
    } catch (error) {
      throw new Error(await response.text());
    }

    throw error;
  }

  const operationStatusUrl = (response.headers && response.headers.get("location")) || "";
  const responseBody = (await response.json()) as T;
  return { result: responseBody, operationStatusUrl: operationStatusUrl };
}