@eluvio/elv-client-js 4.0.113 → 4.0.115

package/dist/src/HttpClient.js

@@ -0,0 +1,315 @@
+var _regeneratorRuntime = require("@babel/runtime/regenerator");
+var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");
+var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");
+var _createClass = require("@babel/runtime/helpers/createClass");
+var URI = require("urijs");
+var _Fetch = typeof fetch !== "undefined" ? fetch : require("node-fetch")["default"];
+var _require = require("./LogMessage"),
+  LogMessage = _require.LogMessage;
+var Utils = require("./Utils");
+var HttpClient = /*#__PURE__*/function () {
+  "use strict";
+
+  function HttpClient(_ref) {
+    var uris = _ref.uris,
+      debug = _ref.debug;
+    _classCallCheck(this, HttpClient);
+    this.uris = uris;
+    this.uriIndex = 0;
+    this.debug = debug;
+    this.draftURIs = {};
+    this.retries = Math.max(3, uris.length);
+  }
+  _createClass(HttpClient, [{
+    key: "Log",
+    value: function Log(message) {
+      var error = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      LogMessage(this, message, error);
+    }
+  }, {
+    key: "BaseURI",
+    value: function BaseURI(uriIndex) {
+      if (uriIndex === undefined) {
+        uriIndex = this.uriIndex;
+      }
+      return new URI(this.uris[uriIndex]);
+    }
+  }, {
+    key: "RecordWriteToken",
+    value: function RecordWriteToken(writeToken, nodeUrlStr) {
+      if (!nodeUrlStr) throw Error("RecordWriteToken() - nodeUrlStr not supplied");
+      if (!writeToken) throw Error("RecordWriteToken() - writeToken not supplied");
+      this.draftURIs[writeToken] = new URI(nodeUrlStr);
+    }
+  }, {
+    key: "ClearWriteToken",
+    value: function ClearWriteToken(_ref2) {
+      var writeToken = _ref2.writeToken;
+      if (Object.hasOwn(this.draftURIs, writeToken)) {
+        delete this.draftURIs[writeToken];
+      }
+    }
+  }, {
+    key: "RequestHeaders",
+    value: function RequestHeaders(bodyType) {
+      var headers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (!headers.Accept) {
+        headers["Accept"] = "application/json";
+      }
+      if (bodyType === "JSON") {
+        headers["Content-type"] = "application/json";
+      } else if (bodyType === "BINARY") {
+        headers["Content-type"] = "application/octet-stream";
+      }
+      return headers;
+    }
+  }, {
+    key: "Request",
+    value: function () {
+      var _Request = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref3) {
+        var method, path, _ref3$queryParams, queryParams, body, _ref3$bodyType, bodyType, _ref3$headers, headers, _ref3$attempts, attempts, _ref3$allowFailover, allowFailover, _ref3$forceFailover, forceFailover, _ref3$allowRetry, allowRetry, uriIndex, baseURI, writeTokenMatch, writeToken, uri, fetchParameters, response, responseType, errorBody, error;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              method = _ref3.method, path = _ref3.path, _ref3$queryParams = _ref3.queryParams, queryParams = _ref3$queryParams === void 0 ? {} : _ref3$queryParams, body = _ref3.body, _ref3$bodyType = _ref3.bodyType, bodyType = _ref3$bodyType === void 0 ? "JSON" : _ref3$bodyType, _ref3$headers = _ref3.headers, headers = _ref3$headers === void 0 ? {} : _ref3$headers, _ref3$attempts = _ref3.attempts, attempts = _ref3$attempts === void 0 ? 0 : _ref3$attempts, _ref3$allowFailover = _ref3.allowFailover, allowFailover = _ref3$allowFailover === void 0 ? true : _ref3$allowFailover, _ref3$forceFailover = _ref3.forceFailover, forceFailover = _ref3$forceFailover === void 0 ? false : _ref3$forceFailover, _ref3$allowRetry = _ref3.allowRetry, allowRetry = _ref3$allowRetry === void 0 ? true : _ref3$allowRetry, uriIndex = _ref3.uriIndex;
+              baseURI = this.BaseURI(uriIndex); // If URL contains a write token, it must go to the correct server and can not fail over
+              writeTokenMatch = path.replace(/^\//, "").match(/(qlibs\/ilib[a-zA-Z0-9]+|q|qid)\/(tqw__[a-zA-Z0-9]+)/);
+              writeToken = writeTokenMatch ? writeTokenMatch[2] : undefined;
+              if (writeToken) {
+                allowFailover = false;
+                if (this.draftURIs[writeToken]) {
+                  // Use saved write token URI
+                  baseURI = this.draftURIs[writeToken];
+                } else {
+                  // Save current URI for all future requests involving this write token
+                  this.draftURIs[writeToken] = baseURI;
+                }
+              }
+              uri = baseURI.path(path).query(queryParams).hash("");
+              fetchParameters = {
+                method: method,
+                headers: this.RequestHeaders(bodyType, headers)
+              };
+              if (method === "POST" || method === "PUT" || method === "DELETE") {
+                if (body && bodyType === "JSON") {
+                  fetchParameters.body = JSON.stringify(body);
+                } else if (body) {
+                  fetchParameters.body = body;
+                }
+              }
+              if (this.debug) {
+                this.Log("".concat(method, " - ").concat(uri.toString()));
+                this.Log("fetchParameters: ".concat(JSON.stringify(fetchParameters, null, 2)));
+              }
+              _context.prev = 9;
+              _context.next = 12;
+              return HttpClient.Fetch(uri.toString(), fetchParameters);
+            case 12:
+              response = _context.sent;
+              _context.next = 18;
+              break;
+            case 15:
+              _context.prev = 15;
+              _context.t0 = _context["catch"](9);
+              response = {
+                ok: false,
+                status: 500,
+                statusText: "ElvClient Error: " + _context.t0.message,
+                url: uri.toString(),
+                stack: _context.t0.stack
+              };
+            case 18:
+              if (response.ok) {
+                _context.next = 47;
+                break;
+              }
+              if (!((parseInt(response.status) >= 500 || forceFailover) && allowRetry && attempts < this.retries)) {
+                _context.next = 31;
+                break;
+              }
+              if (!allowFailover) {
+                _context.next = 25;
+                break;
+              }
+              // Fail over to alternate node
+              this.uriIndex = (this.uriIndex + 1) % this.uris.length;
+              this.Log("HttpClient failing over from ".concat(baseURI.toString(), ": ").concat(attempts + 1, " attempts"), true);
+              _context.next = 28;
+              break;
+            case 25:
+              // Wait and retry
+              this.Log("HttpClient retrying request from ".concat(baseURI.toString(), ": ").concat(attempts + 1, " attempts"), true);
+              _context.next = 28;
+              return new Promise(function (resolve) {
+                return setTimeout(resolve, 1000);
+              });
+            case 28:
+              _context.next = 30;
+              return this.Request({
+                method: method,
+                path: path,
+                queryParams: queryParams,
+                body: body,
+                bodyType: bodyType,
+                headers: headers,
+                attempts: attempts + 1,
+                uriIndex: uriIndex,
+                forceFailover: forceFailover
+              });
+            case 30:
+              return _context.abrupt("return", _context.sent);
+            case 31:
+              // Parse JSON error if headers indicate JSON
+              responseType = response.headers ? response.headers.get("content-type") || "" : "";
+              errorBody = "";
+              if (!(response.text && response.json)) {
+                _context.next = 44;
+                break;
+              }
+              if (!responseType.includes("application/json")) {
+                _context.next = 40;
+                break;
+              }
+              _context.next = 37;
+              return response.json();
+            case 37:
+              _context.t1 = _context.sent;
+              _context.next = 43;
+              break;
+            case 40:
+              _context.next = 42;
+              return response.text();
+            case 42:
+              _context.t1 = _context.sent;
+            case 43:
+              errorBody = _context.t1;
+            case 44:
+              error = {
+                name: "ElvHttpClientError",
+                status: response.status,
+                statusText: response.statusText,
+                message: response.statusText,
+                url: uri.toString(),
+                body: errorBody,
+                requestParams: fetchParameters
+              };
+              if (this.debug) this.Log(JSON.stringify(error, null, 2), true);
+              throw error;
+            case 47:
+              this.Log("".concat(response.status, " - ").concat(method, " ").concat(uri.toString()));
+              return _context.abrupt("return", response);
+            case 49:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[9, 15]]);
+      }));
+      function Request(_x) {
+        return _Request.apply(this, arguments);
+      }
+      return Request;
+    }()
+  }, {
+    key: "RequestAll",
+    value: function () {
+      var _RequestAll = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(_ref4) {
+        var _this = this;
+        var method, path, _ref4$queryParams, queryParams, body, _ref4$bodyType, bodyType, _ref4$headers, headers;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              method = _ref4.method, path = _ref4.path, _ref4$queryParams = _ref4.queryParams, queryParams = _ref4$queryParams === void 0 ? {} : _ref4$queryParams, body = _ref4.body, _ref4$bodyType = _ref4.bodyType, bodyType = _ref4$bodyType === void 0 ? "JSON" : _ref4$bodyType, _ref4$headers = _ref4.headers, headers = _ref4$headers === void 0 ? {} : _ref4$headers;
+              _context3.next = 3;
+              return Promise.all(Array.from(new Array(this.uris.length).keys()).map( /*#__PURE__*/function () {
+                var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(uriIndex) {
+                  return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+                    while (1) switch (_context2.prev = _context2.next) {
+                      case 0:
+                        _context2.prev = 0;
+                        _context2.next = 3;
+                        return _this.Request({
+                          method: method,
+                          path: path,
+                          queryParams: queryParams,
+                          body: body,
+                          bodyType: bodyType,
+                          headers: headers,
+                          allowFailover: false,
+                          uriIndex: uriIndex
+                        });
+                      case 3:
+                        return _context2.abrupt("return", _context2.sent);
+                      case 6:
+                        _context2.prev = 6;
+                        _context2.t0 = _context2["catch"](0);
+                        return _context2.abrupt("return", _context2.t0);
+                      case 9:
+                      case "end":
+                        return _context2.stop();
+                    }
+                  }, _callee2, null, [[0, 6]]);
+                }));
+                return function (_x3) {
+                  return _ref5.apply(this, arguments);
+                };
+              }()));
+            case 3:
+              return _context3.abrupt("return", _context3.sent);
+            case 4:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function RequestAll(_x2) {
+        return _RequestAll.apply(this, arguments);
+      }
+      return RequestAll;
+    }() // Perform http request and then return response body parsed as JSON
+    // ResponseToJson() will log response if this.debug === true
+  }, {
+    key: "RequestJsonBody",
+    value: function () {
+      var _RequestJsonBody = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(params) {
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              return _context4.abrupt("return", Utils.ResponseToJson(this.Request(params), this.debug, this.Log.bind(this)));
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function RequestJsonBody(_x4) {
+        return _RequestJsonBody.apply(this, arguments);
+      }
+      return RequestJsonBody;
+    }()
+  }, {
+    key: "URL",
+    value: function URL(_ref6) {
+      var path = _ref6.path,
+        _ref6$queryParams = _ref6.queryParams,
+        queryParams = _ref6$queryParams === void 0 ? {} : _ref6$queryParams;
+      var baseURI = this.BaseURI();
+
+      // If URL contains a write token, it must go to the correct server and can not fail over
+      var writeTokenMatch = path.replace(/^\//, "").match(/(qlibs\/ilib[a-zA-Z0-9]+|q|qid)\/(tqw__[a-zA-Z0-9]+)/);
+      var writeToken = writeTokenMatch ? writeTokenMatch[2] : undefined;
+      if (writeToken && this.draftURIs[writeToken]) {
+        // Use saved write token URI
+        baseURI = this.draftURIs[writeToken];
+      }
+      return baseURI.path(path).query(queryParams).hash("").toString();
+    }
+  }], [{
+    key: "Fetch",
+    value: function Fetch(url) {
+      var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return _Fetch(url, params);
+    }
+  }]);
+  return HttpClient;
+}();
+module.exports = HttpClient;

