rqlite-js 2.5.6 → 2.6.0

package/lib/http-request/index.js

@@ -1,10 +1,10 @@
-"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 _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+"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 _url = require("url");
 var _httpMethods = require("./http-methods");
 
 
@@ -12,21 +12,24 @@ var _httpMethods = require("./http-methods");
 var _contentTypes = require("./content-types");
 
 
-
 var _errors = require("./errors");
-var _retryable = require("./retryable");function ownKeys(object, enumerableOnly) {var keys = Object.keys(object);if (Object.getOwnPropertySymbols) {var symbols = Object.getOwnPropertySymbols(object);enumerableOnly && (symbols = symbols.filter(function (sym) {return Object.getOwnPropertyDescriptor(object, sym).enumerable;})), keys.push.apply(keys, symbols);}return keys;}function _objectSpread(target) {for (var i = 1; i < arguments.length; i++) {var source = null != arguments[i] ? arguments[i] : {};i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {(0, _defineProperty2.default)(target, key, source[key]);}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));});}return target;} /**
- * Plain HTTP client to be used when creating RQLite specific API HTTP clients
- * @module http-request
- */
+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 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
@@ -35,7 +38,7 @@ var _retryable = require("./retryable");function ownKeys(object, enumerableOnly)
  * @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
+ * @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
@@ -49,30 +52,31 @@ var _retryable = require("./retryable");function ownKeys(object, enumerableOnly)
  * @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 = 30000;
+const DEAULT_TIMEOUT = exports.DEAULT_TIMEOUT = 30000;
 
 /**
  * The default to retry a request using the next host in the chain
- */exports.DEAULT_TIMEOUT = DEAULT_TIMEOUT;
-const DEAULT_RETRY_DELAY = 30000;
+ */
+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
- */exports.DEAULT_RETRY_DELAY = DEAULT_RETRY_DELAY;
+ */
 function createDefaultHeaders(headers = {}) {
-  const _headers$Accept = headers.Accept,Accept = _headers$Accept === void 0 ? _contentTypes.CONTENT_TYPE_APPLICATION_JSON : _headers$Accept;
-  return _objectSpread(_objectSpread({}, headers), {}, { Accept });
+  const accept = headers[_httpHeaders.HTTP_HEADER_ACCEPT] || _contentTypes.CONTENT_TYPE_APPLICATION_JSON;
+  return { ...headers, [_httpHeaders.HTTP_HEADER_ACCEPT]: accept };
 }
 
 /**
@@ -96,7 +100,7 @@ function getWaitTimeExponential(attempt = 0, base = 100, exponent = 2) {
   if (attempt === 0) {
     return 0;
   }
-  return Math.pow(exponent, attempt) * base;
+  return exponent ** attempt * base;
 }
 
 /**
@@ -105,84 +109,82 @@ function getWaitTimeExponential(attempt = 0, base = 100, exponent = 2) {
  * 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
@@ -206,53 +208,53 @@ class HttpRequest {
    * for retry exponential backoff
    * @param {Number} [options.exponentailBackoffExponent] Exponent to increase backoff each try
    */
