@oada/oada-cache/build/index.js

"use strict";

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

var _regenerator = require("babel-runtime/regenerator");

var _regenerator2 = _interopRequireDefault(_regenerator);

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

var _keys2 = _interopRequireDefault(_keys);

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

var _typeof3 = _interopRequireDefault(_typeof2);

var _asyncToGenerator2 = require("babel-runtime/helpers/asyncToGenerator");

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _cache = require("./cache");

var _cache2 = _interopRequireDefault(_cache);

var _uuid = require("uuid");

var _uuid2 = _interopRequireDefault(_uuid);

var _lodash = require("lodash");

var _lodash2 = _interopRequireDefault(_lodash);

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

var Promise = require("bluebird");
var pretty = require('prettyjson');

var urlLib = require("url");
var pointer = require("json-pointer");
var ws = require("./websocket");
var axios = require("axios");
var _TOKEN = require("./token");

var connect = function () {
  var _ref2 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee18(_ref) {
    var _makeResourceAndLink = function () {
      var _ref4 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee(_ref3, waitTime) {
        var path = _ref3.path,
            data = _ref3.data,
            headers = _ref3.headers;

        var _id, linkReq, resReq, link, pathPieces, parentPath, response, newHeaders, resource;

        return _regenerator2.default.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _id = _lodash2.default.clone(data._id) || "resources/" + (0, _uuid2.default)();
                linkReq = {
                  path: path,
                  type: data._type,
                  headers: headers,
                  data: { _id: _id }
                };
                // Create a version link of the tree specifies it so.

                if (data._rev) linkReq.data._rev = '0-0';
                resReq = {
                  path: "/" + _id,
                  type: data._type,
                  data: data
                };
                _context.prev = 4;
                _context.next = 7;
                return put(linkReq);

              case 7:
                link = _context.sent;
                _context.next = 42;
                break;

              case 10:
                _context.prev = 10;
                _context.t0 = _context["catch"](4);

                if (!(_context.t0.response && _context.t0.response.status === 412)) {
                  _context.next = 41;
                  break;
                }

                pathPieces = path.split('/');
                parentPath = pathPieces.splice(0, pathPieces.length - 1).join('/');
                // Wait time increases exponentially: 1s, 2s, 4s, 8s, 16s. Throw after 16s.

                if (!(waitTime > 16000)) {
                  _context.next = 17;
                  break;
                }

                throw _context.t0;

              case 17:
                _context.prev = 17;
                _context.next = 20;
                return NOCACHEREQUEST({ method: 'get', url: DOMAIN + parentPath, headers: { "Authorization": "Bearer " + TOKEN } });

              case 20:
                response = _context.sent;
                _context.next = 29;
                break;

              case 23:
                _context.prev = 23;
                _context.t1 = _context["catch"](17);

                waitTime = waitTime || 1000;
                _context.next = 28;
                return Promise.delay(waitTime);

              case 28:
                return _context.abrupt("return", _makeResourceAndLink({ path: path, data: data, headers: headers }, waitTime * 2));

              case 29:
                if (!response.data[pathPieces[pathPieces.length - 1]]) {
                  _context.next = 33;
                  break;
                }

                resReq.path = path;
                _context.next = 39;
                break;

              case 33:
                waitTime = waitTime || 1000;
                _context.next = 36;
                return Promise.delay(waitTime);

              case 36:
                newHeaders = _lodash2.default.cloneDeep(headers);

                newHeaders['if-match'] = response.headers['x-oada-rev'];
                return _context.abrupt("return", _makeResourceAndLink({ path: path, data: data, headers: newHeaders }, waitTime * 2));

              case 39:
                _context.next = 42;
                break;

              case 41:
                throw _context.t0;

              case 42:
                // Delete the _rev  and _id keys. No need for them in the resource object.
                delete resReq.data._rev;
                delete resReq.data._id;
                _context.next = 46;
                return put(resReq);

              case 46:
                resource = _context.sent;
                return _context.abrupt("return", { link: link, resource: resource });

              case 48:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this, [[4, 10], [17, 23]]);
      }));

      return function _makeResourceAndLink(_x2, _x3) {
        return _ref4.apply(this, arguments);
      };
    }();

    // Construct the request object and catch any 401s (expired token)
    var _buildRequest = function () {
      var _ref8 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee3(_ref7) {
        var method = _ref7.method,
            url = _ref7.url,
            path = _ref7.path,
            headers = _ref7.headers,
            data = _ref7.data,
            type = _ref7.type;
        var req;
        return _regenerator2.default.wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                if (!(!path && !url)) {
                  _context3.next = 2;
                  break;
                }

                throw new Error("Either path or url must be specified.");

              case 2:
                if (!url) {
                  _context3.next = 9;
                  break;
                }

                if (!/^\//.test(url)) {
                  _context3.next = 7;
                  break;
                }

                url = domain + url;
                _context3.next = 9;
                break;

              case 7:
                if (!(url.indexOf(domain) !== 0)) {
                  _context3.next = 9;
                  break;
                }

                throw new Error("'url' key must begin with the domain used to connect");

              case 9:
                method = method.toLowerCase();
                req = {
                  method: method,
                  url: url || DOMAIN + path,
                  headers: { authorization: "Bearer " + TOKEN }
                };

                if (/\/$/.test(req.url)) req.url = req.url.slice(0, req.url.length - 1);

                //handle headers
                (0, _keys2.default)(headers || {}).forEach(function (header) {
                  req.headers[header.toLowerCase()] = headers[header];
                });

                if (method === "put" || method === 'post') {
                  req.headers["content-type"] = req.headers["content-type"] || type || data._type;
                  req.data = data;
                }

                if (method === "delete") {
                  req.headers["content-type"] = req.headers["content-type"] || type;
                }
                return _context3.abrupt("return", req);

              case 16:
              case "end":
                return _context3.stop();
            }
          }
        }, _callee3, this);
      }));

      return function _buildRequest(_x5) {
        return _ref8.apply(this, arguments);
      };
    }();

    var _sendRequest = function () {
      var _ref9 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee4(req) {
        return _regenerator2.default.wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                _context4.prev = 0;
                return _context4.abrupt("return", REQUEST(req));

              case 4:
                _context4.prev = 4;
                _context4.t0 = _context4["catch"](0);

                if (!(_context4.t0 && _context4.t0.response.status === 401)) {
                  _context4.next = 10;
                  break;
                }

                _context4.next = 9;
                return reconnect();

              case 9:
                return _context4.abrupt("return", REQUEST(req));

              case 10:
                throw _context4.t0;

              case 11:
              case "end":
                return _context4.stop();
            }
          }
        }, _callee4, this, [[0, 4]]);
      }));

      return function _sendRequest(_x6) {
        return _ref9.apply(this, arguments);
      };
    }();

    var get = function () {
      var _ref11 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee5(_ref10) {
        var url = _ref10.url,
            path = _ref10.path,
            headers = _ref10.headers,
            watch = _ref10.watch,
            tree = _ref10.tree;
        var req, response, pieces, treePath, subTree, stuff;
        return _regenerator2.default.wrap(function _callee5$(_context5) {
          while (1) {
            switch (_context5.prev = _context5.next) {
              case 0:
                _context5.next = 2;
                return _buildRequest({ method: "get", url: url, path: path, headers: headers });

              case 2:
                req = _context5.sent;
                _context5.next = 5;
                return _sendRequest(req);

              case 5:
                response = _context5.sent;

                if (!tree) {
                  _context5.next = 17;
                  break;
                }

                pieces = urlLib.parse(req.url).path.replace(/^\//, "").split("/");
                treePath = _convertSetupTreePath(pieces, tree);

                if (pointer.has(tree, treePath)) {
                  _context5.next = 11;
                  break;
                }

                throw new Error("The path does not exist on the given tree.");

              case 11:
                //return get({url: req.url})
                subTree = pointer.get(tree, treePath);
                _context5.next = 14;
                return _recursiveGet(req.url, subTree, {}, true);

              case 14:
                stuff = _context5.sent;

                response.data = stuff.data;
                response.cached = stuff.cached;

              case 17:
                if (!watch) {
                  _context5.next = 22;
                  break;
                }

                path = path || urlLib.parse(url).path;
                req.headers["x-oada-rev"] = response.data._rev;
                _context5.next = 22;
                return _watch({
                  headers: req.headers,
                  path: path,
                  func: watch.func,
                  payload: watch.payload
                });

              case 22:
                return _context5.abrupt("return", response);

              case 23:
              case "end":
                return _context5.stop();
            }
          }
        }, _callee5, this);
      }));

      return function get(_x7) {
        return _ref11.apply(this, arguments);
      };
    }(); //get

    var _recursiveGet = function () {
      var _ref12 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee7(url, tree, data, cached) {
        var got;
        return _regenerator2.default.wrap(function _callee7$(_context7) {
          while (1) {
            switch (_context7.prev = _context7.next) {
              case 0:
                if (!tree._type) {
                  _context7.next = 6;
                  break;
                }

                _context7.next = 3;
                return get({
                  url: url
                });

              case 3:
                got = _context7.sent;

                data = got.data;
                cached = got.cached ? got.cached : false;

              case 6:
                return _context7.abrupt("return", Promise.map((0, _keys2.default)(data || {}), function () {
                  var _ref13 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee6(key) {
                    var res;
                    return _regenerator2.default.wrap(function _callee6$(_context6) {
                      while (1) {
                        switch (_context6.prev = _context6.next) {
                          case 0:
                            if (!((0, _typeof3.default)(data[key]) === "object")) {
                              _context6.next = 20;
                              break;
                            }

                            if (!tree[key]) {
                              _context6.next = 9;
                              break;
                            }

                            _context6.next = 4;
                            return _recursiveGet(url + "/" + key, tree[key], data[key], cached);

                          case 4:
                            res = _context6.sent;

                            cached = res.cached;
                            return _context6.abrupt("return", data[key] = res.data);

                          case 9:
                            if (!tree["*"]) {
                              _context6.next = 17;
                              break;
                            }

                            _context6.next = 12;
                            return _recursiveGet(url + "/" + key, tree["*"], data[key], cached);

                          case 12:
                            res = _context6.sent;

                            cached = res.cached;
                            return _context6.abrupt("return", data[key] = res.data);

                          case 17:
                            return _context6.abrupt("return");

                          case 18:
                            _context6.next = 21;
                            break;

                          case 20:
                            return _context6.abrupt("return");

                          case 21:
                          case "end":
                            return _context6.stop();
                        }
                      }
                    }, _callee6, this);
                  }));

                  return function (_x12) {
                    return _ref13.apply(this, arguments);
                  };
                }()).then(function () {
                  return { data: data, cached: cached };
                }));

              case 7:
              case "end":
                return _context7.stop();
            }
          }
        }, _callee7, this);
      }));

      return function _recursiveGet(_x8, _x9, _x10, _x11) {
        return _ref12.apply(this, arguments);
      };
    }();

    // Identify the stored resources vs those that need to be setup.


    var _ensureTree = function () {
      var _ref15 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee9(_ref14) {
        var url = _ref14.url,
            tree = _ref14.tree,
            data = _ref14.data;
        var path, pieces, firstPath, storedTree, responses, ret, parentRev;
        return _regenerator2.default.wrap(function _callee9$(_context9) {
          while (1) {
            switch (_context9.prev = _context9.next) {
              case 0:
                //If /resources

                //If /bookmarks
                path = urlLib.parse(url).path.replace(/^\//, "");
                pieces = path.replace(/\/$/, "").split("/");

                if (data._id) {
                  firstPath = _convertSetupTreePath(pieces, tree);

                  pointer.set(tree, firstPath + "/_id", data._id);
                }
                //    if (pointer.has(tree, treePath)) pointer.set(tree, treePath, _.merge(pointer.get(tree, treePath),data))
                storedTree = {};
                responses = [];
                // Find the deepest part of the path that exists. Once found, work back down.

                _context9.next = 7;
                return _findDeepestResources(pieces, tree, storedTree);

              case 7:
                ret = _context9.sent;

                // Create all the resources on the way down. ret.stored is an index. Slice
                // takes the length to slice, so no need to subtract 1.
                parentRev = ret._rev;
                _context9.next = 11;
                return Promise.mapSeries(pieces.slice(0, pieces.length - ret.stored), function () {
                  var _ref16 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee8(piece, j) {
                    var i, urlPath, treePath, content, resp;
                    return _regenerator2.default.wrap(function _callee8$(_context8) {
                      while (1) {
                        switch (_context8.prev = _context8.next) {
                          case 0:
                            i = ret.stored + 1 + j; // ret.stored exists; add one to continue beyond.

                            urlPath = "/" + pieces.slice(0, i + 1).join("/");
                            treePath = _convertSetupTreePath(pieces.slice(0, i + 1), tree);

                            if (!(pointer.has(tree, treePath + "/_type") && i <= ret.setup)) {
                              _context8.next = 14;
                              break;
                            }

                            _context8.next = 6;
                            return _replaceLinks(pointer.get(tree, treePath));

                          case 6:
                            content = _context8.sent;
                            _context8.next = 9;
                            return _makeResourceAndLink({
                              path: urlPath,
                              data: _lodash2.default.cloneDeep(content),
                              headers: { 'if-match': parentRev }
                            });

                          case 9:
                            resp = _context8.sent;

                            parentRev = resp.resource.headers['x-oada-rev'];
                            pointer.set(storedTree, urlPath, content);
                            resp.path = urlPath;
                            responses.push(resp);

                          case 14:
                            ;

                          case 15:
                          case "end":
                            return _context8.stop();
                        }
                      }
                    }, _callee8, this);
                  }));

                  return function (_x14, _x15) {
                    return _ref16.apply(this, arguments);
                  };
                }());

              case 11:
                return _context9.abrupt("return", responses);

              case 12:
              case "end":
                return _context9.stop();
            }
          }
        }, _callee9, this);
      }));

      return function _ensureTree(_x13) {
        return _ref15.apply(this, arguments);
      };
    }();

    var _recursiveDelete = function () {
      var _ref20 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee12(url, tree, data) {
        var got;
        return _regenerator2.default.wrap(function _callee12$(_context12) {
          while (1) {
            switch (_context12.prev = _context12.next) {
              case 0:
                if (!tree._type) {
                  _context12.next = 13;
                  break;
                }

                _context12.prev = 1;
                _context12.next = 4;
                return get({
                  url: url
                });

              case 4:
                got = _context12.sent;

                data = got.data;
                _context12.next = 13;
                break;

              case 8:
                _context12.prev = 8;
                _context12.t0 = _context12["catch"](1);

                if (!(_context12.t0.status === 404)) {
                  _context12.next = 13;
                  break;
                }

                data = {};
                return _context12.abrupt("return");

              case 13:
                return _context12.abrupt("return", Promise.map((0, _keys2.default)(data || {}), function () {
                  var _ref21 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee10(key) {
                    var res;
                    return _regenerator2.default.wrap(function _callee10$(_context10) {
                      while (1) {
                        switch (_context10.prev = _context10.next) {
                          case 0:
                            if (!((0, _typeof3.default)(data[key]) === "object")) {
                              _context10.next = 18;
                              break;
                            }

                            if (!tree[key]) {
                              _context10.next = 8;
                              break;
                            }

                            _context10.next = 4;
                            return _recursiveDelete(url + "/" + key, tree[key], data[key]);

                          case 4:
                            res = _context10.sent;
                            return _context10.abrupt("return", data[key] = res.data);

                          case 8:
                            if (!tree["*"]) {
                              _context10.next = 15;
                              break;
                            }

                            _context10.next = 11;
                            return _recursiveDelete(url + "/" + key, tree["*"], data[key]);

                          case 11:
                            res = _context10.sent;
                            return _context10.abrupt("return", data[key] = res.data);

                          case 15:
                            return _context10.abrupt("return");

                          case 16:
                            _context10.next = 19;
                            break;

                          case 18:
                            return _context10.abrupt("return");

                          case 19:
                          case "end":
                            return _context10.stop();
                        }
                      }
                    }, _callee10, this);
                  }));

                  return function (_x19) {
                    return _ref21.apply(this, arguments);
                  };
                }()).then((0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee11() {
                  var link;
                  return _regenerator2.default.wrap(function _callee11$(_context11) {
                    while (1) {
                      switch (_context11.prev = _context11.next) {
                        case 0:
                          if (!tree._type) {
                            _context11.next = 15;
                            break;
                          }

                          _context11.prev = 1;

                          if (!data._id) {
                            _context11.next = 5;
                            break;
                          }

                          _context11.next = 5;
                          return del({
                            path: '/' + data._id,
                            headers: { 'content-type': tree._type }
                          });

                        case 5:
                          _context11.next = 7;
                          return del({
                            url: url,
                            headers: {
                              'content-type': tree._type
                            }
                          });

                        case 7:
                          link = _context11.sent;
                          _context11.next = 15;
                          break;

                        case 10:
                          _context11.prev = 10;
                          _context11.t0 = _context11["catch"](1);

                          if (!(_context11.t0.status === 404)) {
                            _context11.next = 15;
                            break;
                          }

                          data = {};
                          return _context11.abrupt("return");

                        case 15:
                          return _context11.abrupt("return", { link: link, data: data });

                        case 16:
                        case "end":
                          return _context11.stop();
                      }
                    }
                  }, _callee11, this, [[1, 10]]);
                }))));

              case 14:
              case "end":
                return _context12.stop();
            }
          }
        }, _callee12, this, [[1, 8]]);
      }));

      return function _recursiveDelete(_x16, _x17, _x18) {
        return _ref20.apply(this, arguments);
      };
    }();

    var del = function () {
      var _ref24 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee13(_ref23) {
        var url = _ref23.url,
            path = _ref23.path,
            type = _ref23.type,
            headers = _ref23.headers,
            tree = _ref23.tree,
            unwatch = _ref23.unwatch;
        var req, pieces, treePath, subTree, result;
        return _regenerator2.default.wrap(function _callee13$(_context13) {
          while (1) {
            switch (_context13.prev = _context13.next) {
              case 0:
                _context13.next = 2;
                return _buildRequest({ method: "delete", url: url, path: path, type: type, headers: headers });

              case 2:
                req = _context13.sent;

                if (!unwatch) {
                  _context13.next = 6;
                  break;
                }

                path = path || urlLib.parse(url).path;
                return _context13.abrupt("return", SOCKET.unwatch({
                  path: path,
                  headers: req.headers
                }));

              case 6:
                if (!tree) {
                  _context13.next = 16;
                  break;
                }

                pieces = urlLib.parse(req.url).path.replace(/^\//, "").split("/");
                treePath = _convertSetupTreePath(pieces, tree);

                if (pointer.has(tree, treePath)) {
                  _context13.next = 11;
                  break;
                }

                throw new Error("The path does not exist on the given tree.");

              case 11:
                //return get({url: req.url})
                subTree = pointer.get(tree, treePath);
                _context13.next = 14;
                return _recursiveDelete(req.url, subTree, {}, true);

              case 14:
                result = _context13.sent;
                return _context13.abrupt("return", result.link);

              case 16:
                if (req.headers["content-type"]) {
                  _context13.next = 18;
                  break;
                }

                throw new Error("content-type header must be specified.");

              case 18:
                return _context13.abrupt("return", _sendRequest(req));

              case 19:
              case "end":
                return _context13.stop();
            }
          }
        }, _callee13, this);
      }));

      return function del(_x20) {
        return _ref24.apply(this, arguments);
      };
    }();

    // Ensure all resources down to the deepest resource are created before
    // performing a PUT.


    var put = function () {
      var _ref26 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee14(_ref25) {
        var url = _ref25.url,
            path = _ref25.path,
            data = _ref25.data,
            type = _ref25.type,
            headers = _ref25.headers,
            tree = _ref25.tree;
        var req, responses, pieces, treePath;
        return _regenerator2.default.wrap(function _callee14$(_context14) {
          while (1) {
            switch (_context14.prev = _context14.next) {
              case 0:
                _context14.next = 2;
                return _buildRequest({
                  method: "put",
                  url: url,
                  path: path,
                  data: data,
                  type: type,
                  headers: headers
                });

              case 2:
                req = _context14.sent;

                if (!tree) {
                  _context14.next = 10;
                  break;
                }

                _context14.next = 6;
                return _ensureTree({
                  url: req.url,
                  tree: _lodash2.default.cloneDeep(tree),
                  data: data
                });

              case 6:
                responses = _context14.sent;
                pieces = responses.length > 0 ? responses[responses.length - 1].path.replace(/^\//, "").split("/") : urlLib.parse(req.url).path.replace(/^\//, "").split('/');
                treePath = _convertSetupTreePath(pieces, tree) + "/_type";

                if (!req.headers["content-type"] && pointer.has(tree, treePath)) req.headers["content-type"] = _lodash2.default.clone(pointer.get(tree, treePath));

              case 10:
                if (req.headers["content-type"]) {
                  _context14.next = 12;
                  break;
                }

                throw new Error("content-type header must be specified.");

              case 12:
                return _context14.abrupt("return", _sendRequest(req));

              case 13:
              case "end":
                return _context14.stop();
            }
          }
        }, _callee14, this);
      }));

      return function put(_x21) {
        return _ref26.apply(this, arguments);
      };
    }();

    var resetCache = function () {
      var _ref27 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee15(name, expires) {
        return _regenerator2.default.wrap(function _callee15$(_context15) {
          while (1) {
            switch (_context15.prev = _context15.next) {
              case 0:
                if (CACHE) {
                  _context15.next = 2;
                  break;
                }

                return _context15.abrupt("return");

              case 2:
                _context15.next = 4;
                return CACHE.resetCache();

              case 4:
              case "end":
                return _context15.stop();
            }
          }
        }, _callee15, this);
      }));

      return function resetCache(_x22, _x23) {
        return _ref27.apply(this, arguments);
      };
    }();

    var disconnect = function () {
      var _ref28 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee16() {
        return _regenerator2.default.wrap(function _callee16$(_context16) {
          while (1) {
            switch (_context16.prev = _context16.next) {
              case 0:
                if (!CACHE) {
                  _context16.next = 3;
                  break;
                }

                _context16.next = 3;
                return CACHE.db.close();

              case 3:
                //if (CACHE) await CACHE.db.destroy();
                if (SOCKET) SOCKET.close();
                if (_token.isSet()) {
                  _token.cleanUp();
                }

              case 5:
              case "end":
                return _context16.stop();
            }
          }
        }, _callee16, this);
      }));

      return function disconnect() {
        return _ref28.apply(this, arguments);
      };
    }();

    var reconnect = function () {
      var _ref29 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee17() {
        return _regenerator2.default.wrap(function _callee17$(_context17) {
          while (1) {
            switch (_context17.prev = _context17.next) {
              case 0:
                _context17.next = 2;
                return _token.renew();

              case 2:
                TOKEN = _context17.sent;

              case 3:
              case "end":
                return _context17.stop();
            }
          }
        }, _callee17, this);
      }));

      return function reconnect() {
        return _ref29.apply(this, arguments);
      };
    }();

    // get a token


    var domain = _ref.domain,
        options = _ref.options,
        cache = _ref.cache,
        token = _ref.token,
        websocket = _ref.websocket;

    var OFFLINE, CACHE, REQUEST, NOCACHEREQUEST, SOCKET, TOKEN, _token, DOMAIN, NAME, EXPIRES, _replaceLinks, _watch, _findDeepestResources, _convertSetupTreePath, _configureCache, _configureWs, post, socketApi;

    return _regenerator2.default.wrap(function _callee18$(_context18) {
      while (1) {
        switch (_context18.prev = _context18.next) {
          case 0:
            post = function post(_ref19) {
              var url = _ref19.url,
                  path = _ref19.path,
                  data = _ref19.data,
                  type = _ref19.type,
                  headers = _ref19.headers,
                  tree = _ref19.tree;

              url = url || DOMAIN + path;
              url = url[url.length - 1] === "/" ? url + (0, _uuid2.default)() : url + "/" + (0, _uuid2.default)();
              return put({
                url: url,
                data: data,
                type: type,
                headers: headers,
                tree: tree
              });
            };

            _configureWs = function _configureWs(_ref18) {
              var domain = _ref18.domain;

              return ws(domain).then(function (socketApi) {
                REQUEST = socketApi.http;
                NOCACHEREQUEST = socketApi.http;
                return SOCKET = socketApi;
              });
            };

            _configureCache = function _configureCache(_ref17) {
              var name = _ref17.name,
                  req = _ref17.req,
                  expires = _ref17.expires;

              var res = (0, _cache2.default)({ name: name, req: req, expires: expires });
              REQUEST = res.api;
              CACHE = res;
              return;
            };

            _convertSetupTreePath = function _convertSetupTreePath(pathPieces, tree) {
              var newPieces = _lodash2.default.clone(pathPieces);
              newPieces = pathPieces.map(function (piece, i) {
                if (pointer.has(tree, "/" + newPieces.slice(0, i).join("/") + "/*")) {
                  newPieces[i] = "*";
                  return "*";
                } else {
                  return piece;
                }
              });
              return "/" + newPieces.join("/");
            };

            _findDeepestResources = function _findDeepestResources(pieces, tree, storedTree) {
              var stored = 0;
              var setup = void 0;
              var _rev;
              // Walk down the url in reverse order
              return Promise.mapSeries(pieces, function (piece, i) {
                var z = pieces.length - 1 - i; //use z to create paths in reverse order
                var urlPath = "/" + pieces.slice(0, z + 1).join("/");
                var treePath = _convertSetupTreePath(pieces.slice(0, z + 1), tree);
                // Check that its in the stored tree then look for deepest _resource_.
                // If successful, break from the loop by throwing
                if (pointer.has(tree, treePath + "/_type")) {
                  setup = setup || z;
                  if (pointer.has(storedTree, urlPath)) {
                    stored = _lodash2.default.clone(z);
                    throw new Error("stored");
                  }
                  return get({
                    path: urlPath
                  }).then(function (response) {
                    //TODO: Detect whether the returned data matches the given tree
                    pointer.set(storedTree, urlPath, {});
                    stored = _lodash2.default.clone(z);
                    _rev = response.headers['x-oada-rev'];
                    throw new Error("stored");
                  }).catch(function (err) {
                    if (/^stored/.test(err.message)) throw err;
                    return;
                  });
                } else return;
              }).catch(function (err) {
                // Throwing with a number error only should occur on success.
                if (/^stored/.test(err.message)) return { stored: stored, setup: setup };
              }).then(function () {
                return {
                  stored: stored,
                  setup: setup || 0,
                  _rev: _rev
                };
              });
            };

            _watch = function _watch(_ref5) {
              var headers = _ref5.headers,
                  path = _ref5.path,
                  func = _ref5.func,
                  payload = _ref5.payload;

              if (SOCKET) {
                return SOCKET.watch({
                  path: path,
                  headers: headers
                }, function () {
                  var _ref6 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2(response) {
                    var watchPayload;
                    return _regenerator2.default.wrap(function _callee2$(_context2) {
                      while (1) {
                        switch (_context2.prev = _context2.next) {
                          case 0:
                            console.log('some response');
                            //console.log('_watch', pretty.render(response))
                            watchPayload = _lodash2.default.cloneDeep(payload) || {};

                            watchPayload.response = response;
                            watchPayload.request = {
                              url: DOMAIN + path,
                              headers: headers,
                              method: response.change.type
                            };

                            if (!CACHE) {
                              _context2.next = 7;
                              break;
                            }

                            _context2.next = 7;
                            return CACHE.handleWatchChange(watchPayload);

                          case 7:
                            if (!func) {
                              _context2.next = 10;
                              break;
                            }

                            _context2.next = 10;
                            return func(watchPayload);

                          case 10:
                            return _context2.abrupt("return");

                          case 11:
                          case "end":
                            return _context2.stop();
                        }
                      }
                    }, _callee2, this);
                  }));

                  function watchResponse(_x4) {
                    return _ref6.apply(this, arguments);
                  }

                  return watchResponse;
                }());
              } else {
                // Ping a normal GET every 5 seconds in the absense of a websocket
                return setInterval(function () {
                  get({ url: DOMAIN + path }).then(function (result) {
                    func(payload);
                  });
                }, 5000);
              }
            };

            _replaceLinks = function _replaceLinks(obj) {
              var ret = Array.isArray(obj) ? [] : {};
              if (!obj) return obj; // no defined objriptors for this level
              return Promise.map((0, _keys2.default)(obj || {}), function (key) {
                if (key === "*") {
                  // Don't put *s into oada. Ignore them
                  return;
                }
                var val = obj[key];
                if ((typeof val === "undefined" ? "undefined" : (0, _typeof3.default)(val)) !== "object" || !val) {
                  ret[key] = val; // keep it asntType: 'application/vnd.oada.harvest.1+json'
                  return;
                }
                if (val._type) {
                  // If it has a '_type' key, don't worry about it.
                  //It'll get created in future iterations of ensureTree
                  return;
                }
                if (val._id) {
                  // If it's an object, and has an '_id', make it a link from descriptor
                  ret[key] = { _id: val._id };
                  if (val._rev) ret[key]._rev = val._rev;
                  return;
                }
                // otherwise, recurse into the object looking for more links
                return _replaceLinks(val).then(function (result) {
                  ret[key] = result;
                  return;
                });
              }).then(function () {
                return ret;
              });
            };

            if (domain) {
              _context18.next = 9;
              break;
            }

            throw new Error("domain undefined");

          case 9:
            if (!(typeof domain !== "string")) {
              _context18.next = 11;
              break;
            }

            throw new Error("domain must be a string");

          case 11:
            if (!(!options && !token)) {
              _context18.next = 13;
              break;
            }

            throw new Error("options and token undefined");

          case 13:
            if (!(token && typeof token !== "string")) {
              _context18.next = 15;
              break;
            }

            throw new Error("token must be a string");

          case 15:
            if (!(cache !== undefined && typeof cache !== "boolean" && (typeof cache === "undefined" ? "undefined" : (0, _typeof3.default)(cache)) !== "object")) {
              _context18.next = 17;
              break;
            }

            throw new Error("cache must be either a boolean or an object with 'name' and/or 'expires' keys");

          case 17:
            if (!(cache && cache.name && typeof cache.name !== "string")) {
              _context18.next = 19;
              break;
            }

            throw new Error("cache name must be a string");

          case 19:
            if (!(typeof websocket !== "undefined" && typeof websocket !== "boolean")) {
              _context18.next = 21;
              break;
            }

            throw new Error("websocket must be boolean");

          case 21:
            REQUEST = axios;
            NOCACHEREQUEST = axios;
            _token = new _TOKEN({ domain: domain, token: token, options: options });

            if (domain) {
              _context18.next = 26;
              break;
            }

            throw new Error('domain undefined');

          case 26:
            DOMAIN = domain;
            NAME = cache && cache.name ? cache.name : urlLib.parse(domain).hostname.replace(/\./g, "_");
            EXPIRES = cache && cache.expires ? cache.expires : undefined;

            // Loop over the keys of the path and determine whether the object at that level
            // contains a * key. The path must be updated along the way, replacing *s as
            // necessary.

            _context18.next = 31;
            return _token.get();

          case 31:
            TOKEN = _context18.sent;

            if (!(websocket !== false)) {
              _context18.next = 40;
              break;
            }

            _context18.next = 35;
            return ws(domain);

          case 35:
            socketApi = _context18.sent;

            REQUEST = socketApi.http;
            _context18.next = 39;
            return socketApi;

          case 39:
            SOCKET = _context18.sent;

          case 40:
            if (!(cache !== false)) {
              _context18.next = 43;
              break;
            }

            _context18.next = 43;
            return _configureCache({
              name: NAME || (0, _uuid2.default)(),
              req: REQUEST,
              expires: EXPIRES
            });

          case 43:
            return _context18.abrupt("return", {
              token: TOKEN,
              cache: CACHE ? CACHE : false,
              websocket: SOCKET ? SOCKET : false,
              get: get,
              put: put,
              post: post,
              delete: del,
              resetCache: resetCache,
              disconnect: disconnect,
              reconnect: reconnect
            });

          case 44:
          case "end":
            return _context18.stop();
        }
      }
    }, _callee18, this);
  }));

  function connect(_x) {
    return _ref2.apply(this, arguments);
  }

  return connect;
}();

exports.default = {
  connect: connect
};