backendless 6.4.0 → 6.5.0

package/lib/hive/stores/base-store.js

@@ -0,0 +1,249 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HiveStore = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _utils = _interopRequireDefault(require("../../utils"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var HiveStore = /*#__PURE__*/function () {
+  function HiveStore(context, storeKey) {
+    (0, _classCallCheck2["default"])(this, HiveStore);
+    this.TYPE = this.constructor.TYPE;
+
+    if (!storeKey || typeof storeKey !== 'string') {
+      throw new Error('Store key must be a string.');
+    }
+
+    this.app = context.app;
+    this.hiveName = context.hiveName;
+    this.storeKey = storeKey;
+  }
+
+  (0, _createClass2["default"])(HiveStore, [{
+    key: "getBaseURL",
+    value: function getBaseURL() {
+      return "".concat(this.app.urls.hiveStore(this.hiveName, this.TYPE), "/").concat(this.storeKey);
+    }
+  }, {
+    key: "delete",
+    value: function _delete() {
+      return this.constructor["delete"].call(_objectSpread(_objectSpread({}, this), this.constructor), [this.storeKey]);
+    }
+  }, {
+    key: "exists",
+    value: function () {
+      var _exists = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var result;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return this.constructor.exists.call(_objectSpread(_objectSpread({}, this), this.constructor), [this.storeKey]);
+
+              case 2:
+                result = _context.sent;
+                return _context.abrupt("return", !!result);
+
+              case 4:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function exists() {
+        return _exists.apply(this, arguments);
+      }
+
+      return exists;
+    }()
+  }, {
+    key: "rename",
+    value: function rename(newKey, overwrite) {
+      if (!newKey || typeof newKey !== 'string') {
+        throw new Error('New key name 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(), "/rename"),
+        query: {
+          newKey: newKey,
+          overwrite: overwrite
+        }
+      });
+    }
+  }, {
+    key: "getExpiration",
+    value: function getExpiration() {
+      return this.app.request.get({
+        url: "".concat(this.getBaseURL(), "/get-expiration-ttl")
+      });
+    }
+  }, {
+    key: "clearExpiration",
+    value: function clearExpiration() {
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/clear-expiration")
+      });
+    }
+  }, {
+    key: "expireAfter",
+    value: function expireAfter(ttl) {
+      if (isNaN(ttl) || typeof ttl !== 'number') {
+        throw new Error('TTL must be a number.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/expire"),
+        query: {
+          ttl: ttl
+        }
+      });
+    }
+  }, {
+    key: "expireAt",
+    value: function expireAt(unixTime) {
+      if (isNaN(unixTime) || typeof unixTime !== 'number') {
+        throw new Error('Expiration time must be a number.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/expire-at"),
+        query: {
+          unixTime: unixTime
+        }
+      });
+    }
+  }, {
+    key: "touch",
+    value: function touch() {
+      return this.constructor.touch.call(_objectSpread(_objectSpread({}, this), this.constructor), [this.storeKey]);
+    }
+  }, {
+    key: "secondsSinceLastOperation",
+    value: function secondsSinceLastOperation() {
+      return this.app.request.get({
+        url: "".concat(this.getBaseURL(), "/seconds-since-last-operation")
+      });
+    }
+  }], [{
+    key: "registerType",
+    value: function registerType(hive) {
+      var _this = this;
+
+      var context = _objectSpread(_objectSpread({}, this), {}, {
+        app: hive.app,
+        hiveName: hive.hiveName
+      });
+
+      var factory = function factory(storeKey) {
+        return new _this(context, storeKey);
+      };
+
+      this.STATIC_METHODS.forEach(function (methodName) {
+        factory[methodName] = function () {
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+
+          return _this[methodName].apply(context, args);
+        };
+      });
+      return factory;
+    }
+  }, {
+    key: "keys",
+    value: function keys(options) {
+      if (options !== undefined) {
+        if (!_utils["default"].isObject(options)) {
+          throw new Error('Options must be an object.');
+        }
+
+        var cursor = options.cursor,
+            pageSize = options.pageSize,
+            filterPattern = options.filterPattern;
+
+        if (cursor !== undefined && (typeof cursor !== 'number' || isNaN(cursor))) {
+          throw new Error('Cursor must be a number.');
+        }
+
+        if (pageSize !== undefined && (typeof pageSize !== 'number' || isNaN(pageSize))) {
+          throw new Error('Page size must be a number.');
+        }
+
+        if (filterPattern !== undefined && (typeof filterPattern !== 'string' || !filterPattern)) {
+          throw new Error('Filter pattern must be a string.');
+        }
+      }
+
+      return this.app.request.get({
+        url: "".concat(this.app.urls.hiveStore(this.hiveName, this.TYPE), "/keys"),
+        query: options
+      });
+    }
+  }, {
+    key: "delete",
+    value: function _delete(keys) {
+      if (!Array.isArray(keys)) {
+        throw new Error('Keys must be provided and must be a list of strings.');
+      }
+
+      return this.app.request["delete"]({
+        url: this.app.urls.hiveStore(this.hiveName, this.TYPE),
+        data: keys
+      });
+    }
+  }, {
+    key: "exists",
+    value: function exists(keys) {
+      if (!Array.isArray(keys)) {
+        throw new Error('Keys must be provided and must be a list of strings.');
+      }
+
+      return this.app.request.post({
+        url: "".concat(this.app.urls.hiveStore(this.hiveName, this.TYPE), "/action/exists"),
+        data: keys
+      });
+    }
+  }, {
+    key: "touch",
+    value: function touch(keys) {
+      if (!Array.isArray(keys)) {
+        throw new Error('Keys must be provided and must be a list of strings.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.app.urls.hiveStore(this.hiveName, this.TYPE), "/action/touch"),
+        data: keys
+      });
+    }
+  }]);
+  return HiveStore;
+}();
+
+exports.HiveStore = HiveStore;
+(0, _defineProperty2["default"])(HiveStore, "STATIC_METHODS", ['keys', 'delete', 'exists', 'touch']);

