intelicoreact 1.4.81 → 1.4.83

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

@@ -7,55 +7,49 @@ Object.defineProperty(exports, "__esModule", {
 });
 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");
 
-const {
-  jwt
-} = _outerDependencies.default;
-
-class CredentialsProcessing {
-  constructor(settings) {
-    const {
-      credentialsProcessing
-    } = settings;
-    const {
-      //? Для корректной работы установки токенов в запросы от API
-      //? нужно передавать методы getCredentials и getHeadersForAuthorize
-      getCredentials,
-      getHeadersForAuthorize,
-      //? На вход получит токен, должна вернуть объект для коструктора Headers
-      //? Так же опционально можно передавать
-      importCredentials,
-      //? если он передается, то он будет применяться к выводу от вызова getCredentials
-      saveCredentials,
-      //? можно будет найти в объекте credentialsProcessing, чтобы использовать кастомными методами
-      //! Либо вызов getCredentials, либо цепочка вызовов importCredentials(getCredentials())
-      //! должна возвращать требуемую классом структуру
-      //! Класс требует структуры
-      //!   - { token }, если флоу рефреш токена НЕ используется
-      //!   - { token, refreshToken, expires }, если используется флоу рефреш токена
-      // *********
-      //? Подключает флоу рефреша токенов
-      isUseRefreshTokensPropcessing = false,
-      //! Для корректной работы флоу рефреша токенов передача метода saveCredentials становится ОБЯЗАТЕЛЬНОЙ
-      //? Так же для корректной работы флоу рефреша токенов нужно
-      //?   - либо
-      refreshCredentials,
-      //! метод должен возвращать такую же структуру как и метод getCredentials,
-      //? на вход получит текущие креды, к выходу будет применен importCredentials, если этот метод передавался
-      //?   - либо
-      REFRESH_TOKEN_PATH,
-      //! REFRESH_TOKEN_PATH передается ПОЛНОСТЬЮ (глобальная адресация)!
-      CODES_USING_THE_REFRESH_ATTEMPT,
-      //? указывает по каким кодам ответа триггериться рефреш, массив чисел
-      //? Опционально
-      REFRESH_TOKEN_FLAG = "refreshTokenFlag",
-      INTERVAL_FOR_CHECKING_TOKEN_UPDATE = 50,
-      // ms
-      callbackAfterRejectRefresh
-    } = credentialsProcessing || {};
+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; }
+
+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") {
@@ -89,7 +83,9 @@ class CredentialsProcessing {
         throw new Error("No CODES_USING_THE_REFRESH_ATTEMPT [CredentialsProcessing]");
       }
 
-      if (!CODES_USING_THE_REFRESH_ATTEMPT.every(i => typeof i === "number")) {
+      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]");
       }
 
@@ -114,130 +110,350 @@ class CredentialsProcessing {
     }
   }
 
