dataflux 1.0.4 → 1.1.0

package/dist/ObserverStore.js

@@ -21,11 +21,15 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 
 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 _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 _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 
 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
@@ -41,8 +45,30 @@ function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Re
 
 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(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 _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 _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+
+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 _getUniqueSubs = /*#__PURE__*/new WeakMap();
+
+var _propagateChange = /*#__PURE__*/new WeakMap();
+
+var _subscribeToObjects = /*#__PURE__*/new WeakMap();
+
+var _propagateInsertChange = /*#__PURE__*/new WeakSet();
+
 var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
   _inherits(ObserverStore, _PersistentStore);
 
@@ -55,15 +81,17 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
 
     _this = _super.call(this, options);
 
+    _classPrivateMethodInitSpec(_assertThisInitialized(_this), _propagateInsertChange);
+
     _defineProperty(_assertThisInitialized(_this), "subscribe", function (type, callback, filterFunction) {
       var subKey = (0, _uuid.v4)();
 
-      if (!_this.__subscribed[type]) {
-        _this.__subscribed[type] = {};
+      if (!_this._subscribed[type]) {
+        _this._subscribed[type] = {};
       }
 
       _this.find(type, filterFunction).then(function (data) {
-        _this._subscribeToObjects(type, data, {
+        _classPrivateFieldGet(_assertThisInitialized(_this), _subscribeToObjects).call(_assertThisInitialized(_this), type, data, {
           callback: callback,
           filterFunction: filterFunction,
           subKey: subKey
@@ -76,185 +104,204 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
     });
 
     _defineProperty(_assertThisInitialized(_this), "unsubscribe", function (key) {
-      for (var type in _this.__subscribed) {
-        for (var id in _this.__subscribed[type]) {
-          _this.__subscribed[type][id] = _this.__subscribed[type][id].filter(function (i) {
+      for (var type in _this._subscribed) {
+        for (var id in _this._subscribed[type]) {
+          _this._subscribed[type][id] = _this._subscribed[type][id].filter(function (i) {
             return i.subKey !== key;
           });
 
-          if (_this.__subscribed[type][id].length === 0) {
-            delete _this.__subscribed[type][id];
+          if (_this._subscribed[type][id].length === 0) {
+            delete _this._subscribed[type][id];
           }
         }
       }
     });
 
-    _defineProperty(_assertThisInitialized(_this), "_getUniqueSubs", function (objects, type) {
-      var out = {};
+    _classPrivateFieldInitSpec(_assertThisInitialized(_this), _getUniqueSubs, {
+      writable: true,
+      value: function value(objects, type) {
+        var out = {};
 
-      var _iterator = _createForOfIteratorHelper(objects),
-          _step;
+        var _iterator = _createForOfIteratorHelper(objects),
+            _step;
 
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var object = _step.value;
-          var objectId = object.getId();
-          var typeChannel = _this.__subscribed[type] || {};
-          var subscribedToObject = typeChannel[objectId] || [];
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var object = _step.value;
+            var objectId = object.getId();
+            var typeChannel = _this._subscribed[type] || {};
+            var subscribedToObject = typeChannel[objectId] || [];
 
-          var _iterator2 = _createForOfIteratorHelper(subscribedToObject),
-              _step2;
+            var _iterator2 = _createForOfIteratorHelper(subscribedToObject),
+                _step2;
 
-          try {
-            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-              var sub = _step2.value;
-              out[sub.subKey] = out[sub.subKey] || sub;
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                var sub = _step2.value;
+                out[sub.subKey] = out[sub.subKey] || sub;
+              }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
             }
-          } catch (err) {
-            _iterator2.e(err);
-          } finally {
-            _iterator2.f();
           }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
         }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
-      }
-
-      return Object.values(out);
-    });
-
-    _defineProperty(_assertThisInitialized(_this), "_propagateChange", function () {
-      var objects = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-
-      if (objects.length) {
-        var type = objects[0].getModel().getType();
 
-        var uniqueSubs = _this._getUniqueSubs(objects, type);
-
-        (0, _batchPromises["default"])(10, uniqueSubs, function (_ref) {
-          var callback = _ref.callback,
-              filterFunction = _ref.filterFunction;
-          return _this.find(type, filterFunction).then(callback);
-        });
+        return Object.values(out);
       }
     });
 
-    _defineProperty(_assertThisInitialized(_this), "_subscribeToObjects", function (type, objectsToSubscribe, item) {
-      var _iterator3 = _createForOfIteratorHelper(objectsToSubscribe),
-          _step3;
+    _classPrivateFieldInitSpec(_assertThisInitialized(_this), _propagateChange, {
+      writable: true,
+      value: function value() {
+        var objects = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
 
-      try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var object = _step3.value;
-          var id = object.getId();
+        if (objects.length) {
+          var type = objects[0].getModel().getType();
 
-          if (!_this.__subscribed[type][id]) {
-            _this.__subscribed[type][id] = [];
-          }
+          var uniqueSubs = _classPrivateFieldGet(_assertThisInitialized(_this), _getUniqueSubs).call(_assertThisInitialized(_this), objects, type);
 
-          _this.__subscribed[type][id].push(item);
+          (0, _batchPromises["default"])(10, uniqueSubs, function (_ref) {
+            var callback = _ref.callback,
+                filterFunction = _ref.filterFunction;
+            return _this.find(type, filterFunction).then(callback);
+          });
         }
-      } catch (err) {
-        _iterator3.e(err);
-      } finally {
-        _iterator3.f();
+
+        return objects;
       }
     });
 
-    _defineProperty(_assertThisInitialized(_this), "_propagateInsertChange", function (type, newObjects) {
-      var uniqueSubs = {};
-      var objects = Object.values(_this.__subscribed[type]);
-
-      for (var _i = 0, _objects = objects; _i < _objects.length; _i++) {
-        var object = _objects[_i];
-
-        var _iterator4 = _createForOfIteratorHelper(object),
-            _step4;
+    _classPrivateFieldInitSpec(_assertThisInitialized(_this), _subscribeToObjects, {
+      writable: true,
+      value: function value(type, objectsToSubscribe, item) {
+        var _iterator3 = _createForOfIteratorHelper(objectsToSubscribe),
+            _step3;
 
         try {
-          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-            var sub = _step4.value;
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var object = _step3.value;
+            var id = object.getId();
 
-            if (!uniqueSubs[sub.subKey]) {
-              uniqueSubs[sub.subKey] = sub;
+            if (!_this._subscribed[type][id]) {
+              _this._subscribed[type][id] = [];
             }
+
+            _this._subscribed[type][id].push(item);
           }
         } catch (err) {
-          _iterator4.e(err);
+          _iterator3.e(err);
         } finally {
-          _iterator4.f();
+          _iterator3.f();
         }
       }
+    });
 
-      var possibleSubs = Object.values(uniqueSubs);
-      (0, _batchPromises["default"])(10, possibleSubs, function (_ref2) {
-        var callback = _ref2.callback,
-            filterFunction = _ref2.filterFunction;
-        var objectsToSubscribe = filterFunction ? newObjects.filter(filterFunction) : newObjects;
+    _this._subscribed = {};
+    return _this;
+  }
 
-        if (objectsToSubscribe.length) {
-          // Check if the new objects matter
-          return _this.find(type, filterFunction).then(function (data) {
-            var subKey;
+  _createClass(ObserverStore, [{
+    key: "update",
+    value: function update(objects) {
+      return _get(_getPrototypeOf(ObserverStore.prototype), "update", this).call(this, objects).then(_classPrivateFieldGet(this, _propagateChange));
+    }
+  }, {
+    key: "insert",
+    value: function insert(type, objects) {
+      var _this2 = this;
+
+      objects = Array.isArray(objects) ? objects : [objects];
+      return _get(_getPrototypeOf(ObserverStore.prototype), "insert", this).call(this, type, objects).then(function (objects) {
+        _classPrivateMethodGet(_this2, _propagateInsertChange, _propagateInsertChange2).call(_this2, type, objects);
+
+        return objects;
+      });
+    }
+  }, {
+    key: "delete",
+    value: function _delete(typeOrObjects, filterFunction) {
+      return _get(_getPrototypeOf(ObserverStore.prototype), "delete", this).call(this, typeOrObjects, filterFunction).then(_classPrivateFieldGet(this, _propagateChange));
+    }
+  }]);
+
+  return ObserverStore;
+}(_PersistentStore2["default"]);
 
-            var _iterator5 = _createForOfIteratorHelper(data),
-                _step5;
+function _propagateInsertChange2(type, newObjects) {
+  var _this3 = this;
 
-            try {
-              for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-                var d = _step5.value;
+  if (this._subscribed[type]) {
+    var uniqueSubs = {};
+    var objects = Object.values(this._subscribed[type]);
 
-                var item = _this.__subscribed[d.getModel().getType()][d.getId()];
+    for (var _i = 0, _objects = objects; _i < _objects.length; _i++) {
+      var object = _objects[_i];
 
-                subKey = item ? item.subKey : null;
-                if (subKey) break;
-              }
-            } catch (err) {
-              _iterator5.e(err);
-            } finally {
-              _iterator5.f();
-            }
+      var _iterator4 = _createForOfIteratorHelper(object),
+          _step4;
 
-            _this._subscribeToObjects(type, objectsToSubscribe, {
-              callback: callback,
-              filterFunction: filterFunction,
-              subKey: subKey
-            });
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var sub = _step4.value;
 
-            return data;
-          }).then(callback);
+          if (!uniqueSubs[sub.subKey]) {
+            uniqueSubs[sub.subKey] = sub;
+          }
         }
-      });
-    });
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+    }
 
-    _defineProperty(_assertThisInitialized(_this), "trigger", function (event, objects) {
-      switch (event) {
-        case "insert":
-          if (objects[0]) _this._propagateInsertChange(objects[0].getModel().getType(), objects);
-          break;
+    var possibleSubs = Object.values(uniqueSubs);
+    (0, _batchPromises["default"])(10, possibleSubs, function (_ref2) {
+      var callback = _ref2.callback,
+          filterFunction = _ref2.filterFunction;
+      var objectsToSubscribe = filterFunction ? newObjects.filter(filterFunction) : newObjects;
 
-        case "update":
-          _this._propagateChange(objects);
+      if (objectsToSubscribe.length) {
+        // Check if the new objects matter
+        return _this3.find(type, filterFunction).then(function (data) {
+          var subKey;
 
-          break;
+          var _iterator5 = _createForOfIteratorHelper(data),
+              _step5;
 
-        case "delete":
-          _this._propagateChange(objects);
+          try {
+            for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+              var d = _step5.value;
 
-          break;
-      }
+              var item = _this3._subscribed[d.getModel().getType()][d.getId()];
 
-      _this.delayedSave();
-    });
+              subKey = item ? item.subKey : null;
+              if (subKey) break;
+            }
+          } catch (err) {
+            _iterator5.e(err);
+          } finally {
+            _iterator5.f();
+          }
 
-    _this.__subscribed = {};
-    return _this;
-  }
+          _classPrivateFieldGet(_this3, _subscribeToObjects).call(_this3, type, objectsToSubscribe, {
+            callback: callback,
+            filterFunction: filterFunction,
+            subKey: subKey
+          });
 
-  return _createClass(ObserverStore);
-}(_PersistentStore2["default"]);
+          return data;
+        }).then(callback);
+      }
+    });
+  }
+}
 
 var _default = ObserverStore;
 exports["default"] = _default;

package/dist/PersistentStore.js

@@ -9,19 +9,19 @@ exports["default"] = void 0;
 
 var _Store2 = _interopRequireDefault(require("./Store"));
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": 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; } } }; }
+var _axios = _interopRequireDefault(require("axios"));
 
-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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
-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 _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 _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 
 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
@@ -51,98 +51,130 @@ var PersistentStore = /*#__PURE__*/function (_Store) {
 
     _this = _super.call(this, options);
 
-    _defineProperty(_assertThisInitialized(_this), "_saveType", function (type) {
-      return _this._getSets(type).then(function (_ref) {
+    _defineProperty(_assertThisInitialized(_this), "save", function () {
+      _this._busy = true;
+
+      _this.pubSub.publish("save", "start");
+
+      return Promise.all(Object.keys(_this.models).map(_this._saveByType)).then(function (data) {
+        _this._busy = false;
+
+        _this.pubSub.publish("save", "end");
+
+        return data;
+      })["catch"](function (error) {
+        _this._busy = false;
+
+        _this.pubSub.publish("save", "end");
+
+        _this.pubSub.publish("error", error);
+
+        return Promise.reject(error);
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "_saveByType", function (type) {
+      return _this.getDiff(type).then(function (_ref) {
         var inserted = _ref.inserted,
             updated = _ref.updated,
             deleted = _ref.deleted;
-        return _this.models[type].model.insertObjects(inserted).then(function () {
-          return _this.models[type].model.updateObjects(updated);
+        var model = _this.models[type].model; // Operations order:
+        // 1) insert
+        // 2) update
+        // 3) delete
+
+        return model.insertObjects(inserted).then(function () {
+          return _this.applyDiff({
+            inserted: inserted
+          }, type);
         }).then(function () {
-          return _this.models[type].model.deleteObjects(deleted);
+          return model.updateObjects(updated);
         }).then(function () {
-          var _iterator = _createForOfIteratorHelper(deleted),
-              _step;
-
-          try {
-            for (_iterator.s(); !(_step = _iterator.n()).done;) {
-              var object = _step.value;
-              delete _this.models[type].storedObjects[object.id];
-            }
-          } catch (err) {
-            _iterator.e(err);
-          } finally {
-            _iterator.f();
-          }
-
-          var _iterator2 = _createForOfIteratorHelper(updated.concat(inserted)),
-              _step2;
-
-          try {
-            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-              var _object = _step2.value;
-              _this.models[type].storedObjects[_object.id].fingerprint = _object.object.getFingerprint();
-              _this.models[type].storedObjects[_object.id].status = "old";
-            }
-          } catch (err) {
-            _iterator2.e(err);
-          } finally {
-            _iterator2.f();
-          }
-        });
-      });
-    });
-
-    _defineProperty(_assertThisInitialized(_this), "_getSets", function (type) {
-      return _this._getPromise(type).then(function () {
-        var objects = Object.values(_this.models[type].storedObjects);
-        var newObjects = objects.filter(function (object) {
-          return object.status === "new";
-        });
-        var edited = objects.filter(function (object) {
-          return object.status === "old" && object.fingerprint !== object.object.getFingerprint();
-        });
-        var deleted = objects.filter(function (object) {
-          return object.status === "deleted";
+          return _this.applyDiff({
+            updated: updated
+          }, type);
+        }).then(function () {
+          return model.deleteObjects(deleted);
+        }).then(function () {
+          return _this.applyDiff({
+            deleted: deleted
+          }, type);
         });
-        return {
-          inserted: newObjects,
-          updated: edited,
-          deleted: deleted
-        };
       });
     });
 
-    _defineProperty(_assertThisInitialized(_this), "save", function () {
-      return Promise.all(Object.keys(_this.models).map(_this._saveType));
-    });
-
     _defineProperty(_assertThisInitialized(_this), "delayedSave", function () {
       if (_this.options.autoSave) {
-        if (_this.__delayedSaveTimer) {
-          clearTimeout(_this.__delayedSaveTimer);
+        if (_this._delayedSaveTimer) {
+          clearTimeout(_this._delayedSaveTimer);
         }
 
-        _this.__delayedSaveTimer = setTimeout(_this.save, _this.options.saveDelay);
+        _this._delayedSaveTimer = setTimeout(_this.save, _this.options.saveDelay);
       }
-
-      return Promise.resolve();
     });
 
-    _defineProperty(_assertThisInitialized(_this), "trigger", function (event, objects) {
-      if (["insert", "delete", "update"].includes(event)) {
-        _this.delayedSave();
-      }
-    });
+    _this.axios = options.axios || _axios["default"];
+    _this._busy = false;
+    _this._delayedSaveTimer = null;
 
     if (typeof _this.options.autoSave === "number") {
-      setInterval(_this.delayedSave, _this.options.autoSave);
+      setInterval(function () {
+        if (!_this._busy) {
+          _this.delayedSave();
+        }
+      }, _this.options.autoSave);
     }
 
     return _this;
   }
 
-  return _createClass(PersistentStore);
+  _createClass(PersistentStore, [{
+    key: "addModel",
+    value: function addModel(model) {
+      var _this2 = this;
+
+      this._busy = true;
+
+      _get(_getPrototypeOf(PersistentStore.prototype), "addModel", this).call(this, model).then(function () {
+        _this2._busy = false;
+      });
+    }
+  }, {
+    key: "insert",
+    value: function insert(type, objects) {
+      var _this3 = this;
+
+      return _get(_getPrototypeOf(PersistentStore.prototype), "insert", this).call(this, type, objects).then(function (data) {
+        _this3.delayedSave();
+
+        return data;
+      });
+    }
+  }, {
+    key: "delete",
+    value: function _delete(typeOrObjects, filterFunction) {
+      var _this4 = this;
+
+      return _get(_getPrototypeOf(PersistentStore.prototype), "delete", this).call(this, typeOrObjects, filterFunction).then(function (data) {
+        _this4.delayedSave();
+
+        return data;
+      });
+    }
+  }, {
+    key: "update",
+    value: function update(objects) {
+      var _this5 = this;
+
+      return _get(_getPrototypeOf(PersistentStore.prototype), "update", this).call(this, objects).then(function (data) {
+        _this5.delayedSave();
+
+        return data;
+      });
+    }
+  }]);
+
+  return PersistentStore;
 }(_Store2["default"]);
 
 exports["default"] = PersistentStore;