dataflux 1.4.2 → 1.5.0

package/README.md

@@ -178,7 +178,7 @@ const subscriptions = [
     ["author"], // No filter function, all objects returned
 ];
 
-const callback = ([books, authors]) => {
+const callback = ({book, author}) => {
     // Objects are ready
 };
 
@@ -275,6 +275,7 @@ All the possible options for a model creation are (they are all optional):
 | axios        | It allows to specify an axios instance to be used for the queries. If not specified, a new one will be used.                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | A new axios instance |
 | parseMoment  | Automatically creates Moment.js objects out of ISO8601 strings. E.g., if an object has a property `createdAt: "2022-01-07T21:38:50.295Z"`, this will be transformed to a moment object.                                                                                                                                                                                                                                                                                                                                                                                       |                      | 
 | hiddenFields | An array of attribute names that will never be sent back to the API. E.g., if you set `hiddenFields: ["pages"]`, a book object can contain an attribute `pages` locally, but this will be stripped out in PUT/POST requests.                                                                                                                                                                                                                                                                                                                                                  |
+| deep         | A boolean defining if nested objects should be enriched with the object methods.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | true                 |
 
 ### 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.

package/dist/BasicObj.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dateRegex = exports.BasicObj = void 0;
+
+var _moment = _interopRequireDefault(require("moment/moment"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+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 _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; }
+
+var dateRegex = new RegExp("^[0-9][0-9][0-9][0-9]-[0-9].*T[0-9].*Z$");
+exports.dateRegex = dateRegex;
+
+var _setHidden = /*#__PURE__*/new WeakMap();
+
+var BasicObj = /*#__PURE__*/_createClass(function BasicObj(values, model) {
+  var _this = this;
+
+  _classCallCheck(this, BasicObj);
+
+  _classPrivateFieldInitSpec(this, _setHidden, {
+    writable: true,
+    value: {}
+  });
+
+  _defineProperty(this, "get", function (attribute, defaultValue) {
+    var _ref, _classPrivateFieldGet2;
+
+    return (_ref = (_classPrivateFieldGet2 = _classPrivateFieldGet(_this, _setHidden)[attribute]) !== null && _classPrivateFieldGet2 !== void 0 ? _classPrivateFieldGet2 : _this[attribute]) !== null && _ref !== void 0 ? _ref : defaultValue;
+  });
+
+  _defineProperty(this, "set", function (attribute, value, hidden) {
+    if (hidden) {
+      _classPrivateFieldGet(_this, _setHidden)[attribute] = value;
+    } else {
+      if (attribute === "id") {
+        throw new Error("You cannot change the ID");
+      }
+
+      _this[attribute] = value;
+    }
+
+    return _this.update();
+  });
+
+  _defineProperty(this, "setConstant", function (attribute, value) {
+    var _classPrivateFieldGet3;
+
+    _classPrivateFieldGet(_this, _setHidden)[attribute] = (_classPrivateFieldGet3 = _classPrivateFieldGet(_this, _setHidden)[attribute]) !== null && _classPrivateFieldGet3 !== void 0 ? _classPrivateFieldGet3 : value;
+  });
+
+  _defineProperty(this, "toJSON", function () {
+    var attrs = Object.keys(_this);
+    var out = {};
+
+    for (var _i = 0, _attrs = attrs; _i < _attrs.length; _i++) {
+      var a = _attrs[_i];
+
+      if (_this[a] instanceof _moment["default"]) {
+        out[a] = _this[a].toISOString();
+      } else if (_this[a] instanceof Date) {
+        out[a] = (0, _moment["default"])(_this[a]).toISOString();
+      } else if (_this[a].toJSON) {
+        out[a] = _this[a].toJSON();
+      } else if (Array.isArray(_this[a]) && _this[a].every(function (i) {
+        return i.toJSON;
+      })) {
+        out[a] = _this[a].map(function (i) {
+          return i.toJSON();
+        });
+      } else if (typeof _this[a] !== "function") {
+        out[a] = _this[a];
+      }
+    }
+
+    return out;
+  });
+
+  _defineProperty(this, "toString", function () {
+    return JSON.stringify(_this.toJSON());
+  });
+
+  _defineProperty(this, "update", function () {
+    return Promise.resolve();
+  });
+});
+
+exports.BasicObj = BasicObj;

package/dist/Model.js

@@ -110,7 +110,9 @@ var _updateObjects = /*#__PURE__*/new WeakMap();
 var _deleteObjects = /*#__PURE__*/new WeakMap();
 
 var Model = /*#__PURE__*/_createClass(function Model(name) {
-  var _this = this;
+  var _this = this,
+      _options$deep,
+      _options$parseMoment;
 
   var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
@@ -375,7 +377,8 @@ var Model = /*#__PURE__*/_createClass(function Model(name) {
   _classPrivateFieldSet(this, _type, name);
 
   this.options = {
-    parseMoment: options.parseMoment
+    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
   };
 
   _classPrivateFieldSet(this, _store, null);

package/dist/Obj.js

@@ -9,16 +9,36 @@ var _fingerprint = _interopRequireDefault(require("./fingerprint"));
 
 var _uuid = require("uuid");
 
+var _BasicObj2 = require("./BasicObj");
+
 var _moment = _interopRequireDefault(require("moment/moment"));
 
+var _SubObj = _interopRequireDefault(require("./SubObj"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
+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 _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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
 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); }
@@ -35,134 +55,98 @@ function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!priva
 
 function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
 
-var dateRegex = new RegExp("^[0-9][0-9][0-9][0-9]-[0-9].*T[0-9].*Z$");
-
 var _loaded = /*#__PURE__*/new WeakMap();
 
-var _setHidden = /*#__PURE__*/new WeakMap();
-
-var Obj = /*#__PURE__*/_createClass(function Obj(values, _model) {
-  var _this = this;
-
-  _classCallCheck(this, Obj);
+var Obj = /*#__PURE__*/function (_BasicObj) {
+  _inherits(Obj, _BasicObj);
 
-  _classPrivateFieldInitSpec(this, _loaded, {
-    writable: true,
-    value: false
-  });
+  var _super = _createSuper(Obj);
 
-  _classPrivateFieldInitSpec(this, _setHidden, {
-    writable: true,
-    value: {}
-  });
+  function Obj(values, _model) {
+    var _this;
 
-  _defineProperty(this, "load", function () {
-    if (_classPrivateFieldGet(_this, _loaded)) {
-      return Promise.resolve(_this);
-    } else {
-      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
-    }
-  });
+    _classCallCheck(this, Obj);
 
-  _defineProperty(this, "getFingerprint", function () {
-    return (0, _fingerprint["default"])(_this.toJSON());
-  });
+    _this = _super.call(this, values, _model);
 
-  _defineProperty(this, "get", function (attribute, defaultValue) {
-    var _ref, _classPrivateFieldGet2;
+    _classPrivateFieldInitSpec(_assertThisInitialized(_this), _loaded, {
+      writable: true,
+      value: false
+    });
 
-    return (_ref = (_classPrivateFieldGet2 = _classPrivateFieldGet(_this, _setHidden)[attribute]) !== null && _classPrivateFieldGet2 !== void 0 ? _classPrivateFieldGet2 : _this[attribute]) !== null && _ref !== void 0 ? _ref : defaultValue;
-  });
+    _defineProperty(_assertThisInitialized(_this), "load", function () {
+      if (_classPrivateFieldGet(_assertThisInitialized(_this), _loaded)) {
+        return Promise.resolve(_assertThisInitialized(_this));
+      } else {
+        var model = _this.getModel();
 
-  _defineProperty(this, "getRelation", function (type, filterFunction) {
-    return _this.getModel().getRelation(_this, type, filterFunction);
-  });
+        return model.load(_assertThisInitialized(_this)).then(function () {
+          _classPrivateFieldSet(_assertThisInitialized(_this), _loaded, true);
 
-  _defineProperty(this, "set", function (attribute, value, hidden) {
-    if (hidden) {
-      _classPrivateFieldGet(_this, _setHidden)[attribute] = value;
-    } else {
-      if (attribute === "id") {
-        throw new Error("You cannot change the ID");
+          return model.getStore().update([_assertThisInitialized(_this)], true); // Propagate update
+        }).then(function () {
+          return _assertThisInitialized(_this);
+        }); // return always this
       }
-
-      _this[attribute] = value;
-    }
-
-    return _this.getModel().getStore().update([_this]);
-  });
-
-  _defineProperty(this, "setConstant", function (attribute, value) {
-    var _classPrivateFieldGet3;
-
-    _classPrivateFieldGet(_this, _setHidden)[attribute] = (_classPrivateFieldGet3 = _classPrivateFieldGet(_this, _setHidden)[attribute]) !== null && _classPrivateFieldGet3 !== void 0 ? _classPrivateFieldGet3 : value;
-  });
-
-  _defineProperty(this, "save", function () {
-    return _this.getModel().getStore().save([_this]);
-  });
-
-  _defineProperty(this, "destroy", function () {
-    return _this.getModel().getStore()["delete"]([_this]);
-  });
-
-  _defineProperty(this, "toJSON", function () {
-    var attrs = Object.keys(_this);
-    var out = {};
-
-    for (var _i = 0, _attrs = attrs; _i < _attrs.length; _i++) {
-      var a = _attrs[_i];
-
-      if (_this[a] instanceof _moment["default"]) {
-        out[a] = _this[a].toISOString();
-      } else if (_this[a] instanceof Date) {
-        out[a] = (0, _moment["default"])(_this[a]).toISOString();
-      } else if (typeof _this[a] !== "function") {
-        out[a] = _this[a];
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "getFingerprint", function () {
+      return (0, _fingerprint["default"])(_this.toJSON());
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "getRelation", function (type, filterFunction) {
+      return _this.getModel().getRelation(_assertThisInitialized(_this), type, filterFunction);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "save", function () {
+      return _this.getModel().getStore().save([_assertThisInitialized(_this)]);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "destroy", function () {
+      return _this.getModel().getStore()["delete"]([_assertThisInitialized(_this)]);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "update", function () {
+      return _this.getModel().getStore().update([_assertThisInitialized(_this)]);
+    });
+
+    Object.keys(values).forEach(function (key) {
+      var value = values[key];
+
+      if (_model.options.parseMoment && _BasicObj2.dateRegex.test(value)) {
+        var mmnt = (0, _moment["default"])(value);
+        _this[key] = mmnt.isValid() ? mmnt : value;
+      } else if (_model.options.deep && _typeof(value) === "object" && !Array.isArray(value)) {
+        _this[key] = new _SubObj["default"](_assertThisInitialized(_this), value, _model);
+      } else if (_model.options.deep && Array.isArray(value)) {
+        _this[key] = value.map(function (i) {
+          return new _SubObj["default"](_assertThisInitialized(_this), i, _model);
+        });
+      } else {
+        _this[key] = value;
       }
-    }
+    });
 
-    return out;
-  });
+    _this.getModel = function () {
+      return _model;
+    };
 
-  _defineProperty(this, "toString", function () {
-    return JSON.stringify(_this.toJSON());
-  });
+    var id;
 
-  this.getModel = function () {
-    return _model;
-  };
-
-  var frEach = _model.options.parseMoment ? function (key) {
-    if (dateRegex.test(values[key])) {
-      var mmnt = (0, _moment["default"])(values[key]);
-      _this[key] = mmnt.isValid() ? mmnt : values[key];
+    if (_this.id && (typeof _this.id === "string" || typeof _this.id === "number")) {
+      id = _this.id.toString();
     } else {
-      _this[key] = values[key];
+      id = (0, _uuid.v4)();
     }
-  } : function (key) {
-    return _this[key] = values[key];
-  };
-  Object.keys(values).forEach(frEach);
-  var id;
-
-  if (this.id && (typeof this.id === "string" || typeof this.id === "number")) {
-    id = this.id.toString();
-  } else {
-    id = (0, _uuid.v4)();
+
+    _this.getId = function () {
+      return id;
+    };
+
+    return _this;
   }
 
-  this.getId = function () {
-    return id;
-  };
-});
+  return _createClass(Obj);
+}(_BasicObj2.BasicObj);
 
 exports["default"] = Obj;

package/dist/ObserverStore.js

@@ -15,19 +15,19 @@ var _PersistentStore2 = _interopRequireDefault(require("./PersistentStore"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+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(_e2) { throw _e2; }, 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(_e3) { didErr = true; err = _e3; }, 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 _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 
-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 _nonIterableRest() { throw new TypeError("Invalid attempt to destructure 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 _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 _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _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 _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
@@ -92,14 +92,31 @@ 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));
+      var dataPayload = {};
+
+      var areAllDone = function areAllDone() {
+        return subscriptions.map(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 1),
+              name = _ref2[0];
+
+          return name;
+        }).every(function (name) {
+          return dataPayload[name] !== undefined;
         });
+      };
+
+      return Promise.all(subscriptions.map(function (sub) {
+        var _sub = _slicedToArray(sub, 2),
+            name = _sub[0],
+            _sub$ = _sub[1],
+            filterFunction = _sub$ === void 0 ? null : _sub$;
+
+        var wrappedCallback = function wrappedCallback(data) {
+          dataPayload[name] = data;
+          return areAllDone() && callback(dataPayload);
+        };
+
+        return _this.subscribe(name, wrappedCallback, filterFunction);
       })).then(function (subKeys) {
         var subKey = (0, _uuid.v4)();
         _this._multipleSubscribed[subKey] = subKeys;
@@ -209,9 +226,9 @@ var ObserverStore = /*#__PURE__*/function (_PersistentStore) {
 
           var uniqueSubs = _classPrivateFieldGet(_assertThisInitialized(_this), _getUniqueSubs).call(_assertThisInitialized(_this), objects, type);
 
-          (0, _batchPromises["default"])(10, uniqueSubs, function (_ref) {
-            var callback = _ref.callback,
-                filterFunction = _ref.filterFunction;
+          (0, _batchPromises["default"])(10, uniqueSubs, function (_ref3) {
+            var callback = _ref3.callback,
+                filterFunction = _ref3.filterFunction;
             return _this.find(type, filterFunction).then(callback);
           });
         }
@@ -284,8 +301,8 @@ function _propagateInsertChange2(type, newObjects) {
     var uniqueSubs = {};
     var objects = Object.values(this._subscribed[type]);
 
-    for (var _i = 0, _objects = objects; _i < _objects.length; _i++) {
-      var object = _objects[_i];
+    for (var _i2 = 0, _objects = objects; _i2 < _objects.length; _i2++) {
+      var object = _objects[_i2];
 
       var _iterator5 = _createForOfIteratorHelper(object),
           _step5;
@@ -306,9 +323,9 @@ function _propagateInsertChange2(type, newObjects) {
     }
 
     var possibleSubs = Object.values(uniqueSubs);
-    (0, _batchPromises["default"])(10, possibleSubs, function (_ref2) {
-      var callback = _ref2.callback,
-          filterFunction = _ref2.filterFunction;
+    (0, _batchPromises["default"])(10, possibleSubs, function (_ref4) {
+      var callback = _ref4.callback,
+          filterFunction = _ref4.filterFunction;
       var objectsToSubscribe = filterFunction ? newObjects.filter(filterFunction) : newObjects;
 
       if (objectsToSubscribe.length) {

package/dist/SubObj.js

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _uuid = require("uuid");
+
+var _BasicObj2 = require("./BasicObj");
+
+var _moment = _interopRequireDefault(require("moment/moment"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+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 _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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+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 _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; }
+
+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 _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 _model = /*#__PURE__*/new WeakMap();
+
+var _parent = /*#__PURE__*/new WeakMap();
+
+var SubObj = /*#__PURE__*/function (_BasicObj) {
+  _inherits(SubObj, _BasicObj);
+
+  var _super = _createSuper(SubObj);
+
+  function SubObj(parent, values, model) {
+    var _this;
+
+    _classCallCheck(this, SubObj);
+
+    _this = _super.call(this, values, model);
+
+    _classPrivateFieldInitSpec(_assertThisInitialized(_this), _model, {
+      writable: true,
+      value: void 0
+    });
+
+    _classPrivateFieldInitSpec(_assertThisInitialized(_this), _parent, {
+      writable: true,
+      value: void 0
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "save", function () {
+      return _classPrivateFieldGet(_assertThisInitialized(_this), _model).getStore().save([_classPrivateFieldGet(_assertThisInitialized(_this), _parent)]);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "destroy", function () {
+      return _classPrivateFieldGet(_assertThisInitialized(_this), _model).getStore()["delete"]([_classPrivateFieldGet(_assertThisInitialized(_this), _parent)]);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "update", function () {
+      return _classPrivateFieldGet(_assertThisInitialized(_this), _model).getStore().update([_classPrivateFieldGet(_assertThisInitialized(_this), _parent)]);
+    });
+
+    _classPrivateFieldSet(_assertThisInitialized(_this), _model, model);
+
+    _classPrivateFieldSet(_assertThisInitialized(_this), _parent, parent);
+
+    Object.keys(values).forEach(function (key) {
+      var value = values[key];
+
+      if (model.options.parseMoment && _BasicObj2.dateRegex.test(value)) {
+        var mmnt = (0, _moment["default"])(value);
+        _this[key] = mmnt.isValid() ? mmnt : value;
+      } else if (model.options.deep && _typeof(value) === "object" && !Array.isArray(value)) {
+        _this[key] = new SubObj(_assertThisInitialized(_this), value, model);
+      } else if (model.options.deep && Array.isArray(value)) {
+        _this[key] = value.map(function (i) {
+          return new SubObj(_assertThisInitialized(_this), i, model);
+        });
+      } else {
+        _this[key] = value;
+      }
+    });
+
+    _this.getId = function () {
+      return (0, _uuid.v4)();
+    };
+
+    return _this;
+  }
+
+  return _createClass(SubObj);
+}(_BasicObj2.BasicObj);
+
+exports["default"] = SubObj;

package/dist/modelHooksUtils.js

@@ -12,6 +12,8 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "d
 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 getDataStringHook = function getDataStringHook(hook) {
+  var _hook$fields;
+
   var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
   var axios = arguments.length > 2 ? arguments[2] : undefined;
   var options = {
@@ -25,7 +27,7 @@ var getDataStringHook = function getDataStringHook(hook) {
     options.headers = hook.headers;
   }
 
-  if (hook.fields) {
+  if (hook !== null && hook !== void 0 && (_hook$fields = hook.fields) !== null && _hook$fields !== void 0 && _hook$fields.length) {
     setFields(options, hook);
   }
 
@@ -55,7 +57,9 @@ var createHookItem = function createHookItem(optionItem, defaultMethod, defaultU
       } else {
         return {
           method: defaultMethod,
-          url: defaultUrl
+          url: defaultUrl,
+          fields: options.fields || [],
+          headers: options.headers || {}
         };
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dataflux",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "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",