-  getIsTokenStartRefresh() {
-    return localStorage.getItem(this.REFRESH_TOKEN_FLAG);
-  }
-
-  setIsTokenStartRefresh() {
-    localStorage.setItem(this.REFRESH_TOKEN_FLAG, true);
-  }
-
-  removeIsTokenStartRefresh() {
-    localStorage.removeItem(this.REFRESH_TOKEN_FLAG);
-  }
-
-  async getCredentials(isCatchCallbackProcess, callback) {
-    let credentials = await this.getCredentialsByOuter();
-    if (typeof this.importCredentials === "function") credentials = await this.importCredentials(credentials);
-    if (!(0, _utils.getIsOnlyAnObject)(credentials)) credentials = {};
-    const token = credentials.token || null;
-
-    if (token && !isCatchCallbackProcess) {
-      let decoded;
-
-      try {
-        decoded = jwt.decode(token);
-      } catch {
-        decoded = null;
-      }
-
-      const currentTime = Date.now() / 1000;
-      if (decoded !== null && Number(decoded.exp) < currentTime) credentials = { ...credentials,
-        isNeedRefresh: true
-      };
+  (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:
+                _context.next = 2;
+                return this.getCredentialsByOuter();
+
+              case 2:
+                credentials = _context.sent;
+
+                if (!(typeof this.importCredentials === "function")) {
+                  _context.next = 7;
+                  break;
+                }
+
+                _context.next = 6;
+                return this.importCredentials(credentials);
+
+              case 6:
+                credentials = _context.sent;
+
+              case 7:
+                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 && Number(decoded.exp) < currentTime) credentials = _objectSpread(_objectSpread({}, credentials), {}, {
+                    isNeedRefresh: true
+                  });
+                }
+
+                if (!callback) {
+                  _context.next = 13;
+                  break;
+                }
+
+                _context.next = 13;
+                return callback(_objectSpread(_objectSpread({}, credentials), {}, {
+                  isCatchCallbackProcess: isCatchCallbackProcess
+                }));
+
+              case 13:
+                return _context.abrupt("return", _objectSpread(_objectSpread({}, credentials), {}, {
+                  isCatchCallbackProcess: isCatchCallbackProcess
+                }));
+
+              case 14:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
 
-    if (callback) await callback({ ...credentials,
-      isCatchCallbackProcess
-    });
-    return { ...credentials,
-      isCatchCallbackProcess
-    };
-  }
-
-  async refreshCredentials(currentCredentials, callback) {
-    const CONTEXT = this;
+      function getCredentials(_x, _x2) {
+        return _getCredentials.apply(this, arguments);
+      }
 
-    async function finalize(cred) {
-      if (callback) await callback(cred);
-      return Promise.resolve(cred).then(async res => {
-        CONTEXT.removeIsTokenStartRefresh();
-        return res;
-      });
-    }
+      return getCredentials;
+    }()
+  }, {
+    key: "refreshCredentials",
+    value: function () {
+      var _refreshCredentials = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(currentCredentials, callback) {
+        var CONTEXT, finalize, _finalize, refreshCredentialsByDefault, _refreshCredentialsByDefault, newCredentials;
+
+        return _regenerator.default.wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                _refreshCredentialsByDefault = function _refreshCredentialsBy2() {
+                  _refreshCredentialsByDefault = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4() {
+                    var token, refreshToken, headers, body;
+                    return _regenerator.default.wrap(function _callee4$(_context4) {
+                      while (1) {
+                        switch (_context4.prev = _context4.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 _context4.abrupt("return", fetch("".concat(CONTEXT.REFRESH_TOKEN_PATH), {
+                              mode: "cors",
+                              method: "POST",
+                              headers: headers,
+                              body: body,
+                              redirect: "follow"
+                            }));
+
+                          case 10:
+                          case "end":
+                            return _context4.stop();
+                        }
+                      }
+                    }, _callee4);
+                  }));
+                  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 _callee3(cred) {
+                    return _regenerator.default.wrap(function _callee3$(_context3) {
+                      while (1) {
+                        switch (_context3.prev = _context3.next) {
+                          case 0:
+                            if (!callback) {
+                              _context3.next = 3;
+                              break;
+                            }
+
+                            _context3.next = 3;
+                            return callback(cred);
+
+                          case 3:
+                            return _context3.abrupt("return", Promise.resolve(cred).then( /*#__PURE__*/function () {
+                              var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(res) {
+                                return _regenerator.default.wrap(function _callee2$(_context2) {
+                                  while (1) {
+                                    switch (_context2.prev = _context2.next) {
+                                      case 0:
+                                        CONTEXT.removeIsTokenStartRefresh();
+                                        return _context2.abrupt("return", res);
+
+                                      case 2:
+                                      case "end":
+                                        return _context2.stop();
+                                    }
+                                  }
+                                }, _callee2);
+                              }));
+
+                              return function (_x6) {
+                                return _ref2.apply(this, arguments);
+                              };
+                            }()));
+
+                          case 4:
+                          case "end":
+                            return _context3.stop();
+                        }
+                      }
+                    }, _callee3);
+                  }));
+                  return _finalize.apply(this, arguments);
+                };
+
+                finalize = function _finalize2(_x5) {
+                  return _finalize.apply(this, arguments);
+                };
+
+                CONTEXT = this;
+
+                if (!(!(currentCredentials !== null && currentCredentials !== void 0 && currentCredentials.token) || !(currentCredentials !== null && currentCredentials !== void 0 && currentCredentials.refreshToken))) {
+                  _context5.next = 7;
+                  break;
+                }
+
+                return _context5.abrupt("return", finalize(CONTEXT.DEFAULT_CREDENTIALS));
+
+              case 7:
+                if (!(typeof CONTEXT.refreshCredentialsByOuter === "function")) {
+                  _context5.next = 13;
+                  break;
+                }
+
+                _context5.next = 10;
+                return CONTEXT.refreshCredentialsByOuter(currentCredentials);
+
+              case 10:
+                _context5.t0 = _context5.sent;
+                _context5.next = 16;
+                break;
+
+              case 13:
+                _context5.next = 15;
+                return refreshCredentialsByDefault();
+
+              case 15:
+                _context5.t0 = _context5.sent;
+
+              case 16:
+                newCredentials = _context5.t0;
+                return _context5.abrupt("return", finalize(newCredentials));
+
+              case 18:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
 
-    if (!(currentCredentials !== null && currentCredentials !== void 0 && currentCredentials.token) || !(currentCredentials !== null && currentCredentials !== void 0 && currentCredentials.refreshToken)) return finalize(CONTEXT.DEFAULT_CREDENTIALS); //! ВНИМАНИЕ! Данный механизм рефреша принят на проекте finturfreactfrontend (админка)
-    //! На кабинете он ТОЧНО НЕ ТАКОЙ
-
-    async function refreshCredentialsByDefault() {
-      const {
-        token,
-        refreshToken
-      } = currentCredentials;
-      const headers = new Headers();
-      headers.append(...Object.entries(CONTEXT.getHeadersForAuthorize(token)));
-      const 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 fetch("".concat(CONTEXT.REFRESH_TOKEN_PATH), {
-        mode: "cors",
-        method: "POST",
-        headers,
-        body,
-        redirect: "follow"
-      });
-    } //? Передавайте собственный refreshCredentials при получении экземляра RESTAPI, если не уверены,
-    //? что механизм рефреша токенов ИМЕННО ТАКОЙ как в ф-и refreshCredentialsByDefault!
-    //! currentCredentials передаются в формате класса! ({ token, refreshToken, expires })
-
-
-    const newCredentials = typeof CONTEXT.refreshCredentialsByOuter === "function" ? await CONTEXT.refreshCredentialsByOuter(currentCredentials) : await refreshCredentialsByDefault();
-    return finalize(newCredentials);
-  }
+      function refreshCredentials(_x3, _x4) {
+        return _refreshCredentials.apply(this, arguments);
+      }
 
