merchi_sdk_ts 0.0.1-a

package/dist/entity.js

@@ -0,0 +1,888 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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 _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 _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"); } }
+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, _toPropertyKey(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 _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import 'reflect-metadata';
+// eslint-disable-next-line no-unused-vars
+
+// eslint-disable-next-line no-unused-vars
+
+// eslint-disable-next-line no-unused-vars
+
+// eslint-disable-next-line no-unused-vars
+
+// eslint-disable-next-line no-unused-vars
+
+// eslint-disable-next-line no-unused-vars
+
+// eslint-disable-next-line no-unused-vars
+
+import { generateUUID } from './uuid';
+function toUnixTimestamp(date) {
+  return parseInt(String(date.getTime() / 1000)).toFixed(0);
+}
+export var SerialiseMethod = /*#__PURE__*/function (SerialiseMethod) {
+  SerialiseMethod["TO_DICT"] = "to_dict";
+  SerialiseMethod["ONLY_ID"] = "only_id";
+  return SerialiseMethod;
+}({});
+export var Entity = /*#__PURE__*/function () {
+  function Entity(merchi) {
+    var _this = this;
+    _classCallCheck(this, Entity);
+    _defineProperty(this, "isDirty", false);
+    _defineProperty(this, "backObjects", new Set());
+    _defineProperty(this, "key", generateUUID());
+    _defineProperty(this, "getPrimaryKeyValue", function () {
+      var name = _this.constructor.primaryKey;
+      var info = _this.propertiesMap.get(name);
+      /* istanbul ignore next */
+      if (info !== undefined) {
+        return info.currentValue;
+      }
+      /* istanbul ignore next */
+      return undefined;
+    });
+    _defineProperty(this, "setupProperties", function () {
+      var properties = {};
+      var makeSetSingle = function makeSetSingle(info) {
+        var get = function get() {
+          return info.currentValue;
+        };
+        var set = function set(newValue) {
+          info.currentValue = newValue;
+          _this.addBackObject(newValue);
+          _this.markDirty(info.property, newValue);
+        };
+        return {
+          get: get,
+          set: set
+        };
+      };
+      var makeSetScalar = function makeSetScalar(info) {
+        var get = function get() {
+          return info.currentValue;
+        };
+        var set = function set(newValue) {
+          info.currentValue = newValue;
+          _this.markDirty(info.property, newValue);
+        };
+        return {
+          get: get,
+          set: set
+        };
+      };
+      var makeSetArray = function makeSetArray(info) {
+        var get = function get() {
+          return info.currentValue;
+        };
+        var set = function set(newValue) {
+          info.currentValue = newValue;
+          _this.addBackObjectList(newValue);
+          _this.markDirty(info.property, newValue);
+        };
+        return {
+          get: get,
+          set: set
+        };
+      };
+      var _iterator = _createForOfIteratorHelper(_this.propertiesMap.values()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var info = _step.value;
+          if (info.type.prototype instanceof Entity) {
+            properties[info.attribute] = makeSetSingle(info);
+          } else if (info.arrayType) {
+            properties[info.attribute] = makeSetArray(info);
+          } else {
+            properties[info.attribute] = makeSetScalar(info);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      Object.defineProperties(_this, properties);
+    });
+    _defineProperty(this, "save", function (options) {
+      var primaryKey = _this.getPrimaryKeyValue();
+      var constructor = _this.constructor;
+      var resourceName = constructor.resourceName;
+      var singularName = constructor.singularName;
+      var resource = "/".concat(resourceName, "/").concat(String(primaryKey), "/");
+      var data = _this.toFormData();
+      var fetchOptions = {
+        method: 'PATCH',
+        body: data
+      };
+      fetchOptions.query = [];
+      if (options && options.embed) {
+        fetchOptions.query.push(['embed', JSON.stringify(options.embed)]);
+      }
+      if (!(options && options.withRights)) {
+        fetchOptions.query.push(['skip_rights', 'y']);
+      }
+      return _this.merchi.authenticatedFetch(resource, fetchOptions).then(function (data) {
+        _this.fromJson(data[singularName]);
+        _this.cleanDirty();
+        return _this;
+      });
+    });
+    _defineProperty(this, "createFactory", function (_ref) {
+      var _ref$resourceName = _ref.resourceName,
+        resourceName = _ref$resourceName === void 0 ? _this.constructor.resourceName : _ref$resourceName;
+      return function (options) {
+        var resource = "/".concat(resourceName, "/");
+        var data = _this.toFormData();
+        var singularName = _this.constructor.singularName;
+        var fetchOptions = {
+          method: 'POST',
+          body: data
+        };
+        fetchOptions.query = [];
+        if (options && options.embed) {
+          fetchOptions.query.push(['embed', JSON.stringify(options.embed)]);
+        }
+        if (!(options && options.withRights)) {
+          fetchOptions.query.push(['skip_rights', 'y']);
+        }
+        return _this.merchi.authenticatedFetch(resource, fetchOptions).then(function (data) {
+          _this.fromJson(data[singularName]);
+          _this.cleanDirty();
+          return _this;
+        });
+      };
+    });
+    _defineProperty(this, "create", this.createFactory({}));
+    _defineProperty(this, "getEntityClass", function (name) {
+      if (name === undefined) {
+        return undefined;
+      }
+      return _this.merchi[name];
+    });
+    _defineProperty(this, "cleanDirty", function () {
+      // remove all dirty records of this entity, makes it untouched
+      // entity
+      _this.isDirty = false;
+      var _iterator2 = _createForOfIteratorHelper(_this.propertiesMap.entries()),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var entry = _step2.value;
+          var propertyInfo = entry[1];
+          propertyInfo.dirty = false;
+          if (propertyInfo.currentValue !== undefined) {
+            if (propertyInfo.arrayType) {
+              propertyInfo.currentValue.map(function (v) {
+                return v.cleanDirty();
+              });
+            } else if (_this.isSingleEntityProperty(propertyInfo)) {
+              if (propertyInfo.currentValue) {
+                propertyInfo.currentValue.cleanDirty();
+              }
+            }
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    });
+    _defineProperty(this, "fromJson", function (json, options) {
+      options = options || {};
+      var _options = options,
+        _options$makeDirty = _options.makeDirty,
+        makeDirty = _options$makeDirty === void 0 ? false : _options$makeDirty,
+        _options$arrayValueSt = _options.arrayValueStrict,
+        arrayValueStrict = _options$arrayValueSt === void 0 ? true : _options$arrayValueSt;
+      options = {
+        makeDirty: makeDirty,
+        arrayValueStrict: arrayValueStrict
+      };
+      var _loop = function _loop() {
+          var value = json[key];
+          if (value === undefined) return 0; // continue
+          var propertyInfo = _this.propertiesMap.get(key);
+          if (propertyInfo !== undefined) {
+            propertyInfo.dirty = makeDirty;
+            if (propertyInfo.arrayType) {
+              // ignore array value if it is not an array and we did expect it
+              if (!arrayValueStrict && !Array.isArray(value)) return 0; // continue
+              var newValue = value.map(function (item, index) {
+                var currentValue = propertyInfo.currentValue;
+                // if property already have an array of entities as relationship,
+                // try to merge with json one by one, this behavior may need to be
+                // configurable in the future.
+                if (currentValue && currentValue[index]) {
+                  return currentValue[index].fromJson(item, options);
+                }
+                var nested = new propertyInfo.arrayType(_this.merchi);
+                return nested.fromJson(item, options);
+              });
+              propertyInfo.currentValue = newValue;
+            } else if (_this.isSingleEntityProperty(propertyInfo)) {
+              // if property already have a entity as relationship, try to merge
+              // with json first, this behavior may need to be configurable in the
+              // future.
+              if (propertyInfo.currentValue) {
+                propertyInfo.currentValue.fromJson(value, options);
+              } else {
+                var nested = new propertyInfo.type(_this.merchi);
+                propertyInfo.currentValue = nested.fromJson(value, options);
+              }
+            } else {
+              propertyInfo.currentValue = value;
+              if (propertyInfo.type === Date && !!value) {
+                propertyInfo.currentValue = new Date(value * 1000);
+              }
+            }
+          }
+        },
+        _ret;
+      for (var key in json) {
+        _ret = _loop();
+        if (_ret === 0) continue;
+      }
+      return _this;
+    });
+    _defineProperty(this, "toJson", function () {
+      var json = {};
+      var _iterator3 = _createForOfIteratorHelper(_this.propertiesMap.entries()),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var entry = _step3.value;
+          var propertyName = entry[0];
+          var propertyInfo = entry[1];
+          if (propertyInfo.currentValue !== undefined) {
+            if (propertyInfo.arrayType) {
+              var array = propertyInfo.currentValue.map(function (v) {
+                return v.toJson();
+              });
+              json[propertyName] = array;
+            } else if (_this.isSingleEntityProperty(propertyInfo)) {
+              if (propertyInfo.currentValue === null) {
+                json[propertyName] = null;
+              } else {
+                json[propertyName] = propertyInfo.currentValue.toJson();
+              }
+            } else {
+              var value = propertyInfo.currentValue;
+              json[propertyName] = value;
+              if (propertyInfo.type === Date && !!value) {
+                json[propertyName] = value.getTime() / 1000;
+              }
+            }
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return json;
+    });
+    _defineProperty(this, "forEachProperty", function (fn) {
+      var _iterator4 = _createForOfIteratorHelper(_this.propertiesMap.values()),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var info = _step4.value;
+          fn(info);
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+    });
+    _defineProperty(this, "toFormData", function (options, fileIndex) {
+      if (options === undefined) {
+        options = {};
+      }
+      var result = options.existing || new FormData();
+      var prefix = options._prefix || '';
+      var excludeOld = options.excludeOld === undefined ? true : options.excludeOld;
+      if (fileIndex === undefined) {
+        fileIndex = {
+          value: 0
+        };
+      }
+      var appendData = function appendData(name, value) {
+        /* istanbul ignore next */
+        if (name === undefined || value === undefined) {
+          /* istanbul ignore next */
+          return;
+        }
+        if (prefix) {
+          name = prefix + '-' + name;
+        }
+        result.set(name, value);
+      };
+      if (_this.fileData !== undefined) {
+        result.set(String(fileIndex.value), _this.fileData);
+        appendData('fileDataIndex', fileIndex.value);
+        fileIndex.value++;
+      }
+      var processArrayProperty = function processArrayProperty(info, value) {
+        var remoteCount = value.length;
+        var initialLength = Array.from(result.entries()).length;
+        if (remoteCount === 0 && info.dirty) {
+          appendData(info.property + '-count', 0);
+          return;
+        }
+        var isDirty = false;
+        var _iterator5 = _createForOfIteratorHelper(value),
+          _step5;
+        try {
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            var item = _step5.value;
+            if (item.isDirty) {
+              isDirty = true;
+              break;
+            }
+          }
+        } catch (err) {
+          _iterator5.e(err);
+        } finally {
+          _iterator5.f();
+        }
+        isDirty = isDirty || info.dirty;
+        if (!isDirty && excludeOld) {
+          return;
+        }
+        for (var _i = 0; _i < remoteCount; ++_i) {
+          var innerPrefix = info.property + '-' + _i;
+          if (prefix) {
+            innerPrefix = prefix + '-' + innerPrefix;
+          }
+          value[_i].toFormData({
+            existing: result,
+            _prefix: innerPrefix,
+            excludeOld: excludeOld
+          }, fileIndex);
+        }
+        var finalLength = Array.from(result.entries()).length;
+        if (finalLength - initialLength > 0) {
+          appendData(info.property + '-count', remoteCount);
+          if (info.updatingOrder) {
+            appendData(info.property + '-*updateOrder', 'true');
+          }
+        }
+      };
+      var processSingleEntityProperty = function processSingleEntityProperty(info, value) {
+        var primaryKey = _this.constructor.primaryKey;
+        var innerPrefix = info.property + '-0';
+        if (prefix) {
+          innerPrefix = prefix + '-' + innerPrefix;
+        }
+        if (value === null) {
+          if (info.dirty || !excludeOld) {
+            appendData(info.property + '-0-' + primaryKey, '-1');
+            appendData(info.property + '-count', 1);
+          }
+          return;
+        }
+        if (!(info.dirty || value.isDirty) && excludeOld) {
+          return;
+        }
+        var initialLength = Array.from(result.entries()).length;
+        value.toFormData({
+          existing: result,
+          _prefix: innerPrefix,
+          excludeOld: excludeOld
+        }, fileIndex);
+        var finalLength = Array.from(result.entries()).length;
+        if (finalLength - initialLength > 0) {
+          appendData(info.property + '-count', 1);
+        }
+      };
+      var processScalarProperty = function processScalarProperty(info, value) {
+        var primaryKey = _this.constructor.primaryKey;
+        if (!excludeOld || info.dirty || info.property === primaryKey && value) {
+          if (info.type === Date && !!value) {
+            value = value.getTime() / 1000;
+          }
+          appendData(info.property, value);
+        }
+      };
+      var processProperty = function processProperty(info) {
+        var value = _this[info.attribute];
+        if (value === undefined) {
+          return;
+        } else if (info.arrayType) {
+          processArrayProperty(info, value);
+        } else if (_this.isSingleEntityProperty(info)) {
+          processSingleEntityProperty(info, value);
+        } else {
+          processScalarProperty(info, value);
+        }
+      };
+      _this.forEachProperty(processProperty);
+      return result;
+    });
+    _defineProperty(this, "addBackObject", function (remote) {
+      if (remote !== undefined) {
+        remote.backObjects.add(_this);
+      }
+    });
+    _defineProperty(this, "addBackObjectList", function (remotes) {
+      if (remotes !== undefined) {
+        remotes.forEach(_this.addBackObject);
+      }
+    });
+    _defineProperty(this, "updateOrder", function (property) {
+      _this.propertiesMap.get(property).updatingOrder = true;
+    });
+    _defineProperty(this, "markDirty", function (property, newValue) {
+      if (newValue === undefined) {
+        return;
+      }
+      _this.propertiesMap.get(property).dirty = true;
+      var openSet = []; /* Queue (BFS) */
+      var closedSet = new Set();
+      openSet.push(_this);
+      while (openSet.length > 0) {
+        var current = openSet.shift();
+        if (!closedSet.has(current)) {
+          current.isDirty = true;
+          closedSet.add(current);
+          var _iterator6 = _createForOfIteratorHelper(current.backObjects),
+            _step6;
+          try {
+            for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+              var child = _step6.value;
+              openSet.push(child);
+            }
+          } catch (err) {
+            _iterator6.e(err);
+          } finally {
+            _iterator6.f();
+          }
+        }
+      }
+    });
+    _defineProperty(this, "delete", function (options) {
+      var primaryKey = _this.getPrimaryKeyValue();
+      var resourceName = _this.constructor.resourceName;
+      var resource = "/".concat(resourceName, "/").concat(String(primaryKey), "/");
+      var fetchOptions = {
+        method: 'DELETE'
+      };
+      fetchOptions.query = [];
+      if (!(options && options.withRights)) {
+        fetchOptions.query.push(['skip_rights', 'y']);
+      }
+      if (_this.merchi.sessionToken) {
+        fetchOptions.query.push(['session_token', _this.merchi.sessionToken]);
+      }
+      return _this.merchi.authenticatedFetch(resource, fetchOptions, true).then(function () {
+        return _this;
+      });
+    });
+    _defineProperty(this, "recover", function (options) {
+      var primaryKey = _this.getPrimaryKeyValue();
+      var constructor = _this.constructor;
+      var resourceName = constructor.resourceName;
+      var singularName = constructor.singularName;
+      var resource = "/unarchive/".concat(resourceName, "/").concat(String(primaryKey), "/");
+      var fetchOptions = {
+        method: 'POST'
+      };
+      fetchOptions.query = [];
+      if (options && options.embed) {
+        fetchOptions.query.push(['embed', JSON.stringify(options.embed)]);
+      }
+      if (!(options && options.withRights)) {
+        fetchOptions.query.push(['skip_rights', 'y']);
+      }
+      return _this.merchi.authenticatedFetch(resource, fetchOptions).then(function (data) {
+        _this.fromJson(data[singularName]);
+        return _this;
+      });
+    });
+    /* istanbul ignore next */
+    if (merchi !== undefined) {
+      this.merchi = merchi;
+    }
+    this.propertiesMap = this.makePropertiesMap();
+    this.setupProperties();
+  }
+  _createClass(Entity, [{
+    key: "isSingleEntityProperty",
+    value: function isSingleEntityProperty(info) {
+      // the choice of 'Product' below is unimportant -- all Entities should
+      // have the same prototype but i don't know how to get instanceof
+      // working, so i just compare prototypes directly.
+      return info.type.prototype === this.merchi.Product.prototype || info.type.prototype instanceof Entity;
+    }
+  }, {
+    key: "makePropertiesMap",
+    value: function makePropertiesMap() {
+      var map = new Map();
+      var self = this;
+      var properties = Reflect.getMetadata(Entity.propertiesSetKey, this.constructor);
+      properties.forEach(function (attributeName) {
+        var jsonName = Reflect.getMetadata(Entity.jsonNameKey, self, attributeName);
+        var propertyType = Reflect.getMetadata('design:type', self, attributeName);
+        // the array type is needed because 'design:type' breaks down
+        // with recursive classes, and also, does not contain the type
+        // of an arrays elements, which we need
+        var arrayType = Reflect.getMetadata(Entity.arrayTypeKey, self, attributeName);
+        var realArrayType = self.getEntityClass(arrayType);
+        var options = Reflect.getMetadata(Entity.extraOptionsKey, self, attributeName);
+        if (arrayType !== undefined) {
+          /* istanbul ignore next */
+          if (propertyType !== Object && propertyType !== Array) {
+            /* istanbul ignore next */
+            throw new Error('array type can only be given for arrays');
+          }
+        }
+        var type;
+        if (options.type === undefined) {
+          type = propertyType;
+        } else {
+          type = options.type;
+          if (typeof type === 'string') {
+            type = self.getEntityClass(type);
+          }
+          if (type.prototype instanceof Entity) {
+            type = self.merchi.setupClass(type);
+          }
+        }
+        var normallyEmbeddedByDefault = !(realArrayType || type.prototype instanceof Entity);
+        var embeddedByDefault = options.embeddedByDefault !== undefined ? options.embeddedByDefault : normallyEmbeddedByDefault;
+        /* istanbul ignore next */
+        if (type === Object) {
+          /* istanbul ignore next */
+          var resource = self.constructor.resourceName;
+          var err = 'Bad attribute type ' + "".concat(resource, ".").concat(attributeName, ": ").concat(type);
+          throw new Error(err);
+        }
+        var propertyInfo = {
+          property: jsonName,
+          attribute: attributeName,
+          type: type,
+          arrayType: realArrayType,
+          embeddedByDefault: embeddedByDefault,
+          dirty: true,
+          updatingOrder: false
+        };
+        map.set(jsonName, propertyInfo);
+      });
+      return map;
+    }
+  }], [{
+    key: "property",
+    value: function property(options) {
+      return function (target, propertyKey) {
+        if (!options) {
+          options = {};
+        }
+        var arrayType = options.arrayType;
+        var jsonName = options.jsonName || propertyKey;
+        var properties = Reflect.getMetadata(Entity.propertiesSetKey, target.constructor);
+        properties = properties || new Set();
+        properties.add(propertyKey);
+        Reflect.defineMetadata(Entity.propertiesSetKey, properties, target.constructor);
+        Reflect.defineMetadata(Entity.jsonNameKey, jsonName, target, propertyKey);
+        Reflect.defineMetadata(Entity.arrayTypeKey, arrayType, target, propertyKey);
+        Reflect.defineMetadata(Entity.extraOptionsKey, options, target, propertyKey);
+      };
+    }
+  }, {
+    key: "get",
+    value: function get(key, options) {
+      var _this2 = this;
+      var resource = "/".concat(this.resourceName, "/").concat(String(key), "/");
+      var fetchOptions = {};
+      fetchOptions.query = [];
+      if (options && options.embed) {
+        fetchOptions.query.push(['embed', JSON.stringify(options.embed)]);
+      }
+      if (options && options.includeArchived) {
+        fetchOptions.query.push(['include_archived', JSON.stringify(options.includeArchived)]);
+      }
+      if (!(options && options.withRights)) {
+        fetchOptions.query.push(['skip_rights', 'y']);
+      }
+      return this.merchi.authenticatedFetch(resource, fetchOptions).then(function (data) {
+        var result = new _this2();
+        result.fromJson(data[_this2.singularName]);
+        return result;
+      });
+    }
+  }, {
+    key: "list",
+    value: function list(options) {
+      var _this3 = this;
+      var resource = "/".concat(this.resourceName, "/");
+      var fetchOptions = {};
+      fetchOptions.query = [];
+      if (options) {
+        if (options.embed) {
+          fetchOptions.query.push(['embed', JSON.stringify(options.embed)]);
+        }
+        if (options.offset !== undefined) {
+          fetchOptions.query.push(['offset', options.offset.toString()]);
+        }
+        if (options.limit !== undefined) {
+          fetchOptions.query.push(['limit', options.limit.toString()]);
+        }
+        if (options.q !== undefined) {
+          fetchOptions.query.push(['q', options.q]);
+        }
+        if (options.sort !== undefined) {
+          fetchOptions.query.push(['sort', options.sort]);
+        }
+        if (options.order !== undefined) {
+          fetchOptions.query.push(['order', options.order]);
+        }
+        if (options.serialiseMethod !== undefined) {
+          fetchOptions.query.push(['serialise_method', options.serialiseMethod]);
+        }
+        if (options.tab !== undefined) {
+          fetchOptions.query.push(['tab', options.tab]);
+        }
+        if (options.as !== undefined) {
+          fetchOptions.query.push(['as', options.as]);
+        }
+        if (options.state !== undefined) {
+          fetchOptions.query.push(['state', options.state]);
+        }
+        if (options.categoryId !== undefined) {
+          fetchOptions.query.push(['category_id', options.categoryId.toString()]);
+        }
+        if (options.platformCategoryId !== undefined) {
+          fetchOptions.query.push(['platform_category_id', options.platformCategoryId.toString()]);
+        }
+        if (options.inDomain !== undefined) {
+          fetchOptions.query.push(['in_domain', options.inDomain.toString()]);
+        }
+        if (options.inDomainName !== undefined) {
+          fetchOptions.query.push(['in_domain_name', options.inDomainName.toString()]);
+        }
+        if (options.inDomainRoles !== undefined) {
+          fetchOptions.query.push(['in_domain_roles', JSON.stringify(options.inDomainRoles)]);
+        }
+        if (options.isPrivate !== undefined) {
+          fetchOptions.query.push(['is_private', options.isPrivate.toString()]);
+        }
+        if (options.asRole !== undefined) {
+          fetchOptions.query.push(['as_role', options.asRole.toString()]);
+        }
+        if (options.groupBuyOnly !== undefined) {
+          fetchOptions.query.push(['group_buy_only', options.groupBuyOnly.toString()]);
+        }
+        if (options.publicOnly !== undefined) {
+          fetchOptions.query.push(['public_only', options.publicOnly.toString()]);
+        }
+        if (options.managedOnly !== undefined) {
+          fetchOptions.query.push(['managed_only', options.managedOnly.toString()]);
+        }
+        if (options.doesNotHaveAdminDomain !== undefined) {
+          fetchOptions.query.push(['does_not_have_admin_domain', options.doesNotHaveAdminDomain.toString()]);
+        }
+        if (options.clientOnly !== undefined) {
+          fetchOptions.query.push(['client_only', options.clientOnly.toString()]);
+        }
+        if (options.teamOnly !== undefined) {
+          fetchOptions.query.push(['team_only', options.teamOnly.toString()]);
+        }
+        if (options.memberOnly !== undefined) {
+          fetchOptions.query.push(['member_only', options.memberOnly.toString()]);
+        }
+        if (options.merchiOnly !== undefined) {
+          fetchOptions.query.push(['merchi_only', options.merchiOnly.toString()]);
+        }
+        if (options.supplierResellOnly !== undefined) {
+          fetchOptions.query.push(['supplier_resell_only', options.supplierResellOnly.toString()]);
+        }
+        if (options.shopifyOnly !== undefined) {
+          fetchOptions.query.push(['shopify_only', options.shopifyOnly.toString()]);
+        }
+        if (options.inbound !== undefined) {
+          fetchOptions.query.push(['inbound', options.inbound.toString()]);
+        }
+        if (options.isMaster !== undefined) {
+          fetchOptions.query.push(['is_master', options.isMaster.toString()]);
+        }
+        if (options.domainRoles !== undefined) {
+          fetchOptions.query.push(['domain_roles', options.domainRoles.join(',')]);
+        }
+        if (options.domainTypes !== undefined) {
+          fetchOptions.query.push(['domain_types', options.domainTypes.join(',')]);
+        }
+        if (options.entityTypes !== undefined) {
+          fetchOptions.query.push(['entity_types', options.entityTypes.join(',')]);
+        }
+        if (options.productTypes !== undefined) {
+          fetchOptions.query.push(['product_types', options.productTypes.join(',')]);
+        }
+        if (options.managedDomainsOnly !== undefined) {
+          fetchOptions.query.push(['managed_domains_only', options.managedDomainsOnly.toString()]);
+        }
+        if (options.businessDomainsOnly !== undefined) {
+          fetchOptions.query.push(['business_domains_only', options.businessDomainsOnly.toString()]);
+        }
+        if (options.dateFrom !== undefined) {
+          fetchOptions.query.push(['date_from', toUnixTimestamp(options.dateFrom)]);
+        }
+        if (options.dateTo !== undefined) {
+          fetchOptions.query.push(['date_to', toUnixTimestamp(options.dateTo)]);
+        }
+        if (options.originalOf !== undefined) {
+          fetchOptions.query.push(['original_of', options.originalOf.toString()]);
+        }
+        if (options.relatedComponent !== undefined) {
+          fetchOptions.query.push(['related_component', options.relatedComponent.toString()]);
+        }
+        if (options.relatedAssignment !== undefined) {
+          fetchOptions.query.push(['related_assignment', options.relatedAssignment.toString()]);
+        }
+        if (options.relatedDraft !== undefined) {
+          fetchOptions.query.push(['related_draft', options.relatedDraft.toString()]);
+        }
+        if (options.relatedJob !== undefined) {
+          fetchOptions.query.push(['related_job', options.relatedJob.toString()]);
+        }
+        if (options.relatedProduct !== undefined) {
+          fetchOptions.query.push(['related_product', options.relatedProduct.toString()]);
+        }
+        if (options.jobNotifiable !== undefined) {
+          fetchOptions.query.push(['job_notifiable', options.jobNotifiable.toString()]);
+        }
+        if (options.notificationType !== undefined) {
+          fetchOptions.query.push(['notification_type', options.notificationType.toString()]);
+        }
+        if (options.notificationRecipient !== undefined) {
+          fetchOptions.query.push(['notification_recipient', options.notificationRecipient.toString()]);
+        }
+        if (options.notificationJob !== undefined) {
+          fetchOptions.query.push(['notification_job', options.notificationJob.toString()]);
+        }
+        if (options.relatedUser !== undefined) {
+          fetchOptions.query.push(['related_user', options.relatedUser.toString()]);
+        }
+        if (options.clientId !== undefined) {
+          fetchOptions.query.push(['client_id', options.clientId.toString()]);
+        }
+        if (options.managerId !== undefined) {
+          fetchOptions.query.push(['manager_id', options.managerId.toString()]);
+        }
+        if (options.masterProduct !== undefined) {
+          fetchOptions.query.push(['master_product', options.masterProduct.toString()]);
+        }
+        if (options.clientCompanyId !== undefined) {
+          fetchOptions.query.push(['client_company_id', options.clientCompanyId.toString()]);
+        }
+        if (options.savedByUser !== undefined) {
+          fetchOptions.query.push(['saved_by_user', options.savedByUser.toString()]);
+        }
+        if (options.receiverId !== undefined) {
+          fetchOptions.query.push(['receiver_id', options.receiverId.toString()]);
+        }
+        if (options.companyCustomerId !== undefined) {
+          fetchOptions.query.push(['company_customer_id', options.companyCustomerId.toString()]);
+        }
+        if (options.companyId !== undefined) {
+          fetchOptions.query.push(['company_id', options.companyId.toString()]);
+        }
+        if (options.companySupplierId !== undefined) {
+          fetchOptions.query.push(['company_supplier_id', options.companySupplierId.toString()]);
+        }
+        if (options.componentId !== undefined) {
+          fetchOptions.query.push(['component_id', options.componentId.toString()]);
+        }
+        if (options.groupBuyForJobId !== undefined) {
+          fetchOptions.query.push(['group_buy_for_job_id', options.groupBuyForJobId.toString()]);
+        }
+        if (options.section !== undefined) {
+          fetchOptions.query.push(['section', options.section.toString()]);
+        }
+        if (options.senderRole !== undefined) {
+          fetchOptions.query.push(['sender_role', options.senderRole.toString()]);
+        }
+        if (options.isOrder) {
+          fetchOptions.query.push(['is_order', 'true']);
+        }
+        if (options.tags !== undefined) {
+          fetchOptions.query.push(['tags', options.tags.join(',')]);
+        }
+        if (options.tagsInternal !== undefined) {
+          fetchOptions.query.push(['tags_internal', options.tagsInternal.join(',')]);
+        }
+        if (options.tagNames !== undefined) {
+          fetchOptions.query.push(['tag_names', options.tagNames.join(',')]);
+        }
+        if (options.exclude !== undefined) {
+          fetchOptions.query.push(['exclude', options.exclude.join(',')]);
+        }
+        if (options.excludeComponents !== undefined) {
+          fetchOptions.query.push(['exclude_components', options.excludeComponents.join(',')]);
+        }
+        if (options.excludeDomains !== undefined) {
+          fetchOptions.query.push(['exclude_domains', options.excludeDomains.join(',')]);
+        }
+        if (options.includeOnly !== undefined) {
+          fetchOptions.query.push(['include_only', options.includeOnly.join(',')]);
+        }
+        if (options.orClientId !== undefined) {
+          fetchOptions.query.push(['or_client_id', options.orClientId.toString()]);
+        }
+        if (options.orClientCompanyId !== undefined) {
+          fetchOptions.query.push(['or_client_company_id', options.orClientCompanyId.toString()]);
+        }
+      }
+      if (!(options && options.withRights)) {
+        fetchOptions.query.push(['skip_rights', 'y']);
+      }
+      return this.merchi.authenticatedFetch(resource, fetchOptions).then(function (data) {
+        var metadata = {
+          canCreate: data.canCreate,
+          available: data.available,
+          count: data.count,
+          limit: data.limit,
+          offset: data.offset
+        };
+        var pluralName = _this3.pluralName;
+        var singularName = _this3.singularName;
+        var items = data[pluralName];
+        var entities = [];
+        var _iterator7 = _createForOfIteratorHelper(items),
+          _step7;
+        try {
+          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+            var item = _step7.value;
+            var entity = new _this3();
+            entity.fromJson(item[singularName]);
+            entities.push(entity);
+          }
+        } catch (err) {
+          _iterator7.e(err);
+        } finally {
+          _iterator7.f();
+        }
+        return {
+          items: entities,
+          metadata: metadata
+        };
+      });
+    }
+  }]);
+  return Entity;
+}();
+_defineProperty(Entity, "jsonNameKey", Symbol('jsonName'));
+_defineProperty(Entity, "arrayTypeKey", Symbol('arrayType'));
+_defineProperty(Entity, "extraOptionsKey", Symbol('extraOptions'));
+_defineProperty(Entity, "propertiesSetKey", Symbol('propertiesSet'));
+_defineProperty(Entity, "primaryKey", 'id');