@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 _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

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

var _typeof3 = _interopRequireDefault(_typeof2);

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

var _keys2 = _interopRequireDefault(_keys);

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 urlLib = require('url');
var pointer = require('json-pointer');
var websocket = require('./websocket');
var Promise = require('bluebird');
var axios = require('axios');
var oadaIdClient = require('@oada/oada-id-client');

var connect = function connect(_ref) {
  var _this3 = this;

  // Ensure all resources down to the deepest resource are created before
  // performing a PUT.
  var put = function () {
    var _ref13 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee3(_ref12) {
      var url = _ref12.url,
          path = _ref12.path,
          data = _ref12.data,
          type = _ref12.type,
          headers = _ref12.headers,
          tree = _ref12.tree;
      var req, pieces, treePath;
      return _regenerator2.default.wrap(function _callee3$(_context3) {
        while (1) {
          switch (_context3.prev = _context3.next) {
            case 0:
              req = {
                method: 'put',
                url: url || DOMAIN + path,
                headers: _lodash2.default.merge({ 'Authorization': 'Bearer ' + TOKEN }, headers),
                data: data
              };

              if (type) req.headers['Content-Type'] = type;

              if (!tree) {
                _context3.next = 5;
                break;
              }

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

            case 5:
              pieces = urlLib.parse(req.url).path.replace(/^\//, '').split('/');
              treePath = _convertSetupTreePath(pieces, tree) + '/_type';

              if (pointer.has(tree, treePath)) req.headers['Content-Type'] = pointer.get(tree, treePath);
              return _context3.abrupt('return', REQUEST(req));

            case 9:
            case 'end':
              return _context3.stop();
          }
        }
      }, _callee3, this);
    }));

    return function put(_x3) {
      return _ref13.apply(this, arguments);
    };
  }();

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

              return _context4.abrupt('return');

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

            case 4:
              return _context4.abrupt('return', _configureCache({
                name: NAME,
                req: SOCKET.http || axios,
                exp: exp || EXP
              }));

            case 5:
            case 'end':
              return _context4.stop();
          }
        }
      }, _callee4, this);
    }));

    return function resetCache(_x4, _x5) {
      return _ref14.apply(this, arguments);
    };
  }();

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

  var CACHE = undefined;
  var REQUEST = axios;
  var SOCKET = undefined;
  var TOKEN = undefined;
  var DOMAIN = domain;
  var NAME = urlLib.parse(domain).hostname.replace(/\./g, '_');
  var EXP = cache ? cache.exp : undefined;

  if (!DOMAIN) throw 'domain undefined';

  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: obj[key]._id };
        if (val._rev) ret[key]._rev = '0-0';
        return;
      }
      // otherwise, recurse into the object looking for more links
      return _replaceLinks(val).then(function (result) {
        ret[key] = result;
        return;
      });
    }).then(function () {
      return ret;
    });
  }

  function _makeResourceAndLink(_ref2) {
    var path = _ref2.path,
        data = _ref2.data;

    var req = {
      path: data._id ? '/' + data._id : '/resources/' + (0, _uuid2.default)(),
      type: data._type,
      data: data
    };
    var link = {
      path: path,
      type: data._type,
      data: { _id: data._id || req.path.replace(/^\//, '') }
    };
    if (data._rev) link.data._rev = '0-0';
    return put(link).then(function () {
      return put(req);
    });
  }

  function _watch(_ref3) {
    var _this = this;

    var headers = _ref3.headers,
        path = _ref3.path,
        func = _ref3.func,
        payload = _ref3.payload;

    if (SOCKET) {
      return SOCKET.watch({
        path: path,
        headers: headers
      }, function () {
        var _ref4 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee(response) {
          return _regenerator2.default.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  if (!payload) payload = {};
                  payload.response = response;
                  payload.request = {
                    url: DOMAIN + path,
                    headers: headers,
                    method: payload.response.change.type
                  };

                  if (!CACHE) {
                    _context.next = 6;
                    break;
                  }

                  _context.next = 6;
                  return CACHE.handleWatchChange(payload);

                case 6:
                  return _context.abrupt('return', func(payload));

                case 7:
                case 'end':
                  return _context.stop();
              }
            }
          }, _callee, this);
        }));

        function watchResponse(_x) {
          return _ref4.apply(this, arguments);
        }

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

  function get(_ref5) {
    var _this2 = this;

    var url = _ref5.url,
        path = _ref5.path,
        headers = _ref5.headers,
        watch = _ref5.watch,
        tree = _ref5.tree;

    var req = {
      method: 'get',
      url: url || DOMAIN + path,
      headers: _lodash2.default.merge({ 'Authorization': 'Bearer ' + TOKEN }, headers)
    };

    var prom = void 0;

    if (tree) {
      // Tree must be rooted at /bookmarks. Get the subtree for the given path.
      var pieces = urlLib.parse(req.url).path.replace(/^\//, '').split('/');
      var treePath = _convertSetupTreePath(pieces, tree);
      if (!pointer.has(tree, treePath)) return get({ url: url });
      tree = pointer.get(tree, treePath);
      prom = _recursiveGet(req.url, tree, {}).then(function (res) {
        return {
          data: res,
          status: 200
        };
      }).catch(function (err) {
        return;
      });
    } else {
      prom = REQUEST(req);
    }

    return prom.then(function () {
      var _ref6 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2(response) {
        return _regenerator2.default.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                if (!watch) {
                  _context2.next = 6;
                  break;
                }

                path = path || urlLib.parse(url).path;
                req.headers['x-oada-rev'] = response.data._rev;
                console.log(path, response.data._rev);
                _context2.next = 6;
                return _watch({
                  headers: req.headers,
                  path: path,
                  func: watch.func,
                  payload: watch.payload
                });

              case 6:
                return _context2.abrupt('return', response);

              case 7:
              case 'end':
                return _context2.stop();
            }
          }
        }, _callee2, _this2);
      }));

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

  function _recursiveGet(url, tree, returnData) {
    return Promise.try(function () {
      // Perform a GET if we have reached the next resource break.
      if (tree._type) {
        // its a resource
        return get({
          url: url
        }).then(function (response) {
          returnData = response.data;
          return;
        });
      }
      return tree;
    }).then(function () {
      // Walk down the data at this url and continue recursion.
      return Promise.map((0, _keys2.default)(tree || {}), function (key) {
        // If tree contains a *, this means we should get ALL content on the server
        // at this level and continue recursion for each returned key.
        if (key === '*') {
          return Promise.map((0, _keys2.default)(returnData || {}), function (resKey) {
            if (resKey.charAt(0) === '_') return;
            return _recursiveGet(url + '/' + resKey, tree[key] || {}, returnData[resKey]).then(function (res) {
              return returnData[resKey] = res;
            });
          });
        } else if ((0, _typeof3.default)(tree[key]) === 'object') {
          return _recursiveGet(url + '/' + key, tree[key] || {}, returnData[key]).then(function (res) {
            return returnData[key] = res;
          });
        } else return returnData[key];
      }).then(function () {
        return returnData;
      });
    }).catch(function (err) {
      if (err.response.status === 404) {
        return;
      }
      throw err;
    });
  }

  // Identify the cached resources vs those that need to be setup.
  function _findDeepestResources(pieces, tree, cachedTree) {
    var cached = 0;
    var setup = void 0;
    // 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 cached 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(cachedTree, urlPath)) {
          cached = _lodash2.default.clone(z);
          throw new Error('cached');
        }
        return get({
          path: urlPath
        }).then(function (response) {
          pointer.set(cachedTree, urlPath, {});
          cached = _lodash2.default.clone(z);
          throw new Error('cached');
        }).catch(function (err) {
          //          pointer.set(cachedTree, urlPath, {})
          if (/^cached/.test(err.message)) throw err;
          return;
        });
      }
      return;
    }).catch(function (err) {
      // Throwing with a number error only should occur on success.
      if (/^cached/.test(err.message)) return { cached: cached, setup: setup };
    }).then(function () {
      return {
        cached: cached,
        setup: setup || 0
      };
    });
  }

  // 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.
  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('/');
  }

  function _ensureTree(_ref7) {
    var url = _ref7.url,
        tree = _ref7.tree,
        data = _ref7.data;

    //If /resources

    //If /bookmarks
    var path = urlLib.parse(url).path.replace(/^\//, '');
    var pieces = path.replace(/\/$/, '').split('/');
    if (data._id) {
      var 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))
    var cachedTree = {};
    // Find the deepest part of the path that exists. Once found, work back down.
    return _findDeepestResources(pieces, tree, cachedTree).then(function (ret) {
      // Create all the resources on the way down. ret.cached is an index. Slice
      // takes the length to slice, so no need to subtract 1.
      return Promise.mapSeries(pieces.slice(0, pieces.length - ret.cached), function (piece, j) {
        var i = ret.cached + 1 + j; // ret.cached exists; add one to continue beyond.
        var urlPath = '/' + pieces.slice(0, i + 1).join('/');
        var treePath = _convertSetupTreePath(pieces.slice(0, i + 1), tree);
        if (pointer.has(tree, treePath + '/_type') && i <= ret.setup) {
          // its a resource
          return _replaceLinks(pointer.get(tree, treePath)).then(function (content) {
            return _makeResourceAndLink({
              path: urlPath,
              data: _lodash2.default.cloneDeep(content)
            }).then(function (resp) {
              pointer.set(cachedTree, urlPath, content);
              return resp;
            }).catch(function (err) {
              return err;
            });
          });
        } else return;
      });
    }).then(function (responses) {
      return responses[responses.length - 1];
    }).catch(function (err) {
      return err;
    });
  }

  function post(_ref8) {
    var url = _ref8.url,
        path = _ref8.path,
        data = _ref8.data,
        type = _ref8.type,
        headers = _ref8.headers,
        tree = _ref8.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
    });
  }

  function del(_ref9) {
    var url = _ref9.url,
        path = _ref9.path,
        headers = _ref9.headers,
        unwatch = _ref9.unwatch;

    var req = {
      method: 'delete',
      url: url || DOMAIN + path,
      headers: _lodash2.default.merge({ 'Authorization': 'Bearer ' + TOKEN }, headers)
    };

    if (unwatch) {
      console.log('UNWATCHING');
      path = path || urlLib.parse(url).path;
      return SOCKET.unwatch({
        path: path,
        headers: req.headers
      }).then(function () {
        console.log('UNWATCHING DONE');
        return;
      });
    }

    return REQUEST(req);
  }

  function _configureCache(_ref10) {
    var name = _ref10.name,
        req = _ref10.req,
        exp = _ref10.exp;

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

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

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

  function disconnect() {
    if (CACHE) CACHE.db.destroy();
    if (CACHE) CACHE.db.close();
    if (SOCKET) SOCKET.close();
  }

  var urlObj = urlLib.parse(domain);
  var prom = void 0;
  if (token) {
    prom = Promise.resolve({ access_token: token });
  } else {
    if (typeof window === 'undefined') {
      prom = oadaIdClient.node(urlObj.host, options);
    } else {
      // the library itself detects a browser environment and delivers .browser
      var gat = Promise.promisify(oadaIdClient.getAccessToken);
      prom = gat(urlObj.host, options);
    }
  }
  return prom.then(function () {
    var _ref15 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee5(result) {
      var wsProm;
      return _regenerator2.default.wrap(function _callee5$(_context5) {
        while (1) {
          switch (_context5.prev = _context5.next) {
            case 0:
              TOKEN = result.access_token;
              wsProm = void 0;

              if (!noWebsocket) {
                wsProm = websocket(domain).then(function (socketApi) {
                  REQUEST = socketApi.http;
                  return SOCKET = socketApi;
                });
              } else wsProm = Promise.resolve();
              return _context5.abrupt('return', wsProm.then(function () {
                var cacheProm = void 0;
                if (cache === false) return;
                return _configureCache({
                  name: NAME || (0, _uuid2.default)(),
                  req: REQUEST,
                  exp: EXP
                });
              }));

            case 4:
            case 'end':
              return _context5.stop();
          }
        }
      }, _callee5, _this3);
    }));

    return function (_x6) {
      return _ref15.apply(this, arguments);
    };
  }()).then(function (f) {
    return {
      token: TOKEN,
      //      cache: CACHE,
      //socket: SOCKET,
      get: get,
      put: put,
      post: post,
      delete: del,
      resetCache: resetCache,
      disconnect: disconnect
    };
  });
};

exports.default = {
  connect: connect
};