common.ts

/**
 * JavaScript and Node.js SDK for OpenFGA
 *
 * API version: 1.x
 * Website: https://openfga.dev
 * Documentation: https://openfga.dev/docs
 * Support: https://openfga.dev/community
 * License: [Apache-2.0](https://github.com/openfga/js-sdk/blob/main/LICENSE)
 *
 * NOTE: This file was auto generated by OpenAPI Generator (https://openapi-generator.tech). DO NOT EDIT.
 */


import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from "axios";
import { metrics } from "@opentelemetry/api";

import { Configuration } from "./configuration";
import type { Credentials } from "./credentials";
import {
  FgaApiError,
  FgaApiInternalError,
  FgaApiAuthenticationError,
  FgaApiNotFoundError,
  FgaApiRateLimitExceededError,
  FgaApiValidationError,
  FgaError
} from "./errors";
import { setNotEnumerableProperty } from "./utils";
import { buildAttributes } from "./telemetry";

const meter = metrics.getMeter("@openfga/sdk", "0.6.2");
const durationHist = meter.createHistogram("fga-client.request.duration", {
  description: "The duration of requests",
  unit: "milliseconds",
});
const queryDurationHist = meter.createHistogram("fga-client.query.duration", {
  description: "The duration of queries on the FGA server",
  unit: "milliseconds",
});

/**
 *
 * @export
 */
export const DUMMY_BASE_URL = "https://example.com";

/**
 *
 * @export
 * @interface RequestArgs
 */
export interface RequestArgs {
    url: string;
    options: any;
}


/**
 *
 * @export
 */
export const setBearerAuthToObject = async function (object: any, credentials: Credentials) {
  const accessTokenHeader = await credentials.getAccessTokenHeader();
  if (accessTokenHeader && !object[accessTokenHeader.name]) {
    object[accessTokenHeader.name] = accessTokenHeader.value;
  }
};

/**
 *
 * @export
 */
export const setSearchParams = function (url: URL, ...objects: any[]) {
  const searchParams = new URLSearchParams(url.search);
  for (const object of objects) {
    for (const key in object) {
      if (Array.isArray(object[key])) {
        searchParams.delete(key);
        for (const item of object[key]) {
          searchParams.append(key, item);
        }
      } else {
        searchParams.set(key, object[key]);
      }
    }
  }
  url.search = searchParams.toString();
};

/**
* Check if the given MIME is a JSON MIME.
* JSON MIME examples:
*   application/json
*   application/json; charset=UTF8
*   APPLICATION/JSON
*   application/vnd.company+json
* @param mime - MIME (Multipurpose Internet Mail Extensions)
* @return True if the given MIME is JSON, false otherwise.
*/
const isJsonMime = (mime: string): boolean => {
  // eslint-disable-next-line no-control-regex
  const jsonMime = new RegExp("^(application/json|[^;/ \t]+/[^;/ \t]+[+]json)[ \t]*(;.*)?$", "i");
  return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === "application/json-patch+json");
};

/**
 *
 * @export
 */
export const serializeDataIfNeeded = function (value: any, requestOptions: any) {
  const nonString = typeof value !== "string";
  const needsSerialization = nonString
    ? isJsonMime(requestOptions.headers["Content-Type"])
    : nonString;
  return needsSerialization
    ? JSON.stringify(value !== undefined ? value : {})
    : (value || "");
};

/**
 *
 * @export
 */
export const toPathString = function (url: URL) {
  return url.pathname + url.search + url.hash;
};

type ObjectOrVoid = object | void;

export type CallResult<T extends ObjectOrVoid> = T & {
    $response: AxiosResponse<T>
};

export type PromiseResult<T extends ObjectOrVoid> = Promise<CallResult<T>>;

/**
 * Returns true if this error is returned from axios
 * source: https://github.com/axios/axios/blob/21a5ad34c4a5956d81d338059ac0dd34a19ed094/lib/helpers/isAxiosError.js#L12
 * @param err
 */
function isAxiosError(err: any): boolean {
  return err && typeof err === "object" && err.isAxiosError === true;
}
function randomTime(loopCount: number, minWaitInMs: number): number {
  const min = Math.ceil(2 ** loopCount * minWaitInMs);
  const max = Math.ceil(2 ** (loopCount + 1) * minWaitInMs);
  return Math.floor(Math.random() * (max - min) + min); //The maximum is exclusive and the minimum is inclusive
}

export async function attemptHttpRequest<B, R>(
  request: AxiosRequestConfig<B>,
  config: {
        maxRetry: number;
        minWaitInMs: number;
    },
  axiosInstance: AxiosInstance,
): Promise<AxiosResponse<R> | undefined> {
  let iterationCount = 0;
  do {
    iterationCount++;
    try {
      return await axiosInstance(request);
    } catch (err: any) {
      if (!isAxiosError(err)) {
        throw new FgaError(err);
      }
      const status = (err as any)?.response?.status;
      if (status === 400 || status === 422) {
        throw new FgaApiValidationError(err);
      } else if (status === 401 || status === 403) {
        throw new FgaApiAuthenticationError(err);
      } else if (status === 404) {
        throw new FgaApiNotFoundError(err);
      } else if (status === 429 || status >= 500) {
        if (iterationCount >= config.maxRetry) {
        // We have reached the max retry limit
        // Thus, we have no choice but to throw
          if (status === 429) {
            throw new FgaApiRateLimitExceededError(err);
          } else {
            throw new FgaApiInternalError(err);
          }
        }
        await new Promise(r => setTimeout(r, randomTime(iterationCount, config.minWaitInMs)));
      } else {
        throw new FgaApiError(err);
      }
    }
  } while(iterationCount < config.maxRetry + 1);
}

/**
 * creates an axios request function
 */
export const createRequestFunction = function (axiosArgs: RequestArgs, axiosInstance: AxiosInstance, configuration: Configuration, credentials: Credentials, methodAttributes: Record<string, unknown> = {}) {
  configuration.isValid();

  const retryParams = axiosArgs.options?.retryParams ? axiosArgs.options?.retryParams : configuration.retryParams;
  const maxRetry:number = retryParams ? retryParams.maxRetry : 0;
  const minWaitInMs:number = retryParams ? retryParams.minWaitInMs : 0;

  const start = Date.now();

  return async (axios: AxiosInstance = axiosInstance) : PromiseResult<any> => {
    await setBearerAuthToObject(axiosArgs.options.headers, credentials!);

    const axiosRequestArgs = {...axiosArgs.options, url: configuration.getBasePath() + axiosArgs.url};
    const response = await attemptHttpRequest(axiosRequestArgs, {
      maxRetry,
      minWaitInMs,
    }, axios);
    const executionTime = Date.now() - start;

    const data = typeof response?.data === "undefined" ? {} : response?.data;
    const result: CallResult<any> = { ...data };
    setNotEnumerableProperty(result, "$response", response);

    const attributes = buildAttributes(response, configuration.credentials, methodAttributes);

    if (response?.headers) {
      const duration = response.headers["fga-query-duration-ms"];
      if (duration !== undefined) {
        queryDurationHist.record(parseInt(duration, 10), attributes);
      }
    }

    durationHist.record(executionTime, attributes);

    return result;
  };
};