backendless 6.3.15 → 6.5.0

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

@@ -0,0 +1,173 @@
+import Utils from '../../utils'
+
+export class HiveStore {
+
+  static STATIC_METHODS = ['keys', 'delete', 'exists', 'touch']
+
+  static registerType(hive) {
+    const context = { ...this, app: hive.app, hiveName: hive.hiveName }
+    const factory = storeKey => new this(context, storeKey)
+
+    this.STATIC_METHODS.forEach(methodName => {
+      factory[methodName] = (...args) => this[methodName].apply(context, args)
+    })
+
+    return factory
+  }
+
+  constructor(context, storeKey) {
+    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
+  }
+
+  static keys(options) {
+    if (options !== undefined) {
+      if (!Utils.isObject(options)) {
+        throw new Error('Options must be an object.')
+      }
+
+      const { cursor, pageSize, filterPattern } = options
+
+      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  : `${this.app.urls.hiveStore(this.hiveName, this.TYPE)}/keys`,
+        query: options
+      })
+  }
+
+  static 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
+      })
+  }
+
+  static 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 : `${this.app.urls.hiveStore(this.hiveName, this.TYPE)}/action/exists`,
+        data: keys
+      })
+  }
+
+  static 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 : `${this.app.urls.hiveStore(this.hiveName, this.TYPE)}/action/touch`,
+        data: keys
+      })
+  }
+
+  getBaseURL() {
+    return `${this.app.urls.hiveStore(this.hiveName, this.TYPE)}/${this.storeKey}`
+  }
+
+  delete() {
+    return this.constructor.delete.call({ ...this, ...this.constructor }, [this.storeKey])
+  }
+
+  async exists() {
+    const result = await this.constructor.exists.call({ ...this, ...this.constructor }, [this.storeKey])
+
+    return !!result
+  }
+
+  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  : `${this.getBaseURL()}/rename`,
+        query: { newKey, overwrite }
+      })
+  }
+
+  getExpiration() {
+    return this.app.request
+      .get({
+        url: `${this.getBaseURL()}/get-expiration-ttl`,
+      })
+  }
+
+  clearExpiration() {
+    return this.app.request
+      .put({
+        url: `${this.getBaseURL()}/clear-expiration`,
+      })
+  }
+
+  expireAfter(ttl) {
+    if (isNaN(ttl) || typeof ttl !== 'number') {
+      throw new Error('TTL must be a number.')
+    }
+
+    return this.app.request
+      .put({
+        url  : `${this.getBaseURL()}/expire`,
+        query: { ttl }
+      })
+  }
+
+  expireAt(unixTime) {
+    if (isNaN(unixTime) || typeof unixTime !== 'number') {
+      throw new Error('Expiration time must be a number.')
+    }
+
+    return this.app.request
+      .put({
+        url  : `${this.getBaseURL()}/expire-at`,
+        query: { unixTime }
+      })
+  }
+
+  touch() {
+    return this.constructor.touch.call({ ...this, ...this.constructor }, [this.storeKey])
+  }
+
+  secondsSinceLastOperation() {
+    return this.app.request
+      .get({
+        url: `${this.getBaseURL()}/seconds-since-last-operation`,
+      })
+  }
+}

package/src/hive/stores/index.js

@@ -0,0 +1,5 @@
+export * from './key-value'
+export * from './list'
+export * from './map'
+export * from './set'
+export * from './sorted-set'

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

@@ -0,0 +1,108 @@
+import { HiveTypes } from '../constants'
+import { HiveStore } from './base-store'
+import Utils from '../../utils'
+
+export class KeyValueStore extends HiveStore {
+
+  static TYPE = HiveTypes.KEY_VALUE
+
+  static STATIC_METHODS = [...HiveStore.STATIC_METHODS, 'get', 'set']
+
+  static 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
+      })
+  }
+
+  static set(key, value, options) {
+    if (Utils.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.isObject(options)) {
+        throw new Error('Options must be an object.')
+      }
+
+      const { ttl, expireAt, condition } = options
+
+      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 : `${this.app.urls.hiveStore(this.hiveName, this.TYPE)}/${key}`,
+        data: {
+          value,
+          ...options
+        }
+      })
+  }
+
+  get() {
+    return this.app.request
+      .get({
+        url: this.getBaseURL(),
+      })
+  }
+
+  set(value, options) {
+    return this.constructor.set.apply({ ...this, ...this.constructor }, [this.storeKey, value, options])
+  }
+
+  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  : `${this.getBaseURL()}/increment`,
+        query: {
+          value
+        }
+      })
+  }
+
+  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  : `${this.getBaseURL()}/decrement`,
+        query: {
+          value
+        }
+      })
+  }
+}

