@aws-amplify/datastore 3.7.8-unstable.3 → 3.7.8-unstable.5

package/dist/aws-amplify-datastore.js

@@ -61185,21 +61185,68 @@ function () {
 
       var bypassCache = params ? params.bypassCache : false;
       user.getUserData(function (err, data) {
-        if (err) {
-          logger.debug('getting preferred mfa failed', err);
-          rej(err);
-          return;
-        }
+        return __awaiter(_this, void 0, void 0, function () {
+          var cleanUpError_1, mfaType;
+          return __generator(this, function (_a) {
+            switch (_a.label) {
+              case 0:
+                if (!err) return [3
+                /*break*/
+                , 5];
+                logger.debug('getting preferred mfa failed', err);
+                if (!this.isSessionInvalid(err)) return [3
+                /*break*/
+                , 4];
+                _a.label = 1;
 
-        var mfaType = that._getMfaTypeFromUserData(data);
+              case 1:
+                _a.trys.push([1, 3,, 4]);
 
-        if (!mfaType) {
-          rej('invalid MFA Type');
-          return;
-        } else {
-          res(mfaType);
-          return;
-        }
+                return [4
+                /*yield*/
+                , this.cleanUpInvalidSession(user)];
+
+              case 2:
+                _a.sent();
+
+                return [3
+                /*break*/
+                , 4];
+
+              case 3:
+                cleanUpError_1 = _a.sent();
+                rej(new Error("Session is invalid due to: " + err.message + " and failed to clean up invalid session: " + cleanUpError_1.message));
+                return [2
+                /*return*/
+                ];
+
+              case 4:
+                rej(err);
+                return [2
+                /*return*/
+                ];
+
+              case 5:
+                mfaType = that._getMfaTypeFromUserData(data);
+
+                if (!mfaType) {
+                  rej('invalid MFA Type');
+                  return [2
+                  /*return*/
+                  ];
+                } else {
+                  res(mfaType);
+                  return [2
+                  /*return*/
+                  ];
+                }
+
+                return [2
+                /*return*/
+                ];
+            }
+          });
+        });
       }, {
         bypassCache: bypassCache,
         clientMetadata: clientMetadata
@@ -61241,16 +61288,62 @@ function () {
   };
 
   AuthClass.prototype._getUserData = function (user, params) {
+    var _this = this;
+
     return new Promise(function (res, rej) {
       user.getUserData(function (err, data) {
-        if (err) {
-          logger.debug('getting user data failed', err);
-          rej(err);
-          return;
-        } else {
-          res(data);
-          return;
-        }
+        return __awaiter(_this, void 0, void 0, function () {
+          var cleanUpError_2;
+          return __generator(this, function (_a) {
+            switch (_a.label) {
+              case 0:
+                if (!err) return [3
+                /*break*/
+                , 5];
+                logger.debug('getting user data failed', err);
+                if (!this.isSessionInvalid(err)) return [3
+                /*break*/
+                , 4];
+                _a.label = 1;
+
+              case 1:
+                _a.trys.push([1, 3,, 4]);
+
+                return [4
+                /*yield*/
+                , this.cleanUpInvalidSession(user)];
+
+              case 2:
+                _a.sent();
+
+                return [3
+                /*break*/
+                , 4];
+
+              case 3:
+                cleanUpError_2 = _a.sent();
+                rej(new Error("Session is invalid due to: " + err.message + " and failed to clean up invalid session: " + cleanUpError_2.message));
+                return [2
+                /*return*/
+                ];
+
+              case 4:
+                rej(err);
+                return [2
+                /*return*/
+                ];
+
+              case 5:
+                res(data);
+                _a.label = 6;
+
+              case 6:
+                return [2
+                /*return*/
+                ];
+            }
+          });
+        });
       }, params);
     });
   };
@@ -61266,6 +61359,8 @@ function () {
     return __awaiter(this, void 0, void 0, function () {
       var clientMetadata, userData, smsMfaSettings, totpMfaSettings, _a, mfaList, currentMFAType, that;
 
+      var _this = this;
+
       return __generator(this, function (_b) {
         switch (_b.label) {
           case 0:
@@ -61405,12 +61500,53 @@ function () {
                 logger.debug('Caching the latest user data into local'); // cache the latest result into user data
 
                 user.getUserData(function (err, data) {
-                  if (err) {
-                    logger.debug('getting user data failed', err);
-                    return rej(err);
-                  } else {
-                    return res(result);
-                  }
+                  return __awaiter(_this, void 0, void 0, function () {
+                    var cleanUpError_3;
+                    return __generator(this, function (_a) {
+                      switch (_a.label) {
+                        case 0:
+                          if (!err) return [3
+                          /*break*/
+                          , 5];
+                          logger.debug('getting user data failed', err);
+                          if (!this.isSessionInvalid(err)) return [3
+                          /*break*/
+                          , 4];
+                          _a.label = 1;
+
+                        case 1:
+                          _a.trys.push([1, 3,, 4]);
+
+                          return [4
+                          /*yield*/
+                          , this.cleanUpInvalidSession(user)];
+
+                        case 2:
+                          _a.sent();
+
+                          return [3
+                          /*break*/
+                          , 4];
+
+                        case 3:
+                          cleanUpError_3 = _a.sent();
+                          rej(new Error("Session is invalid due to: " + err.message + " and failed to clean up invalid session: " + cleanUpError_3.message));
+                          return [2
+                          /*return*/
+                          ];
+
+                        case 4:
+                          return [2
+                          /*return*/
+                          , rej(err)];
+
+                        case 5:
+                          return [2
+                          /*return*/
+                          , res(result)];
+                      }
+                    });
+                  });
                 }, {
                   bypassCache: true,
                   clientMetadata: clientMetadata
@@ -61747,7 +61883,7 @@ function () {
    * Delete the current authenticated user
    * @return {Promise}
    **/
-  //TODO: Check return type void
+  // TODO: Check return type void
 
 
   AuthClass.prototype.deleteUser = function () {
@@ -61799,44 +61935,80 @@ function () {
                     } else {
                       user_1.getSession(function (err, session) {
                         return __awaiter(_this, void 0, void 0, function () {
+                          var cleanUpError_4;
+
                           var _this = this;
 
                           return __generator(this, function (_a) {
-                            if (err) {
-                              logger.debug('Failed to get the user session', err);
-                              return [2
-                              /*return*/
-                              , rej(err)];
-                            } else {
-                              user_1.deleteUser(function (err, result) {
-                                if (err) {
-                                  rej(err);
-                                } else {
-                                  dispatchAuthEvent('userDeleted', result, 'The authenticated user has been deleted.');
-                                  user_1.signOut();
-                                  _this.user = null;
-
-                                  try {
-                                    _this.cleanCachedItems(); // clean aws credentials
-
-                                  } catch (e) {
-                                    // TODO: change to rejects in refactor
-                                    logger.debug('failed to clear cached items');
-                                  }
+                            switch (_a.label) {
+                              case 0:
+                                if (!err) return [3
+                                /*break*/
+                                , 5];
+                                logger.debug('Failed to get the user session', err);
+                                if (!this.isSessionInvalid(err)) return [3
+                                /*break*/
+                                , 4];
+                                _a.label = 1;
+
+                              case 1:
+                                _a.trys.push([1, 3,, 4]);
+
+                                return [4
+                                /*yield*/
+                                , this.cleanUpInvalidSession(user_1)];
+
+                              case 2:
+                                _a.sent();
 
-                                  if (isSignedInHostedUI) {
-                                    _this.oAuthSignOutRedirect(res, rej);
+                                return [3
+                                /*break*/
+                                , 4];
+
+                              case 3:
+                                cleanUpError_4 = _a.sent();
+                                rej(new Error("Session is invalid due to: " + err.message + " and failed to clean up invalid session: " + cleanUpError_4.message));
+                                return [2
+                                /*return*/
+                                ];
+
+                              case 4:
+                                return [2
+                                /*return*/
+                                , rej(err)];
+
+                              case 5:
+                                user_1.deleteUser(function (err, result) {
+                                  if (err) {
+                                    rej(err);
                                   } else {
-                                    dispatchAuthEvent('signOut', _this.user, "A user has been signed out");
-                                    res(result);
+                                    dispatchAuthEvent('userDeleted', result, 'The authenticated user has been deleted.');
+                                    user_1.signOut();
+                                    _this.user = null;
+
+                                    try {
+                                      _this.cleanCachedItems(); // clean aws credentials
+
+                                    } catch (e) {
+                                      // TODO: change to rejects in refactor
+                                      logger.debug('failed to clear cached items');
+                                    }
+
+                                    if (isSignedInHostedUI) {
+                                      _this.oAuthSignOutRedirect(res, rej);
+                                    } else {
+                                      dispatchAuthEvent('signOut', _this.user, "A user has been signed out");
+                                      res(result);
+                                    }
                                   }
-                                }
-                              });
-                            }
+                                });
+                                _a.label = 6;
 
-                            return [2
-                            /*return*/
-                            ];
+                              case 6:
+                                return [2
+                                /*return*/
+                                ];
+                            }
                           });
                         });
                       });
@@ -61944,6 +62116,93 @@ function () {
       };
     });
   };
+
+  AuthClass.prototype.isErrorWithMessage = function (err) {
+    return _typeof(err) === 'object' && Object.prototype.hasOwnProperty.call(err, 'message');
+  }; // Session revoked by another app
+
+
+  AuthClass.prototype.isTokenRevokedError = function (err) {
+    return this.isErrorWithMessage(err) && err.message === 'Access Token has been revoked';
+  };
+
+  AuthClass.prototype.isRefreshTokenRevokedError = function (err) {
+    return this.isErrorWithMessage(err) && err.message === 'Refresh Token has been revoked';
+  };
+
+  AuthClass.prototype.isUserDisabledError = function (err) {
+    return this.isErrorWithMessage(err) && err.message === 'User is disabled.';
+  };
+
+  AuthClass.prototype.isUserDoesNotExistError = function (err) {
+    return this.isErrorWithMessage(err) && err.message === 'User does not exist.';
+  };
+
+  AuthClass.prototype.isRefreshTokenExpiredError = function (err) {
+    return this.isErrorWithMessage(err) && err.message === 'Refresh Token has expired';
+  };
+
+  AuthClass.prototype.isSignedInHostedUI = function () {
+    return this._oAuthHandler && this._storage.getItem('amplify-signin-with-hostedUI') === 'true';
+  };
+
+  AuthClass.prototype.isSessionInvalid = function (err) {
+    return this.isUserDisabledError(err) || this.isUserDoesNotExistError(err) || this.isTokenRevokedError(err) || this.isRefreshTokenRevokedError(err) || this.isRefreshTokenExpiredError(err);
+  };
+
+  AuthClass.prototype.cleanUpInvalidSession = function (user) {
+    return __awaiter(this, void 0, void 0, function () {
+      var e_6;
+
+      var _this = this;
+
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            user.signOut();
+            this.user = null;
+            _a.label = 1;
+
+          case 1:
+            _a.trys.push([1, 3,, 4]);
+
+            return [4
+            /*yield*/
+            , this.cleanCachedItems()];
+
+          case 2:
+            _a.sent(); // clean aws credentials
+
+
+            return [3
+            /*break*/
+            , 4];
+
+          case 3:
+            e_6 = _a.sent();
+            logger.debug('failed to clear cached items');
+            return [3
+            /*break*/
+            , 4];
+
+          case 4:
+            if (this.isSignedInHostedUI()) {
+              return [2
+              /*return*/
+              , new Promise(function (res, rej) {
+                _this.oAuthSignOutRedirect(res, rej);
+              })];
+            } else {
+              dispatchAuthEvent('signOut', this.user, "A user has been signed out");
+            }
+
+            return [2
+            /*return*/
+            ];
+        }
+      });
+    });
+  };
   /**
    * Get current authenticated user
    * @return - A promise resolves to current authenticated CognitoUser if success
@@ -62014,74 +62273,143 @@ function () {
 
                 user.getSession(function (err, session) {
                   return __awaiter(_this, void 0, void 0, function () {
-                    var bypassCache, clientMetadata, _a, scope;
+                    var cleanUpError_5, bypassCache, clientMetadata, _a, scope;
 
                     var _this = this;
 
                     return __generator(this, function (_b) {
                       switch (_b.label) {
                         case 0:
-                          if (err) {
-                            logger.debug('Failed to get the user session', err);
-                            rej(err);
-                            return [2
-                            /*return*/
-                            ];
-                          }
+                          if (!err) return [3
+                          /*break*/
+                          , 5];
+                          logger.debug('Failed to get the user session', err);
+                          if (!this.isSessionInvalid(err)) return [3
+                          /*break*/
+                          , 4];
+                          _b.label = 1;
+
+                        case 1:
+                          _b.trys.push([1, 3,, 4]);
+
+                          return [4
+                          /*yield*/
+                          , this.cleanUpInvalidSession(user)];
+
+                        case 2:
+                          _b.sent();
+
+                          return [3
+                          /*break*/
+                          , 4];
+
+                        case 3:
+                          cleanUpError_5 = _b.sent();
+                          rej(new Error("Session is invalid due to: " + err.message + " and failed to clean up invalid session: " + cleanUpError_5.message));
+                          return [2
+                          /*return*/
+                          ];
+
+                        case 4:
+                          rej(err);
+                          return [2
+                          /*return*/
+                          ];
 
+                        case 5:
                           bypassCache = params ? params.bypassCache : false;
                           if (!bypassCache) return [3
                           /*break*/
-                          , 2];
+                          , 7];
                           return [4
                           /*yield*/
                           , this.Credentials.clear()];
 
-                        case 1:
+                        case 6:
                           _b.sent();
 
-                          _b.label = 2;
+                          _b.label = 7;
 
-                        case 2:
+                        case 7:
                           clientMetadata = this._config.clientMetadata;
                           _a = session.getAccessToken().decodePayload().scope, scope = _a === void 0 ? '' : _a;
 
                           if (scope.split(' ').includes(USER_ADMIN_SCOPE)) {
                             user.getUserData(function (err, data) {
-                              if (err) {
-                                logger.debug('getting user data failed', err); // Make sure the user is still valid
-
-                                if (err.message === 'User is disabled.' || err.message === 'User does not exist.' || err.message === 'Access Token has been revoked' // Session revoked by another app
-                                ) {
-                                  rej(err);
-                                } else {
-                                  // the error may also be thrown when lack of permissions to get user info etc
-                                  // in that case we just bypass the error
-                                  res(user);
-                                }
+                              return __awaiter(_this, void 0, void 0, function () {
+                                var cleanUpError_6, preferredMFA, attributeList, i, attribute, userAttribute, attributes;
+                                return __generator(this, function (_a) {
+                                  switch (_a.label) {
+                                    case 0:
+                                      if (!err) return [3
+                                      /*break*/
+                                      , 7];
+                                      logger.debug('getting user data failed', err);
+                                      if (!this.isSessionInvalid(err)) return [3
+                                      /*break*/
+                                      , 5];
+                                      _a.label = 1;
 
-                                return;
-                              }
+                                    case 1:
+                                      _a.trys.push([1, 3,, 4]);
 
-                              var preferredMFA = data.PreferredMfaSetting || 'NOMFA';
-                              var attributeList = [];
+                                      return [4
+                                      /*yield*/
+                                      , this.cleanUpInvalidSession(user)];
 
-                              for (var i = 0; i < data.UserAttributes.length; i++) {
-                                var attribute = {
-                                  Name: data.UserAttributes[i].Name,
-                                  Value: data.UserAttributes[i].Value
-                                };
-                                var userAttribute = new amazon_cognito_identity_js__WEBPACK_IMPORTED_MODULE_2__["CognitoUserAttribute"](attribute);
-                                attributeList.push(userAttribute);
-                              }
+                                    case 2:
+                                      _a.sent();
 
-                              var attributes = _this.attributesToObject(attributeList);
+                                      return [3
+                                      /*break*/
+                                      , 4];
+
+                                    case 3:
+                                      cleanUpError_6 = _a.sent();
+                                      rej(new Error("Session is invalid due to: " + err.message + " and failed to clean up invalid session: " + cleanUpError_6.message));
+                                      return [2
+                                      /*return*/
+                                      ];
+
+                                    case 4:
+                                      rej(err);
+                                      return [3
+                                      /*break*/
+                                      , 6];
+
+                                    case 5:
+                                      res(user);
+                                      _a.label = 6;
+
+                                    case 6:
+                                      return [2
+                                      /*return*/
+                                      ];
+
+                                    case 7:
+                                      preferredMFA = data.PreferredMfaSetting || 'NOMFA';
+                                      attributeList = [];
+
+                                      for (i = 0; i < data.UserAttributes.length; i++) {
+                                        attribute = {
+                                          Name: data.UserAttributes[i].Name,
+                                          Value: data.UserAttributes[i].Value
+                                        };
+                                        userAttribute = new amazon_cognito_identity_js__WEBPACK_IMPORTED_MODULE_2__["CognitoUserAttribute"](attribute);
+                                        attributeList.push(userAttribute);
+                                      }
 
-                              Object.assign(user, {
-                                attributes: attributes,
-                                preferredMFA: preferredMFA
+                                      attributes = this.attributesToObject(attributeList);
+                                      Object.assign(user, {
+                                        attributes: attributes,
+                                        preferredMFA: preferredMFA
+                                      });
+                                      return [2
+                                      /*return*/
+                                      , res(user)];
+                                  }
+                                });
                               });
-                              return res(user);
                             }, {
                               bypassCache: bypassCache,
                               clientMetadata: clientMetadata
@@ -62127,7 +62455,7 @@ function () {
 
   AuthClass.prototype.currentAuthenticatedUser = function (params) {
     return __awaiter(this, void 0, void 0, function () {
-      var federatedUser, e_6, federatedInfo, user, e_7;
+      var federatedUser, e_7, federatedInfo, user, e_8;
       return __generator(this, function (_a) {
         switch (_a.label) {
           case 0:
@@ -62150,9 +62478,9 @@ function () {
             , 4];
 
           case 3:
-            e_6 = _a.sent();
-            logger.debug('Failed to sync cache info into memory', e_6);
-            throw e_6;
+            e_7 = _a.sent();
+            logger.debug('Failed to sync cache info into memory', e_7);
+            throw e_7;
 
           case 4:
             try {
@@ -62195,13 +62523,13 @@ function () {
             , 9];
 
           case 8:
-            e_7 = _a.sent();
+            e_8 = _a.sent();
 
-            if (e_7 === 'No userPool') {
+            if (e_8 === 'No userPool') {
               logger.error('Cannot get the current user because the user pool is missing. ' + 'Please make sure the Auth module is configured with a valid Cognito User Pool ID');
             }
 
-            logger.debug('The user is not authenticated by the error', e_7);
+            logger.debug('The user is not authenticated by the error', e_8);
             return [2
             /*return*/
             , Promise.reject('The user is not authenticated')];
@@ -62226,7 +62554,7 @@ function () {
     logger.debug('Getting current session'); // Purposely not calling the reject method here because we don't need a console error
 
     if (!this.userPool) {
-      return Promise.reject();
+      return this.rejectNoUserPool();
     }
 
     return new Promise(function (res, rej) {
@@ -62254,6 +62582,8 @@ function () {
 
 
   AuthClass.prototype.userSession = function (user) {
+    var _this = this;
+
     if (!user) {
       logger.debug('the user is null');
       return this.rejectAuthError(_types_Auth__WEBPACK_IMPORTED_MODULE_7__["AuthErrorTypes"].NoUserSession);
@@ -62261,18 +62591,59 @@ function () {
 
     var clientMetadata = this._config.clientMetadata; // TODO: verify behavior if this is override during signIn
 
-    return new Promise(function (resolve, reject) {
+    return new Promise(function (res, rej) {
       logger.debug('Getting the session from this user:', user);
       user.getSession(function (err, session) {
-        if (err) {
-          logger.debug('Failed to get the session from user', user);
-          reject(err);
-          return;
-        } else {
-          logger.debug('Succeed to get the user session', session);
-          resolve(session);
-          return;
-        }
+        return __awaiter(_this, void 0, void 0, function () {
+          var cleanUpError_7;
+          return __generator(this, function (_a) {
+            switch (_a.label) {
+              case 0:
+                if (!err) return [3
+                /*break*/
+                , 5];
+                logger.debug('Failed to get the session from user', user);
+                if (!this.isSessionInvalid(err)) return [3
+                /*break*/
+                , 4];
+                _a.label = 1;
+
+              case 1:
+                _a.trys.push([1, 3,, 4]);
+
+                return [4
+                /*yield*/
+                , this.cleanUpInvalidSession(user)];
+
+              case 2:
+                _a.sent();
+
+                return [3
+                /*break*/
+                , 4];
+
+              case 3:
+                cleanUpError_7 = _a.sent();
+                rej(new Error("Session is invalid due to: " + err.message + " and failed to clean up invalid session: " + cleanUpError_7.message));
+                return [2
+                /*return*/
+                ];
+
+              case 4:
+                rej(err);
+                return [2
+                /*return*/
+                ];
+
+              case 5:
+                logger.debug('Succeed to get the user session', session);
+                res(session);
+                return [2
+                /*return*/
+                ];
+            }
+          });
+        });
       }, {
         clientMetadata: clientMetadata
       });
@@ -62286,7 +62657,7 @@ function () {
 
   AuthClass.prototype.currentUserCredentials = function () {
     return __awaiter(this, void 0, void 0, function () {
-      var e_8, federatedInfo;
+      var e_9, federatedInfo;
 
       var _this = this;
 
@@ -62311,9 +62682,9 @@ function () {
             , 4];
 
           case 3:
-            e_8 = _a.sent();
-            logger.debug('Failed to sync cache info into memory', e_8);
-            throw e_8;
+            e_9 = _a.sent();
+            logger.debug('Failed to sync cache info into memory', e_9);
+            throw e_9;
 
           case 4:
             federatedInfo = null;
@@ -62335,8 +62706,8 @@ function () {
               , this.currentSession().then(function (session) {
                 logger.debug('getting session success', session);
                 return _this.Credentials.set(session, 'session');
-              })["catch"](function (error) {
-                logger.debug('getting session failed', error);
+              })["catch"](function () {
+                logger.debug('getting guest credentials');
                 return _this.Credentials.set(null, 'guest');
               })];
             }
@@ -62428,7 +62799,7 @@ function () {
 
   AuthClass.prototype.cognitoIdentitySignOut = function (opts, user) {
     return __awaiter(this, void 0, void 0, function () {
-      var e_9, isSignedInHostedUI;
+      var e_10, isSignedInHostedUI;
 
       var _this = this;
 
@@ -62449,9 +62820,9 @@ function () {
             , 3];
 
           case 2:
-            e_9 = _a.sent();
-            logger.debug('Failed to sync cache info into memory', e_9);
-            throw e_9;
+            e_10 = _a.sent();
+            logger.debug('Failed to sync cache info into memory', e_10);
+            throw e_10;
 
           case 3:
             isSignedInHostedUI = this._oAuthHandler && this._storage.getItem('amplify-signin-with-hostedUI') === 'true';
@@ -62465,25 +62836,70 @@ function () {
                 var clientMetadata = _this._config.clientMetadata; // TODO: verify behavior if this is override during signIn
 
                 user.getSession(function (err, result) {
-                  if (err) {
-                    logger.debug('failed to get the user session', err);
-                    return rej(err);
-                  }
+                  return __awaiter(_this, void 0, void 0, function () {
+                    var cleanUpError_8;
 
-                  user.globalSignOut({
-                    onSuccess: function onSuccess(data) {
-                      logger.debug('global sign out success');
+                    var _this = this;
 
-                      if (isSignedInHostedUI) {
-                        _this.oAuthSignOutRedirect(res, rej);
-                      } else {
-                        return res();
+                    return __generator(this, function (_a) {
+                      switch (_a.label) {
+                        case 0:
+                          if (!err) return [3
+                          /*break*/
+                          , 5];
+                          logger.debug('failed to get the user session', err);
+                          if (!this.isSessionInvalid(err)) return [3
+                          /*break*/
+                          , 4];
+                          _a.label = 1;
+
+                        case 1:
+                          _a.trys.push([1, 3,, 4]);
+
+                          return [4
+                          /*yield*/
+                          , this.cleanUpInvalidSession(user)];
+
+                        case 2:
+                          _a.sent();
+
+                          return [3
+                          /*break*/
+                          , 4];
+
+                        case 3:
+                          cleanUpError_8 = _a.sent();
+                          rej(new Error("Session is invalid due to: " + err.message + " and failed to clean up invalid session: " + cleanUpError_8.message));
+                          return [2
+                          /*return*/
+                          ];
+
+                        case 4:
+                          return [2
+                          /*return*/
+                          , rej(err)];
+
+                        case 5:
+                          user.globalSignOut({
+                            onSuccess: function onSuccess(data) {
+                              logger.debug('global sign out success');
+
+                              if (isSignedInHostedUI) {
+                                _this.oAuthSignOutRedirect(res, rej);
+                              } else {
+                                return res();
+                              }
+                            },
+                            onFailure: function onFailure(err) {
+                              logger.debug('global sign out failed', err);
+                              return rej(err);
+                            }
+                          });
+                          return [2
+                          /*return*/
+                          ];
                       }
-                    },
-                    onFailure: function onFailure(err) {
-                      logger.debug('global sign out failed', err);
-                      return rej(err);
-                    }
+                    });
                   });
                 }, {
                   clientMetadata: clientMetadata
@@ -62526,7 +62942,7 @@ function () {
 
 
     setTimeout(function () {
-      return reject('Signout timeout fail');
+      return reject(Error('Signout timeout fail'));
     }, 3000);
   };
   /**
@@ -62538,7 +62954,7 @@ function () {
 
   AuthClass.prototype.signOut = function (opts) {
     return __awaiter(this, void 0, void 0, function () {
-      var e_10, user;
+      var e_11, user;
       return __generator(this, function (_a) {
         switch (_a.label) {
           case 0:
@@ -62556,7 +62972,7 @@ function () {
             , 3];
 
           case 2:
-            e_10 = _a.sent();
+            e_11 = _a.sent();
             logger.debug('failed to clear cached items');
             return [3
             /*break*/
@@ -62591,7 +63007,7 @@ function () {
             , 8];
 
           case 7:
-            logger.debug('no Congito User pool');
+            logger.debug('no Cognito User pool');
             _a.label = 8;
 
           case 8:
@@ -62757,7 +63173,7 @@ function () {
 
   AuthClass.prototype.currentUserInfo = function () {
     return __awaiter(this, void 0, void 0, function () {
-      var source, user, attributes, userAttrs, credentials, e_11, info, err_1, user;
+      var source, user, attributes, userAttrs, credentials, e_12, info, err_1, user;
       return __generator(this, function (_a) {
         switch (_a.label) {
           case 0:
@@ -62809,8 +63225,8 @@ function () {
             , 7];
 
           case 6:
-            e_11 = _a.sent();
-            logger.debug('Failed to retrieve credentials while getting current user info', e_11);
+            e_12 = _a.sent();
+            logger.debug('Failed to retrieve credentials while getting current user info', e_12);
             return [3
             /*break*/
             , 7];