dataflux 1.2.1 → 1.2.5

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 Massimo Candela
+Copyright (c) 2022-present Massimo Candela
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -30,23 +30,34 @@ Create your global store by creating a file (e.g., named `store.js`) containing
 Consider the following hypothetical store/model declaration common to all the examples below:
 
 ```js
+// Content of your store.js
 import {Store, Model} from "dataflux";
 
+// We create a new Store
 const store = new Store();
-const author = new Model("author", `https://rest.example.net/api/v1/authors`);
-const book = new Model("book", `https://rest.example.net/api/v1/books`);
 
-store.addModel(author);
+// We now create two models, "author" and "book". 
+// Both of them are auto generated based on the output of a REST API.
+// The REST API does NOT need to provide a specific format.
+// E.g., /books returns [{"title": "Hamlet", "year": 1600}, ...].
+// See "REST API format" below for more info.
+const book = new Model("book", `https://api.example.net/books`);
+const author = new Model("author", `https://api.example.net/authors`);
+
+// We add the models to the store
 store.addModel(book);
+store.addModel(author);
 
-// An object relation between author.id and book.authorId as follows
+// Optionally, we can declare relations among models.
+// E.g., we can declare that an author has one or more books.
 author.addRelation(book, "id", "authorId");
+// The relation will provide all the books where author.id = book.authorId
 
 export default store;
 ```
 
 
-The store can be initialized with [various options](#configuration). You need only one store for the entire application, that's why you should declare it in its own file and import it in multiple places.
+The store can be initialized with [various options](#configuration). You need only one store for the entire application, that's why you should declare it in its own file (store.js in this case) and import it in multiple places.
 
 The creation of a model requires at least a name and a url. GET, POST, PUT, and DELETE operations are going to be performed against the same url. [Models can be created with considerably more advanced options.](#models-creation)
 
@@ -55,28 +66,31 @@ A JS object is automatically created for each item returned by the API, for each
 
 ### Example 1
 
-Retrieve and edit an author not knowing the ID:
+Retrieve and edit an author by name and surname:
 
 ```js
-import store from "./store";
+import store from "./store"; // Import our store.js
 
 // Find the author Dante Alighieri
 store.find("author", ({name, surname}) => name == "Dante" && surname == "Alighieri")
         .then(([author]) => {
+
+          // We got the author, let's now edit it
           author.set("country", "Italy");
           author.set("type", "poet");
-          // Nothing else to do, the store does a single PUT request to the model's API about the edited object
         });
 ```
 
-> You don't necessarily need to use `object.set` to edit an object attribute. You could do `author.country = "Italy"`. However, this approach relies on a periodic detection of changes (while `.set` triggers an update immediately). Check the `autoSave` option for more information
+Nothing else to do! After your edit, the store will do a single PUT request to the model's API to save the edited object. This behavior can be disabled, see next example.
+
+> You don't necessarily need to use `object.set` to edit an object attribute. You could do `author.country = "Italy"`. However, this approach has disadvantages, read [editing objects](#editing-objects) for more information
 
 ### Example 2
 
-Operations without autoSave:
+DataFlux automatically sends the edited objects back to the API to be saved. However, you can disable this behavior and manually instruct the store when to save. 
 
 ```js
-// To disable autoSave you must declare the store as follows
+// To disable autoSave you must declare the store (in store.js) as follows
 const store = new Store({autoSave: false});
 ```
 
@@ -86,11 +100,13 @@ The same example above now becomes:
 // Find the author Dante Alighieri
 store.find("author", ({name, surname}) => name == "Dante" && surname == "Alighieri")
         .then(([author]) => {
-          // When autoSave = false, you can still use author.set, but there is no actual benefit
+            
+          // When autoSave is false, author.set("country", "Italy") and 
+          // author.country = "Italy" are equivalent
           author.country = "Italy"
           author.type = "poet"
 
-          store.save(); // Even if we changed only one author, prefer always store.save() to author.save()
+          store.save(); // Instruct the store to save
         });
 ```
 
@@ -129,6 +145,7 @@ author.getRelation("book");
 
 If you use `subscribe` instead of `find`, you can provide a callback to be invoked when data is ready or there is a change in the data.
 
+_**DataFlux remembers your query and calls your callback every time any change is affecting the result of your query!**_
 
 ```js
 const drawBooksCallback = (books) => {
@@ -139,7 +156,7 @@ const drawBooksCallback = (books) => {
 store.subscribe("book", drawBooks, ({price}) => price < 20);
 ```
 
