dataflux 1.16.0 → 1.17.1

package/README.md

@@ -350,25 +350,25 @@ const book = new Model("book", options);
 
 All the possible options for a model creation are (they are all optional):
 
-| Name         | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Default              |
-|--------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------|
-| retrieve     | Describes the operation to retrieve the collection of objects from the REST API. It can be an operation object or a function. See [operations](#operations).                                                                                                                                                                                                                                                                                                                                                                                                                  | `{method: "get"}`    |
-| insert       | Describes the operation to insert a new object in the collection. It can be an operation object or a function. See [operations](#operations).                                                                                                                                                                                                                                                                                                                                                                                                                                 | `{method: "post"}`   |
-| update       | Describes the operation to update objects of the collection. It can be an operation object or a function. See [operations](#operations).                                                                                                                                                                                                                                                                                                                                                                                                                                      | `{method: "put"}`    |
-| delete       | Describes the operation to remove objects from the collection. It can be an operation object or a function. See [operations](#operations).                                                                                                                                                                                                                                                                                                                                                                                                                                    | `{method: "delete"}` |
-| fields       | An array of strings defining which attributes the retrieved objects should have. Essentially, it allows you to contemporarily specify the [X-Fields header](https://flask-restplus.readthedocs.io/en/stable/mask.html) and the [fields GET parameter](https://developers.google.com/slides/api/guides/performance#partial). This reduces transfer size and memory usage. E.g., if you have a collection of books, of which you are interested only in the name, you can define `fields: ["name"]`. In combination with `load` it allows for partial lazy load of the objects. | All the fields       |
-| headers      | A dictionary of headers for the HTTP request. E.g., `{"Authorization": "bearer XXXX"}`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | No headers           |
-| load         | A function that allows to enrich the objects on demand. E.g., you can use `fields` to download only the titles of a collection of books, and `load` to load completely the object. See [object enrichment](#object-enrichment).                                                                                                                                                                                                                                                                                                                                               |
-| axios        | It allows to specify an axios instance to be used for the queries. If not specified, a new one will be used.                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | A new axios instance |
-| parseMoment  | Automatically creates Moment.js objects out of ISO8601 strings. E.g., if an object has a property `createdAt: "2022-01-07T21:38:50.295Z"`, this will be transformed to a moment object.                                                                                                                                                                                                                                                                                                                                                                                       |                      | 
-| hiddenFields | An array of attribute names that will never be sent back to the API. E.g., if you set `hiddenFields: ["pages"]`, a book object can contain an attribute `pages` locally, but this will be stripped out in PUT/POST requests.                                                                                                                                                                                                                                                                                                                                                  |
-| deep         | A boolean defining if nested objects should be enriched with the object methods.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | true                 |
-| lazyLoad     | A boolean defining if the model should be lazy loaded on the first use. This takes precedence over the lazyLoad declared during store initialization.                                                                                                                                                                                                                                                                                                                                                                                                                         | false                |
-| validate     | A dictionary containing functions to validate the objects of this model. See [objects validation](#objects-validation)                                                                                                                                                                                                                                                                                                                                                                                                                                                        | no validation        |
-| autoRefresh  | Set auto refresh for the specific model. See `autoRefresh` in the [store config](#configuration).                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |                      |
-| autoSave     | It allows to specify `autoSave` at model level. If store.autoSave is true, `autoSave: false` at model level will allow to disable autoSave only for the specific model.                                                                                                                                                                                                                                                                                                                                                                                                       |
-| pre          | A function that is executed for every object retrieved, before creating the collection in the store. It is useful for pre-processing every data item received from the API.                                                                                                                                                                                                                                                                                                                                                                                                   |
-| post         | A function that is executed for every object retrieved before delete, update, and insert operations. It is useful for post-processing every data item before sending them back to the API.                                                                                                                                                                                                                                                                                                                                                                                    |
+| Name                 | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Default              |
+|----------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------|
+| retrieve             | Describes the operation to retrieve the collection of objects from the REST API. It can be an operation object or a function. See [operations](#operations).                                                                                                                                                                                                                                                                                                                                                                                                                  | `{method: "get"}`    |
+| insert               | Describes the operation to insert a new object in the collection. It can be an operation object or a function. See [operations](#operations).                                                                                                                                                                                                                                                                                                                                                                                                                                 | `{method: "post"}`   |
+| update               | Describes the operation to update objects of the collection. It can be an operation object or a function. See [operations](#operations).                                                                                                                                                                                                                                                                                                                                                                                                                                      | `{method: "put"}`    |
+| delete               | Describes the operation to remove objects from the collection. It can be an operation object or a function. See [operations](#operations).                                                                                                                                                                                                                                                                                                                                                                                                                                    | `{method: "delete"}` |
+| fields               | An array of strings defining which attributes the retrieved objects should have. Essentially, it allows you to contemporarily specify the [X-Fields header](https://flask-restplus.readthedocs.io/en/stable/mask.html) and the [fields GET parameter](https://developers.google.com/slides/api/guides/performance#partial). This reduces transfer size and memory usage. E.g., if you have a collection of books, of which you are interested only in the name, you can define `fields: ["name"]`. In combination with `load` it allows for partial lazy load of the objects. | All the fields       |
+| headers              | A dictionary of headers for the HTTP request. E.g., `{"Authorization": "bearer XXXX"}`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | No headers           |
+| load                 | A function that allows to enrich the objects on demand. E.g., you can use `fields` to download only the titles of a collection of books, and `load` to load completely the object. See [object enrichment](#object-enrichment).                                                                                                                                                                                                                                                                                                                                               |
+| axios                | It allows to specify an axios instance to be used for the queries. If not specified, a new one will be used.                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | A new axios instance |
+| parseMoment          | Automatically creates Moment.js objects out of ISO8601 strings. E.g., if an object has a property `createdAt: "2022-01-07T21:38:50.295Z"`, this will be transformed to a moment object.                                                                                                                                                                                                                                                                                                                                                                                       |                      | 
+| hiddenFields         | An array of attribute names that will never be sent back to the API. E.g., if you set `hiddenFields: ["pages"]`, a book object can contain an attribute `pages` locally, but this will be stripped out in PUT/POST requests.                                                                                                                                                                                                                                                                                                                                                  |
+| deep                 | A boolean defining if nested objects should be enriched with the object methods.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | true                 |
+| lazyLoad             | A boolean defining if the model should be lazy loaded on the first use. This takes precedence over the lazyLoad declared during store initialization.                                                                                                                                                                                                                                                                                                                                                                                                                         | false                |
+| validate             | A dictionary containing functions to validate the objects of this model. See [objects validation](#objects-validation)                                                                                                                                                                                                                                                                                                                                                                                                                                                        | no validation        |
+| autoRefresh          | Set auto refresh for the specific model. See `autoRefresh` in the [store config](#configuration).                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |                      |
+| autoSave             | It allows to specify `autoSave` at model level. If store.autoSave is true, `autoSave: false` at model level will allow to disable autoSave only for the specific model.                                                                                                                                                                                                                                                                                                                                                                                                       |
+| pre(object, objects) | A function that is executed for every object retrieved, before creating the collection in the store. It is useful for pre-processing every data item received from the API. It receives in input a object of the collection (first parameter) and the entire collection (second parameter).                                                                                                                                                                                                                                                                                   |
+| post                 | A function that is executed for every object retrieved before delete, update, and insert operations. It is useful for post-processing every data item before sending them back to the API. It receives in input a object of the collection (first parameter) and the entire collection (second parameter).                                                                                                                                                                                                                                                                    |
 
 ### Operations
 As described in the table above, there are four possible operations: **retrieve, insert, update,** and **delete**. An operation can be defined as an operation object or a function.
@@ -624,7 +624,7 @@ The store has the following method.
 | addModel(model)                                        | Introduce a new model to the store. If lazyLoad = false (default), the model is populated with the objects coming from the API.                                                                                                                                                                                                                                                                                                                     |
 | get(type, id)                                          | It allows to retrieve an object based on its type and store's ID (see `getId()` in [objects methods](#objects-methods). The type is the name of the model.                                                                                                                                                                                                                                                                                          |
 | find(type, filterFunction)                             | The promise-oriented method to access objects given a type and a filter function. If the filter function is missing, all the objects are returned. See [example 1](#example-1).                                                                                                                                                                                                                                                                     |
-| delete(objects)                                        | It deletes an array of objects. See [example 1](#example-3).                                                                                                                                                                                                                                                                                                                                                                                        |
+| delete(objects)                                        | It deletes an array of objects. See [example 3](#example-3).                                                                                                                                                                                                                                                                                                                                                                                        |
 | delete(type, filterFunction)                           | It deleted objects given an array and a filter function. See [example 1](#example-3).                                                                                                                                                                                                                                                                                                                                                               |
 | insert(type, object)                                   | It creates a new object of a given type and inserts it in the store. The object inserted MUST be ready to be persisted, read `mock()` below.                                                                                                                                                                                                                                                                                                        |
 | mock(type, object)                                     | It creates a mock object of a given type and inserts it in the store. The mock object behaves exactly like a real object, except that it is not persisted (sent to the API) as long as you don't call `object.insert()`. This is useful when you want to create an object but you need to be able to change some properties before to send it to the API. Read [insert vs. mock](#insert-vs-mock).                                                  |
@@ -632,7 +632,7 @@ The store has the following method.
 | multipleSubscribe(subscriptions, callback)             | A method to subscribe to multiple models. The first parameter is an array of models' names and filterFunctions, the second parameter is the callback to be called when the cumulative dataset is ready. E.g., `multipleSubscribe([["book", filterFunction1], ["author", filterFunction2]], callback)`. It returns the key of the subscription. See [example 5](#example-5---observability).                                                         |
 | unsubscribe(key)                                       | Method to terminate a subscription given a subscription key. See [example 5](#example-5---observability).                                                                                                                                                                                                                                                                                                                                           |
 | findOne(type, stateAttribute, context, filterFunction) | This method automatically injects and updates the React state with the requested data. If multiple objects satisfy the query, only the first is selected. The `stateAttribute` is the name of the attribute that will be added/updated in the state, the `context` is the React.Component. It automatically unsubscribe when the React.Component will unmount. See [example 6](#example-6---observability--react).                                  |
-| findAll(type, stateAttribute, context, filterFunction) | This method automatically injects and updates the React state with the requested data. The `stateAttribute` is the name of the attribute that will be added/updated in the state, the `context` is the React.Component. It automatically unsubscribe when the React.Component will unmount. If the filter function is missing, all the objects are returned. See [example 6](#example-6---observability--react).                                    |
+| findAll(type, stateAttribute, context, filterFunction) | This method automatically injects and updates the React state with the requested data. The `stateAttribute` is the name of the attribute that will be added/updated in the state, the `context` is the React.Component. It automatically unsubscribe when the React.Component will unmount. If the filter function is missing, all the objects are returned. See [example 7](#example-6---observability--react).                                    |
 | 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).                                                                                                                                                                                                                                                                                   |
@@ -641,6 +641,7 @@ The store has the following method.
 | 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.*                                                                                                                                                                                          |
 | hasChanged(type, object)                               | This method receives in input a model type and an object (optional). It returns a boolean, `true` if the object is dirty (it changed but it has not yet being persisted). If the object is not passed, the method checks if any of the objects of the specified model type has changed.                                                                                                                                                             |
 | didUpdate(context)                                     | If you pass an object as a prop to a React component, the component will not refresh if the object changes. To address this, you can use this method inside the `componentDidUpdate` to check if any of the objects changed. See [example 6](#example-7---react-props-and-observability)                                                                                                                                                            |
+| getCollection(type)                                    | This method receives in input a model type . It returns all the raw (JSON) objects available for that model.                                                                                                                                                                                                                                                                                                                                        |
 
 ### Insert vs. Mock
 

package/dist/BasicObj.js

@@ -81,6 +81,9 @@ var BasicObj = exports.BasicObj = /*#__PURE__*/function () {
     _defineProperty(this, "isDataflux", function () {
       return true;
     });
+    _defineProperty(this, "isMock", function () {
+      return false;
+    });
     _defineProperty(this, "setId", function (id) {
       _this.id = id;
     });

package/dist/Model.js

@@ -225,7 +225,9 @@ var Model = exports["default"] = /*#__PURE__*/_createClass(function Model(name)
       return _classPrivateFieldGet(_toArray, _this).call(_this, data);
     }).then(function (data) {
       var _this$options;
-      return (_this$options = _this.options) !== null && _this$options !== void 0 && _this$options.pre ? data.map(_this.options.pre) : data;
+      return (_this$options = _this.options) !== null && _this$options !== void 0 && _this$options.pre ? data.map(function (n) {
+        return _this.options.pre(n, data);
+      }) : data;
     });
   });
   _defineProperty(this, "insertObjects", function (objects) {
@@ -273,6 +275,12 @@ var Model = exports["default"] = /*#__PURE__*/_createClass(function Model(name)
     } finally {
       _iterator.f();
     }
+    for (var _i = 0, _Object$values = Object.values(json); _i < _Object$values.length; _i++) {
+      var obj = _Object$values[_i];
+      if (_typeof(obj) === "object") {
+        _classPrivateFieldGet(_removeHiddenFields, _this).call(_this, obj);
+      }
+    }
     return json;
   });
   _classPrivateFieldInitSpec(this, _toArray, function (data) {
@@ -297,11 +305,12 @@ var Model = exports["default"] = /*#__PURE__*/_createClass(function Model(name)
     }
   });
   _classPrivateFieldInitSpec(this, _unWrap, function (objects) {
-    var data = Object.values(objects).map(function (object) {
+    var arrayObjects = Object.values(objects);
+    var data = arrayObjects.map(function (object) {
       return _classPrivateFieldGet(_removeHiddenFields, _this).call(_this, object.toJSON());
     }).map(function (object) {
       var _this$options2;
-      return (_this$options2 = _this.options) !== null && _this$options2 !== void 0 && _this$options2.post ? _this.options.post(object) : object;
+      return (_this$options2 = _this.options) !== null && _this$options2 !== void 0 && _this$options2.post ? _this.options.post(object, arrayObjects) : object;
     });
     if (data.value != null && Object.keys(data).length === 1) {
       return data.value;

package/dist/Store.js

@@ -74,6 +74,32 @@ var Store = exports["default"] = /*#__PURE__*/function () {
       });
       return filterFunction ? all.filter(filterFunction) : all;
     });
+    _defineProperty(this, "_validateTypeInput", function (type) {
+      if (!_this.models[type]) {
+        throw new Error("Not valid model type");
+      }
+    });
+    _defineProperty(this, "_getDiffSync", function (type) {
+      var objects = Object.values(_this.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.status === "old" && _this.hasChanged(type, object.object)) {
+          updated.push(object);
+        } // Nothing for mock objects
+      }
+      return {
+        inserted: inserted,
+        updated: updated,
+        deleted: deleted
+      };
+    });
     _defineProperty(this, "refreshObjectByType", function (type) {
       var force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
       return _this._getPromise(type).then(function () {
@@ -174,8 +200,14 @@ var Store = exports["default"] = /*#__PURE__*/function () {
         throw new Error("The provided status is not valid");
       }
       if (status === "mock") {
+        wrapper.isMock = function () {
+          return true;
+        };
         wrapper.insert = function () {
           _this.models[type].storedObjects[id].status = "new";
+          wrapper.isMock = function () {
+            return false;
+          };
           _this.update([wrapper]);
           delete wrapper.insert;
         };
@@ -359,9 +391,7 @@ var Store = exports["default"] = /*#__PURE__*/function () {
     key: "hasChanged",
     value: function hasChanged(type, object) {
       var _this8 = this;
-      if (!this.models[type]) {
-        throw new Error("Not valid model type");
-      }
+      this._validateTypeInput(type);
       var _hasChanged = function _hasChanged(type, object) {
         var obj = _this8.models[type].storedObjects[object.getId()];
         return !obj || obj.fingerprint !== obj.object.getFingerprint();
@@ -369,8 +399,12 @@ var Store = exports["default"] = /*#__PURE__*/function () {
       if (object) {
         return _hasChanged(type, object);
       } else {
-        return Object.values(this.models[type].storedObjects).some(function (i) {
-          return _hasChanged(type, i.object);
+        var _this$_getDiffSync = this._getDiffSync(type),
+          inserted = _this$_getDiffSync.inserted,
+          updated = _this$_getDiffSync.updated,
+          deleted = _this$_getDiffSync.deleted;
+        return [inserted, updated, deleted].some(function (i) {
+          return i.length > 0;
         });
       }
     }
@@ -383,26 +417,9 @@ var Store = exports["default"] = /*#__PURE__*/function () {
     key: "getDiff",
     value: function getDiff(type, ifLoaded) {
       var _this9 = this;
+      this._validateTypeInput(type);
       return this._getPromise(type, ifLoaded).then(function () {
-        var objects = Object.values(_this9.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.status === "old" && _this9.hasChanged(type, object.object)) {
-            updated.push(object);
-          } // Nothing for mock objects
-        }
-        return {
-          inserted: inserted,
-          updated: updated,
-          deleted: deleted
-        };
+        return _this9._getDiffSync(type);
       });
     }
   }, {
@@ -453,6 +470,20 @@ var Store = exports["default"] = /*#__PURE__*/function () {
         return this.models[type].promise;
       }
     }
+  }, {
+    key: "getCollection",
+    value: function getCollection(type) {
+      var _this12 = this;
+      return this._getPromise(type).then(function () {
+        return Object.values(_this12.models[type].storedObjects).map(function (i) {
+          return i.object;
+        }).sort(function (a, b) {
+          return a.getId().localeCompare(b.getId());
+        }).map(function (i) {
+          return i.toJSON();
+        });
+      });
+    }
   }]);
 }();
 function _error(error) {
@@ -461,9 +492,9 @@ function _error(error) {
   return Promise.reject(error);
 }
 function _deleteByFilter(type, filterFunction) {
-  var _this12 = this;
+  var _this13 = this;
   return this._getPromise(type).then(function () {
-    var deleted = Object.values(_this12.models[type].storedObjects).filter(function (i) {
+    var deleted = Object.values(_this13.models[type].storedObjects).filter(function (i) {
       return filterFunction(i.object);
     });
     var _iterator5 = _createForOfIteratorHelper(deleted),
@@ -484,7 +515,7 @@ function _deleteByFilter(type, filterFunction) {
   });
 }
 function _loadObjects(type) {
-  var _this13 = this;
+  var _this14 = this;
   var item = this.models[type];
   this.pubSub.publish("loading", {
     status: "start",
@@ -496,14 +527,14 @@ function _loadObjects(type) {
     try {
       for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
         var _item2 = _step6.value;
-        _classPrivateFieldGet(_insertObject, _this13).call(_this13, type, _item2, "old");
+        _classPrivateFieldGet(_insertObject, _this14).call(_this14, type, _item2, "old");
       }
     } catch (err) {
       _iterator6.e(err);
     } finally {
       _iterator6.f();
     }
-    _this13.pubSub.publish("loading", {
+    _this14.pubSub.publish("loading", {
       status: "end",
       model: type
     });