rollun-ts-datastore/dist/clients/LocalDataClient.js

rollun-datastore written in TS

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _rollunTsRql = require("rollun-ts-rql");

var _fp = _interopRequireDefault(require("lodash/fp"));

var _QueryNodeHandlerFactory = require("../utils/QueryNodeHandlerFactory");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

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) { _defineProperty(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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

var LocalDataClient = function () {
  function LocalDataClient(options) {
    _classCallCheck(this, LocalDataClient);

    _defineProperty(this, "identifier", void 0);

    _defineProperty(this, "data", void 0);

    this.data = options && options.initialData || [];
    this.identifier = options && options.idField || 'id';
  }

  _createClass(LocalDataClient, [{
    key: "getDataLength",
    value: function getDataLength() {
      return this.data.length;
    }
  }, {
    key: "delete",
    value: function _delete(id) {
      var _this = this;

      var removedItem = null;
      this.data = this.data.filter(function (el) {
        if (el[_this.identifier] === id) {
          removedItem = el;
          return false;
        }

        return true;
      });

      if (!removedItem) {
        throw new Error("Could not find item with key identifier ".concat(id, " to delete"));
      }

      return removedItem;
    }
  }, {
    key: "read",
    value: function read(id) {
      var _this2 = this;

      return this.data.find(function (el) {
        return el[_this2.identifier] === id;
      });
    }
  }, {
    key: "get",
    value: function get(query) {
      if (!query) {
        return this.data;
      }

      return _fp["default"].compose(this._getLimitHandler(query.limitNode), this._getSortHandler(query.sortNode), this._getSelectAndGroupByHandler(query.selectNode), this._getGroupByHandler(query.groupNode), this._getQueryHandler(query.queryNode))(this.data);
    }
  }, {
    key: "update",
    value: function update(item) {
      var _this3 = this;

      var id = item[this.identifier];

      if (!id) {
        throw new TypeError("Item does not have key identifier [".concat(this.identifier, "]"));
      }

      var updatedItem = null;
      this.data = this.data.map(function (el) {
        if (el[_this3.identifier] === id) {
          updatedItem = _objectSpread(_objectSpread({}, el), item);
          return updatedItem;
        }

        return el;
      });

      if (updatedItem) {
        return updatedItem;
      }

      throw new Error("Could not find item with key identifier ".concat(id, " to update"));
    }
  }, {
    key: "create",
    value: function create(item) {
      var _this4 = this;

      var id = item[this.identifier];

      if (!id) {
        throw new Error('Item does not have key identifier');
      }

      var existingItem = this.data.find(function (el) {
        return el[_this4.identifier] === id;
      });

      if (existingItem) {
        throw new Error("Item with key identifier ".concat(id, " already exists"));
      }

      this.data = this.data.concat(item);
      return item;
    }
  }, {
    key: "_getSortHandler",
    value: function _getSortHandler(node) {
      if (!node) {
        return function (data) {
          return data;
        };
      }

      return function (data) {
        return data.sort(function (a, b) {
          var sortOptions = Object.entries(node.sortOptions);

          for (var _i = 0, _sortOptions = sortOptions; _i < _sortOptions.length; _i++) {
            var sortOption = _sortOptions[_i];

            var _sortOption = _slicedToArray(sortOption, 2),
                _key = _sortOption[0],
                value = _sortOption[1];

            if (!a.hasOwnProperty(_key) || !b.hasOwnProperty(_key)) {
              throw new Error("Field ".concat(_key, " does not exist in list"));
            }

            if (a[_key] > b[_key]) {
              return 1 * value;
            } else if (a[_key] < b[_key]) {
              return -1 * value;
            }
          }

          return 0;
        });
      };
    }
  }, {
    key: "_getLimitHandler",
    value: function _getLimitHandler(node) {
      if (!node) {
        return function (data) {
          return data;
        };
      }

      return function (data) {
        return data.slice(node.offset, node.offset + node.limit);
      };
    }
  }, {
    key: "_getSelectAndGroupByHandler",
    value: function _getSelectAndGroupByHandler(node) {
      if (!node) {
        return function (data) {
          return data;
        };
      }

      return function (data) {
        return data.map(function (el) {
          var newItem = {};
          node.fields.forEach(function (field) {
            if (field instanceof _rollunTsRql.AggregateFunctionNode) {} else {
              if (el.hasOwnProperty(field)) {
                newItem[field] = el[field];
              } else {
                throw new Error("Field ".concat(field, " does not exist in list"));
              }
            }
          });
          return newItem;
        });
      };
    }
  }, {
    key: "_getItemHandlerRecursively",
    value: function _getItemHandlerRecursively(node) {
      if (node instanceof _rollunTsRql.AbstractLogicalNode) {
        var handlers = new Array(node.subNodes.length);

        for (var i = 0; i < node.subNodes.length; i++) {
          handlers[i] = this._getItemHandlerRecursively(node.subNodes[i]);
        }

        return (0, _QueryNodeHandlerFactory.logicalNodesHandlersFactory)(node)(handlers);
      } else {
        return (0, _QueryNodeHandlerFactory.queryNodeHandlerFactory)(node);
      }
    }
  }, {
    key: "_getGroupByHandler",
    value: function _getGroupByHandler(node) {
      if (!node) {
        return function (data) {
          return data;
        };
      }

      var checkIfElementExists = function checkIfElementExists(array, el) {
        var _iterator = _createForOfIteratorHelper(node.fields),
            _step;

        try {
          var _loop = function _loop() {
            var field = _step.value;

            if (!el.hasOwnProperty(field)) {
              throw new Error("Field ".concat(field, " does not exist in list"));
            }

            if (!array.find(function (e) {
              return e[field] === el[field];
            })) {
              return {
                v: false
              };
            }
          };

          for (_iterator.s(); !(_step = _iterator.n()).done;) {
            var _ret = _loop();

            if (_typeof(_ret) === "object") return _ret.v;
          }
        } catch (err) {
          _iterator.e(err);
        } finally {
          _iterator.f();
        }

        return true;
      };

      var reducer = function reducer(acc, el) {
        return checkIfElementExists(acc, el) ? acc : acc.concat(el);
      };

      return function (data) {
        return data.reduce(reducer, []);
      };
    }
  }, {
    key: "_getQueryHandler",
    value: function _getQueryHandler(node) {
      if (!node) {
        return function (data) {
          return data;
        };
      }

      var handler = this._getItemHandlerRecursively(node);

      return function (data) {
        return data.filter(handler);
      };
    }
  }]);

  return LocalDataClient;
}();

exports["default"] = LocalDataClient;