backendless 6.4.0 → 6.5.0

package/es/hive/stores/list.js

@@ -0,0 +1,210 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ListStore = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _constants = require("../constants");
+
+var _baseStore = require("./base-store");
+
+var _utils = _interopRequireDefault(require("../../utils"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var ListStore = /*#__PURE__*/function (_HiveStore) {
+  (0, _inherits2["default"])(ListStore, _HiveStore);
+
+  var _super = _createSuper(ListStore);
+
+  function ListStore() {
+    (0, _classCallCheck2["default"])(this, ListStore);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2["default"])(ListStore, [{
+    key: "get",
+    value: function get(from, to) {
+      if (to !== undefined) {
+        if (isNaN(to) || typeof to !== 'number') {
+          throw new Error('Index To must be a number.');
+        }
+
+        if (isNaN(from) || typeof from !== 'number') {
+          throw new Error('Index From must be a number.');
+        }
+
+        return this.app.request.get({
+          url: this.getBaseURL(),
+          query: {
+            from: from,
+            to: to
+          }
+        });
+      }
+
+      if (from !== undefined) {
+        if (isNaN(from) || typeof from !== 'number') {
+          throw new Error('Index must be a number.');
+        }
+
+        return this.app.request.get({
+          url: "".concat(this.getBaseURL(), "/").concat(from)
+        });
+      }
+
+      return this.app.request.get({
+        url: this.getBaseURL()
+      });
+    }
+  }, {
+    key: "set",
+    value: function set(value, index) {
+      if (Array.isArray(value)) {
+        return this.app.request.put({
+          url: this.getBaseURL(),
+          data: value
+        });
+      }
+
+      if (isNaN(index) || typeof index !== 'number') {
+        throw new Error('Index must be a number.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/").concat(index),
+        data: {
+          value: value
+        }
+      });
+    }
+  }, {
+    key: "length",
+    value: function length() {
+      return this.app.request.get({
+        url: "".concat(this.getBaseURL(), "/length")
+      });
+    }
+  }, {
+    key: "insertBefore",
+    value: function insertBefore(valueToInsert, anchorValue) {
+      return this.insert(valueToInsert, anchorValue, true);
+    }
+  }, {
+    key: "insertAfter",
+    value: function insertAfter(valueToInsert, anchorValue) {
+      return this.insert(valueToInsert, anchorValue, false);
+    }
+  }, {
+    key: "insert",
+    value: function insert(valueToInsert, anchorValue, before) {
+      if (!valueToInsert || typeof valueToInsert !== 'string') {
+        throw new Error('ValueToInsert must be provided and must be a string.');
+      }
+
+      if (!anchorValue || typeof anchorValue !== 'string') {
+        throw new Error('AnchorValue must be provided and must be a string.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/insert-").concat(before ? 'before' : 'after'),
+        data: {
+          valueToInsert: valueToInsert,
+          anchorValue: anchorValue
+        }
+      });
+    }
+  }, {
+    key: "deleteValue",
+    value: function deleteValue(value, count) {
+      if (!value || typeof value !== 'string') {
+        throw new Error('Value must be provided and must be a string.');
+      }
+
+      if (count !== undefined && (isNaN(count) || typeof count !== 'number')) {
+        throw new Error('Count must be a number.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/delete-value"),
+        data: {
+          value: value,
+          count: count
+        }
+      });
+    }
+  }, {
+    key: "addFirst",
+    value: function addFirst(value) {
+      if (!value || !(typeof value === 'string' || Array.isArray(value))) {
+        throw new Error('Value(s) must be provided and must be a string or list of strings.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/add-first"),
+        data: _utils["default"].castArray(value)
+      });
+    }
+  }, {
+    key: "addLast",
+    value: function addLast(value) {
+      if (!value || !(typeof value === 'string' || Array.isArray(value))) {
+        throw new Error('Value(s) must be provided and must be a string or list of strings.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/add-last"),
+        data: _utils["default"].castArray(value)
+      });
+    }
+  }, {
+    key: "deleteFirst",
+    value: function deleteFirst(count) {
+      if (count !== undefined && (isNaN(count) || typeof count !== 'number')) {
+        throw new Error('Count must be a number.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/get-first-and-delete"),
+        query: {
+          count: count
+        }
+      });
+    }
+  }, {
+    key: "deleteLast",
+    value: function deleteLast(count) {
+      if (count !== undefined && (isNaN(count) || typeof count !== 'number')) {
+        throw new Error('Count must be a number.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/get-last-and-delete"),
+        query: {
+          count: count
+        }
+      });
+    }
+  }]);
+  return ListStore;
+}(_baseStore.HiveStore);
+
+exports.ListStore = ListStore;
+(0, _defineProperty2["default"])(ListStore, "TYPE", _constants.HiveTypes.LIST);

package/es/hive/stores/map.js

@@ -0,0 +1,222 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MapStore = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _constants = require("../constants");
+
+var _baseStore = require("./base-store");
+
+var _utils = _interopRequireDefault(require("../../utils"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var MapStore = /*#__PURE__*/function (_HiveStore) {
+  (0, _inherits2["default"])(MapStore, _HiveStore);
+
+  var _super = _createSuper(MapStore);
+
+  function MapStore() {
+    (0, _classCallCheck2["default"])(this, MapStore);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2["default"])(MapStore, [{
+    key: "get",
+    value: function get(keys) {
+      if (keys !== undefined && !(typeof keys === 'string' || Array.isArray(keys))) {
+        throw new Error('Key(s) must be a string or list of strings.');
+      }
+
+      return this.app.request.post({
+        url: this.getBaseURL(),
+        data: _utils["default"].castArray(keys)
+      });
+    }
+  }, {
+    key: "getValue",
+    value: function getValue(key) {
+      if (!key || typeof key !== 'string') {
+        throw new Error('Key must be provided and must be a string.');
+      }
+
+      return this.app.request.get({
+        url: "".concat(this.getBaseURL(), "/get/").concat(key)
+      });
+    }
+  }, {
+    key: "keyExists",
+    value: function keyExists(key) {
+      if (!key || typeof key !== 'string') {
+        throw new Error('Key must be provided and must be a string.');
+      }
+
+      return this.app.request.get({
+        url: "".concat(this.getBaseURL(), "/exists/").concat(key)
+      });
+    }
+  }, {
+    key: "length",
+    value: function length() {
+      return this.app.request.get({
+        url: "".concat(this.getBaseURL(), "/length")
+      });
+    }
+  }, {
+    key: "keys",
+    value: function keys() {
+      return this.app.request.get({
+        url: "".concat(this.getBaseURL(), "/keys")
+      });
+    }
+  }, {
+    key: "values",
+    value: function values() {
+      return this.app.request.get({
+        url: "".concat(this.getBaseURL(), "/values")
+      });
+    }
+  }, {
+    key: "set",
+    value: function set(key, value) {
+      if (!key) {
+        throw new Error('First argument must be provided and must be a string or an object.');
+      }
+
+      if (_utils["default"].isObject(key)) {
+        if (!Object.keys(key).length) {
+          throw new Error('Provided object must have at least 1 key.');
+        }
+
+        return this.app.request.put({
+          url: this.getBaseURL(),
+          data: key
+        });
+      }
+
+      if (typeof key !== 'string') {
+        throw new Error('Key must be a string.');
+      }
+
+      if (!value || typeof value !== 'string') {
+        throw new Error('Value must be provided and must be a string.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/set/").concat(key),
+        data: {
+          value: value
+        }
+      });
+    }
+  }, {
+    key: "setWithOverwrite",
+    value: function setWithOverwrite(key, value, overwrite) {
+      if (!key || typeof key !== 'string') {
+        throw new Error('Key must be provided and must be a string.');
+      }
+
+      if (!value || typeof value !== 'string') {
+        throw new Error('Value must be provided and must be a string.');
+      }
+
+      if (overwrite !== undefined && typeof overwrite !== 'boolean') {
+        throw new Error('Overwrite must be a boolean.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/set-with-overwrite/").concat(key),
+        data: {
+          value: value,
+          overwrite: overwrite
+        }
+      });
+    }
+  }, {
+    key: "add",
+    value: function add(data) {
+      if (!_utils["default"].isObject(data)) {
+        throw new Error('Payload must be an object.');
+      }
+
+      if (!Object.keys(data).length) {
+        throw new Error('Provided object must have at least 1 key.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/add"),
+        data: data
+      });
+    }
+  }, {
+    key: "increment",
+    value: function increment(key, count) {
+      if (!key || typeof key !== 'string') {
+        throw new Error('Key must be provided and must be a string.');
+      }
+
+      if (count !== undefined && (isNaN(count) || typeof count !== 'number')) {
+        throw new Error('Count must be a number.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/increment/").concat(key),
+        query: {
+          count: count
+        }
+      });
+    }
+  }, {
+    key: "decrement",
+    value: function decrement(key, count) {
+      if (!key || typeof key !== 'string') {
+        throw new Error('Key must be provided and must be a string.');
+      }
+
+      if (count !== undefined && (isNaN(count) || typeof count !== 'number')) {
+        throw new Error('Count must be a number.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/decrement/").concat(key),
+        query: {
+          count: count
+        }
+      });
+    }
+  }, {
+    key: "deleteKeys",
+    value: function deleteKeys(keys) {
+      if (!keys || !(typeof keys === 'string' || Array.isArray(keys))) {
+        throw new Error('Key(s) must be provided and must be a string or list of strings.');
+      }
+
+      return this.app.request["delete"]({
+        url: "".concat(this.getBaseURL(), "/by-obj-keys"),
+        data: _utils["default"].castArray(keys)
+      });
+    }
+  }]);
+  return MapStore;
+}(_baseStore.HiveStore);
+
+exports.MapStore = MapStore;
+(0, _defineProperty2["default"])(MapStore, "TYPE", _constants.HiveTypes.MAP);

package/es/hive/stores/set.js

@@ -0,0 +1,180 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SetStore = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _baseStore = require("./base-store");
+
+var _constants = require("../constants");
+
+var _utils = _interopRequireDefault(require("../../utils"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var SetStore = /*#__PURE__*/function (_HiveStore) {
+  (0, _inherits2["default"])(SetStore, _HiveStore);
+
+  var _super = _createSuper(SetStore);
+
+  function SetStore() {
+    (0, _classCallCheck2["default"])(this, SetStore);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2["default"])(SetStore, [{
+    key: "get",
+    value: function get() {
+      return this.app.request.get({
+        url: this.getBaseURL()
+      });
+    }
+  }, {
+    key: "getRandom",
+    value: function getRandom(count) {
+      if (count !== undefined && (isNaN(count) || typeof count !== 'number')) {
+        throw new Error('Count must be a number.');
+      }
+
+      return this.app.request.get({
+        url: "".concat(this.getBaseURL(), "/random"),
+        query: {
+          count: count
+        }
+      });
+    }
+  }, {
+    key: "getRandomAndDelete",
+    value: function getRandomAndDelete(count) {
+      if (count !== undefined && (isNaN(count) || typeof count !== 'number')) {
+        throw new Error('Count must be a number.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/random"),
+        query: {
+          count: count
+        }
+      });
+    }
+  }, {
+    key: "set",
+    value: function set(values) {
+      if (!values || typeof values !== 'string' && !Array.isArray(values)) {
+        throw new Error('Value(s) must be provided and must be a string or list of strings.');
+      }
+
+      return this.app.request.put({
+        url: this.getBaseURL(),
+        data: _utils["default"].castArray(values)
+      });
+    }
+  }, {
+    key: "add",
+    value: function add(values) {
+      if (!values || !(typeof values === 'string' || Array.isArray(values))) {
+        throw new Error('Value(s) must be provided and must be a string or list of strings.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/add"),
+        data: _utils["default"].castArray(values)
+      });
+    }
+  }, {
+    key: "deleteValues",
+    value: function deleteValues(values) {
+      if (!values || !(typeof values === 'string' || Array.isArray(values))) {
+        throw new Error('Value(s) must be provided and must be a string or list of strings.');
+      }
+
+      return this.app.request["delete"]({
+        url: "".concat(this.getBaseURL(), "/values"),
+        data: _utils["default"].castArray(values)
+      });
+    }
+  }, {
+    key: "isMember",
+    value: function isMember(value) {
+      if (typeof value === 'string') {
+        value = [value];
+      }
+
+      if (!Array.isArray(value)) {
+        throw new Error('Value must be provided and must be a string or a list of strings.');
+      }
+
+      return this.app.request.post({
+        url: "".concat(this.getBaseURL(), "/contains"),
+        data: value
+      });
+    }
+  }, {
+    key: "length",
+    value: function length() {
+      return this.app.request.get({
+        url: "".concat(this.getBaseURL(), "/length")
+      });
+    }
+  }], [{
+    key: "difference",
+    value: function difference(keyNames) {
+      if (!Array.isArray(keyNames)) {
+        throw new Error('Store keys must be provided and must be an array.');
+      }
+
+      return this.app.request.post({
+        url: "".concat(this.app.urls.hiveStore(this.hiveName, this.TYPE), "/action/difference"),
+        data: keyNames
+      });
+    }
+  }, {
+    key: "intersection",
+    value: function intersection(keyNames) {
+      if (!Array.isArray(keyNames)) {
+        throw new Error('Store keys must be provided and must be an array.');
+      }
+
+      return this.app.request.post({
+        url: "".concat(this.app.urls.hiveStore(this.hiveName, this.TYPE), "/action/intersection"),
+        data: keyNames
+      });
+    }
+  }, {
+    key: "union",
+    value: function union(keyNames) {
+      if (!Array.isArray(keyNames)) {
+        throw new Error('Store keys must be provided and must be an array.');
+      }
+
+      return this.app.request.post({
+        url: "".concat(this.app.urls.hiveStore(this.hiveName, this.TYPE), "/action/union"),
+        data: keyNames
+      });
+    }
+  }]);
+  return SetStore;
+}(_baseStore.HiveStore);
+
+exports.SetStore = SetStore;
+(0, _defineProperty2["default"])(SetStore, "TYPE", _constants.HiveTypes.SET);
+(0, _defineProperty2["default"])(SetStore, "STATIC_METHODS", [].concat((0, _toConsumableArray2["default"])(_baseStore.HiveStore.STATIC_METHODS), ['difference', 'intersection', 'union']));