@audius/sdk 1.0.30 → 1.0.32

package/dist/index.esm.js

@@ -36930,9 +36930,9 @@ var ChatPermission;
 })(ChatPermission || (ChatPermission = {}));
 
 var name = "@audius/sdk";
-var version = "1.0.30";
+var version = "1.0.32";
 var audius = {
-	releaseSHA: "7ce874a45ba7adba69a2f46056ce11392c38509e"
+	releaseSHA: "4a054eaea012fe2486864db78f64558101523e33"
 };
 var description = "";
 var main = "dist/index.cjs.js";
@@ -62642,6 +62642,250 @@ var syncNodes = /*#__PURE__*/function () {
   };
 }();
 
+var THREE_SECONDS = 3000;
+var MAX_TRIES = 3;
+/** Check if the user's primary creator node is healthy */
+
+var checkPrimaryHealthy = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(libs, primary, tries) {
+    var healthy;
+    return regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return Utils.isHealthy(primary);
+
+          case 2:
+            healthy = _context.sent;
+
+            if (!healthy) {
+              _context.next = 7;
+              break;
+            }
+
+            return _context.abrupt("return", healthy);
+
+          case 7:
+            if (!(tries === 0)) {
+              _context.next = 9;
+              break;
+            }
+
+            return _context.abrupt("return", false);
+
+          case 9:
+            _context.next = 11;
+            return Utils.wait(THREE_SECONDS);
+
+          case 11:
+            _context.next = 13;
+            return checkPrimaryHealthy(libs, primary, tries - 1);
+
+          case 13:
+            return _context.abrupt("return", _context.sent);
+
+          case 14:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function checkPrimaryHealthy(_x, _x2, _x3) {
+    return _ref.apply(this, arguments);
+  };
+}();
+/** Gets new endpoints from a user's secondaries */
+
+
+var getNewPrimary = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(libs, secondaries) {
+    var _iterator, _step, _libs$creatorNode, secondary, syncStatus;
+
+    return regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _iterator = _createForOfIteratorHelper(secondaries);
+            _context2.prev = 1;
+
+            _iterator.s();
+
+          case 3:
+            if ((_step = _iterator.n()).done) {
+              _context2.next = 14;
+              break;
+            }
+
+            secondary = _step.value;
+            _context2.next = 7;
+            return (_libs$creatorNode = libs.creatorNode) === null || _libs$creatorNode === void 0 ? void 0 : _libs$creatorNode.getSyncStatus(secondary);
+
+          case 7:
+            syncStatus = _context2.sent;
+
+            if (syncStatus) {
+              _context2.next = 10;
+              break;
+            }
+
+            return _context2.abrupt("continue", 12);
+
+          case 10:
+            if (syncStatus.isBehind) {
+              _context2.next = 12;
+              break;
+            }
+
+            return _context2.abrupt("return", secondary);
+
+          case 12:
+            _context2.next = 3;
+            break;
+
+          case 14:
+            _context2.next = 19;
+            break;
+
+          case 16:
+            _context2.prev = 16;
+            _context2.t0 = _context2["catch"](1);
+
+            _iterator.e(_context2.t0);
+
+          case 19:
+            _context2.prev = 19;
+
+            _iterator.f();
+
+            return _context2.finish(19);
+
+          case 22:
+            throw new Error("Could not find valid secondaries for user ".concat(secondaries));
+
+          case 23:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[1, 16, 19, 22]]);
+  }));
+
+  return function getNewPrimary(_x4, _x5) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+var rolloverNodes = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(libs, creatorNodeWhitelist, creatorNodeBlacklist) {
+    var _libs$userStateManage;
+
+    var user, primary, healthy, secondaries, _libs$ServiceProvider, _libs$User, _libs$User2, _libs$creatorNode2, _libs$User3, newPrimary, index, newSecondaries, autoselect, newEndpoints, newMetadata;
+
+    return regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            console.debug('Sanity Check - rolloverNodes');
+            user = (_libs$userStateManage = libs.userStateManager) === null || _libs$userStateManage === void 0 ? void 0 : _libs$userStateManage.getCurrentUser();
+
+            if (user) {
+              _context3.next = 4;
+              break;
+            }
+
+            return _context3.abrupt("return");
+
+          case 4:
+            primary = CreatorNode.getPrimary(user.creator_node_endpoint);
+
+            if (primary) {
+              _context3.next = 7;
+              break;
+            }
+
+            return _context3.abrupt("return");
+
+          case 7:
+            _context3.next = 9;
+            return checkPrimaryHealthy(libs, primary, MAX_TRIES);
+
+          case 9:
+            healthy = _context3.sent;
+
+            if (!(healthy && !(creatorNodeBlacklist !== null && creatorNodeBlacklist !== void 0 && creatorNodeBlacklist.has(primary)))) {
+              _context3.next = 12;
+              break;
+            }
+
+            return _context3.abrupt("return");
+
+          case 12:
+            secondaries = CreatorNode.getSecondaries(user.creator_node_endpoint);
+            _context3.prev = 13;
+            _context3.next = 16;
+            return getNewPrimary(libs, secondaries);
+
+          case 16:
+            newPrimary = _context3.sent;
+            index = secondaries.indexOf(newPrimary); // Get new secondaries and backfill up to 2
+
+            newSecondaries = _toConsumableArray(secondaries);
+            newSecondaries.splice(index, 1);
+            _context3.next = 22;
+            return (_libs$ServiceProvider = libs.ServiceProvider) === null || _libs$ServiceProvider === void 0 ? void 0 : _libs$ServiceProvider.autoSelectCreatorNodes({
+              numberOfNodes: 2 - newSecondaries.length,
+              whitelist: creatorNodeWhitelist,
+              // Exclude ones we currently have
+              blacklist: new Set([newPrimary].concat(_toConsumableArray(newSecondaries))),
+              preferHigherPatchForPrimary: (_libs$User = libs.User) === null || _libs$User === void 0 ? void 0 : _libs$User.preferHigherPatchForPrimary,
+              preferHigherPatchForSecondaries: (_libs$User2 = libs.User) === null || _libs$User2 === void 0 ? void 0 : _libs$User2.preferHigherPatchForSecondaries
+            });
+
+          case 22:
+            autoselect = _context3.sent;
+
+            if (autoselect) {
+              newSecondaries = newSecondaries.concat([autoselect.primary].concat(_toConsumableArray(autoselect.secondaries)));
+            } // Set the new endpoint and connect to it
+
+
+            newEndpoints = [newPrimary].concat(_toConsumableArray(newSecondaries));
+            _context3.next = 27;
+            return (_libs$creatorNode2 = libs.creatorNode) === null || _libs$creatorNode2 === void 0 ? void 0 : _libs$creatorNode2.setEndpoint(newEndpoints[0]);
+
+          case 27:
+            // Update the user
+            newMetadata = _objectSpread2({}, user);
+            newMetadata.creator_node_endpoint = newEndpoints.join(',');
+            console.debug("Sanity Check - rolloverNodes - new nodes ".concat(newMetadata.creator_node_endpoint));
+            _context3.next = 32;
+            return (_libs$User3 = libs.User) === null || _libs$User3 === void 0 ? void 0 : _libs$User3.updateCreator(user.user_id, newMetadata);
+
+          case 32:
+            _context3.next = 37;
+            break;
+
+          case 34:
+            _context3.prev = 34;
+            _context3.t0 = _context3["catch"](13);
+            console.error(_context3.t0);
+
+          case 37:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3, null, [[13, 34]]);
+  }));
+
+  return function rolloverNodes(_x6, _x7, _x8) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+
 /**
  * Sanity check for whether a user needs a recovery email to be sent.
  * Users with accounts created before email recovery existed need
@@ -62735,9 +62979,14 @@ var assignReplicaSetIfNecessary = /*#__PURE__*/function () {
 
 var SanityChecks = /*#__PURE__*/function () {
   function SanityChecks(libsInstance) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      skipRollover: false
+    };
+
     _classCallCheck(this, SanityChecks);
 
     this.libs = libsInstance;
+    this.options = options;
   }
   /**
    * Runs sanity checks
@@ -62748,26 +62997,40 @@ var SanityChecks = /*#__PURE__*/function () {
     key: "run",
     value: function () {
       var _run = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+        var creatorNodeWhitelist,
+            creatorNodeBlacklist,
+            _args = arguments;
         return regeneratorRuntime.wrap(function _callee$(_context) {
           while (1) {
             switch (_context.prev = _context.next) {
               case 0:
-                _context.next = 2;
-                return addSecondaries(this.libs);
-
-              case 2:
+                creatorNodeWhitelist = _args.length > 0 && _args[0] !== undefined ? _args[0] : null;
+                creatorNodeBlacklist = _args.length > 1 && _args[1] !== undefined ? _args[1] : null;
                 _context.next = 4;
-                return assignReplicaSetIfNecessary(this.libs);
+                return addSecondaries(this.libs);
 
               case 4:
                 _context.next = 6;
-                return syncNodes(this.libs);
+                return assignReplicaSetIfNecessary(this.libs);
 
               case 6:
                 _context.next = 8;
-                return needsRecoveryEmail(this.libs);
+                return syncNodes(this.libs);
 
               case 8:
+                if (this.options.skipRollover) {
+                  _context.next = 11;
+                  break;
+                }
+
+                _context.next = 11;
+                return rolloverNodes(this.libs, creatorNodeWhitelist, creatorNodeBlacklist);
+
+              case 11:
+                _context.next = 13;
+                return needsRecoveryEmail(this.libs);
+
+              case 13:
               case "end":
                 return _context.stop();
             }