rqlite-js 2.6.0 → 3.0.0

package/lib/http-request/index.js

@@ -1,764 +0,0 @@
-"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");Object.defineProperty(exports, "__esModule", { value: true });exports.DEAULT_TIMEOUT = exports.DEAULT_RETRY_DELAY = void 0;exports.createDefaultHeaders = createDefaultHeaders;exports.default = void 0;exports.getWaitTimeExponential = getWaitTimeExponential;
-
-
-
-
-var _axios = _interopRequireDefault(require("axios"));
-var _qs = require("qs");
-var _httpMethods = require("./http-methods");
-
-
-
-var _contentTypes = require("./content-types");
-
-
-var _errors = require("./errors");
-var _retryable = require("./retryable");
-
-
-
-
-var _authKeys = require("./auth-keys");
-var _httpHeaders = require("./http-headers"); /**
- * Plain HTTP client to be used when creating RQLite specific API HTTP clients
- * @module http-request
- * @see https://rqlite.io/docs/api/api/
- */ /**
- * RQliteJS HTTP Request options
- * @typedef HttpRequestOptions
- * @type {Object}
- * @property {Object} [auth] A object for user authentication
- * @property {String} [auth.username] The username for authentication
- * @property {String} [auth.password] The password for authentication
- * @property {Object} [body] The body of the HTTP request
- * @property {Object} [headers={}] HTTP headers to send with the request
- * @property {String} [httpMethod=HTTP_METHOD_GET] The HTTP method for the request
- * i.e. GET or POST
- * @property {Object} [query] An object with the query to send with the HTTP request
- * @property {Boolean} [stream=false] When true the returned value is a request object with
- * stream support instead of a request-promise result
- * @property {Number} [timeout=DEAULT_TIMEOUT] Optional timeout to override default
- * @property {String} [uri] The uri for the request which can be a relative path to use
- * the currently active host or a full i.e. http://localhost:4001/db/query which is used
- * literally
- * @property {Boolean} [useLeader=false] When true the request will use the master host, the
- * first host in this.hosts, this is ideal for write operations to skip the redirect
- * @property {Number} [retries] The number of retries, defaults to the number of
- * hosts times 3
- * @property {Number} [maxRedirects=10] The maximum number of HTTP redirects to follow before
- * throwing an error
- * @property {Number} [attempt=0] The current attempt count when retrying or redirecting
- * @property {Number} [retryAttempt=0] The current attempt based on retry logic
- * @property {Number} [redirectAttempt=0] The current attempt based on redirect logic
- * @property {Number} [attemptHostIndex] When in a retry state the host index of the last
- * attempt which is used to get the next host index
- * @property {Number} [exponentailBackoffBase] Optional exponential backoff base override
- * @property {Number} [exponentailBackoffExponent] Optional backoff exponent override
- * @property {Boolean} [json] Legacy option; axios uses JSON unless stream is true
- * @property {import('http').Agent} [httpAgent] An option http agent, useful for
- * keepalive pools using plain HTTP
- * @property {import('https').Agent} [httpsAgent] An option http agent, useful
- * for keepalive pools using SSL
- */ /**
- * The default timeout value
- */
-const DEAULT_TIMEOUT = exports.DEAULT_TIMEOUT = 30000;
-
-/**
- * The default to retry a request using the next host in the chain
- */
-const DEAULT_RETRY_DELAY = exports.DEAULT_RETRY_DELAY = 30000;
-
-/**
- * Create default header for all HTTP requests
- * @param {Object} [headers={}] HTTP headers to send with the request
- * @returns {Object} The headers with defaults applied
- */
-function createDefaultHeaders(headers = {}) {
-  const accept = headers[_httpHeaders.HTTP_HEADER_ACCEPT] || _contentTypes.CONTENT_TYPE_APPLICATION_JSON;
-  return { ...headers, [_httpHeaders.HTTP_HEADER_ACCEPT]: accept };
-}
-
-/**
- * Clean the request path remove / from the beginning
- * @param {String} path The path to clean
- * @returns {String} The clean path
- */
-function cleanPath(path) {
-  return String(path).replace(/^\//, '');
-}
-
-/**
- * Returns the next wait interval, in milliseconds, using an exponential
- * backoff algorithm.
- * @param {Number} attempt The retry attempt
- * @param {Number} base The base of the exponential backoff
- * @param {Number} exponent The exponential power
- * @returns {Number} The time to wait in milliseconds
- */
-function getWaitTimeExponential(attempt = 0, base = 100, exponent = 2) {
-  if (attempt === 0) {
-    return 0;
-  }
-  return exponent ** attempt * base;
-}
-
-/**
- * Generic HTTP Request class which all RQLiteJS client
- * should extend for consistent communitication with an RQLite
- * server
- */
-class HttpRequest {
-  /**
-   * The index of the host in this.hosts which will be tried
-   * first before attempting other hosts
-   * @type {Number}
-   */
-  activeHostIndex = 0;
-
-  /**
-   * Whether or not the setNextActiveHostIndex() should
-   * perform a round robin strategy
-   */
-  activeHostRoundRobin = true;
-
-  /**
-   * The regex pattern to check if a uri is absolute or relative,
-   * if it is absolute the host is not appended
-   */
-  absoluteUriPattern = /^https?:\/\//;
-
-  /**
-   * A list of hosts that are tried in round robin fashion
-   * when certain HTTP responses are received
-   * @type {String[]}
-   */
-  hosts = [];
-
-  /**
-   * @type {import('http').Agent} The http agent if it is set
-   */
-  httpAgent;
-
-  /**
-   * @type {import('https').Agent} The https agent if it is set
-   */
-  httpsAgent;
-
-  /**
-   * The host list index of the leader node defaults
-   * to the first host
-   * @type {Number}
-   */
-  leaderHostIndex = 0;
-
-  /**
-   * Http error codes which are considered retryable
-   * @type {Set<String>}
-   */
-  retryableErrorCodes = _retryable.RETRYABLE_ERROR_CODES;
-
-  /**
-   * Http status codes which are considered retryable
-   * @type {Set<Number>}
-   */
-  retryableStatusCodes = _retryable.RETRYABLE_STATUS_CODES;
-
-  /**
-   * Http methods which are considered retryable
-   * @type {Set<String>}
-   */
-  retryableHttpMethods = _retryable.RETRYABLE_HTTP_METHODS;
-
-  /**
-   * The exponential backoff base for retries
-   */
-  exponentailBackoffBase = 100;
-
-  /**
-   * The exponent to increase backoff each try
-   */
-  exponentailBackoffExponent = 1.1;
-
-  /**
-   * Authentication Map
-   * @type {Map<String, String>}
-   */
-  authentication = new Map();
-
-  /**
-   * Construtor for HttpRequest
-   * @param {String[]|String} hosts An array of RQLite hosts or a string
-   * that will be split on "," to create an array of hosts, the first
-   * host will be tried first when there are multiple hosts
-   * @param {Object} [options={}] Additional options
-   * @param {Object} [options.authentication] Authentication options
-   * @param {String} [options.authentication.username] The host authentication username
-   * @param {String} [options.authentication.password] The host authentication password
-   * @param {Boolean} [options.activeHostRoundRobin=true] If true this.setNextActiveHostIndex()
-   * will perform a round robin when called
-   * @param {import('http').Agent} [options.httpAgent] An option http agent, useful for
-   * keepalive pools using plain HTTP
-   * @param {import('https').Agent} [options.httpsAgent] An option http agent, useful
-   * for keepalive pools using SSL
-   * @param {Set|String[]} [options.retryableErrorCodes] The list of retryable error codes
-   * @param {Set|Number[]} [options.retryableStatusCodes] The list of retryable http status codes
-   * @param {Set|String[]} [options.retryableHttpMethods] The list of retryable http methods
-   * @param {Number} [options.exponentailBackoffBase] The value for exponentail backoff base
-   * for retry exponential backoff
-   * @param {Number} [options.exponentailBackoffExponent] Exponent to increase backoff each try
-   */
-  constructor(hosts, options = {}) {
-    this.setHosts(hosts);
-    if (this.getTotalHosts() === 0) {
-      throw new Error('At least one host must be provided');
-    }
-    const {
-      activeHostRoundRobin = true,
-      httpAgent,
-      httpsAgent,
-      retryableErrorCodes,
-      retryableStatusCodes,
-      retryableHttpMethods,
-      exponentailBackoffExponent,
-      exponentailBackoffBase,
-      authentication
-    } = options;
-    if (typeof authentication === 'object') {
-      const { username, password } = authentication;
-      if (username) {
-        this.authentication.set(_authKeys.AUTH_USERNAME, username);
-      }
-      if (password) {
-        this.authentication.set(_authKeys.AUTH_PASSWORD, password);
-      }
-    }
-    if (typeof activeHostRoundRobin !== 'undefined') {
-      this.setActiveHostRoundRobin(activeHostRoundRobin);
-    }
-    if (typeof httpAgent !== 'undefined') {
-      this.setHttpAgent(httpAgent);
-    }
-    if (typeof httpsAgent !== 'undefined') {
-      this.setHttpsAgent(httpsAgent);
-    }
-    if (retryableErrorCodes instanceof Set || Array.isArray(retryableErrorCodes)) {
-      this.setRetryableErrorCodes(
-        Array.isArray(retryableErrorCodes) ? new Set(retryableErrorCodes) : retryableErrorCodes
-      );
-    }
-    if (retryableStatusCodes instanceof Set || Array.isArray(retryableStatusCodes)) {
-      this.setRetryableStatusCodes(
-        Array.isArray(retryableStatusCodes) ? new Set(retryableStatusCodes) : retryableStatusCodes
-      );
-    }
-    if (retryableHttpMethods instanceof Set || Array.isArray(retryableHttpMethods)) {
-      this.setRetryableHttpMethods(
-        Array.isArray(retryableHttpMethods) ? new Set(retryableHttpMethods) : retryableHttpMethods
-      );
-    }
-    if (Number.isFinite(exponentailBackoffBase)) {
-      this.setExponentailBackoffBase(exponentailBackoffBase);
-    }
-    if (Number.isFinite(exponentailBackoffExponent)) {
-      this.setExponentailBackoffExponent(exponentailBackoffExponent);
-    }
-  }
-
-  /**
-   * Set authentication information
-   * @param {Object} [authentication] Authentication data
-   * @param {String} [authentication.username] The host authentication username
-   * @param {String} [authentication.password] The host authentication password
-   */
-  setAuthentication(authentication = {}) {
-    const { username, password } = authentication;
-    if (username) {
-      this.authentication.set(_authKeys.AUTH_USERNAME, username);
-    }
-    if (password) {
-      this.authentication.set(_authKeys.AUTH_PASSWORD, password);
-    }
-  }
-
-  /**
-   * Set the exponentail backoff base
-   * @param {Number} exponentailBackoffBase
-   */
-  setExponentailBackoffBase(exponentailBackoffBase) {
-    this.exponentailBackoffBase = exponentailBackoffBase;
-  }
-
-  /**
-   * Get the exponentail backoff base
-   * @returns {Number} The exponentail backoff base
-   */
-  getExponentailBackoffBase() {
-    return this.exponentailBackoffBase;
-  }
-
-  /**
-   * Set the exponentail backoff exponent
-   * @param {Number} exponentailBackoffExponent
-   */
-  setExponentailBackoffExponent(exponentailBackoffExponent) {
-    this.exponentailBackoffExponent = exponentailBackoffExponent;
-  }
-
-  /**
-   * Get the exponentail backoff exponent
-   * @returns {Number} The exponentail backoff exponent
-   */
-  getExponentailBackoffExponent() {
-    return this.exponentailBackoffExponent;
-  }
-
-  /**
-   * Set the retryable error codes
-   * @param {Set<String>} retryableErrorCodes
-   */
-  setRetryableErrorCodes(retryableErrorCodes) {
-    this.retryableErrorCodes = retryableErrorCodes;
-  }
-
-  /**
-   * Get the retryable error codes
-   * @returns {Set<String>}
-   */
-  getRetryableErrorCodes() {
-    return this.retryableErrorCodes;
-  }
-
-  /**
-   * Set the retryable status codes
-   * @param {Set<Number>} retryableStatusCodes
-   */
-  setRetryableStatusCodes(retryableStatusCodes) {
-    this.retryableStatusCodes = retryableStatusCodes;
-  }
-
-  /**
-   * Get the retryable status codes
-   * @returns {Set<Number>}
-   */
-  getRetryableStatusCodes() {
-    return this.retryableStatusCodes;
-  }
-
-  /**
-   * Set the retryable http methods
-   * @param {Set<String>} retryableHttpMethods
-   */
-  setRetryableHttpMethods(retryableHttpMethods) {
-    this.retryableHttpMethods = retryableHttpMethods;
-  }
-
-  /**
-   * Get the retryable http methods
-   * @returns {Set<String>}
-   */
-  getRetryableHttpMethods() {
-    return this.retryableHttpMethods;
-  }
-
-  /**
-   * Set an http agent which is useful for http keepalive requests
-   * @param {import('http').Agent} httpAgent An http agent
-   */
-  setHttpAgent(httpAgent) {
-    this.httpAgent = httpAgent;
-  }
-
-  /**
-   * Get the set http agent
-   * @returns {import('http').Agent|undefined} The https agent if it is set
-   */
-  getHttpAgent() {
-    return this.httpAgent;
-  }
-
-  /**
-   * Set an https agent which is useful for https keepalive requests
-   * @param {import('https').Agent} httpsAgent An https agent
-   */
-  setHttpsAgent(httpsAgent) {
-    this.httpsAgent = httpsAgent;
-  }
-
-  /**
-   * Get the set https agent
-   * @returns {import('https').Agent|undefined} The https agent if it is set
-   */
-  getHttpsAgent() {
-    return this.httpsAgent;
-  }
-
-  /**
-   * Set the list of hosts
-   * @param {String[]|String} hosts An array of RQLite hosts or a string
-   * that will be split on "," to create an array of hosts, the first
-   * host will be tried first when there are multiple hosts
-   */
-  setHosts(hosts) {
-    this.hosts = !Array.isArray(hosts) ? String(hosts).split(',') : hosts;
-    this.hosts = this.hosts.reduce((acc, v) => {
-      // Remove trailing slashed from hosts
-      const host = String(v).trim().replace(/\/$/, '');
-      if (!host) {
-        return acc;
-      }
-      return acc.concat(host);
-    }, []);
-  }
-
-  /**
-   * Get the list of hosts
-   * @returns {String[]} The list of hosts
-   */
-  getHosts() {
-    return this.hosts;
-  }
-
-  /**
-   * Given a host string find the index of that host in the hosts
-   * @param {String} host A host to find in hosts
-   * @returns {Number} The found host index or -1 if not found
-   */
-  findHostIndex(host) {
-    let parsedHostToFind;
-    try {
-      parsedHostToFind = new URL(host);
-    } catch (e) {
-      return -1;
-    }
-    return this.getHosts().findIndex((v) => {
-      try {
-        const parsedHost = new URL(v);
-        // Find a host where all the parsed fields match the requested host
-        return ['hostname', 'protocol', 'port', 'pathname'].every(
-          (field) => parsedHostToFind[field] === parsedHost[field]
-        );
-      } catch (e) {
-        return false;
-      }
-    });
-  }
-
-  /**
-   * Get the current active host from the hosts array
-   * @param {Boolean} useLeader If true use the first host which is always
-   * the master, this is prefered for write operations
-   * @returns {String} The active host
-   */
-  getActiveHost(useLeader) {
-    // When useLeader is true we should just use the first host
-    const activeHostIndex = useLeader ? this.getLeaderHostIndex() : this.getActiveHostIndex();
-    return this.getHosts()[activeHostIndex];
-  }
-
-  /**
-   * Set the active host index with check based on this.hosts
-   * @param {Number} activeHostIndex The index
-   * @returns {Number} The active host index
-   */
-  setActiveHostIndex(activeHostIndex) {
-    if (!Number.isFinite(activeHostIndex)) {
-      throw new Error('The activeHostIndex should be a finite number');
-    }
-    const totalHosts = this.getTotalHosts();
-    if (activeHostIndex < 0) {
-      // Don't allow an index less then zero
-      this.activeHostIndex = 0;
-    } else if (activeHostIndex >= totalHosts) {
-      // Don't allow an index greater then the length of the hosts
-      this.activeHostIndex = totalHosts - 1;
-    } else {
-      this.activeHostIndex = activeHostIndex;
-    }
-    return this.activeHostIndex;
-  }
-
-  /**
-   * Get the host index for the leader node
-   * @returns {Number} The host index for the leader node
-   */
-  getLeaderHostIndex() {
-    return this.leaderHostIndex;
-  }
-
-  /**
-   * Set the index in the host array for the leader node
-   * @param {Number} leaderHostIndex The index of the host that is the leader node
-   * @returns {Number} The host index for the leader node
-   */
-  setLeaderHostIndex(leaderHostIndex) {
-    if (!Number.isFinite(leaderHostIndex)) {
-      throw new Error('The leaderHostIndex should be a finite number');
-    }
-    const totalHosts = this.getTotalHosts();
-    if (leaderHostIndex < 0) {
-      this.leaderHostIndex = 0;
-    } else if (leaderHostIndex > totalHosts) {
-      this.leaderHostIndex = totalHosts - 1;
-    } else {
-      this.leaderHostIndex = leaderHostIndex;
-    }
-    return this.leaderHostIndex;
-  }
-
-  /**
-   * Get the active host index
-   * @returns {Number} The active host index
-   */
-  getActiveHostIndex() {
-    return this.activeHostIndex;
-  }
-
-  /**
-   * Set active host round robin value
-   * @param {Boolean} activeHostRoundRobin If true setActiveHostIndex() will
-   * perform a round robin
-   */
-  setActiveHostRoundRobin(activeHostRoundRobin) {
-    if (typeof activeHostRoundRobin !== 'boolean') {
-      throw new Error('The activeHostRoundRobin argument must be boolean');
-    }
-    this.activeHostRoundRobin = activeHostRoundRobin;
-  }
-
-  /**
-   * Get active host round robin value
-   * @returns {Boolean} The value of activeHostRoundRobin
-   */
-  getActiveHostRoundRobin() {
-    return this.activeHostRoundRobin;
-  }
-
-  /**
-   * Get the next active host index
-   * @param {Number} [activeHostIndex] An optional paramater to provide the active host index
-   * @returns {Number} The next active host index which will wrap around to zero
-   */
-  getNextActiveHostIndex(activeHostIndex = this.getActiveHostIndex()) {
-    const totalHosts = this.getTotalHosts();
-    const nextIndex = activeHostIndex + 1;
-    // If we are past the last index start back over at 1
-    if (totalHosts === nextIndex) {
-      return 0;
-    }
-    return nextIndex;
-  }
-
-  /**
-   * Set the active host index to the next host using a
-   * round robin strategy
-   */
-  setNextActiveHostIndex() {
-    // Don't bother if we only have one host
-    if (!this.getActiveHostRoundRobin()) {
-      return;
-    }
-    const totalHosts = this.getTotalHosts();
-    if (this.getActiveHostRoundRobin() && totalHosts <= 1) {
-      return;
-    }
-    this.setActiveHostIndex(this.getNextActiveHostIndex());
-  }
-
-  /**
-   * Get the total number of hosts
-   * @returns {Number} The total number of hosts
-   */
-  getTotalHosts() {
-    return this.getHosts().length;
-  }
-
-  /**
-   * Returns whether or not the uri passes a test for this.absoluteUriPattern
-   * @returns {Boolean} True if the path is absolute
-   */
-  uriIsAbsolute(uri) {
-    return this.absoluteUriPattern.test(uri);
-  }
-
-  /**
-   * Returns true when the HTTP request is retryable
-   * @param {Object} [options={}] The options
-   * @param {Number} [options.statusCode] The HTTP status code
-   * @param {String} [options.errorCode] The error code
-   * @param {String} [options.httpMethod] The http method
-   * @returns {Boolean} True if the request is retry able
-   */
-  requestIsRetryable(options = {}) {
-    const {
-      statusCode,
-      errorCode,
-      httpMethod
-    } = options;
-    // Honor strictly the http method
-    if (!this.getRetryableHttpMethods().has(httpMethod)) {
-      return false;
-    }
-    if (statusCode && this.getRetryableStatusCodes().has(statusCode)) {
-      return true;
-    }
-    if (errorCode && this.getRetryableErrorCodes().has(errorCode)) {
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Perform an HTTP request using the provided options
-   * @param {HttpRequestOptions} [options={}] Options for the HTTP client
-   * @returns {Promise<{status: Number, body: Object|String}>} An object with a status and body
-   * property when stream is false and a stream when the stream option is true
-   * @throws {ERROR_HTTP_REQUEST_MAX_REDIRECTS} When the maximum number of redirect has been reached
-   */
-  async fetch(options = {}) {
-    const {
-      body,
-      headers = {},
-      httpMethod = _httpMethods.HTTP_METHOD_GET,
-      query,
-      stream = false,
-      timeout = DEAULT_TIMEOUT,
-      useLeader = false,
-      retries = this.getTotalHosts() * 3,
-      maxRedirects = 10,
-      attempt = 0,
-      retryAttempt = 0,
-      redirectAttempt = 0,
-      attemptHostIndex,
-      exponentailBackoffExponent = this.getExponentailBackoffExponent(),
-      exponentailBackoffBase = this.getExponentailBackoffBase(),
-      httpAgent = this.getHttpAgent(),
-      httpsAgent = this.getHttpsAgent()
-    } = options;
-    // Honor the supplied attemptHostIndex or get the active host
-    const activeHost = Number.isFinite(attemptHostIndex) ? this.getHosts()[attemptHostIndex] :
-    this.getActiveHost(useLeader);
-    let { uri } = options;
-    if (!uri) {
-      throw new Error('The uri option is required');
-    }
-    uri = this.uriIsAbsolute(uri) ? uri : `${activeHost}/${cleanPath(uri)}`;
-    try {
-      let auth;
-      if (this.authentication.size) {
-        auth = {
-          [_authKeys.AUTH_USERNAME]: this.authentication.get(_authKeys.AUTH_USERNAME),
-          [_authKeys.AUTH_PASSWORD]: this.authentication.get(_authKeys.AUTH_PASSWORD)
-        };
-      }
-      const response = await (0, _axios.default)({
-        url: uri,
-        auth,
-        data: body,
-        maxRedirects: 0, // Handle redirects manually to allow reposting data
-        headers: createDefaultHeaders(headers),
-        responseType: stream ? 'stream' : 'json',
-        method: httpMethod,
-        params: query,
-        timeout,
-        httpsAgent,
-        httpAgent,
-        paramsSerializer(params) {
-          return (0, _qs.stringify)(params, { arrayFormat: 'brackets' });
-        }
-      });
-      if (stream) {
-        return response.data;
-      }
-      return {
-        body: response.data,
-        status: response.status
-      };
-    } catch (e) {
-      const { response = {}, code: errorCode } = e;
-      const { status: responseStatus, headers: responseHeaders = {} } = response;
-      // Check if the error was a redirect
-      const retryable = this.requestIsRetryable({
-        statusCode: responseStatus,
-        errorCode,
-        httpMethod
-      });
-      // Save the next active host index and pass it to retry manually
-      let nextAttemptHostIndex = Number.isFinite(attemptHostIndex) ? attemptHostIndex :
-      this.getActiveHostIndex();
-      nextAttemptHostIndex += 1;
-      // We go past the last index start from zero
-      if (nextAttemptHostIndex === this.getTotalHosts()) {
-        nextAttemptHostIndex = 0;
-      }
-      // First check if this is a redirect error
-      if (responseStatus === 301 || responseStatus === 302) {
-        // We maxed out on redirect attempts
-        if (redirectAttempt >= maxRedirects) {
-          throw new _errors.ERROR_HTTP_REQUEST_MAX_REDIRECTS(`The maximum number of redirects ${maxRedirects} has been reached`);
-        }
-        const location = typeof responseHeaders === 'object' ?
-        responseHeaders[_httpHeaders.HTTP_HEADER_LOCATION.toLowerCase()] ||
-        responseHeaders[_httpHeaders.HTTP_HEADER_LOCATION] :
-        undefined;
-        // If we were asked to use the leader, but got redirect the leader moved so remember it
-        if (useLeader) {
-          const newLeaderHostIndex = this.findHostIndex(location);
-          // If the redirect exists in the hosts list remember it for next time
-          if (newLeaderHostIndex > -1) {
-            this.setLeaderHostIndex(newLeaderHostIndex);
-          }
-        }
-        return this.fetch({
-          ...options,
-          uri: location,
-          attempt: attempt + 1,
-          redirectAttempt: redirectAttempt + 1,
-          attemptHostIndex: nextAttemptHostIndex
-        });
-      }
-      if (retryable && retryAttempt < retries) {
-        const waitTime = getWaitTimeExponential(
-          retryAttempt,
-          exponentailBackoffBase,
-          exponentailBackoffExponent
-        );
-        await new Promise((resolve) => {
-          setTimeout(() => {
-            resolve(undefined);
-          }, waitTime);
-        });
-        return this.fetch({
-          ...options,
-          attempt: attempt + 1,
-          retryAttempt: retryAttempt + 1,
-          attemptHostIndex: nextAttemptHostIndex
-        });
-      }
-      throw e;
-    }
-  }
-
-  /**
-   * Perform an HTTP GET request
-   * @param {...*} args HttpRequestOptions, or (path, sql, options) when overridden by ApiClient
-   * @returns {Promise<*>}
-   * @see HttpRequest#fetch
-   */
-  async get(...args) {
-    const options = args[0] || {};
-    return this.fetch({ ...options, httpMethod: _httpMethods.HTTP_METHOD_GET });
-  }
-
-  /**
-   * Perform an HTTP POST request
-   * @param {...*} args HttpRequestOptions, or (path, sql, options) when overridden by ApiClient
-   * @returns {Promise<*>}
-   * @see HttpRequest#fetch
-   */
-  async post(...args) {
-    const options = args[0] || {};
-    return this.fetch({ ...options, httpMethod: _httpMethods.HTTP_METHOD_POST });
-  }
-}exports.default = HttpRequest;
-//# sourceMappingURL=index.js.map