package/dist/src/Id.js

@@ -0,0 +1,21 @@
+var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");
+var _createClass = require("@babel/runtime/helpers/createClass");
+// Incremental numerical IDs
+
+var __id = 0;
+var Id = /*#__PURE__*/function () {
+  "use strict";
+
+  function Id() {
+    _classCallCheck(this, Id);
+  }
+  _createClass(Id, null, [{
+    key: "next",
+    value: function next() {
+      __id++;
+      return __id;
+    }
+  }]);
+  return Id;
+}();
+module.exports = Id;

package/dist/src/LogMessage.js

@@ -0,0 +1,25 @@
+var _typeof = require("@babel/runtime/helpers/typeof");
+var CustomLogFunc = function CustomLogFunc(attrName, debugOpts) {
+  return _typeof(debugOpts) === "object" && typeof debugOpts[attrName] === "function" ? debugOpts[attrName] : null;
+};
+var StringifyIfObject = function StringifyIfObject(message) {
+  return _typeof(message) === "object" ? JSON.stringify(message) : message;
+};
+var LogMessage = function LogMessage(reporter, message) {
+  var error = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  if (!reporter.debug) {
+    return;
+  }
+  var customLog = CustomLogFunc("log", reporter.debugOptions);
+  var customError = CustomLogFunc("error", reporter.debugOptions);
+  var prefix = "(elv-client-js#".concat(reporter.constructor.name, ")");
+  var standardMsg = "\n".concat(prefix, " ").concat(StringifyIfObject(message), "\n");
+  error ? customError ? customError(prefix, message) :
+  // eslint-disable-next-line no-console
+  console.error(standardMsg) : customLog ? customLog(prefix, message) :
+  // eslint-disable-next-line no-console
+  console.log(standardMsg);
+};
+module.exports = {
+  LogMessage: LogMessage
+};