fluorine-orchestra/lib/Store.js

A data orchestration layer for Fluorine

'use strict';

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

var _keys = require('babel-runtime/core-js/object/keys');

var _keys2 = _interopRequireDefault(_keys);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _symbol = require('babel-runtime/core-js/symbol');

var _symbol2 = _interopRequireDefault(_symbol);

exports.default = createStore;

var _invariant = require('invariant');

var _invariant2 = _interopRequireDefault(_invariant);

var _rxjs = require('rxjs');

var _toMap = require('./util/toMap');

var _toMap2 = _interopRequireDefault(_toMap);

var _createReducerForStore = require('./util/createReducerForStore');

var _createReducerForStore2 = _interopRequireDefault(_createReducerForStore);

var _Collection = require('./Collection');

var _immutable = require('immutable');

var _StoreConstants = require('./constants/StoreConstants');

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

var missing = (0, _symbol2.default)('missingSubject');

function _ref(transformer) {
  (0, _invariant2.default)(typeof transformer === 'function', 'Store: `transformer` is expected to be a function.');

  this.hooks.pre = transformer;
  return this;
}

function _ref2(identifier) {
  var dependencies = this.dependencies;


  (0, _invariant2.default)(typeof identifier === 'string', 'Store: `identifier` is expected to be a string.');
  (0, _invariant2.default)(!dependencies[identifier], 'Store: There is already an existing dependency to the store `' + identifier + '`.');

  for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    args[_key - 1] = arguments[_key];
  }

  (0, _invariant2.default)(args.length <= 2 && args.length >= 1, 'Store: `dependsOn` is expected to receive `setter` or `getter` and `setter`.');

  var dependency = void 0;
  if (args.length === 1) {
    var setter = args[0];

    (0, _invariant2.default)(typeof setter === 'function', 'Store: `setter` is expected to be a function.');

    dependency = { identifier: identifier, setter: setter };
  } else {
    var getter = args[0];
    var _setter = args[1];

    (0, _invariant2.default)(typeof getter === 'function', 'Store: `getter` is expected to be a function.');
    (0, _invariant2.default)(typeof _setter === 'function', 'Store: `setter` is expected to be a function.');

    dependency = { identifier: identifier, getter: getter, setter: _setter };
  }

  dependencies[identifier] = dependency;
  return this;
}

function _ref3(transformer) {
  (0, _invariant2.default)(typeof transformer === 'function', 'Store: `transformer` is expected to be a function.');

  this.hooks.post = transformer;
  return this;
}

function _ref4() {
  return this[missing].subject.asObservable();
}

function _ref5(col) {
  (0, _invariant2.default)(col && col.prototype instanceof _Collection.Collection, 'Store: `col` is expected to be a Collection.');

  this.collection = col;
  return this;
}

function _ref6() {
  return this.identifier;
}

function _ref17(x) {
  return (0, _toMap2.default)(x);
}

function _ref7() {
  return this.hooks.pre || _ref17;
}

function _ref8() {
  return this.dependencies;
}

function _ref9() {
  return this.hooks.post;
}

function _ref10() {
  if (this.reducer && typeof this.reducer === 'function') {
    return this.reducer;
  }

  this.reducer = (0, _createReducerForStore2.default)(this);
  return this.reducer;
}

function _ref11() {
  var CollectionClass = this.collection || _Collection.Collection;

  var res = new CollectionClass();
  res.dependencies = (0, _keys2.default)(this.dependencies);

  return res;
}

function _ref18(x) {
  return typeof x === 'string';
}

function _ref12(ids) {
  var identifier = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
  var _missing2 = this[missing];
  var cache = _missing2.cache;
  var subject = _missing2.subject;


  (0, _invariant2.default)(_immutable.Set.isSet(ids) && ids.every(_ref18), 'Store: `ids` is expected to be an Immutable.Set of ids (string).');

  cache[identifier] = ids;

  var missingIds = (0, _keys2.default)(cache).reduce(function (acc, key) {
    var _set = cache[key];
    return _set ? acc.union(_set) : acc;
  }, new _immutable.Set());

  subject.next(missingIds);
}

function _ref13(payload, groupId) {
  (0, _invariant2.default)(payload && (_immutable.Iterable.isKeyed(payload) || _immutable.Iterable.isIterable(payload) && payload.every && payload.every(_immutable.Iterable.isKeyed)), 'Store: `payload` is expected to be a keyed iterable or an iterable containing keyed iterables.');
  var identifier = this.identifier;


  return {
    type: _StoreConstants.STORE_INSERT,
    identifier: identifier,
    payload: payload,
    groupId: groupId
  };
}

function _ref14(payload) {
  (0, _invariant2.default)(payload && (typeof payload === 'string' || _immutable.Iterable.isKeyed(payload) && typeof payload.get('id') === 'string'), 'Store: `payload` is expected to be an id or a keyed iterable containing an id.');
  var identifier = this.identifier;


  return {
    type: _StoreConstants.STORE_REMOVE,
    identifier: identifier,
    payload: payload
  };
}

function _ref15(selector) {
  (0, _invariant2.default)(typeof selector === 'function', 'Store: `selector` is expected to be a function.');
  var identifier = this.identifier;


  return {
    type: _StoreConstants.STORE_FILTER,
    identifier: identifier,
    selector: selector
  };
}

function _ref16(selector) {
  (0, _invariant2.default)(typeof selector === 'function', 'Store: `selector` is expected to be a function.');
  var identifier = this.identifier;


  return {
    type: _StoreConstants.STORE_UPDATE,
    identifier: identifier,
    selector: selector
  };
}

var Store = exports.Store = function () {
  Store.isStore = function isStore(obj) {
    return typeof obj === 'object' && obj instanceof Store;
  };

  function Store(identifier) {
    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    (0, _classCallCheck3.default)(this, Store);

    (0, _invariant2.default)(typeof identifier === 'string', 'Store: `identifier` is expected to be a string.');

    this[missing] = {
      subject: new _rxjs.BehaviorSubject(),
      cache: {}
    };

    this.identifier = identifier;
    this.opts = opts;
    this.dependencies = {};
    this.hooks = {};

    this.insert = this.insert.bind(this);
    this.remove = this.remove.bind(this);
    this.filter = this.filter.bind(this);
    this.update = this.update.bind(this);
  }

  Store.prototype.pre = _ref;
  Store.prototype.dependsOn = _ref2;
  Store.prototype.post = _ref3;
  Store.prototype.observeMissing = _ref4;
  Store.prototype.useCollection = _ref5;
  Store.prototype.getIdentifier = _ref6;
  Store.prototype.getPre = _ref7;
  Store.prototype.getDependencies = _ref8;
  Store.prototype.getPost = _ref9;
  Store.prototype.getReducer = _ref10;
  Store.prototype.createCollection = _ref11;
  Store.prototype._missing = _ref12;
  Store.prototype.insert = _ref13;
  Store.prototype.remove = _ref14;
  Store.prototype.filter = _ref15;
  Store.prototype.update = _ref16;
  return Store;
}();

function createStore(identifier, opts) {
  return new Store(identifier, opts);
}