graphdb/lib/http/http-client.js

Javascript client library supporting GraphDB and RDF4J REST API.

"use strict";

function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
var axios = require('axios');
var _require = require('uuid'),
  uuidv4 = _require.v4;
var qs = require('qs');
var ConsoleLogger = require('../logging/console-logger');
var REQUEST_ID_HEADER = 'x-request-id';

/**
 * Promise based HTTP client that delegates requests to Axios.
 *
 * The purpose of the delegating is to have an abstraction layer on top of the
 * used library.
 *
 * By default all requests are without a timeout, e.g. execution time is not
 * limited. To change that use {@link #setDefaultReadTimeout} and
 * {@link #setDefaultWriteTimeout} or provide one in each request's
 * configuration object.
 *
 * @class
 * @author Mihail Radkov
 * @author Svilen Velikov
 */
var HttpClient = /*#__PURE__*/function () {
  /**
   * Instantiates new HTTP client with the supplied base URL and default
   * request timeouts.
   *
   * @constructor
   * @param {string} baseURL base URL that will be prepend to all requests
   * GET
   */
  function HttpClient(baseURL) {
    _classCallCheck(this, HttpClient);
    this.axios = axios.create({
      baseURL: baseURL,
      maxContentLength: Infinity,
      maxBodyLength: Infinity,
      paramsSerializer: HttpClient.paramsSerializer
    });
    this.readTimeout = 0;
    this.writeTimeout = 0;
    this.initLogger(baseURL);
  }

  /**
   * Instantiates a logger for this http client instance.
   *
   * @private
   * @param {string} baseURL the URL for this client that will be
   * logged for each request
   */
  return _createClass(HttpClient, [{
    key: "initLogger",
    value: function initLogger(baseURL) {
      this.logger = new ConsoleLogger({
        name: 'HttpClient',
        baseURL: baseURL
      });
    }

    /**
     * Sets the provided header map as default for all requests.
     *
     * Any additional headers provided in the request configuration will
     * be merged with this default map.
     *
     * @param {Map<string, string>} headers map with default headers
     * @return {HttpClient} the current client for method chaining
     */
  }, {
    key: "setDefaultHeaders",
    value: function setDefaultHeaders(headers) {
      this.axios.defaults.headers = headers;
      return this;
    }

    /**
     * Sets the default request read timeout. It will be used in case requests
     * don't explicitly specify it in their request configurations.
     *
     * @param {number} readTimeout the default read timeout
     * @return {HttpClient} the current client for method chaining
     */
  }, {
    key: "setDefaultReadTimeout",
    value: function setDefaultReadTimeout(readTimeout) {
      this.readTimeout = readTimeout;
      return this;
    }

    /**
     * Sets the default request write timeout. It will be used in case requests
     * don't explicitly specify it in their request configurations.
     *
     * @param {number} writeTimeout the default write timeout
     * @return {HttpClient} the current client for method chaining
     */
  }, {
    key: "setDefaultWriteTimeout",
    value: function setDefaultWriteTimeout(writeTimeout) {
      this.writeTimeout = writeTimeout;
      return this;
    }

    /**
     * Performs HTTP request using the supplied request builder.
     *
     * @param {HttpRequestBuilder} requestBuilder
     * @return {Promise<any>} a promise resolving to the request's response
     */
  }, {
    key: "request",
    value: function request(requestBuilder) {
      var config = this.getRequestConfig(requestBuilder);
      this.logger.trace({
        config: config
      }, 'Executing request');
      return this.axios.request(config);
    }

    /**
     * Returns request configuration suitable for from the provided request
     * builder.
     *
     * It generates correlation identifier under the <code>x-request-id</code>
     * header and sets default timeout if it was not provided in the builder.
     *
     * @private
     * @param {HttpRequestBuilder} requestBuilder request builder
     * configuration builder used to produce the request configuration
     * request config builder
     * @return {Object<string, string>}
     */
  }, {
    key: "getRequestConfig",
    value: function getRequestConfig(requestBuilder) {
      this.addXRequestIdHeader(requestBuilder);
      this.addDefaultTimeout(requestBuilder);
      return requestBuilder.get();
    }

    /**
     * Sets the required x-request-id header.
     *
     * @private
     * @param {HttpRequestBuilder} requestBuilder
     */
  }, {
    key: "addXRequestIdHeader",
    value: function addXRequestIdHeader(requestBuilder) {
      requestBuilder.addHeader(REQUEST_ID_HEADER, uuidv4());
    }

    /**
     * Adds a default timeout if it is not explicitly specified in the
     * request builder.
     *
     * @private
     * @param {HttpRequestBuilder} requestBuilder request object supplied to
     * the http client for specific request
     */
  }, {
    key: "addDefaultTimeout",
    value: function addDefaultTimeout(requestBuilder) {
      if (!requestBuilder.getTimeout()) {
        if (requestBuilder.getMethod() === 'get') {
          requestBuilder.setTimeout(this.readTimeout);
        } else {
          requestBuilder.setTimeout(this.writeTimeout);
        }
      }
    }

    /**
     * Returns the base URL which this http client uses to send requests.
     *
     * @return {string} the base URL for each request
     */
  }, {
    key: "getBaseURL",
    value: function getBaseURL() {
      return this.axios.defaults.baseURL;
    }

    /**
     * Serializes the provided parameters in a way that can be properly read by
     * the RDF4J server.
     *
     * It ignores any null or undefined parameters and repeats array parameters.
     *
     * @private
     * @static
     * @param {object} params the parameters for serialization
     * @return {string} the serialized parameters
     */
  }], [{
    key: "paramsSerializer",
    value: function paramsSerializer(params) {
      return qs.stringify(params, {
        arrayFormat: 'repeat',
        skipNulls: true
      });
    }
  }]);
}();
module.exports = HttpClient;