backendless/es/unit-of-work/index.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"] = UnitOfWorkService;
var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
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 _wrapNativeSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapNativeSuper"));
var _utils = _interopRequireDefault(require("../utils"));
var _dataQueryBuilder = _interopRequireDefault(require("../data/data-query-builder"));
var _constants = require("./constants");
var _jsonAdapter = require("./json-adapter");
var _opResult = require("./op-result");
var _opResultValueReference = require("./op-result-value-reference");
var _excluded = ["meta"];
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) { (0, _defineProperty2["default"])(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; }
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 TransactionOperationError = /*#__PURE__*/function (_Error) {
  (0, _inherits2["default"])(TransactionOperationError, _Error);
  var _super = _createSuper(TransactionOperationError);
  function TransactionOperationError(error, operation) {
    var _this;
    (0, _classCallCheck2["default"])(this, TransactionOperationError);
    _this = _super.call(this, error.message);
    _this.code = error.code;
    _this.operation = operation;
    return _this;
  }
  (0, _createClass2["default"])(TransactionOperationError, [{
    key: "toJSON",
    value: function toJSON() {
      return {
        message: this.message,
        operation: this.operation
      };
    }
  }]);
  return TransactionOperationError;
}( /*#__PURE__*/(0, _wrapNativeSuper2["default"])(Error));
var UnitOfWorkResult = /*#__PURE__*/function () {
  function UnitOfWorkResult(_ref) {
    var success = _ref.success,
      error = _ref.error,
      results = _ref.results;
    (0, _classCallCheck2["default"])(this, UnitOfWorkResult);
    this.success = success;
    this.error = error;
    this.results = results;
  }
  (0, _createClass2["default"])(UnitOfWorkResult, [{
    key: "isSuccess",
    value: function isSuccess() {
      return this.success;
    }
  }, {
    key: "getError",
    value: function getError() {
      return this.error;
    }
  }, {
    key: "getResults",
    value: function getResults() {
      return this.results;
    }
  }]);
  return UnitOfWorkResult;
}();
var UnitOfWork = /*#__PURE__*/function () {
  function UnitOfWork(isolationLevelEnum, app) {
    (0, _classCallCheck2["default"])(this, UnitOfWork);
    this.app = app;
    this.payload = {
      isolationLevelEnum: isolationLevelEnum,
      operations: []
    };
    this.usedOpIds = {};
  }
  (0, _createClass2["default"])(UnitOfWork, [{
    key: "getOpResultById",
    value: function getOpResultById(opResultId) {
      var operation = this.payload.operations.find(function (opResult) {
        return opResult.meta.opResult.getOpResultId() === opResultId;
      });
      return operation.meta.opResult;
    }
  }, {
    key: "setIsolationLevel",
    value: function setIsolationLevel(isolationLevelEnum) {
      this.payload.isolationLevelEnum = isolationLevelEnum;
    }
  }, {
    key: "getOpStackName",
    value: function getOpStackName(operationType, table) {
      return "".concat(operationType.toLowerCase()).concat(table);
    }
  }, {
    key: "getNextOpResultIndex",
    value: function getNextOpResultIndex(stackName) {
      if (!this.usedOpIds[stackName]) {
        this.usedOpIds[stackName] = 0;
      }
      return ++this.usedOpIds[stackName];
    }
  }, {
    key: "addOperations",
    value: function addOperations(operationType, table, payload) {
      if (Array.isArray(payload)) {
        payload = payload.map(function (item) {
          delete item.___jsonclass;
          return item;
        });
      } else {
        delete payload.___jsonclass;
      }
      var opResult = new _opResult.OpResult(this, {
        operationType: operationType,
        table: table,
        payload: payload
      });
      this.payload.operations.push({
        operationType: operationType,
        table: table,
        payload: payload,
        meta: {
          opResult: opResult
        }
      });
      return opResult;
    }
  }, {
    key: "composePayload",
    value: function composePayload() {
      return _objectSpread(_objectSpread({}, this.payload), {}, {
        operations: this.payload.operations.map(function (_ref2) {
          var meta = _ref2.meta,
            operation = (0, _objectWithoutProperties2["default"])(_ref2, _excluded);
          return _objectSpread(_objectSpread({}, operation), {}, {
            opResultId: meta.opResult.getOpResultId()
          });
        })
      });
    }
  }, {
    key: "execute",
    value: function () {
      var _execute = (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.app.request.post({
                url: this.app.urls.transactions(),
                data: this.composePayload()
              });
            case 2:
              result = _context.sent;
              return _context.abrupt("return", this.setResult(result));
            case 4:
            case "end":
              return _context.stop();
          }
        }, _callee, this);
      }));
      function execute() {
        return _execute.apply(this, arguments);
      }
      return execute;
    }()
  }, {
    key: "setResult",
    value: function setResult(result) {
      if (result.results) {
        this.payload.operations.forEach(function (operation) {
          var opResultId = operation.meta.opResult.getOpResultId();
          if (result.results[opResultId]) {
            operation.meta.opResult.setResult(result.results[opResultId].result);
          }
        });
      }
      if (result.error) {
        var operation = this.payload.operations.find(function (op) {
          return result.error.operation.opResultId === op.meta.opResult.getOpResultId();
        });
        result.error = new TransactionOperationError(result.error, operation.meta.opResult);
        operation.meta.opResult.setError(result.error);
      }
      return new UnitOfWorkResult(result);
    }
  }, {
    key: "find",
    value: function find(tableName, queryBuilder) {
      var query = queryBuilder instanceof _dataQueryBuilder["default"] ? queryBuilder.toJSON() : queryBuilder || {};
      if (!tableName || typeof tableName !== 'string') {
        throw new Error('Invalid arguments');
      }
      if ((0, _typeof2["default"])(query) !== 'object' || Array.isArray(query)) {
        throw new Error('Invalid arguments');
      }
      var payload = {
        queryOptions: {}
      };
      if (query.pageSize > 0) {
        payload.pageSize = query.pageSize;
      }
      if (query.offset > 0) {
        payload.offset = query.offset;
      }
      if (query.properties) {
        payload.properties = query.properties;
      }
      if (query.excludeProps) {
        payload.excludeProps = query.excludeProps;
      }
      if (query.excludeProps) {
        payload.excludeProps = query.excludeProps;
      }
      if (query.where) {
        payload.whereClause = query.where;
      }
      if (query.having) {
        payload.havingClause = query.having;
      }
      if (query.groupBy) {
        payload.groupBy = query.groupBy;
      }
      if (query.sortBy) {
        payload.queryOptions.sortBy = query.sortBy;
      }
      if (query.relations) {
        payload.queryOptions.related = query.relations;
      }
      if (query.relationsDepth) {
        payload.queryOptions.relationsDepth = query.relationsDepth;
      }
      if (query.relationsPageSize > 0) {
        payload.queryOptions.relationsPageSize = query.relationsPageSize;
      }
      return this.addOperations(_constants.OperationType.FIND, tableName, payload);
    }

    /**
     * upsert(object: object): OpResult;
     * upsert(tableName: string, object: object): OpResult;
     * **/
  }, {
    key: "upsert",
    value: function upsert() {
      var tableName;
      var changes;
      if (arguments.length === 1) {
        tableName = _utils["default"].getClassName(arguments.length <= 0 ? undefined : arguments[0]);
        changes = arguments.length <= 0 ? undefined : arguments[0];
      } else if (arguments.length === 2) {
        tableName = arguments.length <= 0 ? undefined : arguments[0];
        changes = arguments.length <= 1 ? undefined : arguments[1];
      } else {
        throw new Error('Invalid arguments');
      }
      if (!tableName || typeof tableName !== 'string') {
        throw new Error('Invalid arguments');
      }
      if (!changes || (0, _typeof2["default"])(changes) !== 'object' || Array.isArray(changes)) {
        throw new Error('Invalid arguments');
      }
      return this.addOperations(_constants.OperationType.UPSERT, tableName, changes);
    }

    /**
     * create(object: object): OpResult;
     * create(tableName: string, object: object): OpResult;
     * **/
  }, {
    key: "create",
    value: function create() {
      var tableName;
      var changes;
      if (arguments.length === 1) {
        tableName = _utils["default"].getClassName(arguments.length <= 0 ? undefined : arguments[0]);
        changes = arguments.length <= 0 ? undefined : arguments[0];
      } else if (arguments.length === 2) {
        tableName = arguments.length <= 0 ? undefined : arguments[0];
        changes = arguments.length <= 1 ? undefined : arguments[1];
      } else {
        throw new Error('Invalid arguments');
      }
      if (!tableName || typeof tableName !== 'string') {
        throw new Error('Invalid arguments');
      }
      if (!changes || (0, _typeof2["default"])(changes) !== 'object' || Array.isArray(changes)) {
        throw new Error('Invalid arguments');
      }
      return this.addOperations(_constants.OperationType.CREATE, tableName, changes);
    }

    /**
     * update(object: object): OpResult;
     * update(tableName: string, object: object): OpResult;
     * update(opResult: OpResult | OpResultValueReference, object: object): OpResult;
     *
     * update(
     *    opResult: OpResult | OpResultValueReference,
     *    propertyName: string,
     *    propertyValue: OpResultValueReference): OpResult;
     *
     * update(
     *    opResult: OpResult | OpResultValueReference,
     *    propertyName: string,
     *    propertyValue: number | string | boolean): OpResult;
     * **/
  }, {
    key: "update",
    value: function update() {
      var tableName;
      var payload;
      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }
      if (args.length === 1) {
        tableName = _utils["default"].getClassName(args[0]);
        payload = args[0];
      } else if (args.length === 2 && typeof args[0] === 'string') {
        tableName = args[0];
        payload = args[1];
      } else if (args[0] instanceof _opResult.OpResult || args[0] instanceof _opResultValueReference.OpResultValueReference) {
        tableName = args[0].getTableName();
        payload = {
          objectId: args[0]
        };
        if (args.length === 3 && typeof args[1] === 'string') {
          payload[args[1]] = args[2];
        } else if (args.length === 2) {
          payload = _objectSpread(_objectSpread({}, payload), args[1]);
        } else {
          throw new Error('Invalid arguments');
        }
      } else {
        throw new Error('Invalid arguments');
      }
      if (!tableName || typeof tableName !== 'string') {
        throw new Error('Invalid arguments');
      }
      return this.addOperations(_constants.OperationType.UPDATE, tableName, payload);
    }

    /**
     * delete(opResult: OpResult | OpResultValueReference): OpResult;
     * delete(object: object): OpResult;
     * delete(tableName: string, object: object): OpResult;
     * delete(tableName: string, objectId: string): OpResult;
     * **/
  }, {
    key: "delete",
    value: function _delete() {
      var tableName;
      var object;
      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        args[_key2] = arguments[_key2];
      }
      if (args.length === 1) {
        if (args[0] instanceof _opResult.OpResult || args[0] instanceof _opResultValueReference.OpResultValueReference) {
          tableName = args[0].getTableName();
          object = args[0];
        } else if (args[0] && (0, _typeof2["default"])(args[0]) === 'object' && !Array.isArray(args[0])) {
          tableName = _utils["default"].getClassName(args[0]);
          object = args[0].objectId;
        }
      } else if (args.length === 2) {
        tableName = args[0];
        object = args[1] && args[1].objectId || args[1];
      } else {
        throw new Error('Invalid arguments');
      }
      if (!object || Array.isArray(object) || typeof object !== 'string' && (0, _typeof2["default"])(object) !== 'object') {
        throw new Error('Invalid arguments');
      }
      if (!tableName || typeof tableName !== 'string') {
        throw new Error('Table Name must be a string.');
      }
      return this.addOperations(_constants.OperationType.DELETE, tableName, object);
    }

    /**
     * bulkUpsert(tableName: string, objects: object[]): OpResult;
     * bulkUpsert(objects: object[]): OpResult;
     * **/
  }, {
    key: "bulkUpsert",
    value: function bulkUpsert(tableName, objects) {
      if (Array.isArray(tableName)) {
        objects = tableName;
        tableName = _utils["default"].getClassName(objects[0]);
      }
      if (!objects || !Array.isArray(objects)) {
        throw new Error('Objects must be an array of objects.');
      }
      if (!tableName || typeof tableName !== 'string') {
        throw new Error('Table Name must be a string.');
      }
      return this.addOperations(_constants.OperationType.UPSERT_BULK, tableName, objects);
    }

    /**
     * bulkCreate(tableName: string, objects: object[]): OpResult;
     * bulkCreate(objects: object[]): OpResult;
     * **/
  }, {
    key: "bulkCreate",
    value: function bulkCreate(tableName, objects) {
      if (Array.isArray(tableName)) {
        objects = tableName;
        tableName = _utils["default"].getClassName(objects[0]);
      }
      if (!objects || !Array.isArray(objects)) {
        throw new Error('Objects must be an array of objects.');
      }
      if (!tableName || typeof tableName !== 'string') {
        throw new Error('Table Name must be a string.');
      }
      return this.addOperations(_constants.OperationType.CREATE_BULK, tableName, objects);
    }

    /**
     * bulkUpdate(opResult: OpResult, changes: object): OpResult;
     *
     * bulkUpdate(tableName: string, whereClause: string, changes: object): OpResult;
     * bulkUpdate(tableName: string, objectIds: string[], changes: object): OpResult;
     * bulkUpdate(tableName: string, objects: object[], changes: object): OpResult;
     * **/
  }, {
    key: "bulkUpdate",
    value: function bulkUpdate() {
      var tableName;
      var payload = {};
      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
        args[_key3] = arguments[_key3];
      }
      if (args.length === 2) {
        payload.changes = args[1];
        if (typeof args[0] === 'string') {
          tableName = _utils["default"].getClassName(args[1]);
          payload.conditional = args[0];
        } else if (args[0] instanceof _opResult.OpResult) {
          tableName = args[0].getTableName();
          payload.unconditional = args[0];
        }
      } else if (args.length === 3) {
        tableName = args[0];
        payload.changes = args[2];
        if (typeof args[1] === 'string') {
          payload.conditional = args[1];
        } else if (Array.isArray(args[1])) {
          payload.unconditional = args[1].map(function (o) {
            return o.objectId || o;
          });
        } else {
          throw new Error('Invalid arguments');
        }
      } else {
        throw new Error('Invalid arguments');
      }
      if (!tableName || typeof tableName !== 'string') {
        throw new Error('Table Name must be a string.');
      }
      return this.addOperations(_constants.OperationType.UPDATE_BULK, tableName, payload);
    }

    /**
     * bulkDelete(opResult: OpResult): OpResult;
     * bulkDelete(objects: object[]): OpResult;
     *
     * bulkDelete(tableName: string, objects: object[]): OpResult;
     * bulkDelete(tableName: string, objectIds: string[]): OpResult;
     * bulkDelete(tableName: string, whereClause: string): OpResult;
     * **/
  }, {
    key: "bulkDelete",
    value: function bulkDelete() {
      var payload = {};
      var tableName;
      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
        args[_key4] = arguments[_key4];
      }
      if (args.length === 1) {
        if (args[0] instanceof _opResult.OpResult) {
          tableName = args[0].getTableName();
          payload.unconditional = args[0];
        } else if (Array.isArray(args[0])) {
          tableName = _utils["default"].getClassName(args[0][0]);
          payload.unconditional = args[0].map(function (o) {
            return o.objectId;
          });
        } else {
          throw new Error('Invalid arguments');
        }
      } else if (args.length === 2) {
        tableName = args[0];
        if (typeof args[1] === 'string') {
          payload.conditional = args[1];
        } else if (Array.isArray(args[1])) {
          payload.unconditional = args[1].map(function (o) {
            return o.objectId || o;
          });
        } else {
          throw new Error('Invalid arguments');
        }
      } else {
        throw new Error('Invalid arguments');
      }
      if (!tableName || typeof tableName !== 'string') {
        throw new Error('Table Name must be a string.');
      }
      return this.addOperations(_constants.OperationType.DELETE_BULK, tableName, payload);
    }
  }, {
    key: "addToRelation",
    value: function addToRelation() {
      for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
        args[_key5] = arguments[_key5];
      }
      return this.relationsOperation(_constants.OperationType.ADD_RELATION, args);
    }
  }, {
    key: "setRelation",
    value: function setRelation() {
      for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
        args[_key6] = arguments[_key6];
      }
      return this.relationsOperation(_constants.OperationType.SET_RELATION, args);
    }
  }, {
    key: "deleteRelation",
    value: function deleteRelation() {
      for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
        args[_key7] = arguments[_key7];
      }
      return this.relationsOperation(_constants.OperationType.DELETE_RELATION, args);
    }

    /**
     *
     *  uow.[...]Relation(
     *      parentObject: OpResult|OpResultValue|Class,
     *      columnName: String,
     *      children: String|Class|OpResult|OpResultValue|List<String|Class|OpResult|OpResultValue>
     *    )
     *
     *  uow.[...]Relation(
     *      tableName: String,
     *      parentObject: String|Class|Object,
     *      columnName: String,
     *      children: String|Class|OpResult|OpResultValue|List<String|Class|OpResult|OpResultValue>
     *    )
     *
     * */
  }, {
    key: "relationsOperation",
    value: function relationsOperation(operationType, args) {
      var tableName;
      var relationColumn;
      var parentObject;
      var conditional;
      var unconditional;
      var children;
      if (args.length === 3) {
        parentObject = args[0];
        relationColumn = args[1];
        children = args[2];
        if (parentObject instanceof _opResult.OpResult || parentObject instanceof _opResultValueReference.OpResultValueReference) {
          tableName = parentObject.getTableName();
        } else if (parentObject && (0, _typeof2["default"])(parentObject) === 'object') {
          tableName = _utils["default"].getClassName(parentObject);
        } else {
          throw new Error('Invalid the first argument, it must be an instance of [OpResult|OpResultValueReference|Object]');
        }
      } else if (args.length === 4) {
        tableName = args[0];
        relationColumn = args[2];
        children = args[3];
        if (typeof args[1] === 'string') {
          parentObject = args[1];
        } else if (args[1] && (0, _typeof2["default"])(args[1]) === 'object') {
          parentObject = args[1];
        } else {
          throw new Error('Invalid the second argument, it must be an Object or objectId');
        }
      } else {
        throw new Error('Invalid arguments');
      }
      if (parentObject && parentObject.objectId) {
        parentObject = parentObject.objectId;
      }
      if (typeof children === 'string') {
        conditional = children;
      } else if (children instanceof _opResult.OpResult && children.isCollectionRef()) {
        unconditional = children;
      } else {
        if (!Array.isArray(children)) {
          children = [children];
        }
        unconditional = children.map(function (child) {
          if (child) {
            if (child instanceof _opResult.OpResult || child instanceof _opResultValueReference.OpResultValueReference) {
              return child;
            }
            if (typeof child === 'string') {
              return child;
            }
            if (child.objectId) {
              return child.objectId;
            }
          }
          throw new Error('Invalid child argument, it must be an instance of [OpResult|OpResultValueReference|Object] or objectId');
        });
      }
      if (!relationColumn || typeof relationColumn !== 'string') {
        throw new Error('Invalid "relationColumn" parameter, check passed arguments');
      }
      if (!unconditional && !conditional) {
        throw new Error('Neither "unconditional" nor "conditional" parameter is specified, check passed arguments');
      }
      if (!tableName || typeof tableName !== 'string') {
        throw new Error('Table Name must be a string.');
      }
      var payload = {
        parentObject: parentObject,
        relationColumn: relationColumn
      };
      if (conditional) {
        payload.conditional = conditional;
      } else {
        payload.unconditional = unconditional;
      }
      return this.addOperations(operationType, tableName, payload);
    }
  }]);
  return UnitOfWork;
}();
(0, _defineProperty2["default"])(UnitOfWork, "IsolationLevelEnum", _constants.IsolationLevelEnum);
(0, _defineProperty2["default"])(UnitOfWork, "OpResult", _opResult.OpResult);
(0, _defineProperty2["default"])(UnitOfWork, "OpResultValueReference", _opResultValueReference.OpResultValueReference);
function UnitOfWorkService(app) {
  return /*#__PURE__*/function (_UnitOfWork) {
    (0, _inherits2["default"])(_class, _UnitOfWork);
    var _super2 = _createSuper(_class);
    function _class(isolationLevelEnum) {
      (0, _classCallCheck2["default"])(this, _class);
      return _super2.call(this, isolationLevelEnum, app);
    }
    (0, _createClass2["default"])(_class, null, [{
      key: "initFromJSON",
      value: function initFromJSON(data) {
        var uow = new this(data.transactionIsolation);
        data.operations.forEach(function (op) {
          var opResult = _jsonAdapter.OperationJSONAdapter[op.operationType](uow, op);
          opResult.setOpResultId(op.opResultId);
        });
        return uow;
      }
    }]);
    return _class;
  }(UnitOfWork);
}