@eluvio/elv-client-js 4.0.143 → 4.0.144

package/dist/src/client/Contracts.js

@@ -1,7 +1,11 @@
+var _slicedToArray = require("@babel/runtime/helpers/slicedToArray");
 var _defineProperty = require("@babel/runtime/helpers/defineProperty");
 var _typeof = require("@babel/runtime/helpers/typeof");
 var _regeneratorRuntime = require("@babel/runtime/regenerator");
 var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 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) { _defineProperty(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; }
 /**
@@ -1517,4 +1521,429 @@ exports.ResetTenantId = /*#__PURE__*/function () {
   return function (_x21) {
     return _ref48.apply(this, arguments);
   };
+}();
+
+/**
+ * Enum for object types that can be cleaned up after object deletion.
+ * Used by the ObjectCleanup method to determine which associated objects to clean.
+ *
+ * @property {string=} LIBRARY - Cleanup libraries
+ * @property {string=} CONTENT_OBJECT - Cleanup content objects
+ * @property {string=} GROUP - Cleanup access groups
+ * @property {string=} CONTENT_TYPE - Cleanup content types
+ * @property {string=} ALL - Cleanup all of the above
+ */
+var ObjectTypesToClean = Object.freeze({
+  LIBRARY: "library",
+  CONTENT_OBJECT: "content_object",
+  GROUP: "group",
+  CONTENT_TYPE: "content_type",
+  ALL: "all"
+});
+
+/**
+ * Cleans up deleted objects pointed to by the access index of a given "access group" or "user wallet"
+ * Contracts of type "access group" and "user wallet" contain an "access index" - a list of objects that they have access to.
+ *
+ * There are 4 specific indexes, one for each object type:
+ * - content
+ * - library
+ * - access groups
+ * - content types
+ *
+ * If an object gets deleted and the access index still points to it, it will cause errors in API calls for the access
+ * group or user wallet.
+ *
+ * This function checks each index for objects that are deleted, and removes them from the index (either all indexes or
+ * just the one specified by parameter 'objectTypeToClean')
+ *
+ * For user, the cleanup is performed on the user wallet and on all its access group
+ *
+ * @methodGroup Contracts
+ * @namedParams
+ * @param {string=} contractAddress - The address of the object
+ * @param {string=} objectId - The ID of the object
+ * @param {string=} versionHash - A version hash of the object
+ * @param {string=} objectTypeToClean - The type of object to clean: one of "library", "content_object", "group", "content_type", or "all"
+ * @returns {Promise<Object>} - Resolves with an object showing the count of items before and after cleanup.
+ *
+ * Example return value:
+ * {
+ *   "0x123...": {
+ *     beforeCleanup: {
+ *       librariesLength: 2,
+ *       contentObjectsLength: 4,
+ *       accessGroupsLength: 1,
+ *       contentTypesLength: 3
+ *     },
+ *     afterCleanup: {
+ *       librariesLength: 0,
+ *       contentObjectsLength: 0,
+ *       accessGroupsLength: 0,
+ *       contentTypesLength: 0
+ *     }
+ *   },
+ *   "groups": {
+ *     "0x123...": {
+ *       beforeCleanup: {
+ *        contentObjectsLength: 1
+ *       },
+ *       afterCleanup: {
+ *        contentObjectsLength: 0
+ *       }
+ *     }
+ *   }
+ * }
+ */
+exports.ObjectCleanup = /*#__PURE__*/function () {
+  var _ref50 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee29(_ref49) {
+    var _this = this,
+      _cleanupTasks;
+    var contractAddress, objectId, versionHash, _ref49$objectTypeToCl, objectTypeToClean, isUserWallet, userAddress, allowedTypes, cleanupTasks, runCleanupTasks, results, res, groupsLength, groupAddressPromises, i, groupAddresses, cleanupResults, _iterator, _step, _step$value, addr, _res2;
+    return _regeneratorRuntime.wrap(function _callee29$(_context29) {
+      while (1) switch (_context29.prev = _context29.next) {
+        case 0:
+          contractAddress = _ref49.contractAddress, objectId = _ref49.objectId, versionHash = _ref49.versionHash, _ref49$objectTypeToCl = _ref49.objectTypeToClean, objectTypeToClean = _ref49$objectTypeToCl === void 0 ? ObjectTypesToClean.ALL : _ref49$objectTypeToCl;
+          _context29.next = 3;
+          return GetObjectIDAndContractAddress({
+            contractAddress: contractAddress,
+            objectId: objectId,
+            versionHash: versionHash
+          });
+        case 3:
+          objectInfo = _context29.sent;
+          contractAddress = objectInfo.contractAddress;
+          isUserWallet = false;
+          _context29.prev = 6;
+          _context29.next = 9;
+          return this.CallContractMethod({
+            contractAddress: contractAddress,
+            methodName: "getLibrariesLength",
+            formatArguments: false
+          });
+        case 9:
+          _context29.next = 24;
+          break;
+        case 11:
+          _context29.prev = 11;
+          _context29.t0 = _context29["catch"](6);
+          _context29.prev = 13;
+          userAddress = contractAddress;
+          _context29.next = 17;
+          return this.userProfileClient.UserWalletAddress({
+            address: contractAddress
+          });
+        case 17:
+          contractAddress = _context29.sent;
+          isUserWallet = true;
+          _context29.next = 24;
+          break;
+        case 21:
+          _context29.prev = 21;
+          _context29.t1 = _context29["catch"](13);
+          throw new Error("Invalid object: ".concat(_context29.t1.message));
+        case 24:
+          allowedTypes = Object.values(ObjectTypesToClean);
+          if (allowedTypes.includes(objectTypeToClean)) {
+            _context29.next = 27;
+            break;
+          }
+          throw Error("Invalid objectType '".concat(objectTypeToClean, "'. Allowed types: ").concat(allowedTypes.join(", ")));
+        case 27:
+          cleanupTasks = (_cleanupTasks = {}, _defineProperty(_cleanupTasks, ObjectTypesToClean.LIBRARY, function () {
+            var _ref52 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee24(_ref51) {
+              var contractAddress, res, before, after;
+              return _regeneratorRuntime.wrap(function _callee24$(_context24) {
+                while (1) switch (_context24.prev = _context24.next) {
+                  case 0:
+                    contractAddress = _ref51.contractAddress, res = _ref51.res;
+                    _context24.next = 3;
+                    return _this.CallContractMethod({
+                      contractAddress: contractAddress,
+                      methodName: "getLibrariesLength",
+                      formatArguments: false
+                    });
+                  case 3:
+                    before = _context24.sent;
+                    res.beforeCleanup.librariesLength = before.toNumber();
+                    _context24.next = 7;
+                    return _this.CallContractMethodAndWait({
+                      contractAddress: contractAddress,
+                      methodName: "cleanUpLibraries",
+                      formatArguments: true
+                    });
+                  case 7:
+                    _context24.next = 9;
+                    return _this.CallContractMethod({
+                      contractAddress: contractAddress,
+                      methodName: "getLibrariesLength",
+                      formatArguments: false
+                    });
+                  case 9:
+                    after = _context24.sent;
+                    res.afterCleanup.librariesLength = after.toNumber();
+                  case 11:
+                  case "end":
+                    return _context24.stop();
+                }
+              }, _callee24);
+            }));
+            return function (_x23) {
+              return _ref52.apply(this, arguments);
+            };
+          }()), _defineProperty(_cleanupTasks, ObjectTypesToClean.CONTENT_OBJECT, function () {
+            var _ref54 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee25(_ref53) {
+              var contractAddress, res, before, after;
+              return _regeneratorRuntime.wrap(function _callee25$(_context25) {
+                while (1) switch (_context25.prev = _context25.next) {
+                  case 0:
+                    contractAddress = _ref53.contractAddress, res = _ref53.res;
+                    _context25.next = 3;
+                    return _this.CallContractMethod({
+                      contractAddress: contractAddress,
+                      methodName: "getContentObjectsLength",
+                      formatArguments: false
+                    });
+                  case 3:
+                    before = _context25.sent;
+                    res.beforeCleanup.contentObjectsLength = before.toNumber();
+                    _context25.next = 7;
+                    return _this.CallContractMethodAndWait({
+                      contractAddress: contractAddress,
+                      methodName: "cleanUpContentObjects",
+                      formatArguments: true
+                    });
+                  case 7:
+                    _context25.next = 9;
+                    return _this.CallContractMethod({
+                      contractAddress: contractAddress,
+                      methodName: "getContentObjectsLength",
+                      formatArguments: false
+                    });
+                  case 9:
+                    after = _context25.sent;
+                    res.afterCleanup.contentObjectsLength = after.toNumber();
+                  case 11:
+                  case "end":
+                    return _context25.stop();
+                }
+              }, _callee25);
+            }));
+            return function (_x24) {
+              return _ref54.apply(this, arguments);
+            };
+          }()), _defineProperty(_cleanupTasks, ObjectTypesToClean.GROUP, function () {
+            var _ref56 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee26(_ref55) {
+              var contractAddress, res, before, after;
+              return _regeneratorRuntime.wrap(function _callee26$(_context26) {
+                while (1) switch (_context26.prev = _context26.next) {
+                  case 0:
+                    contractAddress = _ref55.contractAddress, res = _ref55.res;
+                    _context26.next = 3;
+                    return _this.CallContractMethod({
+                      contractAddress: contractAddress,
+                      methodName: "getAccessGroupsLength",
+                      formatArguments: false
+                    });
+                  case 3:
+                    before = _context26.sent;
+                    res.beforeCleanup.accessGroupsLength = before.toNumber();
+                    _context26.next = 7;
+                    return _this.CallContractMethodAndWait({
+                      contractAddress: contractAddress,
+                      methodName: "cleanUpAccessGroups",
+                      formatArguments: true
+                    });
+                  case 7:
+                    _context26.next = 9;
+                    return _this.CallContractMethod({
+                      contractAddress: contractAddress,
+                      methodName: "getAccessGroupsLength",
+                      formatArguments: false
+                    });
+                  case 9:
+                    after = _context26.sent;
+                    res.afterCleanup.accessGroupsLength = after.toNumber();
+                  case 11:
+                  case "end":
+                    return _context26.stop();
+                }
+              }, _callee26);
+            }));
+            return function (_x25) {
+              return _ref56.apply(this, arguments);
+            };
+          }()), _defineProperty(_cleanupTasks, ObjectTypesToClean.CONTENT_TYPE, function () {
+            var _ref58 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee27(_ref57) {
+              var contractAddress, res, before, after;
+              return _regeneratorRuntime.wrap(function _callee27$(_context27) {
+                while (1) switch (_context27.prev = _context27.next) {
+                  case 0:
+                    contractAddress = _ref57.contractAddress, res = _ref57.res;
+                    _context27.next = 3;
+                    return _this.CallContractMethod({
+                      contractAddress: contractAddress,
+                      methodName: "getContentTypesLength",
+                      formatArguments: false
+                    });
+                  case 3:
+                    before = _context27.sent;
+                    res.beforeCleanup.contentTypesLength = before.toNumber();
+                    _context27.next = 7;
+                    return _this.CallContractMethodAndWait({
+                      contractAddress: contractAddress,
+                      methodName: "cleanUpContentTypes",
+                      formatArguments: true
+                    });
+                  case 7:
+                    _context27.next = 9;
+                    return _this.CallContractMethod({
+                      contractAddress: contractAddress,
+                      methodName: "getContentTypesLength",
+                      formatArguments: false
+                    });
+                  case 9:
+                    after = _context27.sent;
+                    res.afterCleanup.contentTypesLength = after.toNumber();
+                  case 11:
+                  case "end":
+                    return _context27.stop();
+                }
+              }, _callee27);
+            }));
+            return function (_x26) {
+              return _ref58.apply(this, arguments);
+            };
+          }()), _cleanupTasks);
+          runCleanupTasks = /*#__PURE__*/function () {
+            var _ref60 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee28(_ref59) {
+              var contractAddress, _res, _i, _Object$keys, type;
+              return _regeneratorRuntime.wrap(function _callee28$(_context28) {
+                while (1) switch (_context28.prev = _context28.next) {
+                  case 0:
+                    contractAddress = _ref59.contractAddress;
+                    _context28.prev = 1;
+                    _res = {
+                      beforeCleanup: {},
+                      afterCleanup: {}
+                    };
+                    if (!(objectTypeToClean === ObjectTypesToClean.ALL)) {
+                      _context28.next = 14;
+                      break;
+                    }
+                    _i = 0, _Object$keys = Object.keys(cleanupTasks);
+                  case 5:
+                    if (!(_i < _Object$keys.length)) {
+                      _context28.next = 12;
+                      break;
+                    }
+                    type = _Object$keys[_i];
+                    _context28.next = 9;
+                    return cleanupTasks[type]({
+                      contractAddress: contractAddress,
+                      res: _res
+                    });
+                  case 9:
+                    _i++;
+                    _context28.next = 5;
+                    break;
+                  case 12:
+                    _context28.next = 16;
+                    break;
+                  case 14:
+                    _context28.next = 16;
+                    return cleanupTasks[objectTypeToClean]({
+                      contractAddress: contractAddress,
+                      res: _res
+                    });
+                  case 16:
+                    return _context28.abrupt("return", _res);
+                  case 19:
+                    _context28.prev = 19;
+                    _context28.t0 = _context28["catch"](1);
+                    throw new Error("Error during '".concat(objectTypeToClean, "' cleanup for ").concat(contractAddress, ": ").concat(_context28.t0.message));
+                  case 22:
+                  case "end":
+                    return _context28.stop();
+                }
+              }, _callee28, null, [[1, 19]]);
+            }));
+            return function runCleanupTasks(_x27) {
+              return _ref60.apply(this, arguments);
+            };
+          }();
+          results = {}; // run cleanup on main contract
+          _context29.next = 32;
+          return runCleanupTasks({
+            contractAddress: contractAddress
+          });
+        case 32:
+          res = _context29.sent;
+          if (isUserWallet) {
+            results[userAddress] = res;
+          } else {
+            results[contractAddress] = res;
+          }
+
+          // run cleanup on access group contracts if this is a user wallet
+          if (!isUserWallet) {
+            _context29.next = 49;
+            break;
+          }
+          _context29.next = 37;
+          return this.CallContractMethod({
+            contractAddress: contractAddress,
+            methodName: "getAccessGroupsLength",
+            formatArguments: false
+          });
+        case 37:
+          groupsLength = _context29.sent;
+          if (groupsLength > 0) {
+            results["groups"] = {};
+          }
+          groupAddressPromises = [];
+          for (i = 0; i < groupsLength; i++) {
+            groupAddressPromises.push(this.CallContractMethod({
+              contractAddress: contractAddress,
+              methodName: "getAccessGroup",
+              methodArgs: [i],
+              formatArguments: false
+            }));
+          }
+          _context29.next = 43;
+          return Promise.all(groupAddressPromises);
+        case 43:
+          groupAddresses = _context29.sent;
+          _context29.next = 46;
+          return Promise.all(groupAddresses.map(function (addr) {
+            return runCleanupTasks({
+              contractAddress: addr
+            }).then(function (res) {
+              return [addr, res];
+            });
+          }));
+        case 46:
+          cleanupResults = _context29.sent;
+          _iterator = _createForOfIteratorHelper(cleanupResults);
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              _step$value = _slicedToArray(_step.value, 2), addr = _step$value[0], _res2 = _step$value[1];
+              results["groups"][addr] = _res2;
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+        case 49:
+          return _context29.abrupt("return", results);
+        case 50:
+        case "end":
+          return _context29.stop();
+      }
+    }, _callee29, this, [[6, 11], [13, 21]]);
+  }));
+  return function (_x22) {
+    return _ref50.apply(this, arguments);
+  };
 }();