-If now somewhere a book is inserted/deleted/edited:
+If now a book is inserted/deleted/edited:
 * if the book has `price < 20`,  `drawBooksCallback` will be called again with the new dataset;
 * if the book has `price > 20`,  `drawBooksCallback` will NOT be called again (because the new book doesn't impact our selection).
 
@@ -151,14 +168,31 @@ const subKey = store.subscribe("book", drawBooks, ({price}) => price < 20); // S
 store.unsubscribe(subKey); // Unsubscribe
 ```
 
+You can also do multiple subscriptions at once:
+
+```js
+const subscriptions = [
+    ["book", ({title}) => title === "The little prince"], // Model name and filter function
+    ["author"], // No filter function, all objects returned
+];
+
+const callback = ([books, authors]) => {
+    // Objects are ready
+};
+
+const subKey = store.multipleSubscribe(requests, callback); // Subscribe
+
+store.unsubscribe(subKey); // Unsubscribe
+```
+
 ### Example 6 - Observability + React
 
 The integration with React is offered transparently when using the store inside a `React.Component`.
-You can use two methods: `findOne`, and `findAll`.
+You can use two methods: `findOne`, and `findAll` (which are a react-specific syntactic sugar over `subscribe`).
 
-> Since the store is able to detect changes deep in a nested structure, you will not have to worry about the component not re-rendering. Also, the setState will only be triggered when the next change of the dataset is really impacting your selection.
+**_Since the store is able to detect changes deep in a nested structure, you will not have to worry about the component not re-rendering. Also, the setState will be triggered ONLY when the next change of the dataset is impacting your selection._**
 
-React Component example
+React Component example:
 ```jsx
 class MyComponent extends React.Component {
   constructor(props) {
@@ -168,9 +202,9 @@ class MyComponent extends React.Component {
   componentDidMount() {
     // Get all books with a price < 20
     store.findAll("book", "books", this, ({price}) => price < 20);
-    // Every time the dataset changes, a setState will be automatically 
-    // performed. An attribute "books" will be added/updated in the 
-    // state (the rest of the state remains unchanged).
+    // An attribute "books" will be added/updated in the 
+    // state (the rest of the state remains unchanged) every time
+    // a book in our selection is inserted/deleted/edited.
 
     // findAll is a syntactic sugar for:
     // const callback = (books) => {this.setState({...this.state, books})};
@@ -185,7 +219,7 @@ class MyComponent extends React.Component {
                     onTitleChange={(title) => book.set("title", title)}
                     // onTitleChange will alter the book and so the current 
                     // state of "books" (a setState will be performed).
-                    //
+                    
                     // Alternatively:
                     // onTitleChange={store.handleChange(book, "title")} 
                     // is a syntactic sugar of the function above
@@ -194,9 +228,9 @@ class MyComponent extends React.Component {
 }
 ```
 
-The method `findAll` returns always an array. The method `findOne` returns a single object (if multiple objects satisfy the search, the first is returned).
+The method `findAll` returns always an array. The method `findOne` returns a single object (if multiple objects satisfy the query, the first is returned).
 
-When the component will unmount, the `findAll` subscription will be automatically terminated without the need to unsubscribe. Be aware, `store.findAll` injects the unsubscribe call inside `componentWillUnmount`. If your component already implements `componentWillUnmount()`, then you will have to use `store.subscribe` and `store.unsubscribe` instead of `store.findAll`, to avoid side effects when the component is unmounted.
+When the component will unmount, the `findAll` subscription will be automatically terminated without the need to unsubscribe. Be aware, `store.findAll()` injects the unsubscribe call inside `componentWillUnmount()`. If your component already implements `componentWillUnmount()`, then you will have to use `store.subscribe()` and `store.unsubscribe()` instead of `store.findAll()`, to avoid side effects when the component is unmounted.
 
 ## Configuration
 
@@ -205,7 +239,7 @@ 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. | 3000    |
+| 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   |
 
@@ -216,7 +250,7 @@ The store can be configured with the following options:
 A model can be simply created with:
 
 ```js
-const book = new Model("book", `https://rest.example.net/api/v1/books`);
+const book = new Model("book", `https://api.example.net/books`);
 ```
 
 However, sometimes you may want to define a more complex interaction with the API. In such cases you can pass options to perform more elaborated model's initializations.
@@ -418,14 +452,29 @@ author1.getRelation("book", (book) => book.price < 20)
 
 The store has the following method.
 
-| Method                       | Description                                                                                                                                                |
-|------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| 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. 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.                                                                                       |
+| Method                                                 | Description                                                                                                                                                                                                                                                                                                                                                                                                        |
+|--------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| on(event, callback)                                    | Method to subscribe to the events emitted by the store. See [events](#store-events) below.                                                                                                                                                                                                                                                                                                                         |
+| 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(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.                                                                                                                                                                                                                                                                                                                                               |
+| 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).   |
+
+## 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"}`                |
 
 ## Objects methods
 Each object created is enriched with the following methods.

package/dist/Model.js

@@ -33,12 +33,16 @@ function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _d
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
 
 function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
 
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+
 function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
 
 function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
@@ -49,6 +53,18 @@ function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!priva
 
 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; } }
 
+var applyData = function applyData(obj, data) {
+  for (var att in data) {
+    if (att !== "id" || obj.id === undefined || att === "id" && obj.id === data.id) {
+      obj[att] = data[att];
+    } else {
+      return Promise.reject("The loading function cannot change the id of the object.");
+    }
+  }
+
+  return Promise.resolve(obj);
+};
+
 var _type = /*#__PURE__*/new WeakMap();
 
 var _store = /*#__PURE__*/new WeakMap();
@@ -71,6 +87,8 @@ var _axios = /*#__PURE__*/new WeakMap();
 
 var _loadFunction = /*#__PURE__*/new WeakMap();
 
+var _error = /*#__PURE__*/new WeakSet();
+
 var _addRelationByField = /*#__PURE__*/new WeakMap();
 
 var _addRelationByFilter = /*#__PURE__*/new WeakMap();
@@ -92,6 +110,8 @@ var Model = /*#__PURE__*/_createClass(function Model(name) {
 
   _classCallCheck(this, Model);
 
+  _classPrivateMethodInitSpec(this, _error);
+
   _classPrivateFieldInitSpec(this, _type, {
     writable: true,
     value: void 0
@@ -160,35 +180,31 @@ var Model = /*#__PURE__*/_createClass(function Model(name) {
   });
 
   _defineProperty(this, "load", function (obj) {
-    return new Promise(function (resolve, reject) {
-      var applyData = function applyData(data) {
-        for (var att in data) {
-          if (att !== "id" || obj.id === undefined || att === "id" && obj.id === data.id) {
-            obj[att] = data[att];
-          } else {
-            return Promise.reject("The loading function cannot change the id of the object.");
-          }
-        }
-      };
-
-      if (_classPrivateFieldGet(_this, _loadFunction)) {
-        var res = _classPrivateFieldGet(_this, _loadFunction).call(_this, obj.toJson());
+    if (_classPrivateFieldGet(_this, _loadFunction)) {
+      return _this.getStore().whenSaved(_this.getType())["catch"](function () {
+        throw new Error("You cannot perform load() on an unsaved object.");
+      }).then(function () {
+        var res = _classPrivateFieldGet(_this, _loadFunction).call(_this, obj.toJSON());
 
         if (typeof res === "string") {
-          _classPrivateFieldGet(_this, _axios).call(_this, {
+          return _classPrivateFieldGet(_this, _axios).call(_this, {
             method: "get",
             url: res,
             responseType: "json"
           }).then(function (data) {
-            return applyData(data.data);
-          }).then(resolve);
+            return data.data;
+          });
         } else {
-          res.then(applyData).then(resolve);
+          return res;
         }
-      } else {
-        reject("You must define a loading function in the model to enable load().");
-      }
-    });
+      }).then(function (data) {
+        return applyData(obj, data);
+      })["catch"](function (error) {
+        return _classPrivateMethodGet(_this, _error, _error2).call(_this, error);
+      });
+    } else {
+      return _classPrivateMethodGet(_this, _error, _error2).call(_this, "You must define a loading function in the model to enable load().");
+    }
   });
 
   _defineProperty(this, "addRelation", function (model, param2, param3) {
@@ -216,17 +232,15 @@ var Model = /*#__PURE__*/_createClass(function Model(name) {
     var filterRelation = _classPrivateFieldGet(_this, _includes)[includedType];
 
     if (filterRelation) {
-      return _this.getStore().find(includedType, function (item) {
-        return filterRelation(parentObject, item);
-      }).then(function (data) {
-        if (filterFunction) {
-          return data.filter(filterFunction);
-        }
-
-        return data;
+      return parentObject.load()["catch"](function () {}).then(function () {
+        return _this.getStore().find(includedType, function (item) {
+          return filterRelation(parentObject, item);
+        }).then(function (data) {
+          return filterFunction ? data.filter(filterFunction) : data;
+        });
       });
     } else {
-      return Promise.reject("The relation doesn't exist");
+      return _classPrivateMethodGet(_this, _error, _error2).call(_this, "The relation doesn't exist");
     }
   });
 
@@ -235,7 +249,15 @@ var Model = /*#__PURE__*/_createClass(function Model(name) {
   });
 
   _defineProperty(this, "retrieveAll", function () {
-    return (0, _modelHooksUtils.executeHook)("retrieve", _classPrivateFieldGet(_this, _retrieveHook), null, _classPrivateFieldGet(_this, _axios)).then(_classPrivateFieldGet(_this, _toArray));
+    return (0, _modelHooksUtils.executeHook)("retrieve", _classPrivateFieldGet(_this, _retrieveHook), null, _classPrivateFieldGet(_this, _axios)).then(function (data) {
+      if (Array.isArray(data)) {
+        return data;
+      } else {
+        _classPrivateFieldSet(_this, _singleItemQuery, true);
+
+        return [data];
+      }
+    });
   });
 
   _defineProperty(this, "insertObjects", function (objects) {
@@ -275,9 +297,13 @@ var Model = /*#__PURE__*/_createClass(function Model(name) {
     writable: true,
     value: function value(objects, action) {
       if (_classPrivateFieldGet(_this, _singleItemQuery)) {
-        return (0, _batchPromises["default"])(_classPrivateFieldGet(_this, _batchSize), objects, action);
+        return (0, _batchPromises["default"])(_classPrivateFieldGet(_this, _batchSize), objects.map(function (i) {
+          return i.toJSON();
+        }), action);
       } else {
-        return action(objects);
+        return action(objects.map(function (i) {
+          return i.toJSON();
+        }));
       }
     }
   });
@@ -288,8 +314,6 @@ var Model = /*#__PURE__*/_createClass(function Model(name) {
       if (Array.isArray(data)) {
         return data;
       } else {
-        _classPrivateFieldSet(_this, _singleItemQuery, true);
-
         return [data];
       }
     }
@@ -356,4 +380,10 @@ var Model = /*#__PURE__*/_createClass(function Model(name) {
 
 });
 
-exports["default"] = Model;
+exports["default"] = Model;
+
+function _error2(error) {
+  error = error.message || error;
+  this.getStore().pubSub.publish("error", error);
+  return Promise.reject(error);
+}

package/dist/{StoreObject.js → Obj.js}

@@ -35,7 +35,7 @@ function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) {
 
 var _loaded = /*#__PURE__*/new WeakMap();
 
-var Obj = /*#__PURE__*/_createClass(function Obj(values, model) {
+var Obj = /*#__PURE__*/_createClass(function Obj(values, _model) {
   var _this = this;
 
   _classCallCheck(this, Obj);
@@ -49,11 +49,15 @@ var Obj = /*#__PURE__*/_createClass(function Obj(values, model) {
     if (_classPrivateFieldGet(_this, _loaded)) {
       return Promise.resolve(_this);
     } else {
-      return _this.getModel().load(_this).then(function () {
+      var model = _this.getModel();
+
+      return model.load(_this).then(function () {
         _classPrivateFieldSet(_this, _loaded, true);
 
+        return model.getStore().update([_this], true); // Propagate update
+      }).then(function () {
         return _this;
-      });
+      }); // return always this
     }
   });
 
@@ -75,8 +79,7 @@ var Obj = /*#__PURE__*/_createClass(function Obj(values, model) {
     }
 
     _this[attribute] = value;
-
-    _this.getModel().getStore().update([_this]);
+    return _this.getModel().getStore().update([_this]);
   });
 
   _defineProperty(this, "save", function () {
@@ -107,7 +110,7 @@ var Obj = /*#__PURE__*/_createClass(function Obj(values, model) {
   });
 
   this.getModel = function () {
-    return model;
+    return _model;
   };
 
   Object.keys(values).forEach(function (key) {

package/dist/ObserverStore.js

@@ -17,8 +17,16 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "d
 
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
@@ -83,6 +91,22 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
 
     _classPrivateMethodInitSpec(_assertThisInitialized(_this), _propagateInsertChange);
 
+    _defineProperty(_assertThisInitialized(_this), "multipleSubscribe", function (subscriptions, callback) {
+      return Promise.all(subscriptions.map(function (sub, index) {
+        var attrs = Array.from(Array(index + 1)).map(function () {
+          return null;
+        });
+        return _this.subscribe(sub[0], sub[1], function (data) {
+          attrs[index] = data;
+          return callback.apply(void 0, _toConsumableArray(attrs));
+        });
+      })).then(function (subKeys) {
+        var subKey = (0, _uuid.v4)();
+        _this._multipleSubscribed[subKey] = subKeys;
+        return subKey;
+      });
+    });
+
     _defineProperty(_assertThisInitialized(_this), "subscribe", function (type, callback, filterFunction) {
       var subKey = (0, _uuid.v4)();
 
@@ -104,14 +128,33 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
     });
 
     _defineProperty(_assertThisInitialized(_this), "unsubscribe", function (key) {
-      for (var type in _this._subscribed) {
-        for (var id in _this._subscribed[type]) {
-          _this._subscribed[type][id] = _this._subscribed[type][id].filter(function (i) {
-            return i.subKey !== key;
-          });
+      if (_this._multipleSubscribed[key]) {
+        var _iterator = _createForOfIteratorHelper(_this._multipleSubscribed[key]),
+            _step;
+
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var sub = _step.value;
 
-          if (_this._subscribed[type][id].length === 0) {
-            delete _this._subscribed[type][id];
+            _this.unsubscribe(sub);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+
+        delete _this._multipleSubscribed[key];
+      } else {
+        for (var type in _this._subscribed) {
+          for (var id in _this._subscribed[type]) {
+            _this._subscribed[type][id] = _this._subscribed[type][id].filter(function (i) {
+              return i.subKey !== key;
+            });
+
+            if (_this._subscribed[type][id].length === 0) {
+              delete _this._subscribed[type][id];
+            }
           }
         }
       }
@@ -122,34 +165,34 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
       value: function value(objects, type) {
         var out = {};
 
-        var _iterator = _createForOfIteratorHelper(objects),
-            _step;
+        var _iterator2 = _createForOfIteratorHelper(objects),
+            _step2;
 
         try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            var object = _step.value;
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var object = _step2.value;
             var objectId = object.getId();
             var typeChannel = _this._subscribed[type] || {};
             var subscribedToObject = typeChannel[objectId] || [];
 
-            var _iterator2 = _createForOfIteratorHelper(subscribedToObject),
-                _step2;
+            var _iterator3 = _createForOfIteratorHelper(subscribedToObject),
+                _step3;
 
             try {
-              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-                var sub = _step2.value;
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                var sub = _step3.value;
                 out[sub.subKey] = out[sub.subKey] || sub;
               }
             } catch (err) {
-              _iterator2.e(err);
+              _iterator3.e(err);
             } finally {
-              _iterator2.f();
+              _iterator3.f();
             }
           }
         } catch (err) {
-          _iterator.e(err);
+          _iterator2.e(err);
         } finally {
-          _iterator.f();
+          _iterator2.f();
         }
 
         return Object.values(out);
@@ -180,12 +223,12 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
     _classPrivateFieldInitSpec(_assertThisInitialized(_this), _subscribeToObjects, {
       writable: true,
       value: function value(type, objectsToSubscribe, item) {
-        var _iterator3 = _createForOfIteratorHelper(objectsToSubscribe),
-            _step3;
+        var _iterator4 = _createForOfIteratorHelper(objectsToSubscribe),
+            _step4;
 
         try {
-          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-            var object = _step3.value;
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var object = _step4.value;
             var id = object.getId();
 
             if (!_this._subscribed[type][id]) {
@@ -195,21 +238,22 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
             _this._subscribed[type][id].push(item);
           }
         } catch (err) {
-          _iterator3.e(err);
+          _iterator4.e(err);
         } finally {
-          _iterator3.f();
+          _iterator4.f();
         }
       }
     });
 
     _this._subscribed = {};
+    _this._multipleSubscribed = {};
     return _this;
   }
 
   _createClass(ObserverStore, [{
     key: "update",
-    value: function update(objects) {
-      return _get(_getPrototypeOf(ObserverStore.prototype), "update", this).call(this, objects).then(_classPrivateFieldGet(this, _propagateChange));
+    value: function update(objects, skipSave) {
+      return _get(_getPrototypeOf(ObserverStore.prototype), "update", this).call(this, objects, skipSave).then(_classPrivateFieldGet(this, _propagateChange));
     }
   }, {
     key: "insert",
@@ -243,21 +287,21 @@ function _propagateInsertChange2(type, newObjects) {
     for (var _i = 0, _objects = objects; _i < _objects.length; _i++) {
       var object = _objects[_i];
 
-      var _iterator4 = _createForOfIteratorHelper(object),
-          _step4;
+      var _iterator5 = _createForOfIteratorHelper(object),
+          _step5;
 
       try {
-        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-          var sub = _step4.value;
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var sub = _step5.value;
 
           if (!uniqueSubs[sub.subKey]) {
             uniqueSubs[sub.subKey] = sub;
           }
         }
       } catch (err) {
-        _iterator4.e(err);
+        _iterator5.e(err);
       } finally {
-        _iterator4.f();
+        _iterator5.f();
       }
     }
 
@@ -272,12 +316,12 @@ function _propagateInsertChange2(type, newObjects) {
         return _this3.find(type, filterFunction).then(function (data) {
           var subKey;
 
-          var _iterator5 = _createForOfIteratorHelper(data),
-              _step5;
+          var _iterator6 = _createForOfIteratorHelper(data),
+              _step6;
 
           try {
-            for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-              var d = _step5.value;
+            for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+              var d = _step6.value;
 
               var item = _this3._subscribed[d.getModel().getType()][d.getId()];
 
@@ -285,9 +329,9 @@ function _propagateInsertChange2(type, newObjects) {
               if (subKey) break;
             }
           } catch (err) {
-            _iterator5.e(err);
+            _iterator6.e(err);
           } finally {
-            _iterator5.f();
+            _iterator6.f();
           }
 
           _classPrivateFieldGet(_this3, _subscribeToObjects).call(_this3, type, objectsToSubscribe, {

package/dist/PersistentStore.js

@@ -49,11 +49,35 @@ var PersistentStore = /*#__PURE__*/function (_Store) {
 
     _this = _super.call(this, options);
 
+    _defineProperty(_assertThisInitialized(_this), "whenSaved", function (type) {
+      return _this.getDiff(type).then(function (_ref) {
+        var inserted = _ref.inserted,
+            updated = _ref.updated,
+            deleted = _ref.deleted;
+
+        if (inserted.length === 0 && updated.length === 0 && deleted.length === 0) {
+          return true;
+        } else if (_this.options.autoSave) {
+          return _this._saveDiff(type, {
+            inserted: inserted,
+            updated: updated,
+            deleted: deleted
+          });
+        } else {
+          return Promise.reject("Save must be invoked manually");
+        }
+      });
+    });
+
     _defineProperty(_assertThisInitialized(_this), "save", function () {
       _this._busy = true;
 
       _this.pubSub.publish("save", "start");
 
+      if (_this._delayedSaveTimer) {
+        clearTimeout(_this._delayedSaveTimer);
+      }
+
       return Promise.all(Object.keys(_this.models).map(_this._saveByType)).then(function (data) {
         _this._busy = false;
 
@@ -71,33 +95,43 @@ var PersistentStore = /*#__PURE__*/function (_Store) {
       });
     });
 
+    _defineProperty(_assertThisInitialized(_this), "_saveDiff", function (type, _ref2) {
+      var inserted = _ref2.inserted,
+          updated = _ref2.updated,
+          deleted = _ref2.deleted;
+      var model = _this.models[type].model; // Operations order:
+      // 1) insert
+      // 2) update
+      // 3) delete
+
+      return model.insertObjects(inserted.map(function (i) {
+        return i.object;
+      })).then(function () {
+        return _this.applyDiff({
+          inserted: inserted
+        }, type);
+      }).then(function () {
+        return model.updateObjects(updated.map(function (i) {
+          return i.object;
+        }));
+      }).then(function () {
+        return _this.applyDiff({
+          updated: updated
+        }, type);
+      }).then(function () {
+        return model.deleteObjects(deleted.map(function (i) {
+          return i.object;
+        }));
+      }).then(function () {
+        return _this.applyDiff({
+          deleted: deleted
+        }, type);
+      });
+    });
+
     _defineProperty(_assertThisInitialized(_this), "_saveByType", function (type) {
-      return _this.getDiff(type).then(function (_ref) {
-        var inserted = _ref.inserted,
-            updated = _ref.updated,
-            deleted = _ref.deleted;
-        var model = _this.models[type].model; // Operations order:
-        // 1) insert
-        // 2) update
-        // 3) delete
-
-        return model.insertObjects(inserted).then(function () {
-          return _this.applyDiff({
-            inserted: inserted
-          }, type);
-        }).then(function () {
-          return model.updateObjects(updated);
-        }).then(function () {
-          return _this.applyDiff({
-            updated: updated
-          }, type);
-        }).then(function () {
-          return model.deleteObjects(deleted);
-        }).then(function () {
-          return _this.applyDiff({
-            deleted: deleted
-          }, type);
-        });
+      return _this.getDiff(type).then(function (diff) {
+        return _this._saveDiff(type, diff);
       });
     });
 
@@ -131,8 +165,7 @@ var PersistentStore = /*#__PURE__*/function (_Store) {
       var _this2 = this;
 
       this._busy = true;
-
-      _get(_getPrototypeOf(PersistentStore.prototype), "addModel", this).call(this, model).then(function () {
+      return _get(_getPrototypeOf(PersistentStore.prototype), "addModel", this).call(this, model).then(function () {
         _this2._busy = false;
       });
     }
@@ -160,11 +193,13 @@ var PersistentStore = /*#__PURE__*/function (_Store) {
     }
   }, {
     key: "update",
-    value: function update(objects) {
+    value: function update(objects, skipSave) {
       var _this5 = this;
 
       return _get(_getPrototypeOf(PersistentStore.prototype), "update", this).call(this, objects).then(function (data) {
-        _this5.delayedSave();
+        if (!skipSave) {
+          _this5.delayedSave();
+        }
 
         return data;
       });

package/dist/Store.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["default"] = void 0;
 
-var _StoreObject = _interopRequireDefault(require("./StoreObject"));
+var _Obj = _interopRequireDefault(require("./Obj"));
 
 var _PubSub = _interopRequireDefault(require("./PubSub"));
 
@@ -17,21 +17,29 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-function _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); }
-
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+
 function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
 
 function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
 
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+
 function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
 
-var _deleteByObject = /*#__PURE__*/new WeakSet();
+var _error = /*#__PURE__*/new WeakSet();
+
+var _deleteByObject = /*#__PURE__*/new WeakMap();
 
 var _deleteByFilter = /*#__PURE__*/new WeakSet();
 
@@ -43,6 +51,8 @@ var _loadObjects = /*#__PURE__*/new WeakSet();
 
 var Store = /*#__PURE__*/function () {
   function Store() {
+    var _this = this;
+
     var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
     _classCallCheck(this, Store);
@@ -55,10 +65,23 @@ var Store = /*#__PURE__*/function () {
 
     _classPrivateMethodInitSpec(this, _deleteByFilter);
 
-    _classPrivateMethodInitSpec(this, _deleteByObject);
+    _classPrivateMethodInitSpec(this, _error);
+
+    _classPrivateFieldInitSpec(this, _deleteByObject, {
+      writable: true,
+      value: function value(object) {
+        var id = object.getId();
+
+        var filterFunction = function filterFunction(item) {
+          return id === item.getId();
+        };
+
+        return _classPrivateMethodGet(_this, _deleteByFilter, _deleteByFilter2).call(_this, object.getModel().getType(), filterFunction);
+      }
+    });
 
     this.options = {
-      autoSave: options.autoSave !== undefined ? options.autoSave : 5000,
+      autoSave: options.autoSave !== undefined ? options.autoSave : true,
       saveDelay: options.saveDelay || 1000,
       lazyLoad: options.lazyLoad || false
     };
@@ -83,65 +106,75 @@ var Store = /*#__PURE__*/function () {
   }, {
     key: "addModel",
     value: function addModel(model) {
-      var _this = this;
+      var _this2 = this;
 
       return new Promise(function (resolve, reject) {
-        _this.validateModel(model);
+        _this2.validateModel(model);
 
         var type = model.getType();
 
-        if (!_this.models[type]) {
-          _this.models[type] = {
+        if (!_this2.models[type]) {
+          _this2.models[type] = {
             model: model,
             storedObjects: {}
           };
-          model.setStore(_this);
+          model.setStore(_this2);
 
-          if (!_this.options.lazyLoad) {
-            resolve(_classPrivateMethodGet(_this, _loadObjects, _loadObjects2).call(_this, type));
+          if (!_this2.options.lazyLoad) {
+            resolve(_classPrivateMethodGet(_this2, _loadObjects, _loadObjects2).call(_this2, type));
           } else {
             resolve();
           }
         } else {
-          reject("The model already exists");
+          var error = "The model already exists";
+
+          _this2.pubSub.publish("error", error);
+
+          reject(error);
         }
       });
     }
   }, {
     key: "update",
     value: function update(objects) {
-      return Promise.resolve(); // Nothing to do at this level
+      return Promise.resolve(objects); // Nothing to do at this level
     }
   }, {
     key: "delete",
     value: function _delete(typeOrObjects, filterFunction) {
       if (typeof typeOrObjects === "string" && typeof filterFunction === "function") {
-        return _classPrivateMethodGet(this, _deleteByFilter, _deleteByFilter2).call(this, typeOrObjects, filterFunction);
-      } else if (_typeof(typeOrObjects) === "object" && typeOrObjects.length) {
-        return Promise.all(typeOrObjects.map(_classPrivateMethodGet(this, _deleteByObject, _deleteByObject2)));
+        var type = typeOrObjects;
+        return _classPrivateMethodGet(this, _deleteByFilter, _deleteByFilter2).call(this, type, filterFunction);
+      } else if (Array.isArray(typeOrObjects) && typeOrObjects.length && !filterFunction) {
+        var objects = typeOrObjects;
+        return Promise.all(objects.map(_classPrivateFieldGet(this, _deleteByObject))).then(function (data) {
+          return data.flat();
+        });
       } else {
-        return Promise.reject("Invalid delete request. You have to provide a list of objects or a type and a filter function");
+        var error = "Invalid delete request. You have to provide a list of objects or a type and a filter function";
+        this.pubSub.publish("error", error);
+        return Promise.reject(error);
       }
     }
   }, {
     key: "insert",
     value: function insert(type, objects) {
-      var _this2 = this;
+      var _this3 = this;
 
       return _classPrivateMethodGet(this, _getPromise, _getPromise2).call(this, type).then(function () {
         return objects.map(function (object) {
-          return _classPrivateMethodGet(_this2, _insertObject, _insertObject2).call(_this2, type, object, true);
+          return _classPrivateMethodGet(_this3, _insertObject, _insertObject2).call(_this3, type, object, true);
         });
       });
     }
   }, {
     key: "get",
     value: function get(type, id) {
-      var _this3 = this;
+      var _this4 = this;
 
       return _classPrivateMethodGet(this, _getPromise, _getPromise2).call(this, type).then(function () {
         try {
-          return _this3.models[type].storedObjects[id].object;
+          return _this4.models[type].storedObjects[id].object;
         } catch (error) {
           return Promise.reject("Object not found");
         }
@@ -150,17 +183,17 @@ var Store = /*#__PURE__*/function () {
   }, {
     key: "find",
     value: function find(type, filterFunction) {
-      var _this4 = this;
+      var _this5 = this;
 
       return _classPrivateMethodGet(this, _getPromise, _getPromise2).call(this, type).then(function () {
-        var all = Object.values(_this4.models[type].storedObjects).filter(function (i) {
+        var all = Object.values(_this5.models[type].storedObjects).filter(function (i) {
           return i.status !== "deleted";
         }).map(function (i) {
           return i.object;
         });
         return filterFunction ? all.filter(filterFunction) : all;
       })["catch"](function (error) {
-        _this4.pubSub.publish("error", error);
+        _this5.pubSub.publish("error", error);
 
         return Promise.reject(error);
       });
@@ -168,7 +201,7 @@ var Store = /*#__PURE__*/function () {
   }, {
     key: "applyDiff",
     value: function applyDiff(_ref, type) {
-      var _this5 = this;
+      var _this6 = this;
 
       var _ref$inserted = _ref.inserted,
           inserted = _ref$inserted === void 0 ? [] : _ref$inserted,
@@ -185,7 +218,7 @@ var Store = /*#__PURE__*/function () {
             for (_iterator.s(); !(_step = _iterator.n()).done;) {
               var object = _step.value;
 
-              var item = _this5.models[type || object.object.getModel().getType()].storedObjects[object.id];
+              var item = _this6.models[type || object.object.getModel().getType()].storedObjects[object.id];
 
               item.fingerprint = object.object.getFingerprint();
               item.status = "old";
@@ -202,7 +235,7 @@ var Store = /*#__PURE__*/function () {
           try {
             for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
               var _object = _step2.value;
-              delete _this5.models[type || _object.object.getModel().getType()].storedObjects[_object.id];
+              delete _this6.models[type || _object.object.getModel().getType()].storedObjects[_object.id];
             }
           } catch (err) {
             _iterator2.e(err);
@@ -216,13 +249,19 @@ var Store = /*#__PURE__*/function () {
         }
       });
     }
+  }, {
+    key: "hasChanged",
+    value: function hasChanged(type, object) {
+      var obj = this.models[type].storedObjects[object.getId()];
+      return obj.fingerprint !== obj.object.getFingerprint();
+    }
   }, {
     key: "getDiff",
     value: function getDiff(type) {
-      var _this6 = this;
+      var _this7 = this;
 
       return _classPrivateMethodGet(this, _getPromise, _getPromise2).call(this, type).then(function () {
-        var objects = Object.values(_this6.models[type].storedObjects);
+        var objects = Object.values(_this7.models[type].storedObjects);
         var inserted = [];
         var updated = [];
         var deleted = [];
@@ -234,7 +273,7 @@ var Store = /*#__PURE__*/function () {
             inserted.push(object);
           } else if (object.status === "deleted") {
             deleted.push(object);
-          } else if (object.fingerprint !== object.object.getFingerprint()) {
+          } else if (_this7.hasChanged(type, object.object)) {
             updated.push(object);
           }
         }
@@ -253,17 +292,17 @@ var Store = /*#__PURE__*/function () {
 
 exports["default"] = Store;
 
-function _deleteByObject2(object) {
-  return _classPrivateMethodGet(this, _deleteByFilter, _deleteByFilter2).call(this, object.getType(), function (item) {
-    return object.getId() === item.getId();
-  });
+function _error2(error) {
+  error = error.message || error;
+  this.pubSub.publish("error", error);
+  return Promise.reject(error);
 }
 
 function _deleteByFilter2(type, filterFunction) {
-  var _this7 = this;
+  var _this8 = this;
 
   return _classPrivateMethodGet(this, _getPromise, _getPromise2).call(this, type).then(function () {
-    var deleted = Object.values(_this7.models[type].storedObjects).filter(function (i) {
+    var deleted = Object.values(_this8.models[type].storedObjects).filter(function (i) {
       return filterFunction(i.object);
     });
 
@@ -281,12 +320,14 @@ function _deleteByFilter2(type, filterFunction) {
       _iterator3.f();
     }
 
-    return true;
+    return deleted.map(function (i) {
+      return i.object;
+    });
   });
 }
 
 function _getPromise2(type) {
-  var _this8 = this;
+  var _this9 = this;
 
   if (!this.models[type]) {
     return Promise.reject("The model doesn't exist");
@@ -294,7 +335,7 @@ function _getPromise2(type) {
     return Promise.reject("The model is not loaded");
   } else if (!this.models[type].promise && this.options.lazyLoad) {
     return _classPrivateMethodGet(this, _loadObjects, _loadObjects2).call(this, type).then(function () {
-      return _this8.models[type].promise;
+      return _this9.models[type].promise;
     });
   } else {
     return this.models[type].promise;
@@ -304,7 +345,7 @@ function _getPromise2(type) {
 function _insertObject2(type, item) {
   var markAsNew = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   var model = this.models[type].model;
-  var wrapper = new _StoreObject["default"](item, model);
+  var wrapper = new _Obj["default"](item, model);
   var id = wrapper.getId();
 
   if (this.models[type].storedObjects[id]) {
@@ -321,7 +362,7 @@ function _insertObject2(type, item) {
 }
 
 function _loadObjects2(type) {
-  var _this9 = this;
+  var _this10 = this;
 
   var item = this.models[type];
   this.pubSub.publish("loading", {
@@ -336,7 +377,7 @@ function _loadObjects2(type) {
       for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
         var _item = _step4.value;
 
-        _classPrivateMethodGet(_this9, _insertObject, _insertObject2).call(_this9, type, _item, false);
+        _classPrivateMethodGet(_this10, _insertObject, _insertObject2).call(_this10, type, _item, false);
       }
     } catch (err) {
       _iterator4.e(err);
@@ -344,7 +385,7 @@ function _loadObjects2(type) {
       _iterator4.f();
     }
 
-    _this9.pubSub.publish("loading", {
+    _this10.pubSub.publish("loading", {
       status: "end",
       model: type
     });

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "dataflux",
-  "version": "1.2.1",
+  "version": "1.2.5",
   "description": "DataFlux, automatically interfaces with your REST APIs to create a 2-way-synced local data store. Transparently manages data propagation in the React state.",
   "main": "dist/index.js",
   "bin": "dist/index.js",
   "scripts": {
     "babel": "node_modules/.bin/babel",
-    "test": "./node_modules/.bin/mocha tests --require @babel/register",
+    "test": "./node_modules/.bin/mocha tests/*.test.js --require @babel/register --exit",
     "compile": "rm -rf dist/ && ./node_modules/.bin/babel src -d dist",
     "release": "dotenv release-it"
   },
@@ -86,8 +86,11 @@
     "@babel/plugin-transform-runtime": "^7.16.10",
     "@babel/preset-env": "^7.16.11",
     "@babel/preset-react": "^7.16.7",
+    "chai": "^4.3.4",
+    "chai-subset": "^1.6.0",
     "dotenv-cli": "^4.1.1",
-    "release-it": "^14.12.3"
+    "mocha": "^9.2.0",
+    "release-it": "^14.12.4"
   },
   "dependencies": {
     "axios": "^0.25.0",