-  constructor(hosts, options = {}) {/**
-     * The index of the host in this.hosts which will be tried
-     * first before attempting other hosts
-     * @type {Number}
-     */(0, _defineProperty2.default)(this, "activeHostIndex", 0); /**
-     * Whether or not the setNextActiveHostIndex() should
-     * perform a round robin strategy
-     */(0, _defineProperty2.default)(this, "activeHostRoundRobin", true); /**
-     * The regex pattern to check if a uri is absolute or relative,
-     * if it is absolute the host is not appended
-     */(0, _defineProperty2.default)(this, "absoluteUriPattern", /^https?:\/\//); /**
-     * A list of hosts that are tried in round robin fashion
-     * when certain HTTP responses are received
-     * @type {String[]}
-     */(0, _defineProperty2.default)(this, "hosts", []); /**
-     * @type {import('http').Agent} The http agent if it is set
-     */(0, _defineProperty2.default)(this, "httpAgent", void 0); /**
-     * @type {import('https').Agent} The https agent if it is set
-     */(0, _defineProperty2.default)(this, "httpsAgent", void 0); /**
-     * The host list index of the leader node defaults
-     * to the first host
-     * @type {Number}
-     */(0, _defineProperty2.default)(this, "leaderHostIndex", 0); /**
-     * Http error codes which are considered retryable
-     * @type {Set}
-     */(0, _defineProperty2.default)(this, "retryableErrorCodes", _retryable.RETRYABLE_ERROR_CODES); /**
-     * Http status codes which are considered retryable
-     * @type {Set}
-     */(0, _defineProperty2.default)(this, "retryableStatusCodes", _retryable.RETRYABLE_STATUS_CODES); /**
-     * Http methods which are considered retryable
-     * @type {Set}
-     */(0, _defineProperty2.default)(this, "retryableHttpMethods", _retryable.RETRYABLE_HTTP_METHODS); /**
-     * The exponential backoff base for retries
-     */(0, _defineProperty2.default)(this, "exponentailBackoffBase", 100); /**
-     * The exponent to increase backoff each try
-     */(0, _defineProperty2.default)(this, "exponentailBackoffExponent", 1.1); /**
-     * Authentication Map
-     * @type {Map}
-     * @property {String} username
-     * @property {String} password
-     */(0, _defineProperty2.default)(this, "authentication", new Map());this.setHosts(hosts);if (this.getTotalHosts() === 0) {throw new Error('At least one host must be provided');}const _options$activeHostRo = options.activeHostRoundRobin,activeHostRoundRobin = _options$activeHostRo === void 0 ? true : _options$activeHostRo,httpAgent = options.httpAgent,httpsAgent = options.httpsAgent,retryableErrorCodes = options.retryableErrorCodes,retryableStatusCodes = options.retryableStatusCodes,retryableHttpMethods = options.retryableHttpMethods,exponentailBackoffExponent = options.exponentailBackoffExponent,exponentailBackoffBase = options.exponentailBackoffBase,authentication = options.authentication;if (typeof authentication === 'object') {const username = authentication.username,password = authentication.password;if (username) {this.authentication.set('username', username);}if (password) {this.authentication.set('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) ? Set(retryableErrorCodes) : retryableErrorCodes);}if (retryableStatusCodes instanceof Set || Array.isArray(retryableStatusCodes)) {this.setRetryableStatusCodes(
-        Array.isArray(retryableStatusCodes) ? Set(retryableStatusCodes) : retryableStatusCodes
+  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) ? Set(retryableHttpMethods) : retryableHttpMethods
+        Array.isArray(retryableHttpMethods) ? new Set(retryableHttpMethods) : retryableHttpMethods
       );
     }
     if (Number.isFinite(exponentailBackoffBase)) {
@@ -270,12 +272,12 @@ class HttpRequest {
    * @param {String} [authentication.password] The host authentication password
    */
   setAuthentication(authentication = {}) {
-    const username = authentication.username,password = authentication.password;
+    const { username, password } = authentication;
     if (username) {
-      this.authentication.set('username', username);
+      this.authentication.set(_authKeys.AUTH_USERNAME, username);
     }
     if (password) {
-      this.authentication.set('password', password);
+      this.authentication.set(_authKeys.AUTH_PASSWORD, password);
     }
   }
 
@@ -289,7 +291,7 @@ class HttpRequest {
 
   /**
    * Get the exponentail backoff base
-   * @return {Number} The exponentail backoff base
+   * @returns {Number} The exponentail backoff base
    */
   getExponentailBackoffBase() {
     return this.exponentailBackoffBase;
@@ -305,7 +307,7 @@ class HttpRequest {
 
   /**
    * Get the exponentail backoff exponent
-   * @return {Number} The exponentail backoff exponent
+   * @returns {Number} The exponentail backoff exponent
    */
   getExponentailBackoffExponent() {
     return this.exponentailBackoffExponent;
@@ -313,7 +315,7 @@ class HttpRequest {
 
   /**
    * Set the retryable error codes
-   * @param {Set} retryableErrorCodes
+   * @param {Set<String>} retryableErrorCodes
    */
   setRetryableErrorCodes(retryableErrorCodes) {
     this.retryableErrorCodes = retryableErrorCodes;
@@ -321,7 +323,7 @@ class HttpRequest {
 
   /**
    * Get the retryable error codes
-   * @returns {Set}
+   * @returns {Set<String>}
    */
   getRetryableErrorCodes() {
     return this.retryableErrorCodes;
@@ -329,7 +331,7 @@ class HttpRequest {
 
   /**
    * Set the retryable status codes
-   * @param {Set} retryableStatusCodes
+   * @param {Set<Number>} retryableStatusCodes
    */
   setRetryableStatusCodes(retryableStatusCodes) {
     this.retryableStatusCodes = retryableStatusCodes;
@@ -337,7 +339,7 @@ class HttpRequest {
 
   /**
    * Get the retryable status codes
-   * @returns {Set}
+   * @returns {Set<Number>}
    */
   getRetryableStatusCodes() {
     return this.retryableStatusCodes;
@@ -345,7 +347,7 @@ class HttpRequest {
 
   /**
    * Set the retryable http methods
-   * @param {Set} retryableHttpMethods
+   * @param {Set<String>} retryableHttpMethods
    */
   setRetryableHttpMethods(retryableHttpMethods) {
     this.retryableHttpMethods = retryableHttpMethods;
@@ -353,7 +355,7 @@ class HttpRequest {
 
   /**
    * Get the retryable http methods
-   * @returns {Set}
+   * @returns {Set<String>}
    */
   getRetryableHttpMethods() {
     return this.retryableHttpMethods;
@@ -423,11 +425,22 @@ class HttpRequest {
    * @returns {Number} The found host index or -1 if not found
    */
   findHostIndex(host) {
-    const parsedHostToFind = (0, _url.parse)(host);
+    let parsedHostToFind;
+    try {
+      parsedHostToFind = new URL(host);
+    } catch (e) {
+      return -1;
+    }
     return this.getHosts().findIndex((v) => {
-      const parsedHost = (0, _url.parse)(v);
-      // Find a host where all the parsed fields match the requested host
-      return ['hostname', 'protocol', 'port', 'path'].every((field) => parsedHostToFind[field] === parsedHost[field]);
+      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;
+      }
     });
   }
 
@@ -570,18 +583,18 @@ class HttpRequest {
 
   /**
    * 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
+   * @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 =
-
-
-      options.statusCode,errorCode = options.errorCode,httpMethod = options.httpMethod;
+    const {
+      statusCode,
+      errorCode,
+      httpMethod
+    } = options;
     // Honor strictly the http method
     if (!this.getRetryableHttpMethods().has(httpMethod)) {
       return false;
@@ -602,143 +615,150 @@ class HttpRequest {
    * 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
    */
-  fetch(options = {}) {var _this = this;return (0, _asyncToGenerator2.default)(function* () {
-      const
-        body =
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-        options.body,_options$headers = options.headers,headers = _options$headers === void 0 ? {} : _options$headers,_options$httpMethod = options.httpMethod,httpMethod = _options$httpMethod === void 0 ? _httpMethods.HTTP_METHOD_GET : _options$httpMethod,query = options.query,_options$stream = options.stream,stream = _options$stream === void 0 ? false : _options$stream,_options$timeout = options.timeout,timeout = _options$timeout === void 0 ? DEAULT_TIMEOUT : _options$timeout,_options$useLeader = options.useLeader,useLeader = _options$useLeader === void 0 ? false : _options$useLeader,_options$retries = options.retries,retries = _options$retries === void 0 ? _this.getTotalHosts() * 3 : _options$retries,_options$maxRedirects = options.maxRedirects,maxRedirects = _options$maxRedirects === void 0 ? 10 : _options$maxRedirects,_options$attempt = options.attempt,attempt = _options$attempt === void 0 ? 0 : _options$attempt,_options$retryAttempt = options.retryAttempt,retryAttempt = _options$retryAttempt === void 0 ? 0 : _options$retryAttempt,_options$redirectAtte = options.redirectAttempt,redirectAttempt = _options$redirectAtte === void 0 ? 0 : _options$redirectAtte,attemptHostIndex = options.attemptHostIndex,_options$exponentailB = options.exponentailBackoffExponent,exponentailBackoffExponent = _options$exponentailB === void 0 ? _this.getExponentailBackoffExponent() : _options$exponentailB,_options$exponentailB2 = options.exponentailBackoffBase,exponentailBackoffBase = _options$exponentailB2 === void 0 ? _this.getExponentailBackoffBase() : _options$exponentailB2,_options$httpAgent = options.httpAgent,httpAgent = _options$httpAgent === void 0 ? _this.getHttpAgent() : _options$httpAgent,_options$httpsAgent = options.httpsAgent,httpsAgent = _options$httpsAgent === void 0 ? _this.getHttpsAgent() : _options$httpsAgent;
-      // Honor the supplied attemptHostIndex or get the active host
-      const activeHost = Number.isFinite(attemptHostIndex) ? _this.getHosts()[attemptHostIndex] :
-      _this.getActiveHost(useLeader);
-      let uri = options.uri;
-      if (!uri) {
-        throw new Error('The uri option is required');
+  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)
+        };
       }
-      uri = _this.uriIsAbsolute(uri) ? uri : `${activeHost}/${cleanPath(uri)}`;
-      try {
-        let auth;
-        if (_this.authentication.size) {
-          auth = {
-            username: _this.authentication.get('username'),
-            password: _this.authentication.get('password')
-          };
-        }
-        const response = yield (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;
+      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' });
         }
-        return {
-          body: response.data,
-          status: response.status
-        };
-      } catch (e) {
-        const _e$response = e.response,response = _e$response === void 0 ? {} : _e$response,errorCode = e.code;
-        const responseStatus = response.status,_response$headers = response.headers,responseHeaders = _response$headers === void 0 ? {} : _response$headers;
-        // 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;
+      });
+      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`);
         }
-        // First check if this is a redirect error
-        if (responseStatus === 301 || responseStatus === 302) {
-          // We maxed out on redirect attempts
-          if (redirectAttempt >= maxRedirects) {
-            throw (0, _errors.ERROR_HTTP_REQUEST_MAX_REDIRECTS)(`The maximum number of redirects ${maxRedirects} has been reached`);
-          }
-          const location = typeof responseHeaders === 'object' ? responseHeaders.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);
-            }
+        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(_objectSpread(_objectSpread({},
-          options), {}, {
-            uri: location,
-            attempt: attempt + 1,
-            redirectAttempt: redirectAttempt + 1,
-            attemptHostIndex: nextAttemptHostIndex })
-          );
-        }
-        if (retryable && retryAttempt < retries) {
-          const waitTime = getWaitTimeExponential(
-            retryAttempt,
-            exponentailBackoffBase,
-            exponentailBackoffExponent
-          );
-          yield new Promise((resolve) => {
-            setTimeout(() => {
-              resolve(undefined);
-            }, waitTime);
-          });
-          return _this.fetch(_objectSpread(_objectSpread({},
-          options), {}, {
-            attempt: attempt + 1,
-            retryAttempt: retryAttempt + 1,
-            attemptHostIndex: nextAttemptHostIndex })
-          );
         }
-        throw e;
-      }})();
+        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 {HttpRequestOptions} [options={}] The options
-   * @see this.fetch() for options
+   * @param {...*} args HttpRequestOptions, or (path, sql, options) when overridden by ApiClient
+   * @returns {Promise<*>}
+   * @see HttpRequest#fetch
    */
-  get(options = {}) {var _this2 = this;return (0, _asyncToGenerator2.default)(function* () {
-      return _this2.fetch(_objectSpread(_objectSpread({}, options), {}, { httpMethod: _httpMethods.HTTP_METHOD_GET }));})();
+  async get(...args) {
+    const options = args[0] || {};
+    return this.fetch({ ...options, httpMethod: _httpMethods.HTTP_METHOD_GET });
   }
 
   /**
    * Perform an HTTP POST request
-   * @param {HttpRequestOptions} [options={}] The options
-   * @see this.fetch() for options
+   * @param {...*} args HttpRequestOptions, or (path, sql, options) when overridden by ApiClient
+   * @returns {Promise<*>}
+   * @see HttpRequest#fetch
    */
-  post(options = {}) {var _this3 = this;return (0, _asyncToGenerator2.default)(function* () {
-      return _this3.fetch(_objectSpread(_objectSpread({}, options), {}, { httpMethod: _httpMethods.HTTP_METHOD_POST }));})();
+  async post(...args) {
+    const options = args[0] || {};
+    return this.fetch({ ...options, httpMethod: _httpMethods.HTTP_METHOD_POST });
   }
 }exports.default = HttpRequest;
 //# sourceMappingURL=index.js.map