package/dist/src/client/LiveConf.js

@@ -1,3 +1,4 @@
+var _slicedToArray = require("@babel/runtime/helpers/slicedToArray");
 var _defineProperty = require("@babel/runtime/helpers/defineProperty");
 var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");
 var _createClass = require("@babel/runtime/helpers/createClass");
@@ -133,14 +134,17 @@ var LiveConf = /*#__PURE__*/function () {
     key: "getAudioStreamsFromProbe",
     value: function getAudioStreamsFromProbe() {
       var audioStreams = {};
-      for (var index = 0; index < this.probeData.streams.length; index++) {
-        if (this.probeData.streams[index].codec_type == "audio") {
-          audioStreams[index] = {
-            recordingBitrate: Math.max(this.probeData.streams[index].bit_rate, 128000),
-            recordingChannels: this.probeData.streams[index].channels,
-            playoutLabel: "Audio ".concat(index)
-          };
-        }
+      var audioStreamData = this.probeData.streams.filter(function (value) {
+        return value.codec_type === "audio";
+      });
+      for (var index = 0; index < audioStreamData.length; index++) {
+        var currentStreamIndex = audioStreamData[index].stream_index;
+        var currentStreamData = audioStreamData[index];
+        audioStreams[currentStreamIndex] = {
+          recordingBitrate: Math.max(currentStreamData.bit_rate, 128000),
+          recordingChannels: currentStreamData.channels,
+          playoutLabel: "Audio ".concat(index + 1)
+        };
       }
       return audioStreams;
     }
@@ -398,7 +402,7 @@ var LiveConf = /*#__PURE__*/function () {
             recordingChannels: audio.recording_channels || 2
           };
           if (audio.playout) {
-            audioStreams[audioIdx].playoutLabel = audio.playout_label || "Audio ".concat(audioIdx);
+            audioStreams[audioIdx].playoutLabel = audio.playout_label || "Audio ".concat(i + 1);
           }
         }
       }
