@horizon/client/lib/ast.js

'use strict';

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

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

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _Observable = require('rxjs/Observable');

var _empty = require('rxjs/observable/empty');

var _publishReplay = require('rxjs/operator/publishReplay');

var _scan = require('rxjs/operator/scan');

var _filter = require('rxjs/operator/filter');

var _map = require('rxjs/operator/map');

var _snakeCase = require('snake-case');

var _snakeCase2 = _interopRequireDefault(_snakeCase);

var _checkArgs = require('./util/check-args');

var _checkArgs2 = _interopRequireDefault(_checkArgs);

var _validIndexValue = require('./util/valid-index-value.js');

var _validIndexValue2 = _interopRequireDefault(_validIndexValue);

var _serialization = require('./serialization.js');

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

/**
 @this TermBase

 Validation check to throw an exception if a method is chained onto a
 query that already has it. It belongs to TermBase, but we don't want
 to pollute the objects with it (since it isn't useful to api users),
 so it's dynamically bound with :: inside methods that use it.
*/
function checkIfLegalToChain(key) {
  if (this._legalMethods.indexOf(key) === -1) {
    throw new Error(key + ' cannot be called on the current query');
  }
  if ((0, _snakeCase2.default)(key) in this._query) {
    throw new Error(key + ' has already been called on this query');
  }
}

// Abstract base class for terms

var TermBase = function () {
  function TermBase(sendRequest, query, legalMethods) {
    (0, _classCallCheck3.default)(this, TermBase);

    this._sendRequest = sendRequest;
    this._query = query;
    this._legalMethods = legalMethods;
  }
  // Returns a sequence of the result set. Every time it changes the
  // updated sequence will be emitted. If raw change objects are
  // needed, pass the option 'rawChanges: true'. An observable is
  // returned which will lazily emit the query when it is subscribed
  // to


  TermBase.prototype.watch = function watch() {
    var _ref = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

    var _ref$rawChanges = _ref.rawChanges;
    var rawChanges = _ref$rawChanges === undefined ? false : _ref$rawChanges;

    var raw = this._sendRequest('subscribe', this._query);
    if (rawChanges) {
      return raw;
    } else {
      return makePresentable(raw, this._query);
    }
  };
  // Grab a snapshot of the current query (non-changefeed). Emits an
  // array with all results. An observable is returned which will
  // lazily emit the query when subscribed to


  TermBase.prototype.fetch = function fetch() {
    return this._sendRequest('query', this._query);
  };

  TermBase.prototype.findAll = function findAll() {
    for (var _len = arguments.length, fieldValues = Array(_len), _key = 0; _key < _len; _key++) {
      fieldValues[_key] = arguments[_key];
    }

    checkIfLegalToChain.call(this, 'findAll');
    (0, _checkArgs2.default)('findAll', arguments, { maxArgs: 100 });
    return new FindAll(this._sendRequest, this._query, fieldValues);
  };

  TermBase.prototype.find = function find(idOrObject) {
    checkIfLegalToChain.call(this, 'find');
    (0, _checkArgs2.default)('find', arguments);
    return new Find(this._sendRequest, this._query, idOrObject);
  };

  TermBase.prototype.order = function order(fields) {
    var direction = arguments.length <= 1 || arguments[1] === undefined ? 'ascending' : arguments[1];

    checkIfLegalToChain.call(this, 'order');
    (0, _checkArgs2.default)('order', arguments, { minArgs: 1, maxArgs: 2 });
    return new Order(this._sendRequest, this._query, fields, direction);
  };

  TermBase.prototype.above = function above(aboveSpec) {
    var bound = arguments.length <= 1 || arguments[1] === undefined ? 'closed' : arguments[1];

    checkIfLegalToChain.call(this, 'above');
    (0, _checkArgs2.default)('above', arguments, { minArgs: 1, maxArgs: 2 });
    return new Above(this._sendRequest, this._query, aboveSpec, bound);
  };

  TermBase.prototype.below = function below(belowSpec) {
    var bound = arguments.length <= 1 || arguments[1] === undefined ? 'open' : arguments[1];

    checkIfLegalToChain.call(this, 'below');
    (0, _checkArgs2.default)('below', arguments, { minArgs: 1, maxArgs: 2 });
    return new Below(this._sendRequest, this._query, belowSpec, bound);
  };

  TermBase.prototype.limit = function limit(size) {
    checkIfLegalToChain.call(this, 'limit');
    (0, _checkArgs2.default)('limit', arguments);
    return new Limit(this._sendRequest, this._query, size);
  };

  return TermBase;
}();

// Turn a raw observable of server responses into user-presentable events
//
// `observable` is the base observable with full responses coming from
//              the HorizonSocket
// `query` is the value of `options` in the request


