qiscus-sdk-core 2.12.1 → 2.12.2

package/lib/lib/adapters/expired-token.js

@@ -0,0 +1,218 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExpiredTokenAdapter = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _util = require("../util");
+
+// @ts-check
+var ExpiredTokenAdapter = /*#__PURE__*/function () {
+  /** @type {boolean} */
+
+  /** @type {string | null} */
+
+  /** @type {Date | null} */
+
+  /** @type {import('./http').default} */
+
+  /** @type {(token: string, refreshToken: string, expiredAt: Date) => void | undefined} */
+
+  /** @type {any} */
+
+  /** @type {() => boolean} */
+
+  /**
+   * @constructor
+   *
+   * @param {{
+   *  httpAdapter: import('./http').default,
+   *  userId: string,
+   *  refreshToken: string | null,
+   *  expiredAt: string | null,
+   *  onTokenRefreshed: (token: string, refreshToken: string, expiredAt: Date) => void
+   *  getAuthenticationStatus: () => boolean,
+   * }} param
+   */
+  function ExpiredTokenAdapter(_ref) {
+    var httpAdapter = _ref.httpAdapter,
+        refreshToken = _ref.refreshToken,
+        expiredAt = _ref.expiredAt,
+        userId = _ref.userId,
+        onTokenRefreshed = _ref.onTokenRefreshed,
+        getAuthenticationStatus = _ref.getAuthenticationStatus;
+    (0, _classCallCheck2["default"])(this, ExpiredTokenAdapter);
+    (0, _defineProperty2["default"])(this, "_isExpiredTokenEnabled", false);
+    (0, _defineProperty2["default"])(this, "_refreshToken", null);
+    (0, _defineProperty2["default"])(this, "_expiredAt", null);
+    (0, _defineProperty2["default"])(this, "_http", void 0);
+    (0, _defineProperty2["default"])(this, "_onTokenRefreshed", void 0);
+    (0, _defineProperty2["default"])(this, "_timerId", void 0);
+    (0, _defineProperty2["default"])(this, "_getAuthenticationStatus", void 0);
+    this._http = httpAdapter;
+    this._refreshToken = refreshToken; // this._expiredAt = expiredAt == null ? null : new Date(expiredAt)
+
+    this._userId = userId;
+    this._onTokenRefreshed = onTokenRefreshed;
+    this._getAuthenticationStatus = getAuthenticationStatus;
+
+    if (this._refreshToken != null && this._refreshToken === '') {
+      this._refreshToken = null;
+    }
+
+    if (expiredAt != null && expiredAt !== '') {
+      this._expiredAt = new Date(expiredAt);
+    }
+
+    this._isExpiredTokenEnabled = this._refreshToken != null && this._expiredAt != null; // this._timerId = setInterval(this._checkToken, 1000)
+
+    this._checkToken();
+  }
+
+  (0, _createClass2["default"])(ExpiredTokenAdapter, [{
+    key: "_checkToken",
+    value: function () {
+      var _checkToken2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var timeToSleep, now, diff;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                timeToSleep = 5000; // 5 seconds
+
+                if (!(this._getAuthenticationStatus() == false || this._refreshToken == null)) {
+                  _context.next = 3;
+                  break;
+                }
+
+                return _context.abrupt("return");
+
+              case 3:
+                if (!(this._expiredAt != null && this._isExpiredTokenEnabled)) {
+                  _context.next = 9;
+                  break;
+                }
+
+                now = Date.now(); // @ts-ignore
+
+                diff = Math.floor((this._expiredAt - now) / 1000); // console.log('diff', diff)
+
+                if (!(diff < timeToSleep / 1000)) {
+                  _context.next = 9;
+                  break;
+                }
+
+                _context.next = 9;
+                return this.refreshAuthToken();
+
+              case 9:
+                _context.next = 11;
+                return (0, _util.sleep)(timeToSleep);
+
+              case 11:
+                this._checkToken();
+
+              case 12:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function _checkToken() {
+        return _checkToken2.apply(this, arguments);
+      }
+
+      return _checkToken;
+    }()
+  }, {
+    key: "refreshAuthToken",
+    value: function () {
+      var _refreshAuthToken = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        var _this = this;
+
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                return _context2.abrupt("return", this._http.post('api/v2/sdk/refresh_user_token', {
+                  user_id: this._userId,
+                  refresh_token: this._refreshToken
+                }).then(function (r) {
+                  var _this$_onTokenRefresh;
+
+                  var res = r.body.results;
+                  var token = res.token;
+                  _this._refreshToken = res.refresh_token;
+
+                  _this._http.setToken(res.token);
+
+                  if (res.token_expires_at != null) {
+                    _this._expiredAt = new Date(res.token_expires_at);
+                  } // @ts-ignore
+
+
+                  (_this$_onTokenRefresh = _this._onTokenRefreshed) === null || _this$_onTokenRefresh === void 0 ? void 0 : _this$_onTokenRefresh.call(_this, token, _this._refreshToken, _this._expiredAt);
+                  return res;
+                }));
+
+              case 1:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function refreshAuthToken() {
+        return _refreshAuthToken.apply(this, arguments);
+      }
+
+      return refreshAuthToken;
+    }()
+  }, {
+    key: "logout",
+    value: function () {
+      var _logout = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                return _context3.abrupt("return", this._http.post('api/v2/sdk/logout', {
+                  user_id: this._userId,
+                  token: this._http.token
+                }));
+
+              case 1:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function logout() {
+        return _logout.apply(this, arguments);
+      }
+
+      return logout;
+    }()
+  }]);
+  return ExpiredTokenAdapter;
+}();
+
+exports.ExpiredTokenAdapter = ExpiredTokenAdapter;

