dataflux 1.12.3 → 1.13.0

package/README.md

@@ -569,7 +569,8 @@ The store has the following method.
 | preload(type)                                          | This method allows to preLoad all objects of a given model. If you initialize the store with `lazyLoad:true`, the objects of a model are retrieved from the API at the first query performed on that model (e.g., at the first `.find()`). However, sometimes you may want to speed up the first query by pre loading the objects of a specific model while keeping `lazyLoad:true` on the store; in such a case you can use `store.preload(type)`. |
 | save()                                                 | Persist the changes. Edited local objects will be sent to the REST APIs (insert/update/delete). See also [editing objects](#editing-objects).                                                                                                                                                                                                                                                                                                       |
 | save()                                                 | Persist the changes (`local -> remote`). Edited local objects will be sent to the REST APIs (insert/update/delete). See also [editing objects](#editing-objects).                                                                                                                                                                                                                                                                                   |
-| refresh()                                              | This method syncs all the objects in the store with the remote version offered by the REST APIs (`remote -> local`). Remote changes are applied locally, including adding/removing objects. Objects edited locally but not yet persisted are preserved locally (tip: you can also create a store with the `autoRefresh` option).                                                                                                                    |
+| refresh(type)                                          | This method syncs all the objects in the store with the remote version offered by the REST APIs (`remote -> local`). Remote changes are applied locally, including adding/removing objects. Objects edited locally but not yet persisted are preserved locally (tip: you can also create a store with the `autoRefresh` option). If a model type is passed, only objects of that type will be refreshed.                                            |
+| reset(type)                                            | This method syncs all the objects in the store with the remote version offered by the REST APIs (`remote -> local`). Remote changes are applied locally, including adding/removing objects. Objects edited locally but not yet persisted are reverted to the corresponding remote object. If a model type is passed, only objects of that type will be reset.                                                                                       |
 | findSync(type, filterFunction)                         | This method returns the objects in a synchronous way (no Promise). However, *it works only if you already performed an async operation (e.g., like refresh, load, find, subscribe) or if you set lazyLoad to false and the store had enough time to load.*                                                                                                                                                                                          |
 
 ### Insert vs. Mock

package/dist/ObserverStore.js

@@ -250,13 +250,19 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
         _classPrivateFieldGet(_assertThisInitialized(_this), _appendIfNotExistent).call(_assertThisInitialized(_this), _this._subscribed[type]["*"], item);
       }
     });
+    _defineProperty(_assertThisInitialized(_this), "reset", function (type) {
+      return _this._refresh(type, true);
+    });
     _defineProperty(_assertThisInitialized(_this), "refresh", function (type) {
+      return _this._refresh(type, false);
+    });
+    _defineProperty(_assertThisInitialized(_this), "_refresh", function (type, force) {
       var refreshByType = function refreshByType(type) {
         _this.pubSub.publish("refresh", {
           status: "start",
           model: type
         });
-        return _this.refreshObjectByType(type).then(function (_ref5) {
+        return _this.refreshObjectByType(type, force).then(function (_ref5) {
           var _ref6 = _slicedToArray(_ref5, 3),
             inserted = _ref6[0],
             updated = _ref6[1],

package/dist/Store.js

@@ -49,6 +49,7 @@ function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(
                                                                                                                                                                                     */
 var objectStatuses = ["new", "old", "mock", "deleted"];
 var _merge = /*#__PURE__*/new WeakMap();
+var _wipe = /*#__PURE__*/new WeakMap();
 var _error = /*#__PURE__*/new WeakSet();
 var _deleteByObject = /*#__PURE__*/new WeakMap();
 var _deleteByFilter = /*#__PURE__*/new WeakSet();
@@ -77,6 +78,7 @@ var Store = /*#__PURE__*/function () {
       return filterFunction ? all.filter(filterFunction) : all;
     });
     _defineProperty(this, "refreshObjectByType", function (type) {
+      var force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
       return _this._getPromise(type).then(function () {
         var item = _this.models[type];
         var inserted = [];
@@ -107,7 +109,12 @@ var Store = /*#__PURE__*/function () {
                 var oldFingerprint = currentObject.fingerprint;
                 if (oldFingerprint !== newFingerprint) {
                   // Nothing to do otherwise
-                  if (_this.hasChanged(type, currentObject.object)) {// Was the object edited locally?
+                  if (force) {
+                    _classPrivateFieldGet(_this, _wipe).call(_this, currentObject.object);
+                    _classPrivateFieldGet(_this, _merge).call(_this, currentObject.object, wrapper.toJSON());
+                    currentObject.fingerprint = newFingerprint;
+                    updated.push(currentObject.object);
+                  } else if (_this.hasChanged(type, currentObject.object)) {// Was the object edited locally?
 
                     // Nothing for now
                   } else {
@@ -148,7 +155,16 @@ var Store = /*#__PURE__*/function () {
         for (var key in newObject) {
           originalObject[key] = newObject[key];
         }
-        // originalObject.update();
+      }
+    });
+    _classPrivateFieldInitSpec(this, _wipe, {
+      writable: true,
+      value: function value(originalObject) {
+        for (var key in originalObject) {
+          if (key !== "id") {
+            delete originalObject[key];
+          }
+        }
       }
     });
     _classPrivateFieldInitSpec(this, _deleteByObject, {