backendless/lib/data/rt-handlers.js

Backendless JavaScript SDK for Node.js and the browser

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
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 _rt = require("../rt");
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 ChangesTypes = {
  CREATED: 'created',
  UPDATED: 'updated',
  DELETED: 'deleted',
  UPSERTED: 'upserted',
  BULK_CREATED: 'bulk-created',
  BULK_UPDATED: 'bulk-updated',
  BULK_DELETED: 'bulk-deleted',
  BULK_UPSERTED: 'bulk-upserted'
};
var RelationsChangesTypes = {
  ADD: 'add',
  SET: 'set',
  DELETE: 'delete'
};
var SingleChangesTypes = [ChangesTypes.CREATED, ChangesTypes.UPDATED, ChangesTypes.DELETED, ChangesTypes.UPSERTED];
var RTHandlers = /*#__PURE__*/function (_RTListeners) {
  (0, _inherits2["default"])(RTHandlers, _RTListeners);
  var _super = _createSuper(RTHandlers);
  function RTHandlers(dataStore) {
    var _this;
    (0, _classCallCheck2["default"])(this, RTHandlers);
    _this = _super.call(this);
    _this.dataStore = dataStore;
    _this.app = dataStore.app;
    return _this;
  }
  (0, _createClass2["default"])(RTHandlers, [{
    key: "getSubscriptionOptions",
    value: function getSubscriptionOptions() {
      return {
        tableName: this.dataStore.className
      };
    }
  }, {
    key: "addCreateListener",
    value: function addCreateListener(whereClause, callback, onError) {
      this.addChangesListener(ChangesTypes.CREATED, whereClause, callback, onError);
    }
  }, {
    key: "removeCreateListeners",
    value: function removeCreateListeners(whereClause, callback) {
      this.removeChangesListeners(ChangesTypes.CREATED, whereClause, callback);
    }
  }, {
    key: "removeCreateListener",
    value: function removeCreateListener(callback) {
      if (!callback || typeof callback !== 'function') {
        throw new Error('Listener Function must be passed.');
      }
      this.removeCreateListeners(undefined, callback);
    }
  }, {
    key: "addUpsertListener",
    value: function addUpsertListener(whereClause, callback, onError) {
      this.addChangesListener(ChangesTypes.UPSERTED, whereClause, callback, onError);
    }
  }, {
    key: "removeUpsertListeners",
    value: function removeUpsertListeners(whereClause, callback) {
      this.removeChangesListeners(ChangesTypes.UPSERTED, whereClause, callback);
    }
  }, {
    key: "removeUpsertListener",
    value: function removeUpsertListener(callback) {
      if (!callback || typeof callback !== 'function') {
        throw new Error('Listener Function must be passed.');
      }
      this.removeUpsertListeners(undefined, callback);
    }
  }, {
    key: "addUpdateListener",
    value: function addUpdateListener(whereClause, callback, onError) {
      this.addChangesListener(ChangesTypes.UPDATED, whereClause, callback, onError);
    }
  }, {
    key: "removeUpdateListeners",
    value: function removeUpdateListeners(whereClause, callback) {
      this.removeChangesListeners(ChangesTypes.UPDATED, whereClause, callback);
    }
  }, {
    key: "removeUpdateListener",
    value: function removeUpdateListener(callback) {
      if (!callback || typeof callback !== 'function') {
        throw new Error('Listener Function must be passed.');
      }
      this.removeUpdateListeners(undefined, callback);
    }
  }, {
    key: "addDeleteListener",
    value: function addDeleteListener(whereClause, callback, onError) {
      this.addChangesListener(ChangesTypes.DELETED, whereClause, callback, onError);
    }
  }, {
    key: "removeDeleteListeners",
    value: function removeDeleteListeners(whereClause, callback) {
      this.removeChangesListeners(ChangesTypes.DELETED, whereClause, callback);
    }
  }, {
    key: "removeDeleteListener",
    value: function removeDeleteListener(callback) {
      if (!callback || typeof callback !== 'function') {
        throw new Error('Listener Function must be passed.');
      }
      this.removeDeleteListeners(undefined, callback);
    }
  }, {
    key: "addBulkCreateListener",
    value: function addBulkCreateListener(whereClause, callback, onError) {
      this.addChangesListener(ChangesTypes.BULK_CREATED, whereClause, callback, onError);
    }
  }, {
    key: "removeBulkCreateListeners",
    value: function removeBulkCreateListeners() {
      this.removeChangesListeners(ChangesTypes.BULK_CREATED);
    }
  }, {
    key: "removeBulkCreateListener",
    value: function removeBulkCreateListener(callback) {
      if (!callback || typeof callback !== 'function') {
        throw new Error('Listener Function must be passed.');
      }
      this.removeChangesListeners(ChangesTypes.BULK_CREATED, undefined, callback);
    }
  }, {
    key: "addBulkUpdateListener",
    value: function addBulkUpdateListener(whereClause, callback, onError) {
      this.addChangesListener(ChangesTypes.BULK_UPDATED, whereClause, callback, onError);
    }
  }, {
    key: "removeBulkUpdateListeners",
    value: function removeBulkUpdateListeners(whereClause, callback) {
      this.removeChangesListeners(ChangesTypes.BULK_UPDATED, whereClause, callback);
    }
  }, {
    key: "removeBulkUpdateListener",
    value: function removeBulkUpdateListener(callback) {
      if (!callback || typeof callback !== 'function') {
        throw new Error('Listener Function must be passed.');
      }
      this.removeBulkUpdateListeners(undefined, callback);
    }
  }, {
    key: "addBulkDeleteListener",
    value: function addBulkDeleteListener(whereClause, callback, onError) {
      this.addChangesListener(ChangesTypes.BULK_DELETED, whereClause, callback, onError);
    }
  }, {
    key: "removeBulkDeleteListeners",
    value: function removeBulkDeleteListeners(whereClause, callback) {
      this.removeChangesListeners(ChangesTypes.BULK_DELETED, whereClause, callback);
    }
  }, {
    key: "removeBulkDeleteListener",
    value: function removeBulkDeleteListener(callback) {
      if (!callback || typeof callback !== 'function') {
        throw new Error('Listener Function must be passed.');
      }
      this.removeBulkDeleteListeners(undefined, callback);
    }
  }, {
    key: "addBulkUpsertListener",
    value: function addBulkUpsertListener(whereClause, callback, onError) {
      this.addChangesListener(ChangesTypes.BULK_UPSERTED, whereClause, callback, onError);
    }
  }, {
    key: "removeBulkUpsertListeners",
    value: function removeBulkUpsertListeners() {
      this.removeChangesListeners(ChangesTypes.BULK_UPSERTED);
    }
  }, {
    key: "removeBulkUpsertListener",
    value: function removeBulkUpsertListener(callback) {
      if (!callback || typeof callback !== 'function') {
        throw new Error('Listener Function must be passed.');
      }
      this.removeChangesListeners(ChangesTypes.BULK_UPSERTED, undefined, callback);
    }
  }, {
    key: "addSetRelationListener",
    value: function addSetRelationListener(relationColumnName, parentObjects, callback, onError) {
      this.addRelationsChangesListener(RelationsChangesTypes.SET, relationColumnName, parentObjects, callback, onError);
    }
  }, {
    key: "removeSetRelationListener",
    value: function removeSetRelationListener(callback) {
      if (!callback || typeof callback !== 'function') {
        throw new Error('Listener Function must be passed.');
      }
      this.removeRelationsChangesListeners(RelationsChangesTypes.SET, undefined, callback);
    }
  }, {
    key: "removeSetRelationListeners",
    value: function removeSetRelationListeners(relationColumnName, callback) {
      this.removeRelationsChangesListeners(RelationsChangesTypes.SET, relationColumnName, callback);
    }
  }, {
    key: "addAddRelationListener",
    value: function addAddRelationListener(relationColumnName, parentObjects, callback, onError) {
      this.addRelationsChangesListener(RelationsChangesTypes.ADD, relationColumnName, parentObjects, callback, onError);
    }
  }, {
    key: "removeAddRelationListener",
    value: function removeAddRelationListener(callback) {
      if (!callback || typeof callback !== 'function') {
        throw new Error('Listener Function must be passed.');
      }
      this.removeRelationsChangesListeners(RelationsChangesTypes.ADD, undefined, callback);
    }
  }, {
    key: "removeAddRelationListeners",
    value: function removeAddRelationListeners(relationColumnName, callback) {
      this.removeRelationsChangesListeners(RelationsChangesTypes.ADD, relationColumnName, callback);
    }
  }, {
    key: "addDeleteRelationListener",
    value: function addDeleteRelationListener(relationColumnName, parentObjects, callback, onError) {
      this.addRelationsChangesListener(RelationsChangesTypes.DELETE, relationColumnName, parentObjects, callback, onError);
    }
  }, {
    key: "removeDeleteRelationListener",
    value: function removeDeleteRelationListener(callback) {
      if (!callback || typeof callback !== 'function') {
        throw new Error('Listener Function must be passed.');
      }
      this.removeRelationsChangesListeners(RelationsChangesTypes.DELETE, undefined, callback);
    }
  }, {
    key: "removeDeleteRelationListeners",
    value: function removeDeleteRelationListeners(relationColumnName, callback) {
      this.removeRelationsChangesListeners(RelationsChangesTypes.DELETE, relationColumnName, callback);
    }
  }, {
    key: "addChangesListener",
    value: function addChangesListener(event, whereClause, callback, onError) {
      if (typeof whereClause === 'function') {
        onError = callback;
        callback = whereClause;
        whereClause = undefined;
      }
      if (typeof callback !== 'function') {
        throw new Error('Listener Function must be passed.');
      }
      this.addSubscription(event, this.app.RT.subscriptions.onObjectsChanges, {
        callback: callback,
        onError: onError,
        parser: SingleChangesTypes.includes(event) ? this.parseObjectToInstance.bind(this) : undefined,
        params: {
          event: event,
          whereClause: whereClause
        }
      });
    }
  }, {
    key: "removeChangesListeners",
    value: function removeChangesListeners(event, whereClause, callback) {
      if (typeof whereClause === 'function') {
        callback = whereClause;
        whereClause = undefined;
      }
      var matcher = function matcher(subscription) {
        var params = subscription.params;
        if (whereClause) {
          return params.whereClause === whereClause;
        }
        if (callback) {
          return subscription.callback === callback;
        }
        return true;
      };
      this.stopSubscription(event, {
        matcher: matcher
      });
    }
  }, {
    key: "addRelationsChangesListener",
    value: function addRelationsChangesListener(event, relationColumnName, parentObjects, callback, onError) {
      if (!relationColumnName || typeof relationColumnName !== 'string') {
        throw new Error('Relation Column Name must be a string.');
      }
      if (typeof parentObjects === 'function') {
        onError = callback;
        callback = parentObjects;
        parentObjects = undefined;
      }
      if (typeof callback !== 'function') {
        throw new Error('Listener Function must be passed.');
      }
      if (parentObjects) {
        if (!Array.isArray(parentObjects)) {
          throw new Error('Parent Objects must be an array');
        }
        parentObjects = parentObjects.map(function (o) {
          return o.objectId || o;
        });
      }
      this.addSubscription(event, this.app.RT.subscriptions.onRelationsChanges, {
        callback: callback,
        onError: onError,
        params: {
          event: event,
          relationColumnName: relationColumnName,
          parentObjects: parentObjects
        }
      });
    }
  }, {
    key: "removeRelationsChangesListeners",
    value: function removeRelationsChangesListeners(event, relationColumnName, callback) {
      if (typeof relationColumnName === 'function') {
        callback = relationColumnName;
        relationColumnName = undefined;
      }
      var matcher = function matcher(subscription) {
        var params = subscription.params;
        if (relationColumnName) {
          return params.relationColumnName === relationColumnName;
        }
        if (callback) {
          return subscription.callback === callback;
        }
        return true;
      };
      this.stopSubscription(event, {
        matcher: matcher
      });
    }
  }, {
    key: "removeAllListeners",
    value: function removeAllListeners() {
      (0, _get2["default"])((0, _getPrototypeOf2["default"])(RTHandlers.prototype), "removeAllListeners", this).call(this);
    }

    /**
     * @private
     * */
  }, {
    key: "parseObjectToInstance",
    value: function parseObjectToInstance(object) {
      return this.dataStore.parseResponse(object);
    }
  }]);
  return RTHandlers;
}(_rt.RTListeners);
exports["default"] = RTHandlers;