package/lib/hive/stores/index.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _keyValue = require("./key-value");
+
+Object.keys(_keyValue).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _keyValue[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _keyValue[key];
+    }
+  });
+});
+
+var _list = require("./list");
+
+Object.keys(_list).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _list[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _list[key];
+    }
+  });
+});
+
+var _map = require("./map");
+
+Object.keys(_map).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _map[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _map[key];
+    }
+  });
+});
+
+var _set = require("./set");
+
+Object.keys(_set).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _set[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _set[key];
+    }
+  });
+});
+
+var _sortedSet = require("./sorted-set");
+
+Object.keys(_sortedSet).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _sortedSet[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _sortedSet[key];
+    }
+  });
+});

package/lib/hive/stores/key-value.js

@@ -0,0 +1,153 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KeyValueStore = 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 _constants = require("../constants");
+
+var _baseStore = require("./base-store");
+
+var _utils = _interopRequireDefault(require("../../utils"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+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 KeyValueStore = /*#__PURE__*/function (_HiveStore) {
+  (0, _inherits2["default"])(KeyValueStore, _HiveStore);
+
+  var _super = _createSuper(KeyValueStore);
+
+  function KeyValueStore() {
+    (0, _classCallCheck2["default"])(this, KeyValueStore);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2["default"])(KeyValueStore, [{
+    key: "get",
+    value: function get() {
+      return this.app.request.get({
+        url: this.getBaseURL()
+      });
+    }
+  }, {
+    key: "set",
+    value: function set(value, options) {
+      return this.constructor.set.apply(_objectSpread(_objectSpread({}, this), this.constructor), [this.storeKey, value, options]);
+    }
+  }, {
+    key: "increment",
+    value: function increment(value) {
+      if (isNaN(value) || typeof value !== 'number') {
+        throw new Error('Value must be provided and must be a number.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/increment"),
+        query: {
+          value: value
+        }
+      });
+    }
+  }, {
+    key: "decrement",
+    value: function decrement(value) {
+      if (isNaN(value) || typeof value !== 'number') {
+        throw new Error('Value must be provided and must be a number.');
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.getBaseURL(), "/decrement"),
+        query: {
+          value: value
+        }
+      });
+    }
+  }], [{
+    key: "get",
+    value: function get(keys) {
+      if (!Array.isArray(keys)) {
+        throw new Error('Keys must be provided and must be a list of strings.');
+      }
+
+      return this.app.request.post({
+        url: this.app.urls.hiveStore(this.hiveName, this.TYPE),
+        data: keys
+      });
+    }
+  }, {
+    key: "set",
+    value: function set(key, value, options) {
+      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.app.urls.hiveStore(this.hiveName, this.TYPE),
+          data: key
+        });
+      }
+
+      if (!key || typeof key !== 'string') {
+        throw new Error('Key must be provided and must be a string.');
+      }
+
+      if (options !== undefined) {
+        if (!_utils["default"].isObject(options)) {
+          throw new Error('Options must be an object.');
+        }
+
+        var ttl = options.ttl,
+            expireAt = options.expireAt,
+            condition = options.condition;
+
+        if (ttl !== undefined && (isNaN(ttl) || typeof ttl !== 'number')) {
+          throw new Error('TTL in seconds must be a number.');
+        }
+
+        if (expireAt !== undefined && (isNaN(expireAt) || typeof expireAt !== 'number')) {
+          throw new Error('ExpireAt timestamp must be a number.');
+        }
+
+        if (condition !== undefined && !['IfExists', 'IfNotExists', 'Always'].includes(condition)) {
+          throw new Error('Condition must be one of this values: [IfExists, IfNotExists, Always].');
+        }
+      }
+
+      return this.app.request.put({
+        url: "".concat(this.app.urls.hiveStore(this.hiveName, this.TYPE), "/").concat(key),
+        data: _objectSpread({
+          value: value
+        }, options)
+      });
+    }
+  }]);
+  return KeyValueStore;
+}(_baseStore.HiveStore);
+
+exports.KeyValueStore = KeyValueStore;
+(0, _defineProperty2["default"])(KeyValueStore, "TYPE", _constants.HiveTypes.KEY_VALUE);
+(0, _defineProperty2["default"])(KeyValueStore, "STATIC_METHODS", [].concat((0, _toConsumableArray2["default"])(_baseStore.HiveStore.STATIC_METHODS), ['get', 'set']));

package/lib/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);