js-abstract-synchronizer/build/serializer/Serializer.js

abstract synchronizer for backend and frontend

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _SerializableObject = require('js-abstract-synchronizer/serializer/SerializableObject');

var _SerializableObject2 = _interopRequireDefault(_SerializableObject);

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var privates = Symbol('privates');

var simpleTypes = [Number, String, Boolean];

var Serializer = function () {
  function Serializer(_ref) {
    var _ref$prototypes = _ref.prototypes,
        prototypes = _ref$prototypes === undefined ? {} : _ref$prototypes,
        serializerImplementation = _ref.serializerImplementation;

    _classCallCheck(this, Serializer);

    var namesToPrototypesMap = new Map(_lodash2.default.map(prototypes, function (value, key) {
      return [key, value];
    }));
    var prototypesToNamesMap = new Map(_lodash2.default.map(prototypes, function (value, key) {
      return [value, key];
    }));
    this[privates] = {
      namesToPrototypesMap: namesToPrototypesMap,
      prototypesToNamesMap: prototypesToNamesMap,
      SerializableObject: (0, _SerializableObject2.default)(this),
      serializerImplementation: serializerImplementation
    };
  }

  _createClass(Serializer, [{
    key: 'configure',
    value: function configure(dbName) {
      return this[privates].serializerImplementation.configure(dbName);
    }
  }, {
    key: 'createFromSerializedData',
    value: function createFromSerializedData(_ref2) {
      var data = _ref2.data,
          id = _ref2.id,
          prototypeName = _ref2.prototypeName;

      return new this[privates].SerializableObject({ object: Object.assign({ id: id }, data), prototypeName: prototypeName });
    }
  }, {
    key: 'create',
    value: function create(object) {
      if (object instanceof this[privates].SerializableObject) {
        return object;
      }
      if (simpleTypes.includes(object.constructor)) {
        return object;
      }
      var prototypeName = this.getPrototypeName(object.constructor.prototype);
      var serializableObject = new this[privates].SerializableObject({ object: object, prototypeName: prototypeName });

      return serializableObject;
    }
  }, {
    key: 'save',
    value: function save(object) {
      return this[privates].serializerImplementation.save(object);
    }
  }, {
    key: 'reload',
    value: function reload(id) {
      return this[privates].serializerImplementation.reload(id);
    }
  }, {
    key: 'getPrototype',
    value: function getPrototype(prototypeName) {
      var result = this[privates].namesToPrototypesMap.get(prototypeName);

      return result;
    }
  }, {
    key: 'getPrototypeName',
    value: function getPrototypeName(prototype) {
      return this[privates].prototypesToNamesMap.get(prototype);
    }
  }]);

  return Serializer;
}();

exports.default = Serializer;