dataflux 1.0.4 → 1.2.0

package/dist/PubSub.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { 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(_e) { throw _e; }, 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 = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+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 _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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+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 PubSub = /*#__PURE__*/_createClass(function PubSub() {
+  var _this = this;
+
+  _classCallCheck(this, PubSub);
+
+  _defineProperty(this, "subscribe", function (channel, callback) {
+    _this.callbacks[channel] = _this.callbacks[channel] || [];
+
+    _this.callbacks[channel].push(callback);
+  });
+
+  _defineProperty(this, "publish", function (channel, content) {
+    var _iterator = _createForOfIteratorHelper(_this.callbacks[channel] || []),
+        _step;
+
+    try {
+      var _loop = function _loop() {
+        var clb = _step.value;
+        new Promise(function (resolve, reject) {
+          clb(content, channel);
+          resolve(true);
+        })["catch"](console.log);
+      };
+
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        _loop();
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  });
+
+  this.callbacks = {};
+});
+
+exports["default"] = PubSub;

package/dist/ReactStore.js

@@ -39,6 +39,12 @@ function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.g
 
 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; }
 
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { 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(_e) { throw _e; }, 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 = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 
 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); }
@@ -73,6 +79,8 @@ var addSubscriptionToContext = function addSubscriptionToContext(context, subKey
   };
 };
 
