dataflux 1.0.2 → 1.1.2

package/dist/Model.js

@@ -9,6 +9,8 @@ var _modelHooksUtils = require("./modelHooksUtils");
 
 var _batchPromises = _interopRequireDefault(require("batch-promises"));
 
+var _axios2 = _interopRequireDefault(require("axios"));
+
 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); }
@@ -33,80 +35,121 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
 
 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; }
 
-var Model = /*#__PURE__*/_createClass(function Model(name, options) {
+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 _type = /*#__PURE__*/new WeakMap();
+
+var _store = /*#__PURE__*/new WeakMap();
+
+var _includes = /*#__PURE__*/new WeakMap();
+
+var _retrieveHook = /*#__PURE__*/new WeakMap();
+
+var _updateHook = /*#__PURE__*/new WeakMap();
+
+var _insertHook = /*#__PURE__*/new WeakMap();
+
+var _deleteHook = /*#__PURE__*/new WeakMap();
+
+var _singleItemQuery = /*#__PURE__*/new WeakMap();
+
+var _batchSize = /*#__PURE__*/new WeakMap();
+
+var _axios = /*#__PURE__*/new WeakMap();
+
+var _addRelationByField = /*#__PURE__*/new WeakMap();
+
+var _addRelationByFilter = /*#__PURE__*/new WeakMap();
+
+var _bulkOperation = /*#__PURE__*/new WeakMap();
+
+var _toArray = /*#__PURE__*/new WeakMap();
+
+var _insertObjects = /*#__PURE__*/new WeakMap();
+
+var _updateObjects = /*#__PURE__*/new WeakMap();
+
+var _deleteObjects = /*#__PURE__*/new WeakMap();
+
+var Model = /*#__PURE__*/_createClass(function Model(name) {
   var _this = this;
 
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
   _classCallCheck(this, Model);
 
-  _defineProperty(this, "_bulkOperation", function (objects, action) {
-    if (_this.__singleItemQuery) {
-      return (0, _batchPromises["default"])(_this.__batchSize, objects, action);
-    } else {
-      return action(objects);
-    }
+  _classPrivateFieldInitSpec(this, _type, {
+    writable: true,
+    value: void 0
   });
 
-  _defineProperty(this, "getType", function () {
-    return _this.__type;
+  _classPrivateFieldInitSpec(this, _store, {
+    writable: true,
+    value: void 0
   });
 
-  _defineProperty(this, "_toArray", function (data) {
-    if (Array.isArray(data)) {
-      return data;
-    } else {
-      _this.__singleItemQuery = true;
-      return [data];
-    }
+  _classPrivateFieldInitSpec(this, _includes, {
+    writable: true,
+    value: void 0
   });
 
-  _defineProperty(this, "retrieveAll", function () {
-    return (0, _modelHooksUtils.executeHook)("retrieve", _this.__retrieveHook, null).then(_this._toArray);
+  _classPrivateFieldInitSpec(this, _retrieveHook, {
+    writable: true,
+    value: void 0
   });
 
-  _defineProperty(this, "insertObjects", function (objects) {
-    return _this._bulkOperation(objects, _this._insertObjects);
+  _classPrivateFieldInitSpec(this, _updateHook, {
+    writable: true,
+    value: void 0
   });
 
-  _defineProperty(this, "updateObjects", function (objects) {
-    return _this._bulkOperation(objects, _this._updateObjects);
+  _classPrivateFieldInitSpec(this, _insertHook, {
+    writable: true,
+    value: void 0
   });
 
-  _defineProperty(this, "deleteObjects", function (objects) {
-    return _this._bulkOperation(objects, _this._deleteObjects);
+  _classPrivateFieldInitSpec(this, _deleteHook, {
+    writable: true,
+    value: void 0
   });
 
-  _defineProperty(this, "_insertObjects", function (data) {
-    return Promise.resolve(true);
-    return (0, _modelHooksUtils.executeHook)("insert", _this.__insertHook, data).then(_this._toArray);
+  _classPrivateFieldInitSpec(this, _singleItemQuery, {
+    writable: true,
+    value: void 0
   });
 
-  _defineProperty(this, "_updateObjects", function (data) {
-    return Promise.resolve(true);
-    return (0, _modelHooksUtils.executeHook)("update", _this.__updateHook, data).then(_this._toArray);
+  _classPrivateFieldInitSpec(this, _batchSize, {
+    writable: true,
+    value: void 0
   });
 
-  _defineProperty(this, "_deleteObjects", function (data) {
-    return Promise.resolve(true);
-    return (0, _modelHooksUtils.executeHook)("update", _this.__deleteHook, data).then(_this._toArray);
+  _classPrivateFieldInitSpec(this, _axios, {
+    writable: true,
+    value: void 0
   });
 
   _defineProperty(this, "getStore", function () {
-    return _this.store;
+    return _classPrivateFieldGet(_this, _store);
   });
 
-  _defineProperty(this, "addRelationByField", function (model, localField) {
-    var remoteField = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "id";
-
-    var filterFunction = function filterFunction(parentObject, child) {
-      return parentObject[localField] === child[remoteField];
-    };
-
-    return _this.addRelationByFilter(model, filterFunction);
-  });
-
-  _defineProperty(this, "addRelationByFilter", function (model, filterFunction) {
-    var includedType = model.getType();
-    _this.__includes[includedType] = filterFunction;
+  _defineProperty(this, "setStore", function (store) {
+    if (!_classPrivateFieldGet(_this, _store)) {
+      _classPrivateFieldSet(_this, _store, store);
+    } else {
+      throw new Error("This model was already assigned to a store.");
+    }
   });
 
   _defineProperty(this, "addRelation", function (model, param2, param3) {
@@ -115,13 +158,13 @@ var Model = /*#__PURE__*/_createClass(function Model(name, options) {
 
       if (typeof param2 === "string" && (!param3 || typeof param3 === "string")) {
         // explicit model, from, to
-        return _this.addRelationByField(model, param2, param3);
+        return _classPrivateFieldGet(_this, _addRelationByField).call(_this, model, param2, param3);
       } else if (!param3 && typeof param2 === "function") {
         // explicit model, filterFunction
-        return _this.addRelationByFilter(model, param2);
+        return _classPrivateFieldGet(_this, _addRelationByFilter).call(_this, model, param2);
       } else if (!param2 && !param3) {
         // implicit model, from, to (it uses the type as local key and the id as remote key)
-        return _this.addRelationByField(model, model.getType(), "id");
+        return _classPrivateFieldGet(_this, _addRelationByField).call(_this, model, model.getType(), "id");
       } else {
         throw new Error("Invalid relation declaration");
       }
@@ -131,7 +174,7 @@ var Model = /*#__PURE__*/_createClass(function Model(name, options) {
   });
 
   _defineProperty(this, "getRelation", function (parentObject, includedType, filterFunction) {
-    var filterRelation = _this.__includes[includedType];
+    var filterRelation = _classPrivateFieldGet(_this, _includes)[includedType];
 
     if (filterRelation) {
       return _this.getStore().find(includedType, function (item) {
@@ -148,7 +191,99 @@ var Model = /*#__PURE__*/_createClass(function Model(name, options) {
     }
   });
 
-  this.__type = name;
+  _defineProperty(this, "getType", function () {
+    return _classPrivateFieldGet(_this, _type);
+  });
+
+  _defineProperty(this, "retrieveAll", function () {
+    return (0, _modelHooksUtils.executeHook)("retrieve", _classPrivateFieldGet(_this, _retrieveHook), null, _classPrivateFieldGet(_this, _axios)).then(_classPrivateFieldGet(_this, _toArray));
+  });
+
+  _defineProperty(this, "insertObjects", function (objects) {
+    return objects.length ? _classPrivateFieldGet(_this, _bulkOperation).call(_this, objects, _classPrivateFieldGet(_this, _insertObjects)) : Promise.resolve();
+  });
+
+  _defineProperty(this, "updateObjects", function (objects) {
+    return objects.length ? _classPrivateFieldGet(_this, _bulkOperation).call(_this, objects, _classPrivateFieldGet(_this, _updateObjects)) : Promise.resolve();
+  });
+
+  _defineProperty(this, "deleteObjects", function (objects) {
+    return objects.length ? _classPrivateFieldGet(_this, _bulkOperation).call(_this, objects, _classPrivateFieldGet(_this, _deleteObjects)) : Promise.resolve();
+  });
+
+  _classPrivateFieldInitSpec(this, _addRelationByField, {
+    writable: true,
+    value: function value(model, localField) {
+      var remoteField = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "id";
+
+      var filterFunction = function filterFunction(parentObject, child) {
+        return parentObject[localField] === child[remoteField];
+      };
+
+      return _classPrivateFieldGet(_this, _addRelationByFilter).call(_this, model, filterFunction);
+    }
+  });
+
+  _classPrivateFieldInitSpec(this, _addRelationByFilter, {
+    writable: true,
+    value: function value(model, filterFunction) {
+      var includedType = model.getType();
+      _classPrivateFieldGet(_this, _includes)[includedType] = filterFunction;
+    }
+  });
+
+  _classPrivateFieldInitSpec(this, _bulkOperation, {
+    writable: true,
+    value: function value(objects, action) {
+      if (_classPrivateFieldGet(_this, _singleItemQuery)) {
+        return (0, _batchPromises["default"])(_classPrivateFieldGet(_this, _batchSize), objects, action);
+      } else {
+        return action(objects);
+      }
+    }
+  });
+
+  _classPrivateFieldInitSpec(this, _toArray, {
+    writable: true,
+    value: function value(data) {
+      if (Array.isArray(data)) {
+        return data;
+      } else {
+        _classPrivateFieldSet(_this, _singleItemQuery, true);
+
+        return [data];
+      }
+    }
+  });
+
+  _classPrivateFieldInitSpec(this, _insertObjects, {
+    writable: true,
+    value: function value(data) {
+      return (0, _modelHooksUtils.executeHook)("insert", _classPrivateFieldGet(_this, _insertHook), data, _classPrivateFieldGet(_this, _axios)).then(_classPrivateFieldGet(_this, _toArray));
+    }
+  });
+
+  _classPrivateFieldInitSpec(this, _updateObjects, {
+    writable: true,
+    value: function value(data) {
+      return (0, _modelHooksUtils.executeHook)("update", _classPrivateFieldGet(_this, _updateHook), data, _classPrivateFieldGet(_this, _axios)).then(_classPrivateFieldGet(_this, _toArray));
+    }
+  });
+
+  _classPrivateFieldInitSpec(this, _deleteObjects, {
+    writable: true,
+    value: function value(data) {
+      return (0, _modelHooksUtils.executeHook)("delete", _classPrivateFieldGet(_this, _deleteHook), data, _classPrivateFieldGet(_this, _axios)).then(_classPrivateFieldGet(_this, _toArray));
+    }
+  });
+
+  _classPrivateFieldSet(this, _type, name);
+
+  _classPrivateFieldSet(this, _store, null);
+
+  _classPrivateFieldSet(this, _includes, {});
+
+  _classPrivateFieldSet(this, _axios, options.axios || _axios2["default"]);
 
   if (!name || !options) {
     throw new Error("A Model requires at least a name and a hook");
@@ -161,15 +296,19 @@ var Model = /*#__PURE__*/_createClass(function Model(name, options) {
       updateHook = _ref2[2],
       deleteHook = _ref2[3];
 
-  this.__retrieveHook = retrieveHook;
-  this.__updateHook = updateHook;
-  this.__insertHook = insertHook;
-  this.__deleteHook = deleteHook;
-  this.__singleItemQuery = false; // By default use arrays
+  _classPrivateFieldSet(this, _retrieveHook, retrieveHook);
+
+  _classPrivateFieldSet(this, _updateHook, updateHook);
+
+  _classPrivateFieldSet(this, _insertHook, insertHook);
+
+  _classPrivateFieldSet(this, _deleteHook, deleteHook);
+
+  _classPrivateFieldSet(this, _singleItemQuery, false); // By default use arrays
+
 
-  this.__batchSize = 4; // For HTTP requests in parallel if your API doesn't support multiple resources
+  _classPrivateFieldSet(this, _batchSize, 4); // For HTTP requests in parallel if your API doesn't support multiple resources
 
-  this.__includes = {};
 });
 
 exports["default"] = Model;