dataflux 1.7.5 → 1.9.1

package/README.md

@@ -258,11 +258,12 @@ function MyComponent() {
 The store can be configured with the following options:
 
 
-| Option    | Description                                                                                                                                                                                                                                                                                                                                                                              | Default |
-|-----------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
-| autoSave  | It can be `true`, `false`, or an amount of milliseconds (integer). If `false`, you will have to perform `store.save()` manually. If `true`, the store will automatically perform `save()` when objects change. If an amount of milliseconds is provided, the objects are saved periodically AND when a change is detected. See [Editing objects](#editing-objects) for more information. | true    |
-| saveDelay | An amount of milliseconds used to defer synching operations with the server. It triggers `store.save()` milliseconds after the last change on the store's objects is detedect. This allows to bundle together multiple changes operated by an interacting user. See [Editing objects](#editing-objects) for more information.                                                            | 1000    |
-| lazyLoad  | A boolean. If set to `false`, the store is pre-populated with all the models' objects. If set to `true`, models' objects are loaded only on first usage (e.g., 'find', 'subscribe', 'getRelation'). LazyLoad operates per model, only the objects of the used models are loaded.                                                                                                         | false   |
+| Option      | Description                                                                                                                                                                                                                                                                                                                                                                                    | Default |
+|-------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
+| autoSave    | It can be `true`, `false`, or an amount of milliseconds (integer). If `false`, you will have to perform `store.save()` manually. If `true`, the store will automatically perform `store.save()` when objects change. If an amount of milliseconds is provided, the objects are saved periodically AND when a change is detected. See [Editing objects](#editing-objects) for more information. | true    |
+| saveDelay   | An amount of milliseconds used to defer synching operations with the server. It triggers `store.save()` milliseconds after the last change on the store's objects is detedect. This allows to bundle together multiple changes operated by an interacting user. See [Editing objects](#editing-objects) for more information.                                                                  | 1000    |
+| lazyLoad    | A boolean. If set to `false`, the store is pre-populated with all the models' objects. If set to `true`, models' objects are loaded only on first usage (e.g., 'find', 'subscribe', 'getRelation'). LazyLoad operates per model, only the objects of the used models are loaded.                                                                                                               | false   |
+| autoRefresh | It can be `true`, `false`, or an amount of milliseconds (integer). If `false`, you will have to perform `store.refresh()` manually. If `true`, the store will automatically perform `store.refresh()` every 2 minutes. If an amount of milliseconds is provided, the `store.refresh()` is performed periodically. See [store methods](#store-methods) for more information.                    | false   |
 
 
 
@@ -296,6 +297,7 @@ All the possible options for a model creation are (they are all optional):
 | 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        |
 
 ### 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.
@@ -308,10 +310,23 @@ An operation object is an object like follows:
 {
   "method": "get",
   "url": "https://api.example.com",
-  "headers": {"Authorization": "bearer XXXX"}
+  "headers": {
+    "Authorization": "bearer XXXX"
+  },
+  "batch": false
 }
 ```
 
+Possible parameters are:
+
+| Parameter | Description                                                                                                                          | Default                                                                          |
+|-----------|--------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------|
+| method    | HTTP method, accepted are get,post,put, and delete                                                                                   | "get" for retrieve, "post" for insert, "put" for update, and "delete" for delete |
+| url       | The url of the api                                                                                                                   |                                                                                  |
+| headers   | Headers for the HTTP request ([list](https://en.wikipedia.org/wiki/List_of_HTTP_header_fields)).                                     |
+| batch     | A boolean declaring if the API is able to receive an array of objects or an object at a time. This is not applicable for `retrieve`. | false                                                                            |
+
+
 Usage example:
 
 ```js
@@ -540,41 +555,73 @@ The store has the following method.
 | 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(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.                                                                                                                                                                                                                                                                                                                                                                                |
+| 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).                                                  |
 | subscribe(type, callback, filterFunction)              | The callback-oriented method to access objects given a type and a filter function. It returns the key of the subscription, needed to unsubscribe. If the filter function is missing, all the objects are returned. **DataFlux remembers your query and calls the callback every time any change is affecting the result of your query.** See [example 5](#example-5---observability).                                                               |
 | 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).                                    |
 | 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).                                                                                                                    |
+### Insert vs. Mock
+
+If you do:
+```js
+store.insert("book", {title: "The little prince"});
+```
+when the store will try to save, the object `{title: "The little prince"}` will be sent to the API in a post request. However, the API may require an attribute "price" for each book object, hence the post request will fail.
+Of course, you can add the attribute directly in the `.insert()` call; however, the value of this attribute may not be known at that time. For example, the user may need to input the price in a text field.
+
+You may think to delay the `.insert()` up to when all the required attributes are available; however, **this is a bad idea**, because as long as the object is not in the store, you will not benefit from the observability provided by DataFlux. _E.g., your React state will not update automatically and you will need to handle the changes triggered by the input fields yourself_ ([reinventing the wheel](https://en.wikipedia.org/wiki/Reinventing_the_wheel)).
+
+Solution, use `.mock()` to create a mock object:
+
+```js
+store.mock("book", {title: "The little prince"});
+```
+
+The mock object behaves exactly like a normal object: you can retrieve it with `.find`/`.findAll`/`.findOne`/`.subscribe`.
+
+However, the mock object is not sent to the API as long as you don't call `.insert()` on the object itself. When you call `.insert()`, the mock object is promoted to real object.
+
+> Warning: to promote a mock object, you need to call `object.insert()` on the object itself (you must first retrieve it) and NOT `store.insert()`.
+
 
 ## Store events
 The store emits the following events:
 
-| Name    | Description                                                                                                                           |
-|---------|---------------------------------------------------------------------------------------------------------------------------------------|
-| error   | To listen the errors emitted by the store.                                                                                            |
-| save    | Possible emitted values are `start` and `end`. They are emitted when the store starts/finishes to persist the data (API interaction). |
-| loading | The event is emitted while a new model is loaded. The value contains something like `{status: "start", model: "book"}`                |
+| Name       | Description                                                                                                                           |
+|------------|---------------------------------------------------------------------------------------------------------------------------------------|
+| error      | To listen the errors emitted by the store.                                                                                            |
+| save       | Possible emitted values are `start` and `end`. They are emitted when the store starts/finishes to persist the data (API interaction). |
+| loading    | The event is emitted while a new model is loaded. The value contains something like `{status: "start", model: "book"}`                |
+| refreshing | The event is emitted while a model is refreshed. The value contains something like `{status: "start", model: "book"}`                 |
 
 ## Objects methods
 Each object created is enriched with the following methods.
 
 
-| Method                             | Description                                                                                                                                                                                                                                                                                                                                                         |
-|------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| getId()                            | It returns a unique ID used by the store to identify the object. The ID is unique inside a single model. Be aware, `object.id` and `objet.getId()` may return different values, since store's IDs can be different from the one of the REST API.                                                                                                                    |
-| set(attribute, value, hidden)      | A method to set an attribute to the object. It provides some advantages compared to doing `object.attribute = value`, these are discussed in [below](#editing-objects). The third parameter is optional, and when set to true will set the attribute as hidden (see [hiddenFields](#models-creation)).                                                              |
-| setConstant(attribute, value)      | A method to set an unmodifiable hidden attribute on the object. Setting the attribute as a constant will not propagate an update.                                                                                                                                                                                                                                   |
+| Method                             | Description                                                                                                                                                                                                                                                                                                                                                     |
+|------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| getId()                            | It returns a unique ID used by the store to identify the object. The ID is unique inside a single model. Be aware, `object.id` and `objet.getId()` may return different values, since store's IDs can be different from the one of the REST API.                                                                                                                |
+| set(attribute, value, hidden)      | A method to set an attribute to the object. It provides some advantages compared to doing `object.attribute = value`, these are discussed in [below](#editing-objects). The third parameter is optional, and when set to true will set the attribute as hidden (see [hiddenFields](#models-creation)).                                                          |
+| setConstant(attribute, value)      | A method to set an unmodifiable hidden attribute on the object. Setting the attribute as a constant will not propagate an update.                                                                                                                                                                                                                               |
 | get(attribute, defaultValue)       | Method to retrieve the value of an attribute. It does not provide any advantage compared to accessing directly the attribute (e.g., `author.name`); except for hidden fields and constants, which can be retrieved only with the `.get` method. Additionally, you can provide a default value as a second parameter in case the object doesn't have that attribute. |
-| getRelation(model, filterFunction) | To get all the objects respecting a specific relation with this object (see [model relations](#model-relations)).                                                                                                                                                                                                                                                   |
-| save()                             | Method to save the object. You can do `store.save()` instead.                                                                                                                                                                                                                                                                                                       |
-| destroy()                          | Method to delete the object. You can do `store.delete()` instead.                                                                                                                                                                                                                                                                                                   |
-| toJSON()                           | It returns a pure JSON representation of the object.                                                                                                                                                                                                                                                                                                                |
-| toString()                         | It returns a string representation of the object.                                                                                                                                                                                                                                                                                                                   |
-| getFingerprint()                   | It returns a hash of the object. The hash changes at every change of the object or of any nested object. Useful to detect object changes.                                                                                                                                                                                                                           |
-| getModel()                         | It returns the model of this object. Mostly useful to do `object.getModel().getType()` and obtain a string defining the type of the object.                                                                                                                                                                                                                         |
-### Deeper Objects
+| getRelation(model, filterFunction) | To get all the objects respecting a specific relation with this object (see [model relations](#model-relations)).                                                                                                                                                                                                                                               |
+| save()                             | Method to save the object. You can do `store.save()` instead.                                                                                                                                                                                                                                                                                                   |
+| destroy()                          | Method to delete the object. You can do `store.delete()` instead.                                                                                                                                                                                                                                                                                               |
+| toJSON()                           | It returns a pure JSON representation of the object.                                                                                                                                                                                                                                                                                                            |
+| toString()                         | It returns a string representation of the object.                                                                                                                                                                                                                                                                                                               |
+| getFingerprint()                   | It returns a hash of the object. The hash changes at every change of the object or of any nested object. Useful to detect object changes.                                                                                                                                                                                                                       |
+| getModel()                         | It returns the model of this object. Mostly useful to do `object.getModel().getType()` and obtain a string defining the type of the object.                                                                                                                                                                                                                     |
+| getError()                         | If an operation on an object triggers an error, this error can be retrieved with `getError()`. This allows to observe specific objects' errors, instead of the generic `store.on("error", ...)`.                                                                                                                                          |
+| getError(attributeName)            | This method allows you to check if the specificed attribute generated any error according to the validation property specified in the model. See [objects validation](#objects-validation).                                                                                                                                                                     | 
+| setError(error)                    | Additionally to DataFlux's errors, you can trigger your own errors with this method. Other components observing this objet's error will be notified.                                                                                                                                                                                                            |
+
+### Deep Objects
 When a model is declared with the option `deep: true` (default, see [model creation](#models-creation)), all the sub objects will also offer many of the methods above.
 
 Imagine the API returns:
@@ -611,8 +658,75 @@ store.find("book")
         });
 ```
 
+### Objects validation
+
+DataFlux supports automatic validation of the objects. This is important for two reasons:
+* Objects that contain invalid attributes' values are not sent back to the API;
+* Validation errors can be used to automatically suggest errors in the UI.
+
+To specify the validation of the objects for a specific model, you need to add a `validate` dictionary during model creation.
+
+```js
+const book = new Model("book", {
+  retrieve: {
+    url: "https://rest.example.net/api/v1/books/"
+  },
+  validate: {
+    isbn: ({isbn}) => {
+      if (typeof(isbn) !== "number") {
+        throw new Error("The isbn must be a number");
+      }
+    },
+    title: ({title}) => {
+      if (!title) {
+        throw new Error("The title is mandatory");
+      }
+    }
+  }
+});
+```
+
+Each key of the `validate` dictionary is an attribute of the object (a field name), each value is a function receiving in input the object and throwing an error in case the field is not valid.
+
+> Be aware: A validation function cannot return a boolean, you have to throw an error.
+
+To validate a specific attribute of an object, you can do `object.getError(attributeName)` (e.g., `book.getError(isbn)`). In case of error, a string describing the error is returned, `false` otherwise.
+
+Example of usage in a React component.
+
+```js
+class MyComponent extends React.Component {
+  constructor(props) {
+    super(props);
+  }
+
+  render(){
+    const {book} = this.state;
+
+    // A textfield to edit the title of a book
+    return <TextField
+            value={book.title}
+            onChange={store.handleChange(book, "title")}
+            error={object.getError("title")} 
+            // E.g., in material UI the test field will be red in case of errors
+    />;
+  }
+}
+```
+
+> Be aware: if you do `object.getError()` without specifying any attribute, you will receive object errors not associated with any field, such as API errors. This is similar to `store.on("error")`
+
 
 ## Editing objects
+
+The preferred method to edit objects is using the `.set()` method that each object has, instead of editing directly the attributes.  However, there are a few notions to keep in mind.
+
+#### Client-side object validaion will not work when editing attributes directly.
+
+You will be able to validate objects only if you use `.set()`. If you edit directly the attribute (e.g., `book.title = "test"`) errors will be discovered only by the API.
+
+#### Auto save may not work when editing attributes directly.
+
 The option `autoSave` can be `true`, `false`, or a number (milliseconds).
 
 * When `autoSave` is set to `false`, the following operations are equivalent:

package/dist/BasicObj.js

@@ -24,20 +24,21 @@ function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedec
 
 function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
 
-function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
 
-function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
 
-function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
 
 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; }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
 
 function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 
 var dateRegex = new RegExp("^[0-9][0-9][0-9][0-9]-[0-9].*T[0-9].*Z$");
 exports.dateRegex = dateRegex;
+var globalError = "_object";
 
 function setValues(values, model, SubObj, parent, context) {
   Object.keys(values).forEach(function (key) {
@@ -64,6 +65,10 @@ var _setHidden = /*#__PURE__*/new WeakMap();
 
 var _id = /*#__PURE__*/new WeakMap();
 
+var _error = /*#__PURE__*/new WeakMap();
+
+var _model = /*#__PURE__*/new WeakMap();
+
 var BasicObj = /*#__PURE__*/_createClass(function BasicObj(values, model) {
   var _this = this;
 
@@ -79,10 +84,26 @@ var BasicObj = /*#__PURE__*/_createClass(function BasicObj(values, model) {
     value: null
   });
 
+  _classPrivateFieldInitSpec(this, _error, {
+    writable: true,
+    value: {}
+  });
+
+  _classPrivateFieldInitSpec(this, _model, {
+    writable: true,
+    value: void 0
+  });
+
+  _defineProperty(this, "setId", function (id) {
+    _classPrivateFieldSet(_this, _id, id);
+  });
+
   _defineProperty(this, "getId", function () {
     if (!_classPrivateFieldGet(_this, _id)) {
       if (_this.id && (typeof _this.id === "string" || typeof _this.id === "number")) {
         _classPrivateFieldSet(_this, _id, _this.id.toString());
+
+        delete _this.setId;
       } else {
         _classPrivateFieldSet(_this, _id, (0, _uuid.v4)());
       }
@@ -106,15 +127,39 @@ var BasicObj = /*#__PURE__*/_createClass(function BasicObj(values, model) {
       }
 
       _this[attribute] = value;
+
+      _classPrivateFieldGet(_this, _model).validateObjectAttribute(_this, attribute);
     }
 
     return _this.update();
   });
 
-  _defineProperty(this, "setConstant", function (attribute, value) {
+  _defineProperty(this, "getError", function () {
     var _classPrivateFieldGet3;
 
-    _classPrivateFieldGet(_this, _setHidden)[attribute] = (_classPrivateFieldGet3 = _classPrivateFieldGet(_this, _setHidden)[attribute]) !== null && _classPrivateFieldGet3 !== void 0 ? _classPrivateFieldGet3 : value;
+    var attribute = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    var key = attribute ? attribute : globalError;
+    return (_classPrivateFieldGet3 = _classPrivateFieldGet(_this, _error)[key]) !== null && _classPrivateFieldGet3 !== void 0 ? _classPrivateFieldGet3 : false;
+  });
+
+  _defineProperty(this, "setError", function (error) {
+    var attribute = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+
+    if (error && attribute) {
+      _classPrivateFieldGet(_this, _error)[attribute] = error;
+    } else if (error && !attribute) {
+      _classPrivateFieldGet(_this, _error)[globalError] = error;
+    } else if (!error && attribute) {
+      delete _classPrivateFieldGet(_this, _error)[attribute];
+    } else {
+      _classPrivateFieldSet(_this, _error, {});
+    }
+  });
+
+  _defineProperty(this, "setConstant", function (attribute, value) {
+    var _classPrivateFieldGet4;
+
+    _classPrivateFieldGet(_this, _setHidden)[attribute] = (_classPrivateFieldGet4 = _classPrivateFieldGet(_this, _setHidden)[attribute]) !== null && _classPrivateFieldGet4 !== void 0 ? _classPrivateFieldGet4 : value;
   });
 
   _defineProperty(this, "toJSON", function () {
@@ -153,6 +198,8 @@ var BasicObj = /*#__PURE__*/_createClass(function BasicObj(values, model) {
   _defineProperty(this, "update", function () {
     return Promise.resolve();
   });
+
+  _classPrivateFieldSet(this, _model, model);
 });
 
 exports.BasicObj = BasicObj;

package/dist/Model.js

@@ -7,8 +7,6 @@ exports["default"] = void 0;
 
 var _modelHooksUtils = require("./modelHooksUtils");
 
-var _batchPromises = _interopRequireDefault(require("batch-promises"));
-
 var _axios2 = _interopRequireDefault(require("axios"));
 
 var _BasicObj = require("./BasicObj");
@@ -95,22 +93,29 @@ var _addRelationByFilter = /*#__PURE__*/new WeakMap();
 
 var _removeHiddenFields = /*#__PURE__*/new WeakMap();
 
-var _bulkOperation = /*#__PURE__*/new WeakMap();
-
 var _toArray = /*#__PURE__*/new WeakMap();
 
 var _unWrap = /*#__PURE__*/new WeakMap();
 
 var _insertObjects = /*#__PURE__*/new WeakMap();
 
+var _assignId = /*#__PURE__*/new WeakMap();
+
 var _updateObjects = /*#__PURE__*/new WeakMap();
 
 var _deleteObjects = /*#__PURE__*/new WeakMap();
 
+var _hanldeApiError = /*#__PURE__*/new WeakMap();
+
+var _cleanApiError = /*#__PURE__*/new WeakMap();
+
+var _removeFromStoreSilentlyAfterFailure = /*#__PURE__*/new WeakMap();
+
 var Model = /*#__PURE__*/_createClass(function Model(name) {
   var _this = this,
       _options$deep,
-      _options$parseMoment;
+      _options$parseMoment,
+      _options$validate;
 
   var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
@@ -178,6 +183,31 @@ var Model = /*#__PURE__*/_createClass(function Model(name) {
     value: void 0
   });
 
+  _defineProperty(this, "validateObjectAttribute", function (object, key) {
+    var validate = _this.options.validate;
+
+    if (validate && validate[key]) {
+      try {
+        validate[key](object);
+        object.setError(false, key);
+      } catch (error) {
+        object.setError(error.message, key);
+      }
+    }
+  });
+
+  _defineProperty(this, "isObjectValid", function (object) {
+    for (var key in object) {
+      if (typeof object[key] !== "function") {
+        if (object.getError(key)) {
+          return false;
+        }
+      }
+    }
+
+    return true;
+  });
+
   _defineProperty(this, "getStore", function () {
     return _classPrivateFieldGet(_this, _store);
   });
@@ -272,15 +302,15 @@ var Model = /*#__PURE__*/_createClass(function Model(name) {
   });
 
   _defineProperty(this, "insertObjects", function (objects) {
-    return objects.length ? _classPrivateFieldGet(_this, _bulkOperation).call(_this, objects, _classPrivateFieldGet(_this, _insertObjects)) : Promise.resolve();
+    return objects.length ? _classPrivateFieldGet(_this, _insertObjects).call(_this, objects) : Promise.resolve();
   });
 
   _defineProperty(this, "updateObjects", function (objects) {
-    return objects.length ? _classPrivateFieldGet(_this, _bulkOperation).call(_this, objects, _classPrivateFieldGet(_this, _updateObjects)) : Promise.resolve();
+    return objects.length ? _classPrivateFieldGet(_this, _updateObjects).call(_this, objects) : Promise.resolve();
   });
 
   _defineProperty(this, "deleteObjects", function (objects) {
-    return objects.length ? _classPrivateFieldGet(_this, _bulkOperation).call(_this, objects, _classPrivateFieldGet(_this, _deleteObjects)) : Promise.resolve();
+    return objects.length ? _classPrivateFieldGet(_this, _deleteObjects).call(_this, objects) : Promise.resolve();
   });
 
   _defineProperty(this, "factory", function (params) {
@@ -339,26 +369,11 @@ var Model = /*#__PURE__*/_createClass(function Model(name) {
     }
   });
 
-  _classPrivateFieldInitSpec(this, _bulkOperation, {
-    writable: true,
-    value: function value(objects, action) {
-      if (_classPrivateFieldGet(_this, _singleItemQuery)) {
-        return (0, _batchPromises["default"])(_classPrivateFieldGet(_this, _batchSize), objects.map(function (i) {
-          return _classPrivateFieldGet(_this, _removeHiddenFields).call(_this, i.toJSON());
-        }), action);
-      } else {
-        return action(objects.map(function (i) {
-          return _classPrivateFieldGet(_this, _removeHiddenFields).call(_this, i.toJSON());
-        }));
-      }
-    }
-  });
-
   _classPrivateFieldInitSpec(this, _toArray, {
     writable: true,
     value: function value(data) {
       if (Array.isArray(data)) {
-        if (data.every(function (str) {
+        if (data.length && data.every(function (str) {
           return ["string", "number"].includes(_typeof(str));
         })) {
           return [{
@@ -381,7 +396,11 @@ var Model = /*#__PURE__*/_createClass(function Model(name) {
 
   _classPrivateFieldInitSpec(this, _unWrap, {
     writable: true,
-    value: function value(data) {
+    value: function value(objects) {
+      var data = Object.values(objects).map(function (object) {
+        return _classPrivateFieldGet(_this, _removeHiddenFields).call(_this, object.toJSON());
+      });
+
       if (data.value != null && Object.keys(data).length === 1) {
         return data.value;
       } else if (Array.isArray(data) && data.length === 1 && data[0].value != null && Object.keys(data[0]).length === 1) {
@@ -394,22 +413,109 @@ var Model = /*#__PURE__*/_createClass(function Model(name) {
 
   _classPrivateFieldInitSpec(this, _insertObjects, {
     writable: true,
-    value: function value(data) {
-      return (0, _modelHooksUtils.executeHook)("insert", _classPrivateFieldGet(_this, _insertHook), _classPrivateFieldGet(_this, _unWrap).call(_this, data), _classPrivateFieldGet(_this, _axios)).then(_classPrivateFieldGet(_this, _toArray));
+    value: function value(objects) {
+      var operation = "insert";
+      return (0, _modelHooksUtils.executeHook)(operation, _classPrivateFieldGet(_this, _insertHook), _classPrivateFieldGet(_this, _unWrap).call(_this, objects), _classPrivateFieldGet(_this, _axios)).then(function (data) {
+        if (data) _classPrivateFieldGet(_this, _assignId).call(_this, data, objects);
+
+        _classPrivateFieldGet(_this, _cleanApiError).call(_this, objects);
+
+        return data;
+      }).then(_classPrivateFieldGet(_this, _toArray))["catch"](function (error) {
+        _classPrivateFieldGet(_this, _removeFromStoreSilentlyAfterFailure).call(_this, objects);
+
+        return _classPrivateFieldGet(_this, _hanldeApiError).call(_this, error, objects, operation);
+      });
+    }
+  });
+
+  _classPrivateFieldInitSpec(this, _assignId, {
+    writable: true,
+    value: function value(data, objects) {
+      if (data.length === 1) {
+        var newId = data[0].id;
+        objects[0].setId(newId);
+        delete objects[0].setId;
+      }
     }
   });
 
   _classPrivateFieldInitSpec(this, _updateObjects, {
     writable: true,
-    value: function value(data) {
-      return (0, _modelHooksUtils.executeHook)("update", _classPrivateFieldGet(_this, _updateHook), _classPrivateFieldGet(_this, _unWrap).call(_this, data), _classPrivateFieldGet(_this, _axios)).then(_classPrivateFieldGet(_this, _toArray));
+    value: function value(objects) {
+      var operation = "update";
+      return (0, _modelHooksUtils.executeHook)(operation, _classPrivateFieldGet(_this, _updateHook), _classPrivateFieldGet(_this, _unWrap).call(_this, objects), _classPrivateFieldGet(_this, _axios)).then(function (data) {
+        _classPrivateFieldGet(_this, _cleanApiError).call(_this, objects);
+
+        return data;
+      }).then(_classPrivateFieldGet(_this, _toArray))["catch"](function (error) {
+        return _classPrivateFieldGet(_this, _hanldeApiError).call(_this, error, objects, operation);
+      });
     }
   });
 
   _classPrivateFieldInitSpec(this, _deleteObjects, {
     writable: true,
-    value: function value(data) {
-      return (0, _modelHooksUtils.executeHook)("delete", _classPrivateFieldGet(_this, _deleteHook), _classPrivateFieldGet(_this, _unWrap).call(_this, data), _classPrivateFieldGet(_this, _axios)).then(_classPrivateFieldGet(_this, _toArray));
+    value: function value(objects) {
+      var operation = "delete";
+      return (0, _modelHooksUtils.executeHook)(operation, _classPrivateFieldGet(_this, _deleteHook), _classPrivateFieldGet(_this, _unWrap).call(_this, objects), _classPrivateFieldGet(_this, _axios)).then(function (data) {
+        _classPrivateFieldGet(_this, _cleanApiError).call(_this, objects);
+
+        return data;
+      }).then(_classPrivateFieldGet(_this, _toArray))["catch"](function (error) {
+        return _classPrivateFieldGet(_this, _hanldeApiError).call(_this, error, objects, operation);
+      });
+    }
+  });
+
+  _classPrivateFieldInitSpec(this, _hanldeApiError, {
+    writable: true,
+    value: function value(error, objects, operation) {
+      var _error$response$data, _error3, _error3$response, _ref, _error$message, _error4, _error5;
+
+      error = (_error$response$data = (_error3 = error) === null || _error3 === void 0 ? void 0 : (_error3$response = _error3.response) === null || _error3$response === void 0 ? void 0 : _error3$response.data) !== null && _error$response$data !== void 0 ? _error$response$data : error;
+      var targets = objects.map(function (object) {
+        return object.getId();
+      }); // Set errors
+
+      var strError = (_ref = (_error$message = (_error4 = error) === null || _error4 === void 0 ? void 0 : _error4.message) !== null && _error$message !== void 0 ? _error$message : (_error5 = error) === null || _error5 === void 0 ? void 0 : _error5.error) !== null && _ref !== void 0 ? _ref : error;
+      Object.values(objects).map(function (object) {
+        return object.setError(strError);
+      });
+      return Promise.reject(_objectSpread(_objectSpread({}, error), {}, {
+        targets: targets,
+        operation: operation
+      }));
+    }
+  });
+
+  _classPrivateFieldInitSpec(this, _cleanApiError, {
+    writable: true,
+    value: function value(objects) {
+      Object.values(objects).map(function (object) {
+        return object.setError(false);
+      });
+    }
+  });
+
+  _classPrivateFieldInitSpec(this, _removeFromStoreSilentlyAfterFailure, {
+    writable: true,
+    value: function value(objects) {
+      var _iterator2 = _createForOfIteratorHelper(objects.map(function (object) {
+        return object.getId();
+      })),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var target = _step2.value;
+          delete _this.getStore().models[_this.getType()].storedObjects[target];
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
     }
   });
 
@@ -418,7 +524,8 @@ var Model = /*#__PURE__*/_createClass(function Model(name) {
   this.options = _objectSpread(_objectSpread({}, options), {}, {
     deep: (_options$deep = options.deep) !== null && _options$deep !== void 0 ? _options$deep : true,
     parseMoment: (_options$parseMoment = options.parseMoment) !== null && _options$parseMoment !== void 0 ? _options$parseMoment : false,
-    lazyLoad: options.lazyLoad
+    lazyLoad: options.lazyLoad,
+    validate: (_options$validate = options.validate) !== null && _options$validate !== void 0 ? _options$validate : {}
   });
 
   _classPrivateFieldSet(this, _store, null);
@@ -439,12 +546,12 @@ var Model = /*#__PURE__*/_createClass(function Model(name) {
     throw new Error("The load option must be a function");
   }
 
-  var _ref = _typeof(options) === "object" ? (0, _modelHooksUtils.getHooksFromOptions)(options) : (0, _modelHooksUtils.getHooksFromUrl)(options),
-      _ref2 = _slicedToArray(_ref, 4),
-      retrieveHook = _ref2[0],
-      insertHook = _ref2[1],
-      updateHook = _ref2[2],
-      deleteHook = _ref2[3];
+  var _ref2 = _typeof(options) === "object" ? (0, _modelHooksUtils.getHooksFromOptions)(options) : (0, _modelHooksUtils.getHooksFromUrl)(options),
+      _ref3 = _slicedToArray(_ref2, 4),
+      retrieveHook = _ref3[0],
+      insertHook = _ref3[1],
+      updateHook = _ref3[2],
+      deleteHook = _ref3[3];
 
   _classPrivateFieldSet(this, _retrieveHook, retrieveHook);