oro-sdk-apis 5.16.0 → 6.0.0

package/dist/oro-sdk-apis.esm.js

@@ -644,6 +644,9 @@ var ApisPracticeManager = /*#__PURE__*/function () {
     this.getAuthTokenCbk = getAuthTokenCbk;
     this.useLocalStorage = useLocalStorage;
     this.practiceInstances = new Map();
+    // The refreshInstance will be a single instance that is used to refresh the tokens of others this way it will not interfere with requests made by other services 
+    var newPracticeInstance = init(this.serviceCollReq, undefined, this.useLocalStorage);
+    this.practiceInstances.set('refreshInstance', newPracticeInstance);
   }
   /**
    * This function is used to get a `ServiceCollection` associated to a practice. If missing, it will initialize a new `ServiceCollection`.
@@ -654,64 +657,76 @@ var ApisPracticeManager = /*#__PURE__*/function () {
   _proto.get =
   /*#__PURE__*/
   function () {
-    var _get = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(practiceUuid) {
+    var _get = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(practiceUuid) {
       var _this = this;
-      var cacheKey, practiceInstance, newPracticeInstance, authTokenFunc;
-      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-        while (1) switch (_context2.prev = _context2.next) {
+      var cacheKey, practiceInstance, newPracticeInstance;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
           case 0:
             cacheKey = practiceUuid != null ? practiceUuid : 'none';
             practiceInstance = this.practiceInstances.get(cacheKey);
             if (!practiceInstance) {
-              _context2.next = 4;
+              _context.next = 4;
               break;
             }
-            return _context2.abrupt("return", practiceInstance);
+            return _context.abrupt("return", practiceInstance);
           case 4:
-            newPracticeInstance = init(this.serviceCollReq, undefined, this.useLocalStorage); // Create one auth token callback per practice since the practice uuid needs to change
-            authTokenFunc = /*#__PURE__*/function () {
-              var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
-                return _regeneratorRuntime().wrap(function _callee$(_context) {
-                  while (1) switch (_context.prev = _context.next) {
-                    case 0:
-                      if (!newPracticeInstance.guardService) {
-                        _context.next = 7;
-                        break;
-                      }
-                      console.log("\x1B[36m[Auth] Refresh auth called (practiceUuid: " + practiceUuid + ")\x1B[36m");
-                      _context.next = 4;
-                      return _this.getAuthTokenCbk(newPracticeInstance.guardService, practiceUuid);
-                    case 4:
-                      return _context.abrupt("return", _context.sent);
-                    case 7:
-                      throw Error('[Auth] Unable to refresh token guard service is undefined');
-                    case 8:
-                    case "end":
-                      return _context.stop();
-                  }
-                }, _callee);
-              }));
-              return function authTokenFunc() {
-                return _ref.apply(this, arguments);
-              };
-            }(); // Initialize the M2M token
-            _context2.next = 8;
-            return authTokenFunc();
-          case 8:
-            // Set the refresh tokens callback
-            newPracticeInstance.apiService.setAuthRefreshFn(authTokenFunc);
+            newPracticeInstance = init(this.serviceCollReq, undefined, this.useLocalStorage);
+            newPracticeInstance.apiService.setAuthRefreshFn(function () {
+              return _this.authTokenFunc(practiceUuid);
+            });
             this.practiceInstances.set(cacheKey, newPracticeInstance);
-            return _context2.abrupt("return", newPracticeInstance);
-          case 11:
+            return _context.abrupt("return", newPracticeInstance);
+          case 8:
           case "end":
-            return _context2.stop();
+            return _context.stop();
         }
-      }, _callee2, this);
+      }, _callee, this);
     }));
     function get(_x) {
       return _get.apply(this, arguments);
     }
     return get;
+  }()
+  /**
+   * Uses the refresh intance to fetch a new auth token for the given practice
+   * @param practiceUuid the uuid of the practice or key of a specific instance
+   * @returns a new authentication token
+   */
+  ;
+  _proto.authTokenFunc =
+  /*#__PURE__*/
+  function () {
+    var _authTokenFunc = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(practiceUuidOrInstanceName) {
+      var newPracticeInstance;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 2;
+            return this.get('refreshInstance');
+          case 2:
+            newPracticeInstance = _context2.sent;
+            if (!newPracticeInstance.guardService) {
+              _context2.next = 10;
+              break;
+            }
+            console.log("\x1B[36m[Auth] Refresh auth called (practiceUuid: " + practiceUuidOrInstanceName + ")\x1B[36m");
+            _context2.next = 7;
+            return this.getAuthTokenCbk(newPracticeInstance.guardService, practiceUuidOrInstanceName);
+          case 7:
+            return _context2.abrupt("return", _context2.sent);
+          case 10:
+            throw Error('[Auth] Unable to refresh token guard service is undefined');
+          case 11:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, this);
+    }));
+    function authTokenFunc(_x2) {
+      return _authTokenFunc.apply(this, arguments);
+    }
+    return authTokenFunc;
   }();
   return ApisPracticeManager;
 }();