-  async waitRefresh(isNeedRefresh) {
-    return new Promise(resolve => {
-      if (!this.getIsTokenStartRefresh()) {
-        if (isNeedRefresh) this.setIsTokenStartRefresh();
-        resolve();
-      } else {
-        const intervalId = setInterval(() => {
-          if (!this.getIsTokenStartRefresh()) {
-            clearInterval(intervalId);
-            resolve();
+      return refreshCredentials;
+    }()
+  }, {
+    key: "waitRefresh",
+    value: function () {
+      var _waitRefresh = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(isNeedRefresh) {
+        var _this = this;
+
+        return _regenerator.default.wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                return _context6.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 _context6.stop();
+            }
           }
-        }, this.INTERVAL_FOR_CHECKING_TOKEN_UPDATE);
+        }, _callee6);
+      }));
+
+      function waitRefresh(_x7) {
+        return _waitRefresh.apply(this, arguments);
       }
-    });
-  }
 
-  async processCredentials(cred) {
-    if (!cred.isNeedRefresh && !cred.isCatchCallbackProcess) return cred;
-    const CONTEXT = this;
-    return CONTEXT.refreshCredentials(cred, response => CONTEXT.saveCredentials(response)).then(() => {
-      return new Promise(resolve => {
-        setTimeout(async () => {
-          const newCredentials = await CONTEXT.getCredentials();
-
-          if (!(newCredentials !== null && newCredentials !== void 0 && newCredentials.token)) {
-            newCredentials.isRefreshFailed = true;
-            setTimeout(() => {
-              var _CONTEXT$callbackAfte;
-
-              CONTEXT === null || CONTEXT === void 0 ? void 0 : (_CONTEXT$callbackAfte = CONTEXT.callbackAfterRejectRefresh) === null || _CONTEXT$callbackAfte === void 0 ? void 0 : _CONTEXT$callbackAfte.call(CONTEXT);
-            }, 0);
+      return waitRefresh;
+    }()
+  }, {
+    key: "processCredentials",
+    value: function () {
+      var _processCredentials = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8(cred) {
+        var CONTEXT;
+        return _regenerator.default.wrap(function _callee8$(_context8) {
+          while (1) {
+            switch (_context8.prev = _context8.next) {
+              case 0:
+                if (!(!cred.isNeedRefresh && !cred.isCatchCallbackProcess)) {
+                  _context8.next = 2;
+                  break;
+                }
+
+                return _context8.abrupt("return", cred);
+
+              case 2:
+                CONTEXT = this;
+                return _context8.abrupt("return", CONTEXT.refreshCredentials(cred, function (response) {
+                  return CONTEXT.saveCredentials(response);
+                }).then(function () {
+                  return new Promise(function (resolve) {
+                    setTimeout( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7() {
+                      var newCredentials;
+                      return _regenerator.default.wrap(function _callee7$(_context7) {
+                        while (1) {
+                          switch (_context7.prev = _context7.next) {
+                            case 0:
+                              _context7.next = 2;
+                              return CONTEXT.getCredentials();
+
+                            case 2:
+                              newCredentials = _context7.sent;
+
+                              if (!(newCredentials !== null && newCredentials !== void 0 && newCredentials.token)) {
+                                newCredentials.isRefreshFailed = true;
+                                setTimeout(function () {
+                                  var _CONTEXT$callbackAfte;
+
+                                  CONTEXT === null || CONTEXT === void 0 ? void 0 : (_CONTEXT$callbackAfte = CONTEXT.callbackAfterRejectRefresh) === null || _CONTEXT$callbackAfte === void 0 ? void 0 : _CONTEXT$callbackAfte.call(CONTEXT);
+                                }, 0);
+                              }
+
+                              resolve(newCredentials);
+
+                            case 5:
+                            case "end":
+                              return _context7.stop();
+                          }
+                        }
+                      }, _callee7);
+                    })), 0);
+                  });
+                }));
+
+              case 4:
+              case "end":
+                return _context8.stop();
+            }
           }
+        }, _callee8, this);
+      }));
 
-          resolve(newCredentials);
-        }, 0);
-      });
-    });
-  }
+      function processCredentials(_x8) {
+        return _processCredentials.apply(this, arguments);
+      }
 
-}
+      return processCredentials;
+    }()
+  }]);
+  return CredentialsProcessing;
+}();
 
 var _default = CredentialsProcessing;
 exports.default = _default;