dataflux 1.4.5 → 1.5.0

package/README.md

@@ -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/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/package.json

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