+var _fixState = /*#__PURE__*/new WeakSet();
+
 var ReactStore = /*#__PURE__*/function (_ObserverStore) {
   _inherits(ReactStore, _ObserverStore);
 
@@ -85,6 +93,8 @@ var ReactStore = /*#__PURE__*/function (_ObserverStore) {
 
     _this2 = _super.call(this, options);
 
+    _classPrivateMethodInitSpec(_assertThisInitialized(_this2), _fixState);
+
     _defineProperty(_assertThisInitialized(_this2), "handleChange", function (object, name) {
       return function (event, rawValue) {
         var value = event ? event.target.type === "checkbox" ? event.target.checked : event.target.value : "";
@@ -98,14 +108,18 @@ var ReactStore = /*#__PURE__*/function (_ObserverStore) {
   _createClass(ReactStore, [{
     key: "findAll",
     value: function findAll(type, stateAttribute, context, filterFunction) {
+      _classPrivateMethodGet(this, _fixState, _fixState2).call(this, stateAttribute, context);
+
       var subKey = this.subscribe(type, function (data) {
-        context.setState(_objectSpread(_objectSpread({}, context.state), {}, _defineProperty({}, stateAttribute, data)));
+        context.setState(_objectSpread(_objectSpread({}, context.state), {}, _defineProperty({}, stateAttribute, data || [])));
       }, filterFunction);
       addSubscriptionToContext(context, subKey);
     }
   }, {
     key: "findOne",
     value: function findOne(type, stateAttribute, context, filterFunction) {
+      _classPrivateMethodGet(this, _fixState, _fixState2).call(this, stateAttribute, context);
+
       var subKey = this.subscribe(type, function (data) {
         context.setState(_objectSpread(_objectSpread({}, context.state), {}, _defineProperty({}, stateAttribute, data && data.length ? data[0] : null)));
       }, filterFunction);
@@ -116,4 +130,10 @@ var ReactStore = /*#__PURE__*/function (_ObserverStore) {
   return ReactStore;
 }(_ObserverStore2["default"]);
 
-exports["default"] = ReactStore;
+exports["default"] = ReactStore;
+
+function _fixState2(stateAttribute, context) {
+  if (!context[stateAttribute]) {
+    context[stateAttribute] = []; // side effect on state
+  }
+}

package/dist/Store.js

@@ -7,202 +7,346 @@ exports["default"] = void 0;
 
 var _StoreObject = _interopRequireDefault(require("./StoreObject"));
 
-var _fingerprint = _interopRequireDefault(require("./fingerprint"));
+var _PubSub = _interopRequireDefault(require("./PubSub"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
-function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
-
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { 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(_e) { throw _e; }, 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 = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 
 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 _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-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; }
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
 
-var Store = /*#__PURE__*/_createClass(function Store() {
-  var _this = this;
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
 
-  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
 
-  _classCallCheck(this, Store);
+var _deleteByObject = /*#__PURE__*/new WeakSet();
 
-  _defineProperty(this, "validateModel", function (model) {
-    var type = model.getType();
+var _deleteByFilter = /*#__PURE__*/new WeakSet();
 
-    if (typeof type !== "string" || type === "") {
-      throw new Error("Not valid model object: type missing");
-    }
-  });
+var _getPromise = /*#__PURE__*/new WeakSet();
 
-  _defineProperty(this, "addModel", function (model) {
-    _this.validateModel(model);
+var _insertObject = /*#__PURE__*/new WeakSet();
 
-    var type = model.getType();
+var _loadObjects = /*#__PURE__*/new WeakSet();
 
-    if (!_this.models[type]) {
-      _this.models[type] = {
-        model: model,
-        storedObjects: {}
-      };
-      model.store = _this;
+var Store = /*#__PURE__*/function () {
+  function Store() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
-      if (!_this.options.lazyLoad) {
-        _this._loadObjects(type);
-      }
-    } else {
-      throw new Error("The model already exists");
-    }
-  });
+    _classCallCheck(this, Store);
 
-  _defineProperty(this, "_getPromise", function (type) {
-    if (!_this.models[type]) {
-      return Promise.reject("The model doesn't exist");
-    } else if (!_this.models[type].promise && !_this.options.lazyLoad) {
-      return Promise.reject("The model is not loaded");
-    } else if (!_this.models[type].promise && _this.options.lazyLoad) {
-      return _this._loadObjects(type).then(function () {
-        return _this.models[type].promise;
-      });
-    } else {
-      return _this.models[type].promise;
-    }
-  });
+    _classPrivateMethodInitSpec(this, _loadObjects);
 
-  _defineProperty(this, "_insertObject", function (type, item) {
-    var markAsNew = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    var model = _this.models[type].model;
-    var wrapper = new _StoreObject["default"](item, model);
-    var id = wrapper.getId();
+    _classPrivateMethodInitSpec(this, _insertObject);
 
-    if (_this.models[type].storedObjects[id]) {
-      throw new Error("The IDs provided for the model ".concat(type, " are not unique"));
-    }
+    _classPrivateMethodInitSpec(this, _getPromise);
 
-    _this.models[type].storedObjects[id] = {
-      id: id,
-      fingerprint: wrapper.getFingerprint(),
-      object: wrapper,
-      status: markAsNew ? "new" : "old"
-    };
-    return wrapper;
-  });
+    _classPrivateMethodInitSpec(this, _deleteByFilter);
 
-  _defineProperty(this, "_loadObjects", function (type) {
-    var item = _this.models[type];
-    return item.promise = item.model.retrieveAll().then(function (items) {
-      var _iterator = _createForOfIteratorHelper(items),
-          _step;
+    _classPrivateMethodInitSpec(this, _deleteByObject);
 
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var _item = _step.value;
+    this.options = {
+      autoSave: options.autoSave !== undefined ? options.autoSave : 5000,
+      saveDelay: options.saveDelay || 1000,
+      lazyLoad: options.lazyLoad || false
+    };
+    this.models = {};
+    this.pubSub = new _PubSub["default"]();
+  }
+
+  _createClass(Store, [{
+    key: "on",
+    value: function on(channel, callback) {
+      this.pubSub.subscribe(channel, callback);
+    }
+  }, {
+    key: "validateModel",
+    value: function validateModel(model) {
+      var type = model.getType();
 
-          _this._insertObject(type, _item, false);
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
+      if (typeof type !== "string" || type === "") {
+        throw new Error("Not valid model object: type missing");
       }
-    });
-  });
-
-  _defineProperty(this, "get", function (type, id) {
-    return _this._getPromise(type).then(function () {
-      try {
-        _this.models[type].storedObjects[id].object;
-      } catch (error) {
-        return Promise.reject("Object not found");
+    }
+  }, {
+    key: "addModel",
+    value: function addModel(model) {
+      var _this = this;
+
+      return new Promise(function (resolve, reject) {
+        _this.validateModel(model);
+
+        var type = model.getType();
+
+        if (!_this.models[type]) {
+          _this.models[type] = {
+            model: model,
+            storedObjects: {}
+          };
+          model.setStore(_this);
+
+          if (!_this.options.lazyLoad) {
+            resolve(_classPrivateMethodGet(_this, _loadObjects, _loadObjects2).call(_this, type));
+          } else {
+            resolve();
+          }
+        } else {
+          reject("The model already exists");
+        }
+      });
+    }
+  }, {
+    key: "update",
+    value: function update(objects) {
+      return Promise.resolve(); // Nothing to do at this level
+    }
+  }, {
+    key: "delete",
+    value: function _delete(typeOrObjects, filterFunction) {
+      if (typeof typeOrObjects === "string" && typeof filterFunction === "function") {
+        return _classPrivateMethodGet(this, _deleteByFilter, _deleteByFilter2).call(this, typeOrObjects, filterFunction);
+      } else if (_typeof(typeOrObjects) === "object" && typeOrObjects.length) {
+        return Promise.all(typeOrObjects.map(_classPrivateMethodGet(this, _deleteByObject, _deleteByObject2)));
+      } else {
+        return Promise.reject("Invalid delete request. You have to provide a list of objects or a type and a filter function");
       }
-    });
-  });
-
-  _defineProperty(this, "find", function (type, filterFunction) {
-    return _this._getPromise(type).then(function () {
-      var all = Object.values(_this.models[type].storedObjects).filter(function (i) {
-        return i.status !== "deleted";
-      }).map(function (i) {
-        return i.object;
+    }
+  }, {
+    key: "insert",
+    value: function insert(type, objects) {
+      var _this2 = this;
+
+      return _classPrivateMethodGet(this, _getPromise, _getPromise2).call(this, type).then(function () {
+        return objects.map(function (object) {
+          return _classPrivateMethodGet(_this2, _insertObject, _insertObject2).call(_this2, type, object, true);
+        });
       });
-      return filterFunction ? all.filter(filterFunction) : all;
-    });
-  });
-
-  _defineProperty(this, "_deleteByObject", function (object) {
-    return _this._deleteByFilter(object.getType(), function (item) {
-      return (0, _fingerprint["default"])(object) === (0, _fingerprint["default"])(item);
-    });
-  });
-
-  _defineProperty(this, "_deleteByFilter", function (type, filterFunction) {
-    return _this._getPromise(type).then(function () {
-      var deleted = Object.values(_this.models[type].storedObjects).filter(function (i) {
-        return filterFunction(i.object);
+    }
+  }, {
+    key: "get",
+    value: function get(type, id) {
+      var _this3 = this;
+
+      return _classPrivateMethodGet(this, _getPromise, _getPromise2).call(this, type).then(function () {
+        try {
+          return _this3.models[type].storedObjects[id].object;
+        } catch (error) {
+          return Promise.reject("Object not found");
+        }
+      });
+    }
+  }, {
+    key: "find",
+    value: function find(type, filterFunction) {
+      var _this4 = this;
+
+      return _classPrivateMethodGet(this, _getPromise, _getPromise2).call(this, type).then(function () {
+        var all = Object.values(_this4.models[type].storedObjects).filter(function (i) {
+          return i.status !== "deleted";
+        }).map(function (i) {
+          return i.object;
+        });
+        return filterFunction ? all.filter(filterFunction) : all;
+      })["catch"](function (error) {
+        _this4.pubSub.publish("error", error);
+
+        return Promise.reject(error);
+      });
+    }
+  }, {
+    key: "applyDiff",
+    value: function applyDiff(_ref, type) {
+      var _this5 = this;
+
+      var _ref$inserted = _ref.inserted,
+          inserted = _ref$inserted === void 0 ? [] : _ref$inserted,
+          _ref$updated = _ref.updated,
+          updated = _ref$updated === void 0 ? [] : _ref$updated,
+          _ref$deleted = _ref.deleted,
+          deleted = _ref$deleted === void 0 ? [] : _ref$deleted;
+      return new Promise(function (resolve, reject) {
+        try {
+          var _iterator = _createForOfIteratorHelper(inserted.concat(updated)),
+              _step;
+
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var object = _step.value;
+
+              var item = _this5.models[type || object.object.getModel().getType()].storedObjects[object.id];
+
+              item.fingerprint = object.object.getFingerprint();
+              item.status = "old";
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+
+          var _iterator2 = _createForOfIteratorHelper(deleted),
+              _step2;
+
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var _object = _step2.value;
+              delete _this5.models[type || _object.object.getModel().getType()].storedObjects[_object.id];
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+
+          resolve();
+        } catch (error) {
+          return reject(error);
+        }
       });
+    }
+  }, {
+    key: "getDiff",
+    value: function getDiff(type) {
+      var _this6 = this;
+
+      return _classPrivateMethodGet(this, _getPromise, _getPromise2).call(this, type).then(function () {
+        var objects = Object.values(_this6.models[type].storedObjects);
+        var inserted = [];
+        var updated = [];
+        var deleted = [];
+
+        for (var _i = 0, _objects = objects; _i < _objects.length; _i++) {
+          var object = _objects[_i];
+
+          if (object.status === "new") {
+            inserted.push(object);
+          } else if (object.status === "deleted") {
+            deleted.push(object);
+          } else if (object.fingerprint !== object.object.getFingerprint()) {
+            updated.push(object);
+          }
+        }
 
-      var _iterator2 = _createForOfIteratorHelper(deleted),
-          _step2;
+        return {
+          inserted: inserted,
+          updated: updated,
+          deleted: deleted
+        };
+      });
+    }
+  }]);
 
-      try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          var object = _step2.value;
-          object.status = "deleted";
-        }
-      } catch (err) {
-        _iterator2.e(err);
-      } finally {
-        _iterator2.f();
-      }
+  return Store;
+}();
 
-      _this.trigger("delete", deleted.map(function (i) {
-        return i.object;
-      }));
+exports["default"] = Store;
 
-      return true;
-    });
+function _deleteByObject2(object) {
+  return _classPrivateMethodGet(this, _deleteByFilter, _deleteByFilter2).call(this, object.getType(), function (item) {
+    return object.getId() === item.getId();
   });
+}
 
-  _defineProperty(this, "delete", function (typeOrObjects, filterFunction) {
-    if (typeof typeOrObjects === "string" && typeof filterFunction === "function") {
-      return _this._deleteByFilter(typeOrObjects, filterFunction);
-    } else if (_typeof(typeOrObjects) === "object" && typeOrObjects.length) {
-      return Promise.all(typeOrObjects.map(_this._deleteByObject));
-    } else {
-      throw new Error("Invalid delete request. You have to provide a list of objects or a type and a filter function");
-    }
-  });
+function _deleteByFilter2(type, filterFunction) {
+  var _this7 = this;
 
-  _defineProperty(this, "insert", function (type, object) {
-    return _this._getPromise(type).then(function () {
-      var newObj = _this._insertObject(type, object, true);
+  return _classPrivateMethodGet(this, _getPromise, _getPromise2).call(this, type).then(function () {
+    var deleted = Object.values(_this7.models[type].storedObjects).filter(function (i) {
+      return filterFunction(i.object);
+    });
 
-      _this.trigger("insert", [newObj]);
+    var _iterator3 = _createForOfIteratorHelper(deleted),
+        _step3;
 
-      return true;
-    });
-  });
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var object = _step3.value;
+        object.status = "deleted";
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
 
-  _defineProperty(this, "update", function (objects) {
-    _this.trigger("update", objects);
+    return true;
   });
+}
+
+function _getPromise2(type) {
+  var _this8 = this;
+
+  if (!this.models[type]) {
+    return Promise.reject("The model doesn't exist");
+  } else if (!this.models[type].promise && !this.options.lazyLoad) {
+    return Promise.reject("The model is not loaded");
+  } else if (!this.models[type].promise && this.options.lazyLoad) {
+    return _classPrivateMethodGet(this, _loadObjects, _loadObjects2).call(this, type).then(function () {
+      return _this8.models[type].promise;
+    });
+  } else {
+    return this.models[type].promise;
+  }
+}
+
+function _insertObject2(type, item) {
+  var markAsNew = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var model = this.models[type].model;
+  var wrapper = new _StoreObject["default"](item, model);
+  var id = wrapper.getId();
+
+  if (this.models[type].storedObjects[id]) {
+    throw new Error("The IDs provided for the model ".concat(type, " are not unique"));
+  }
+
+  this.models[type].storedObjects[id] = {
+    id: id,
+    fingerprint: wrapper.getFingerprint(),
+    object: wrapper,
+    status: markAsNew ? "new" : "old"
+  };
+  return wrapper;
+}
 
-  _defineProperty(this, "trigger", function (event, objects) {// Nothing here
+function _loadObjects2(type) {
+  var _this9 = this;
+
+  var item = this.models[type];
+  this.pubSub.publish("loading", {
+    status: "start",
+    model: type
   });
+  return item.promise = item.model.retrieveAll().then(function (items) {
+    var _iterator4 = _createForOfIteratorHelper(items),
+        _step4;
 
-  this.options = {
-    autoSave: options.autoSave || 3000,
-    saveDelay: options.autoSave || 1000,
-    lazyLoad: options.lazyLoad || false
-  };
-  this.models = {};
-});
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var _item = _step4.value;
+
+        _classPrivateMethodGet(_this9, _insertObject, _insertObject2).call(_this9, type, _item, false);
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
 
-exports["default"] = Store;
+    _this9.pubSub.publish("loading", {
+      status: "end",
+      model: type
+    });
+  });
+}

package/dist/StoreObject.js

@@ -19,11 +19,44 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
 
 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; }
 
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+
+var _loaded = /*#__PURE__*/new WeakMap();
+
 var Obj = /*#__PURE__*/_createClass(function Obj(values, model) {
   var _this = this;
 
   _classCallCheck(this, Obj);
 
+  _classPrivateFieldInitSpec(this, _loaded, {
+    writable: true,
+    value: false
+  });
+
+  _defineProperty(this, "load", function () {
+    if (_classPrivateFieldGet(_this, _loaded)) {
+      return Promise.resolve(_this);
+    } else {
+      return _this.getModel().load(_this).then(function () {
+        _classPrivateFieldSet(_this, _loaded, true);
+
+        return _this;
+      });
+    }
+  });
+
   _defineProperty(this, "getFingerprint", function () {
     return (0, _fingerprint["default"])(_this.toJson());
   });