dataflux 1.8.0 → 1.9.0

package/dist/ObserverStore.js

@@ -311,6 +311,18 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
       });
     }
   }, {
+    key: "mock",
+    value: function mock(type, objects) {
+      var _this3 = this;
+
+      objects = Array.isArray(objects) ? objects : [objects];
+      return _get(_getPrototypeOf(ObserverStore.prototype), "mock", this).call(this, type, objects).then(function (objects) {
+        _classPrivateMethodGet(_this3, _propagateInsertChange, _propagateInsertChange2).call(_this3, 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));
@@ -321,12 +333,12 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
 }(_PersistentStore2["default"]);
 
 function _propagateInsertChange2(type, newObjects) {
-  var _this3 = this;
+  var _this4 = this;
 
   return (_classPrivateFieldGet(this, _unsubPromises).length ? Promise.all(_classPrivateFieldGet(this, _unsubPromises)) : Promise.resolve()).then(function () {
-    if (_this3._subscribed[type]) {
+    if (_this4._subscribed[type]) {
       var uniqueSubs = {};
-      var objects = Object.values(_this3._subscribed[type]);
+      var objects = Object.values(_this4._subscribed[type]);
 
       for (var _i2 = 0, _objects = objects; _i2 < _objects.length; _i2++) {
         var object = _objects[_i2];
@@ -357,7 +369,7 @@ function _propagateInsertChange2(type, newObjects) {
 
         if (objectsToSubscribe.length) {
           // Check if the new objects matter
-          return _this3.find(type, filterFunction).then(function (data) {
+          return _this4.find(type, filterFunction).then(function (data) {
             var subKey;
 
             var _iterator6 = _createForOfIteratorHelper(data),
@@ -367,7 +379,7 @@ function _propagateInsertChange2(type, newObjects) {
               for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
                 var d = _step6.value;
 
-                var item = _this3._subscribed[d.getModel().getType()][d.getId()];
+                var item = _this4._subscribed[d.getModel().getType()][d.getId()];
 
                 subKey = item ? item.subKey : null;
                 if (subKey) break;
@@ -378,7 +390,7 @@ function _propagateInsertChange2(type, newObjects) {
               _iterator6.f();
             }
 
-            _classPrivateFieldGet(_this3, _subscribeToObjects).call(_this3, type, objectsToSubscribe, {
+            _classPrivateFieldGet(_this4, _subscribeToObjects).call(_this4, type, objectsToSubscribe, {
               callback: callback,
               filterFunction: filterFunction,
               subKey: subKey

package/dist/PersistentStore.js

@@ -105,32 +105,42 @@ var PersistentStore = /*#__PURE__*/function (_Store) {
       var inserted = _ref2.inserted,
           updated = _ref2.updated,
           deleted = _ref2.deleted;
-      var model = _this.models[type].model; // Operations order:
+      var model = _this.models[type].model; // Validate objects
+
+      var correctInserted = inserted.filter(function (object) {
+        return model.isObjectValid(object.object);
+      });
+      var correctUpdated = updated.filter(function (object) {
+        return model.isObjectValid(object.object);
+      });
+      var correctDeleted = deleted.filter(function (object) {
+        return model.isObjectValid(object.object);
+      }); // Operations order:
       // 1) insert
       // 2) update
       // 3) delete
 
-      return model.insertObjects(inserted.map(function (i) {
+      return model.insertObjects(correctInserted.map(function (i) {
         return i.object;
       })).then(function () {
         return _this.applyDiff({
-          inserted: inserted
+          inserted: correctInserted
         }, type);
       }).then(function () {
-        return model.updateObjects(updated.map(function (i) {
+        return model.updateObjects(correctUpdated.map(function (i) {
           return i.object;
         }));
       }).then(function () {
         return _this.applyDiff({
-          updated: updated
+          updated: correctUpdated
         }, type);
       }).then(function () {
-        return model.deleteObjects(deleted.map(function (i) {
+        return model.deleteObjects(correctDeleted.map(function (i) {
           return i.object;
         }));
       }).then(function () {
         return _this.applyDiff({
-          deleted: deleted
+          deleted: correctDeleted
         }, type);
       });
     });
@@ -186,6 +196,11 @@ var PersistentStore = /*#__PURE__*/function (_Store) {
         return data;
       });
     }
+  }, {
+    key: "mock",
+    value: function mock(type, objects) {
+      return _get(_getPrototypeOf(PersistentStore.prototype), "mock", this).call(this, type, objects);
+    }
   }, {
     key: "delete",
     value: function _delete(typeOrObjects, filterFunction) {

package/dist/Store.js

@@ -9,6 +9,8 @@ var _Obj = _interopRequireDefault(require("./Obj"));
 
 var _PubSub = _interopRequireDefault(require("./PubSub"));
 
+var _batchPromises = _interopRequireDefault(require("batch-promises"));
+
 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; } } }; }
@@ -23,10 +25,10 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i+
 
 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 _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
-
 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; }
@@ -39,6 +41,12 @@ function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) {
 
 function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
 
+var objectStatuses = ["new", "old", "mock", "deleted"];
+
+var _refreshObjectByType = /*#__PURE__*/new WeakMap();
+
+var _merge = /*#__PURE__*/new WeakMap();
+
 var _error = /*#__PURE__*/new WeakSet();
 
 var _deleteByObject = /*#__PURE__*/new WeakMap();
@@ -53,7 +61,9 @@ var _loadObjects = /*#__PURE__*/new WeakSet();
 
 var Store = /*#__PURE__*/function () {
   function Store() {
-    var _this = this;
+    var _this = this,
+        _options$autoSave,
+        _options$lazyLoad;
 
     var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
@@ -73,6 +83,93 @@ var Store = /*#__PURE__*/function () {
       return Object.keys(_this.models);
     });
 
+    _defineProperty(this, "refresh", function (type) {
+      if (type) {
+        return _classPrivateFieldGet(_this, _refreshObjectByType).call(_this, type);
+      } else {
+        return Promise.all(Object.keys(_this.models).map(_classPrivateFieldGet(_this, _refreshObjectByType)));
+      }
+    });
+
+    _classPrivateFieldInitSpec(this, _refreshObjectByType, {
+      writable: true,
+      value: function value(type) {
+        return _classPrivateMethodGet(_this, _getPromise, _getPromise2).call(_this, type).then(function () {
+          var item = _this.models[type];
+
+          _this.pubSub.publish("refresh", {
+            status: "start",
+            model: type
+          });
+
+          item.promise = item.model.retrieveAll()["catch"](function () {
+            var objects = Object.values(_this.models[type].storedObjects);
+            var list = [];
+            return (0, _batchPromises["default"])(4, objects, function (object) {
+              return item.model.factory(object.object).then(function (items) {
+                list = list.concat(items);
+              });
+            }).then(function () {
+              return list;
+            });
+          }).then(function (objects) {
+            var _iterator = _createForOfIteratorHelper(objects),
+                _step;
+
+            try {
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                var object = _step.value;
+                var wrapper = new _Obj["default"](object, item.model);
+                var id = wrapper.getId();
+                var currentObject = item === null || item === void 0 ? void 0 : item.storedObjects[id]; // console.log("currentObject", item);
+
+                if (currentObject) {
+                  var newFingerprint = wrapper.getFingerprint();
+                  var oldFingerprint = currentObject.fingerprint;
+
+                  if (oldFingerprint !== newFingerprint) {
+                    // Nothing to do otherwise
+                    if (_this.hasChanged(type, currentObject.object)) {// Was the object edited locally?
+                      // Nothing for now
+                    } else {
+                      // Update with the new object
+                      // console.log("merge", wrapper);
+                      _classPrivateFieldGet(_this, _merge).call(_this, _this.models[type].storedObjects[id].object, wrapper.toJSON());
+
+                      _this.models[type].storedObjects[id].fingerprint = newFingerprint;
+                    }
+                  }
+                } else {
+                  _classPrivateMethodGet(_this, _insertObject, _insertObject2).call(_this, type, object, "old");
+                }
+              }
+            } catch (err) {
+              _iterator.e(err);
+            } finally {
+              _iterator.f();
+            }
+
+            _this.pubSub.publish("refresh", {
+              status: "end",
+              model: type
+            });
+          });
+          return item.promise;
+        });
+      }
+    });
+
+    _classPrivateFieldInitSpec(this, _merge, {
+      writable: true,
+      value: function value(originalObject, newObject) {
+        for (var key in newObject) {
+          originalObject[key] = newObject[key];
+        }
+
+        originalObject.update();
+      }
+    });
+
     _classPrivateFieldInitSpec(this, _deleteByObject, {
       writable: true,
       value: function value(object) {
@@ -87,12 +184,17 @@ var Store = /*#__PURE__*/function () {
     });
 
     this.options = {
-      autoSave: options.autoSave !== undefined ? options.autoSave : true,
+      autoSave: (_options$autoSave = options.autoSave) !== null && _options$autoSave !== void 0 ? _options$autoSave : true,
       saveDelay: options.saveDelay || 1000,
-      lazyLoad: options.lazyLoad || false
+      lazyLoad: (_options$lazyLoad = options.lazyLoad) !== null && _options$lazyLoad !== void 0 ? _options$lazyLoad : false,
+      autoRefresh: options.autoRefresh === true ? 120000 : options.autoRefresh
     };
     this.models = {};
     this.pubSub = new _PubSub["default"]();
+
+    if (this.options.autoRefresh && typeof this.options.autoRefresh === "number") {
+      setInterval(this.refresh, this.options.autoRefresh);
+    }
   }
 
   _createClass(Store, [{
@@ -172,18 +274,29 @@ var Store = /*#__PURE__*/function () {
 
       return _classPrivateMethodGet(this, _getPromise, _getPromise2).call(this, type).then(function () {
         return objects.map(function (object) {
-          return _classPrivateMethodGet(_this3, _insertObject, _insertObject2).call(_this3, type, object, true);
+          return _classPrivateMethodGet(_this3, _insertObject, _insertObject2).call(_this3, type, object, "new");
+        });
+      });
+    }
+  }, {
+    key: "mock",
+    value: function mock(type, objects) {
+      var _this4 = this;
+
+      return _classPrivateMethodGet(this, _getPromise, _getPromise2).call(this, type).then(function () {
+        return objects.map(function (object) {
+          return _classPrivateMethodGet(_this4, _insertObject, _insertObject2).call(_this4, type, object, "mock");
         });
       });
     }
   }, {
     key: "get",
     value: function get(type, id) {
-      var _this4 = this;
+      var _this5 = this;
 
       return _classPrivateMethodGet(this, _getPromise, _getPromise2).call(this, type).then(function () {
         try {
-          return _this4.models[type].storedObjects[id].object;
+          return _this5.models[type].storedObjects[id].object;
         } catch (error) {
           return Promise.reject("Object not found");
         }
@@ -192,17 +305,17 @@ var Store = /*#__PURE__*/function () {
   }, {
     key: "find",
     value: function find(type, filterFunction) {
-      var _this5 = this;
+      var _this6 = this;
 
       return _classPrivateMethodGet(this, _getPromise, _getPromise2).call(this, type).then(function () {
-        var all = Object.values(_this5.models[type].storedObjects).filter(function (i) {
+        var all = Object.values(_this6.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) {
-        _this5.pubSub.publish("error", error);
+        _this6.pubSub.publish("error", error);
 
         return Promise.reject(error);
       });
@@ -210,7 +323,7 @@ var Store = /*#__PURE__*/function () {
   }, {
     key: "applyDiff",
     value: function applyDiff(_ref, type) {
-      var _this6 = this;
+      var _this7 = this;
 
       var _ref$inserted = _ref.inserted,
           inserted = _ref$inserted === void 0 ? [] : _ref$inserted,
@@ -220,41 +333,48 @@ var Store = /*#__PURE__*/function () {
           deleted = _ref$deleted === void 0 ? [] : _ref$deleted;
       return new Promise(function (resolve, reject) {
         try {
-          var _iterator = _createForOfIteratorHelper(inserted.concat(updated)),
-              _step;
+          var _iterator2 = _createForOfIteratorHelper(inserted.concat(updated)),
+              _step2;
 
           try {
-            for (_iterator.s(); !(_step = _iterator.n()).done;) {
-              var object = _step.value;
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var object = _step2.value;
+              type = type || object.object.getModel().getType();
+              var newId = object.object.getId();
+              var oldId = object.id;
+              var item = _this7.models[type].storedObjects[object.id];
 
-              var item = _this6.models[type || object.object.getModel().getType()].storedObjects[object.id];
+              if (newId !== oldId) {
+                _this7.models[type].storedObjects[newId] = item;
+                delete _this7.models[type].storedObjects[object.id];
+              }
 
               item.fingerprint = object.object.getFingerprint();
               item.status = "old";
             }
           } catch (err) {
-            _iterator.e(err);
+            _iterator2.e(err);
           } finally {
-            _iterator.f();
+            _iterator2.f();
           }
 
-          var _iterator2 = _createForOfIteratorHelper(deleted),
-              _step2;
+          var _iterator3 = _createForOfIteratorHelper(deleted),
+              _step3;
 
           try {
-            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-              var _object = _step2.value;
-              delete _this6.models[type || _object.object.getModel().getType()].storedObjects[_object.id];
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var _object = _step3.value;
+              delete _this7.models[type || _object.object.getModel().getType()].storedObjects[_object.id];
             }
           } catch (err) {
-            _iterator2.e(err);
+            _iterator3.e(err);
           } finally {
-            _iterator2.f();
+            _iterator3.f();
           }
 
           resolve();
         } catch (error) {
-          return reject(error);
+          reject(error);
         }
       });
     }
@@ -272,10 +392,10 @@ var Store = /*#__PURE__*/function () {
   }, {
     key: "getDiff",
     value: function getDiff(type) {
-      var _this7 = this;
+      var _this8 = this;
 
       return _classPrivateMethodGet(this, _getPromise, _getPromise2).call(this, type).then(function () {
-        var objects = Object.values(_this7.models[type].storedObjects);
+        var objects = Object.values(_this8.models[type].storedObjects);
         var inserted = [];
         var updated = [];
         var deleted = [];
@@ -287,9 +407,10 @@ var Store = /*#__PURE__*/function () {
             inserted.push(object);
           } else if (object.status === "deleted") {
             deleted.push(object);
-          } else if (_this7.hasChanged(type, object.object)) {
+          } else if (object.status === "old" && _this8.hasChanged(type, object.object)) {
             updated.push(object);
-          }
+          } // Nothing for mock objects
+
         }
 
         return {
@@ -302,34 +423,35 @@ var Store = /*#__PURE__*/function () {
   }, {
     key: "factory",
     value: function factory(type, params) {
-      var _this8 = this;
+      var _this9 = this;
 
       var item = this.models[type];
       this.pubSub.publish("loading", {
         status: "start",
         model: type
       });
-      return item.promise = item.model.factory(params).then(function (items) {
-        var _iterator3 = _createForOfIteratorHelper(items),
-            _step3;
+      item.promise = item.model.factory(params).then(function (items) {
+        var _iterator4 = _createForOfIteratorHelper(items),
+            _step4;
 
         try {
-          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-            var _item = _step3.value;
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var _item = _step4.value;
 
-            _classPrivateMethodGet(_this8, _insertObject, _insertObject2).call(_this8, type, _item, false);
+            _classPrivateMethodGet(_this9, _insertObject, _insertObject2).call(_this9, type, _item, "old");
           }
         } catch (err) {
-          _iterator3.e(err);
+          _iterator4.e(err);
         } finally {
-          _iterator3.f();
+          _iterator4.f();
         }
 
-        _this8.pubSub.publish("loading", {
+        _this9.pubSub.publish("loading", {
           status: "end",
           model: type
         });
       });
+      return item.promise;
     }
   }]);
 
@@ -345,25 +467,25 @@ function _error2(error) {
 }
 
 function _deleteByFilter2(type, filterFunction) {
-  var _this9 = this;
+  var _this10 = this;
 
   return _classPrivateMethodGet(this, _getPromise, _getPromise2).call(this, type).then(function () {
-    var deleted = Object.values(_this9.models[type].storedObjects).filter(function (i) {
+    var deleted = Object.values(_this10.models[type].storedObjects).filter(function (i) {
       return filterFunction(i.object);
     });
 
-    var _iterator4 = _createForOfIteratorHelper(deleted),
-        _step4;
+    var _iterator5 = _createForOfIteratorHelper(deleted),
+        _step5;
 
     try {
-      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-        var object = _step4.value;
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        var object = _step5.value;
         object.status = "deleted";
       }
     } catch (err) {
-      _iterator4.e(err);
+      _iterator5.e(err);
     } finally {
-      _iterator4.f();
+      _iterator5.f();
     }
 
     return deleted.map(function (i) {
@@ -373,7 +495,7 @@ function _deleteByFilter2(type, filterFunction) {
 }
 
 function _getPromise2(type) {
-  var _this10 = this;
+  var _this11 = this;
 
   if (!this.models[type]) {
     return Promise.reject("The model doesn't exist");
@@ -381,15 +503,16 @@ function _getPromise2(type) {
     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 _this10.models[type].promise;
+      return _this11.models[type].promise;
     });
   } else {
     return this.models[type].promise;
   }
 }
 
-function _insertObject2(type, item) {
-  var markAsNew = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+function _insertObject2(type, item, status) {
+  var _this12 = this;
+
   var model = this.models[type].model;
   var wrapper = new _Obj["default"](item, model);
   var id = wrapper.getId();
@@ -398,42 +521,57 @@ function _insertObject2(type, item) {
     throw new Error("The IDs provided for the model ".concat(type, " are not unique"));
   }
 
+  if (!objectStatuses.includes(status)) {
+    throw new Error("The provided status is not valid");
+  }
+
+  if (status === "mock") {
+    wrapper.insert = function () {
+      _this12.models[type].storedObjects[id].status = "new";
+
+      _this12.update([wrapper]);
+
+      delete wrapper.insert;
+    };
+  }
+
   this.models[type].storedObjects[id] = {
     id: id,
     fingerprint: wrapper.getFingerprint(),
     object: wrapper,
-    status: markAsNew ? "new" : "old"
+    status: status
   };
   return wrapper;
 }
 
 function _loadObjects2(type) {
-  var _this11 = this;
+  var _this13 = this;
 
   var item = this.models[type];
   this.pubSub.publish("loading", {
     status: "start",
     model: type
   });
-  return item.promise = item.model.retrieveAll().then(function (items) {
-    var _iterator5 = _createForOfIteratorHelper(items),
-        _step5;
+  item.promise = item.model.retrieveAll().then(function (items) {
+    var _iterator6 = _createForOfIteratorHelper(items),
+        _step6;
 
     try {
-      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-        var _item2 = _step5.value;
+      for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+        var _item2 = _step6.value;
 
-        _classPrivateMethodGet(_this11, _insertObject, _insertObject2).call(_this11, type, _item2, false);
+        _classPrivateMethodGet(_this13, _insertObject, _insertObject2).call(_this13, type, _item2, "old");
       }
     } catch (err) {
-      _iterator5.e(err);
+      _iterator6.e(err);
     } finally {
-      _iterator5.f();
+      _iterator6.f();
     }
 
-    _this11.pubSub.publish("loading", {
+    _this13.pubSub.publish("loading", {
       status: "end",
       model: type
     });
   });
+  return item.promise;
 }