intelicoreact 1.1.95 → 1.2.1

package/dist/Classes/RESTAPI/partials/CredentialsProcessing.js

@@ -0,0 +1,390 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _outerDependencies = _interopRequireDefault(require("./_outerDependencies"));
+
+var _utils = require("./_utils");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var jwt = _outerDependencies.default.jwt;
+
+var CredentialsProcessing = /*#__PURE__*/function () {
+  function CredentialsProcessing(settings) {
+    (0, _classCallCheck2.default)(this, CredentialsProcessing);
+    var credentialsProcessing = settings.credentialsProcessing;
+
+    var _ref = credentialsProcessing || {},
+        getCredentials = _ref.getCredentials,
+        getHeadersForAuthorize = _ref.getHeadersForAuthorize,
+        importCredentials = _ref.importCredentials,
+        saveCredentials = _ref.saveCredentials,
+        _ref$isUseRefreshToke = _ref.isUseRefreshTokensPropcessing,
+        isUseRefreshTokensPropcessing = _ref$isUseRefreshToke === void 0 ? false : _ref$isUseRefreshToke,
+        refreshCredentials = _ref.refreshCredentials,
+        REFRESH_TOKEN_PATH = _ref.REFRESH_TOKEN_PATH,
+        CODES_USING_THE_REFRESH_ATTEMPT = _ref.CODES_USING_THE_REFRESH_ATTEMPT,
+        _ref$REFRESH_TOKEN_FL = _ref.REFRESH_TOKEN_FLAG,
+        REFRESH_TOKEN_FLAG = _ref$REFRESH_TOKEN_FL === void 0 ? 'refreshTokenFlag' : _ref$REFRESH_TOKEN_FL,
+        _ref$INTERVAL_FOR_CHE = _ref.INTERVAL_FOR_CHECKING_TOKEN_UPDATE,
+        INTERVAL_FOR_CHECKING_TOKEN_UPDATE = _ref$INTERVAL_FOR_CHE === void 0 ? 50 : _ref$INTERVAL_FOR_CHE,
+        callbackAfterRejectRefresh = _ref.callbackAfterRejectRefresh;
+
+    if (typeof getCredentials !== 'function') throw new Error('No getCredentials method (CredentialsProcessing)');
+    if (typeof getHeadersForAuthorize !== 'function') throw new Error('No getHeadersForAuthorize method (CredentialsProcessing)');
+    if (importCredentials && typeof importCredentials !== 'function') throw new Error('Bad importCredentials method (CredentialsProcessing)');
+    this.isUseRefreshTokensPropcessing = isUseRefreshTokensPropcessing;
+    this.DEFAULT_CREDENTIALS = {
+      token: null,
+      expires: null,
+      refreshToken: null
+    };
+    this.getCredentialsByOuter = getCredentials;
+    this.getHeadersForAuthorize = getHeadersForAuthorize;
+    this.importCredentials = importCredentials; //? Если метод передан или если не передан, но включен флоу обновления токенов (тогда saveCredentials обязателен)
+
+    if (saveCredentials || isUseRefreshTokensPropcessing) {
+      if (typeof saveCredentials !== 'function') throw new Error('No saveCredentials method (CredentialsProcessing)');else this.saveCredentials = saveCredentials;
+    }
+
+    if (isUseRefreshTokensPropcessing) {
+      if (typeof refreshCredentials === 'function') this.refreshCredentialsByOuter = refreshCredentials;else {
+        if (typeof this.refreshCredentialsByOuter === 'function' && typeof REFRESH_TOKEN_PATH !== 'string') {
+          throw new Error('No REFRESH_TOKEN_PATH (CredentialsProcessing)');
+        }
+
+        if (!Array.isArray(CODES_USING_THE_REFRESH_ATTEMPT)) throw new Error('No CODES_USING_THE_REFRESH_ATTEMPT (CredentialsProcessing)');
+
+        if (!CODES_USING_THE_REFRESH_ATTEMPT.every(function (i) {
+          return typeof i === 'number';
+        })) {
+          throw new Error('Invalid format of CODES_USING_THE_REFRESH_ATTEMPT elements (CredentialsProcessing)');
+        }
+
+        this.REFRESH_TOKEN_PATH = REFRESH_TOKEN_PATH;
+        this.CODES_USING_THE_REFRESH_ATTEMPT = CODES_USING_THE_REFRESH_ATTEMPT;
+      }
+      if (typeof REFRESH_TOKEN_FLAG !== 'string') throw new Error('Bad REFRESH_TOKEN_FLAG (CredentialsProcessing)');
+      if (typeof INTERVAL_FOR_CHECKING_TOKEN_UPDATE !== 'number') throw new Error('Bad INTERVAL_FOR_CHECKING_TOKEN_UPDATE (CredentialsProcessing)');
+      if (typeof INTERVAL_FOR_CHECKING_TOKEN_UPDATE !== 'number') throw new Error('Bad INTERVAL_FOR_CHECKING_TOKEN_UPDATE (CredentialsProcessing)');
+
+      if (callbackAfterRejectRefresh && typeof callbackAfterRejectRefresh !== 'function') {
+        throw new Error('Bad INTERVAL_FOR_CHECKING_TOKEN_UPDATE (CredentialsProcessing)');
+      }
+
+      this.REFRESH_TOKEN_FLAG = REFRESH_TOKEN_FLAG;
+      this.INTERVAL_FOR_CHECKING_TOKEN_UPDATE = INTERVAL_FOR_CHECKING_TOKEN_UPDATE;
+      if (callbackAfterRejectRefresh) this.callbackAfterRejectRefresh = callbackAfterRejectRefresh;
+    }
+  }
+
+  (0, _createClass2.default)(CredentialsProcessing, [{
+    key: "getIsTokenStartRefresh",
+    value: function getIsTokenStartRefresh() {
+      return localStorage.getItem(this.REFRESH_TOKEN_FLAG);
+    }
+  }, {
+    key: "setIsTokenStartRefresh",
+    value: function setIsTokenStartRefresh() {
+      localStorage.setItem(this.REFRESH_TOKEN_FLAG, true);
+    }
+  }, {
+    key: "removeIsTokenStartRefresh",
+    value: function removeIsTokenStartRefresh() {
+      localStorage.removeItem(this.REFRESH_TOKEN_FLAG);
+    }
+  }, {
+    key: "getCredentials",
+    value: function () {
+      var _getCredentials = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(isCatchCallbackProcess, callback) {
+        var credentials, token, decoded, currentTime;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                credentials = this.getCredentialsByOuter();
+                if (typeof this.importCredentials === 'function') credentials = this.importCredentials(credentials);
+                if (!(0, _utils.getIsOnlyAnObject)(credentials)) credentials = {};
+                token = credentials.token || null;
+
+                if (token && !isCatchCallbackProcess) {
+                  try {
+                    decoded = jwt.decode(token);
+                  } catch (_unused) {
+                    decoded = null;
+                  }
+
+                  currentTime = Date.now() / 1000;
+                  if (decoded !== null && +decoded.exp < currentTime) credentials = _objectSpread(_objectSpread({}, credentials), {}, {
+                    isNeedRefresh: true
+                  });
+                }
+
+                if (!callback) {
+                  _context.next = 8;
+                  break;
+                }
+
+                _context.next = 8;
+                return callback(_objectSpread(_objectSpread({}, credentials), {}, {
+                  isCatchCallbackProcess: isCatchCallbackProcess
+                }));
+
+              case 8:
+                return _context.abrupt("return", _objectSpread(_objectSpread({}, credentials), {}, {
+                  isCatchCallbackProcess: isCatchCallbackProcess
+                }));
+
+              case 9:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function getCredentials(_x, _x2) {
+        return _getCredentials.apply(this, arguments);
+      }
+
+      return getCredentials;
+    }()
+  }, {
+    key: "refreshCredentials",
+    value: function () {
+      var _refreshCredentials = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(currentCredentials, callback) {
+        var CONTEXT, finalize, _finalize, refreshCredentialsByDefault, _refreshCredentialsByDefault, newCredentials;
+
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                _refreshCredentialsByDefault = function _refreshCredentialsBy2() {
+                  _refreshCredentialsByDefault = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
+                    var token, refreshToken, headers, body;
+                    return _regenerator.default.wrap(function _callee3$(_context3) {
+                      while (1) {
+                        switch (_context3.prev = _context3.next) {
+                          case 0:
+                            token = currentCredentials.token, refreshToken = currentCredentials.refreshToken;
+                            headers = new Headers();
+                            headers.append.apply(headers, (0, _toConsumableArray2.default)(Object.entries(CONTEXT.getHeadersForAuthorize(token))));
+                            body = new FormData();
+                            body.append('grant_type', 'refresh_token');
+                            body.append('refresh_token', refreshToken);
+                            body.append('client_id', 'oauth');
+                            body.append('client_secret', 'secret');
+                            body.append('access_type', 'offline');
+                            return _context3.abrupt("return", fetch("".concat(CONTEXT.REFRESH_TOKEN_PATH), {
+                              mode: 'cors',
+                              method: 'POST',
+                              headers: headers,
+                              body: body,
+                              redirect: 'follow'
+                            }));
+
+                          case 10:
+                          case "end":
+                            return _context3.stop();
+                        }
+                      }
+                    }, _callee3);
+                  }));
+                  return _refreshCredentialsByDefault.apply(this, arguments);
+                };
+
+                refreshCredentialsByDefault = function _refreshCredentialsBy() {
+                  return _refreshCredentialsByDefault.apply(this, arguments);
+                };
+
+                _finalize = function _finalize3() {
+                  _finalize = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(cred, isSkipImport) {
+                    var output;
+                    return _regenerator.default.wrap(function _callee2$(_context2) {
+                      while (1) {
+                        switch (_context2.prev = _context2.next) {
+                          case 0:
+                            output = typeof CONTEXT.importCredentials === 'function' && !isSkipImport ? CONTEXT.importCredentials(cred) : cred;
+
+                            if (!callback) {
+                              _context2.next = 4;
+                              break;
+                            }
+
+                            _context2.next = 4;
+                            return callback(output);
+
+                          case 4:
+                            return _context2.abrupt("return", Promise.resolve(output).then(function (res) {
+                              CONTEXT.removeIsTokenStartRefresh();
+                              return res;
+                            }));
+
+                          case 5:
+                          case "end":
+                            return _context2.stop();
+                        }
+                      }
+                    }, _callee2);
+                  }));
+                  return _finalize.apply(this, arguments);
+                };
+
+                finalize = function _finalize2(_x5, _x6) {
+                  return _finalize.apply(this, arguments);
+                };
+
+                CONTEXT = this;
+
+                if (!(!(currentCredentials !== null && currentCredentials !== void 0 && currentCredentials.token) || !(currentCredentials !== null && currentCredentials !== void 0 && currentCredentials.refresh))) {
+                  _context4.next = 7;
+                  break;
+                }
+
+                return _context4.abrupt("return", finalize(CONTEXT.DEFAULT_CREDENTIALS, true));
+
+              case 7:
+                if (!(typeof CONTEXT.refreshCredentialsByOuter === 'function')) {
+                  _context4.next = 13;
+                  break;
+                }
+
+                _context4.next = 10;
+                return CONTEXT.refreshCredentialsByOuter(currentCredentials);
+
+              case 10:
+                _context4.t0 = _context4.sent;
+                _context4.next = 16;
+                break;
+
+              case 13:
+                _context4.next = 15;
+                return refreshCredentialsByDefault();
+
+              case 15:
+                _context4.t0 = _context4.sent;
+
+              case 16:
+                newCredentials = _context4.t0;
+                return _context4.abrupt("return", finalize(newCredentials));
+
+              case 18:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function refreshCredentials(_x3, _x4) {
+        return _refreshCredentials.apply(this, arguments);
+      }
+
+      return refreshCredentials;
+    }()
+  }, {
+    key: "waitRefresh",
+    value: function () {
+      var _waitRefresh = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(isNeedRefresh) {
+        var _this = this;
+
+        return _regenerator.default.wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                return _context5.abrupt("return", new Promise(function (resolve) {
+                  if (!_this.getIsTokenStartRefresh()) {
+                    if (isNeedRefresh) _this.setIsTokenStartRefresh();
+                    resolve();
+                  } else {
+                    var intervalId = setInterval(function () {
+                      if (!_this.getIsTokenStartRefresh()) {
+                        clearInterval(intervalId);
+                        resolve();
+                      }
+                    }, _this.INTERVAL_FOR_CHECKING_TOKEN_UPDATE);
+                  }
+                }));
+
+              case 1:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5);
+      }));
+
+      function waitRefresh(_x7) {
+        return _waitRefresh.apply(this, arguments);
+      }
+
+      return waitRefresh;
+    }()
+  }, {
+    key: "processCredentials",
+    value: function () {
+      var _processCredentials = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(cred) {
+        var CONTEXT, output;
+        return _regenerator.default.wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                CONTEXT = this;
+                output = cred;
+
+                if (!(cred.isNeedRefresh || cred.isCatchCallbackProcess)) {
+                  _context6.next = 6;
+                  break;
+                }
+
+                _context6.next = 5;
+                return CONTEXT.refreshCredentials(cred, function (res) {
+                  return CONTEXT.saveCredentials(res);
+                });
+
+              case 5:
+                output = _context6.sent;
+
+              case 6:
+                return _context6.abrupt("return", output);
+
+              case 7:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, this);
+      }));
+
+      function processCredentials(_x8) {
+        return _processCredentials.apply(this, arguments);
+      }
+
+      return processCredentials;
+    }()
+  }]);
+  return CredentialsProcessing;
+}();
+
+var _default = CredentialsProcessing;
+exports.default = _default;

package/dist/Classes/RESTAPI/partials/_outerDependencies.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _jsonwebtoken = _interopRequireDefault(require("jsonwebtoken"));
+
+var _default = {
+  jwt: _jsonwebtoken.default
+};
+exports.default = _default;