function makePresentable(observable, query) {
  // Whether the entire data structure is in each change
  var pointQuery = Boolean(query.find);

  if (pointQuery) {
    var _ret = function () {
      var _context;

      var hasEmitted = false;
      var seedVal = null;
      // Simplest case: just pass through new_val
      return {
        v: (_context = _filter.filter.call(observable, function (change) {
          return !hasEmitted || change.type !== 'state';
        }), _scan.scan).call(_context, function (previous, change) {
          hasEmitted = true;
          if (change.state === 'synced') {
            return previous;
          } else {
            return change.new_val;
          }
        }, seedVal)
      };
    }();

    if ((typeof _ret === 'undefined' ? 'undefined' : (0, _typeof3.default)(_ret)) === "object") return _ret.v;
  } else {
    var _context2;

    var _seedVal = { emitted: false, val: [] };
    return (_context2 = (_context2 = _scan.scan.call(observable, function (state, change) {
      if (change.state === 'synced') {
        state.emitted = true;
      }
      state.val = applyChange(state.val.slice(), change);
      return state;
    }, _seedVal), _filter.filter).call(_context2, function (state) {
      return state.emitted;
    }), _map.map).call(_context2, function (x) {
      return x.val;
    });
  }
}

function applyChange(arr, change) {
  switch (change.type) {
    case 'remove':
    case 'uninitial':
      {
        // Remove old values from the array
        if (change.old_offset != null) {
          arr.splice(change.old_offset, 1);
        } else {
          var index = arr.findIndex(function (x) {
            return x.id === change.old_val.id;
          });
          arr.splice(index, 1);
        }
        break;
      }
    case 'add':
    case 'initial':
      {
        // Add new values to the array
        if (change.new_offset != null) {
          // If we have an offset, put it in the correct location
          arr.splice(change.new_offset, 0, change.new_val);
        } else {
          // otherwise for unordered results, push it on the end
          arr.push(change.new_val);
        }
        break;
      }
    case 'change':
      {
        // Modify in place if a change is happening
        if (change.old_offset != null) {
          // Remove the old document from the results
          arr.splice(change.old_offset, 1);
        }
        if (change.new_offset != null) {
          // Splice in the new val if we have an offset
          arr.splice(change.new_offset, 0, change.new_val);
        } else {
          // If we don't have an offset, find the old val and
          // replace it with the new val
          var _index = arr.findIndex(function (x) {
            return x.id === change.old_val.id;
          });
          arr[_index] = change.new_val;
        }
        break;
      }
    case 'state':
      {
        // This gets hit if we have not emitted yet, and should
        // result in an empty array being output.
        break;
      }
    default:
      throw new Error('unrecognized \'type\' field from server ' + JSON.stringify(change));
  }
  return arr;
}

/** @this Collection
 Implements writeOps for the Collection class
*/
function writeOp(name, args, documents) {
  (0, _checkArgs2.default)(name, args);
  var wrappedDocs = documents;
  if (!Array.isArray(documents)) {
    // Wrap in an array if we need to
    wrappedDocs = [documents];
  } else if (documents.length === 0) {
    // Don't bother sending no-ops to the server
    return _empty.empty.call(_Observable.Observable);
  }
  var options = Object.assign({}, this._query, { data: (0, _serialization.serialize)(wrappedDocs) });
  var observable = this._sendRequest(name, options);
  if (!this._lazyWrites) {
    var _context3;

    // Need to buffer response since this becomes a hot observable and
    // when we subscribe matters
    observable = (_context3 = observable, _publishReplay.publishReplay).call(_context3).refCount();
    observable.subscribe();
  }
  return observable;
}

var Collection = function (_TermBase) {
  (0, _inherits3.default)(Collection, _TermBase);

  function Collection(sendRequest, collectionName, lazyWrites) {
    (0, _classCallCheck3.default)(this, Collection);

    var query = { collection: collectionName };
    var legalMethods = ['find', 'findAll', 'justInitial', 'order', 'above', 'below', 'limit'];

    var _this = (0, _possibleConstructorReturn3.default)(this, _TermBase.call(this, sendRequest, query, legalMethods));

    _this._lazyWrites = lazyWrites;
    return _this;
  }

  Collection.prototype.store = function store(documents) {
    return writeOp.call(this, 'store', arguments, documents);
  };

  Collection.prototype.upsert = function upsert(documents) {
    return writeOp.call(this, 'upsert', arguments, documents);
  };

  Collection.prototype.insert = function insert(documents) {
    return writeOp.call(this, 'insert', arguments, documents);
  };

  Collection.prototype.replace = function replace(documents) {
    return writeOp.call(this, 'replace', arguments, documents);
  };

  Collection.prototype.update = function update(documents) {
    return writeOp.call(this, 'update', arguments, documents);
  };

  Collection.prototype.remove = function remove(documentOrId) {
    var wrapped = (0, _validIndexValue2.default)(documentOrId) ? { id: documentOrId } : documentOrId;
    return writeOp.call(this, 'remove', arguments, wrapped);
  };

  Collection.prototype.removeAll = function removeAll(documentsOrIds) {
    if (!Array.isArray(documentsOrIds)) {
      throw new Error('removeAll takes an array as an argument');
    }
    var wrapped = documentsOrIds.map(function (item) {
      if ((0, _validIndexValue2.default)(item)) {
        return { id: item };
      } else {
        return item;
      }
    });
    return writeOp.call(this, 'removeAll', arguments, wrapped);
  };

  return Collection;
}(TermBase);