@@ -447,18 +451,6 @@ var LiveConf = /*#__PURE__*/function () {
       if (this.syncAudioToVideo) {
         conf.live_recording.recording_config.recording_params.xc_params.sync_audio_to_stream_id = this.syncAudioToStreamIdValue();
       }
-      if (customSettings.edge_write_token) {
-        conf.live_recording.fabric_config.edge_write_token = customSettings.edge_write_token;
-      }
-      if (customSettings.part_ttl) {
-        conf.live_recording.recording_config.recording_params.part_ttl = customSettings.part_ttl;
-      }
-      if (customSettings.connection_timeout) {
-        conf.live_recording.recording_config.recording_params.xc_params.connection_timeout = customSettings.connection_timeout;
-      }
-      if (customSettings.reconnect_timeout) {
-        conf.live_recording.recording_config.recording_params.reconnect_timeout = customSettings.reconnect_timeout;
-      }
 
       // Fill in specifics for protocol
       switch (this.probeKind()) {
@@ -561,6 +553,33 @@ var LiveConf = /*#__PURE__*/function () {
       // Global recording bitrate for all audio streams
       conf.live_recording.recording_config.recording_params.xc_params.audio_bitrate = globalAudioBitrate;
       conf.live_recording.recording_config.recording_params.xc_params.n_audio = nAudio;
+
+      // Iterate through custom settings (which will override any existing setting)
+      function SetByPath(_ref6) {
+        var obj = _ref6.obj,
+          path = _ref6.path,
+          value = _ref6.value;
+        var keys = path.split(".");
+        var temp = obj;
+        for (var _i3 = 0; _i3 < keys.length - 1; _i3++) {
+          if (!temp[keys[_i3]]) {
+            temp[keys[_i3]] = {};
+          }
+          temp = temp[keys[_i3]];
+        }
+        temp[keys[keys.length - 1]] = value;
+      }
+      var metaPathValues = customSettings.metaPathValues;
+      for (var _i4 = 0, _Object$entries = Object.entries(metaPathValues || {}); _i4 < _Object$entries.length; _i4++) {
+        var _Object$entries$_i = _slicedToArray(_Object$entries[_i4], 2),
+          path = _Object$entries$_i[0],
+          value = _Object$entries$_i[1];
+        SetByPath({
+          obj: conf,
+          path: path,
+          value: value
+        });
+      }
       return conf;
     }
   }]);