package/lib/lib/adapters/sync.js

@@ -441,7 +441,9 @@ function SyncAdapter(getHttpAdapter, _ref) {
       getShouldSync = _ref.getShouldSync,
       syncOnConnect = _ref.syncOnConnect,
       lastCommentId = _ref.lastCommentId,
-      statusLogin = _ref.statusLogin;
+      statusLogin = _ref.statusLogin,
+      enableSync = _ref.enableSync,
+      enableSyncEvent = _ref.enableSyncEvent;
   var emitter = (0, _mitt["default"])();
 
   var logger = function logger() {
@@ -452,9 +454,9 @@ function SyncAdapter(getHttpAdapter, _ref) {
     }
 
     return isDebug ? (_console = console).log.apply(_console, ['QSync:'].concat(args)) : {};
-  }; // let lastMessageId = 0
-
+  };
 
+  var lastMessageId = 0;
   var lastEventId = 0;
 
   var getInterval = function getInterval() {
@@ -466,7 +468,11 @@ function SyncAdapter(getHttpAdapter, _ref) {
     return 0;
   };
 
-  var syncFactory = synchronizeFactory(getHttpAdapter, getInterval, getShouldSync, lastCommentId, logger);
+  var _getShouldSync = function _getShouldSync() {
+    return getShouldSync() && enableSync();
+  };
+
+  var syncFactory = synchronizeFactory(getHttpAdapter, getInterval, _getShouldSync, lastCommentId, logger);
   syncFactory.on('last-message-id.new', function (id) {
     return lastMessageId = id;
   });
@@ -476,7 +482,12 @@ function SyncAdapter(getHttpAdapter, _ref) {
   syncFactory.run()["catch"](function (err) {
     return logger('got error when sync', err);
   });
-  var syncEventFactory = synchronizeEventFactory(getHttpAdapter, getInterval, getShouldSync, function () {
+
+  var _getShouldSyncEvent = function _getShouldSyncEvent() {
+    return getShouldSync() && enableSyncEvent();
+  };
+
+  var syncEventFactory = synchronizeEventFactory(getHttpAdapter, getInterval, _getShouldSyncEvent, function () {
     return lastEventId;
   }, logger);
   syncEventFactory.on('last-event-id.new', function (id) {

package/lib/lib/util.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.wrapP = exports.tryCatch = void 0;
+exports.sleep = exports.wrapP = exports.tryCatch = void 0;
 
 var tryCatch = function tryCatch(fn, default_, onError, onSuccess) {
   try {
@@ -26,4 +26,13 @@ var wrapP = function wrapP(promise) {
   });
 };
 
-exports.wrapP = wrapP;
+exports.wrapP = wrapP;
+
+var sleep = function sleep() {
+  var time = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1000;
+  return new Promise(function (r) {
+    return setTimeout(r, time);
+  });
+};
+
+exports.sleep = sleep;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qiscus-sdk-core",
-  "version": "2.12.1",
+  "version": "2.12.2",
   "description": "Qiscus Web SDK Core",
   "license": "MIT",
   "main": "lib/index.js",