var Find = function (_TermBase2) {
  (0, _inherits3.default)(Find, _TermBase2);

  function Find(sendRequest, previousQuery, idOrObject) {
    (0, _classCallCheck3.default)(this, Find);

    var findObject = (0, _validIndexValue2.default)(idOrObject) ? { id: idOrObject } : idOrObject;
    var query = Object.assign({}, previousQuery, { find: findObject });
    return (0, _possibleConstructorReturn3.default)(this, _TermBase2.call(this, sendRequest, query, []));
  }

  return Find;
}(TermBase);

var FindAll = function (_TermBase3) {
  (0, _inherits3.default)(FindAll, _TermBase3);

  function FindAll(sendRequest, previousQuery, fieldValues) {
    (0, _classCallCheck3.default)(this, FindAll);

    var wrappedFields = fieldValues.map(function (item) {
      return (0, _validIndexValue2.default)(item) ? { id: item } : item;
    });
    var options = { find_all: wrappedFields };
    var findAllQuery = Object.assign({}, previousQuery, options);
    var legalMethods = void 0;
    if (wrappedFields.length === 1) {
      legalMethods = ['order', 'above', 'below', 'limit'];
    } else {
      // The vararg version of findAll cannot have anything chained to it
      legalMethods = [];
    }
    return (0, _possibleConstructorReturn3.default)(this, _TermBase3.call(this, sendRequest, findAllQuery, legalMethods));
  }

  return FindAll;
}(TermBase);

var Above = function (_TermBase4) {
  (0, _inherits3.default)(Above, _TermBase4);

  function Above(sendRequest, previousQuery, aboveSpec, bound) {
    (0, _classCallCheck3.default)(this, Above);

    var option = { above: [aboveSpec, bound] };
    var query = Object.assign({}, previousQuery, option);
    var legalMethods = ['findAll', 'order', 'below', 'limit'];
    return (0, _possibleConstructorReturn3.default)(this, _TermBase4.call(this, sendRequest, query, legalMethods));
  }

  return Above;
}(TermBase);

var Below = function (_TermBase5) {
  (0, _inherits3.default)(Below, _TermBase5);

  function Below(sendRequest, previousQuery, belowSpec, bound) {
    (0, _classCallCheck3.default)(this, Below);

    var options = { below: [belowSpec, bound] };
    var query = Object.assign({}, previousQuery, options);
    var legalMethods = ['findAll', 'order', 'above', 'limit'];
    return (0, _possibleConstructorReturn3.default)(this, _TermBase5.call(this, sendRequest, query, legalMethods));
  }

  return Below;
}(TermBase);

var Order = function (_TermBase6) {
  (0, _inherits3.default)(Order, _TermBase6);

  function Order(sendRequest, previousQuery, fields, direction) {
    (0, _classCallCheck3.default)(this, Order);

    var wrappedFields = Array.isArray(fields) ? fields : [fields];
    var options = { order: [wrappedFields, direction] };
    var query = Object.assign({}, previousQuery, options);
    var legalMethods = ['findAll', 'above', 'below', 'limit'];
    return (0, _possibleConstructorReturn3.default)(this, _TermBase6.call(this, sendRequest, query, legalMethods));
  }

  return Order;
}(TermBase);

var Limit = function (_TermBase7) {
  (0, _inherits3.default)(Limit, _TermBase7);

  function Limit(sendRequest, previousQuery, size) {
    (0, _classCallCheck3.default)(this, Limit);

    var query = Object.assign({}, previousQuery, { limit: size });
    // Nothing is legal to chain after .limit
    return (0, _possibleConstructorReturn3.default)(this, _TermBase7.call(this, sendRequest, query, []));
  }

  return Limit;
}(TermBase);

module.exports = {
  TermBase: TermBase,
  Collection: Collection,
  FindAll: FindAll,
  Find: Find,
  Above: Above,
  Below: Below,
  Order: Order,
  Limit: Limit
};
//# sourceMappingURL=ast.js.map