package/src/hive/stores/list.js

@@ -0,0 +1,165 @@
+import { HiveTypes } from '../constants'
+import { HiveStore } from './base-store'
+import Utils from '../../utils'
+
+export class ListStore extends HiveStore {
+
+  static TYPE = HiveTypes.LIST
+
+  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, to }
+        })
+    }
+
+    if (from !== undefined) {
+      if (isNaN(from) || typeof from !== 'number') {
+        throw new Error('Index must be a number.')
+      }
+
+      return this.app.request
+        .get({
+          url: `${this.getBaseURL()}/${from}`,
+        })
+    }
+
+    return this.app.request
+      .get({
+        url: this.getBaseURL(),
+      })
+  }
+
+  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 : `${this.getBaseURL()}/${index}`,
+        data: {
+          value
+        }
+      })
+  }
+
+  length() {
+    return this.app.request
+      .get({
+        url: `${this.getBaseURL()}/length`,
+      })
+  }
+
+  insertBefore(valueToInsert, anchorValue) {
+    return this.insert(valueToInsert, anchorValue, true)
+  }
+
+  insertAfter(valueToInsert, anchorValue) {
+    return this.insert(valueToInsert, anchorValue, false)
+  }
+
+  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 : `${this.getBaseURL()}/insert-${before ? 'before' : 'after'}`,
+        data: {
+          valueToInsert,
+          anchorValue,
+        }
+      })
+  }
+
+  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 : `${this.getBaseURL()}/delete-value`,
+        data: {
+          value,
+          count
+        },
+      })
+  }
+
+  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 : `${this.getBaseURL()}/add-first`,
+        data: Utils.castArray(value)
+      })
+  }
+
+  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 : `${this.getBaseURL()}/add-last`,
+        data: Utils.castArray(value)
+      })
+  }
+
+  deleteFirst(count) {
+    if (count !== undefined && (isNaN(count) || typeof count !== 'number')) {
+      throw new Error('Count must be a number.')
+    }
+
+    return this.app.request
+      .put({
+        url  : `${this.getBaseURL()}/get-first-and-delete`,
+        query: { count },
+      })
+  }
+
+  deleteLast(count) {
+    if (count !== undefined && (isNaN(count) || typeof count !== 'number')) {
+      throw new Error('Count must be a number.')
+    }
+
+    return this.app.request
+      .put({
+        url  : `${this.getBaseURL()}/get-last-and-delete`,
+        query: { count },
+      })
+  }
+}

package/src/hive/stores/map.js

@@ -0,0 +1,180 @@
+import { HiveTypes } from '../constants'
+import { HiveStore } from './base-store'
+import Utils from '../../utils'
+
+export class MapStore extends HiveStore {
+
+  static TYPE = HiveTypes.MAP
+
+  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.castArray(keys)
+      })
+  }
+
+  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: `${this.getBaseURL()}/get/${key}`,
+      })
+  }
+
+  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: `${this.getBaseURL()}/exists/${key}`,
+      })
+  }
+
+  length() {
+    return this.app.request
+      .get({
+        url: `${this.getBaseURL()}/length`,
+      })
+  }
+
+  keys() {
+    return this.app.request
+      .get({
+        url: `${this.getBaseURL()}/keys`,
+      })
+  }
+
+  values() {
+    return this.app.request
+      .get({
+        url: `${this.getBaseURL()}/values`,
+      })
+  }
+
+  set(key, value) {
+    if (!key) {
+      throw new Error('First argument must be provided and must be a string or an object.')
+    }
+
+    if (Utils.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 : `${this.getBaseURL()}/set/${key}`,
+        data: {
+          value,
+        },
+      })
+  }
+
+  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 : `${this.getBaseURL()}/set-with-overwrite/${key}`,
+        data: {
+          value,
+          overwrite
+        },
+      })
+  }
+
+  add(data) {
+    if (!Utils.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: `${this.getBaseURL()}/add`,
+        data,
+      })
+  }
+
+  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  : `${this.getBaseURL()}/increment/${key}`,
+        query: { count }
+      })
+  }
+
+  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  : `${this.getBaseURL()}/decrement/${key}`,
+        query: { count }
+      })
+  }
+
+  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 : `${this.getBaseURL()}/by-obj-keys`,
+        data: Utils.castArray(keys)
+      })
+  }
+}