@horizon/client/lib/index.js

'use strict';

var _from = require('rxjs/observable/from');

var _catch2 = require('rxjs/operator/catch');

var _concatMap = require('rxjs/operator/concatMap');

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

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

var Observable = _require.Observable;

var _require2 = require('./ast.js');

var Collection = _require2.Collection;

var HorizonSocket = require('./socket.js');

var _require3 = require('./logging.js');

var log = _require3.log;
var logError = _require3.logError;
var enableLogging = _require3.enableLogging;

var _require4 = require('./auth');

var authEndpoint = _require4.authEndpoint;
var TokenStorage = _require4.TokenStorage;
var clearAuthTokens = _require4.clearAuthTokens;


var defaultHost = typeof window !== 'undefined' && window.location && '' + window.location.host || 'localhost:8181';
var defaultSecure = typeof window !== 'undefined' && window.location && window.location.protocol === 'https:' || false;

function Horizon() {
  var _context;

  var _ref = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

  var _ref$host = _ref.host;
  var host = _ref$host === undefined ? defaultHost : _ref$host;
  var _ref$secure = _ref.secure;
  var secure = _ref$secure === undefined ? defaultSecure : _ref$secure;
  var _ref$path = _ref.path;
  var path = _ref$path === undefined ? 'horizon' : _ref$path;
  var _ref$lazyWrites = _ref.lazyWrites;
  var lazyWrites = _ref$lazyWrites === undefined ? false : _ref$lazyWrites;
  var _ref$authType = _ref.authType;
  var authType = _ref$authType === undefined ? 'unauthenticated' : _ref$authType;

  // If we're in a redirection from OAuth, store the auth token for
  // this user in localStorage.
  var tokenStorage = new TokenStorage(authType);
  tokenStorage.setAuthFromQueryParams();

  var socket = new HorizonSocket(host, secure, path, tokenStorage.handshake.bind(tokenStorage));

  // Store whatever token we get back from the server when we get a
  // handshake response
  socket.handshake.subscribe(function (handshake) {
    return tokenStorage.set(handshake.token);
  });

  // This is the object returned by the Horizon function. It's a
  // function so we can construct a collection simply by calling it
  // like horizon('my_collection')
  function horizon(name) {
    return new Collection(sendRequest, name, lazyWrites);
  }

  horizon.dispose = function () {
    socket.complete();
  };

  // Dummy subscription to force it to connect to the
  // server. Optionally provide an error handling function if the
  // socket experiences an error.
  // Note: Users of the Observable interface shouldn't need this
  horizon.connect = function () {
    var onError = arguments.length <= 0 || arguments[0] === undefined ? function (err) {
      console.error('Received an error: ' + err);
    } : arguments[0];

    socket.subscribe(function () {}, onError);
  };

  // Either subscribe to status updates, or return an observable with
  // the current status and all subsequent status changes.
  horizon.status = subscribeOrObservable(socket.status);

  // Convenience method for finding out when disconnected
  horizon.onDisconnected = subscribeOrObservable((_context = socket.status, _filter.filter).call(_context, function (x) {
    return x.type === 'disconnected';
  }));

  // Convenience method for finding out when opening
  horizon.onConnected = subscribeOrObservable((_context = socket.status, _filter.filter).call(_context, function (x) {
    return x.type === 'connected';
  }));

  // Convenience method for finding out when ready
  horizon.onReady = subscribeOrObservable((_context = socket.status, _filter.filter).call(_context, function (x) {
    return x.type === 'ready';
  }));

  // Convenience method for finding out when an error occurs
  horizon.onSocketError = subscribeOrObservable((_context = socket.status, _filter.filter).call(_context, function (x) {
    return x.type === 'error';
  }));

  horizon._authMethods = null;
  horizon._horizonPath = path;
  horizon.authEndpoint = authEndpoint;
  horizon.hasAuthToken = tokenStorage.hasAuthToken.bind(tokenStorage);

  return horizon;

  // Sends a horizon protocol request to the server, and pulls the data
  // portion of the response out.
  function sendRequest(type, options) {
    var _context2;

    // Both remove and removeAll use the type 'remove' in the protocol
    var normalizedType = type === 'removeAll' ? 'remove' : type;
    return (_context2 = (_context2 = socket.makeRequest({ type: normalizedType, options: options }) // send the raw request
    , _concatMap.concatMap).call(_context2, function (resp) {
      // unroll arrays being returned
      if (resp.data) {
        return _from.from.call(Observable, resp.data);
      } else {
        // Still need to emit a document even if we have no new data
        return _from.from.call(Observable, [{ state: resp.state, type: resp.type }]);
      }
    }), _catch2._catch).call(_context2, function (e) {
      return Observable.create(function (observer) {
        observer.error(e);
      });
    }); // on error, strip error message
  }
}

function subscribeOrObservable(observable) {
  return function () {
    if (arguments.length > 0) {
      return observable.subscribe.apply(observable, arguments);
    } else {
      return observable;
    }
  };
}

Horizon.log = log;
Horizon.logError = logError;
Horizon.enableLogging = enableLogging;
Horizon.Socket = HorizonSocket;
Horizon.clearAuthTokens = clearAuthTokens;

module.exports = Horizon;
//# sourceMappingURL=index.js.map