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

"use strict";

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

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 _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

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

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

exports.default = setupCache;

var _pouchdb = require('pouchdb');

var _pouchdb2 = _interopRequireDefault(_pouchdb);

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

var Promise = require('bluebird');

var url = require('url');
var _ = require('lodash');
var pointer = require('json-pointer');

//TODO: Should getLookup throw an error or return undefined?
// This needs to be handled by all that call getLookup!!!


function setupCache(_ref) {

  // Accepts an axios-style request. Returns:
  // {
  //
  //   data: the data requested,
  //
  //   _rev: the rev of the parent resource requested
  //
  //   location: e.g.: /resources/abc123/some/path/leftover
  //   
  // }
  var get = function () {
    var _ref2 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee(req) {
      var urlObj, lookup;
      return _regenerator2.default.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              urlObj = url.parse(req.url);

              if (/^\/resources/.test(urlObj.path)) {
                _context.next = 12;
                break;
              }

              _context.prev = 2;
              _context.next = 5;
              return getLookup(req);

            case 5:
              lookup = _context.sent;

              req.url = urlObj.protocol + '//' + urlObj.host + '/' + lookup.doc.resourceId + lookup.doc.pathLeftover;
              _context.next = 12;
              break;

            case 9:
              _context.prev = 9;
              _context.t0 = _context['catch'](2);
              throw _context.t0;

            case 12:
              return _context.abrupt('return', getResFromDb(req).then(function (result) {
                return result;
              }));

            case 13:
            case 'end':
              return _context.stop();
          }
        }
      }, _callee, this, [[2, 9]]);
    }));

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

  // Perform lookup from bookmarks to resource id (and path leftover) mapping.
  // If the lookup fails, use a HEAD request to get it from the server and put
  // it in the cache. An optional _id can be passed into req to force creation
  // of a particular lookup in the even that the resource doesn't yet exist but _will_.
  // This is primarily for when links are created before the resource itself has been.


  /*  async function _recursivePut(req) {
  let urlObj = url.parse(req.url);
  return Promise.map(Object.keys(req.data || {}), (data) => {
    var newData = replaceLinks(data, req)
  })
  if (body._rev) {
    let lookup = await getLookup({
      url: req.url,
      headers: req.headers,
      _id: body._id
    })
    let newBody = replaceLinks(body, {
      url: req.url,
      headers: req.headers
    });
    await dbUpsert({
      url: urlObj.protocol+'//'+urlObj.host+'/'+(body._id || lookup.doc.resourceId),
      headers: req.headers
    }, {
      data: newBody,
      headers: { 'x-oada-rev': newBody._rev },
    })
  }
  if (typeof body === 'object') {
    return Promise.map(Object.keys(body || {}), (key) => {
      if (key.charAt(0) === '_') return
      if (!body[key]) return
      return _recursiveUpsert({
        url: req.url+'/'+key,
        headers: req.headers
      }, body[key])
    })
  } else return
  }*/

  var deleteCheckParent = function () {
    var _ref3 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2(req, res) {
      var urlObj, _rev, lookup, reqPieces, parentUrl;

      return _regenerator2.default.wrap(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              urlObj = url.parse(req.url);
              _rev = res.headers['x-oada-rev'];
              lookup = void 0;
              // Try to get the parent document

              _context2.prev = 3;
              reqPieces = urlObj.path.split('/');
              _context2.next = 7;
              return getLookup({
                url: urlObj.protocol + '//' + urlObj.host + reqPieces.slice(0, reqPieces.length - 1).join('/'),
                headers: req.headers
              });

            case 7:
              lookup = _context2.sent;

              if (!(lookup && lookup.doc.resourceId)) {
                _context2.next = 11;
                break;
              }

              parentUrl = urlObj.protocol + '//' + urlObj.host + '/' + lookup.doc.resourceId + lookup.doc.pathLeftover;
              return _context2.abrupt('return', dbUpsert({
                url: parentUrl,
                headers: req.headers,
                method: req.method
              }, {
                data: undefined,
                _valid: false,
                headers: { 'x-oada-rev': _rev }
              }));

            case 11:
              return _context2.abrupt('return');

            case 14:
              _context2.prev = 14;
              _context2.t0 = _context2['catch'](3);
              throw _context2.t0;

            case 17:
            case 'end':
              return _context2.stop();
          }
        }
      }, _callee2, this, [[3, 14]]);
    }));

    return function deleteCheckParent(_x2, _x3) {
      return _ref3.apply(this, arguments);
    };
  }();

  // ALTERNATIVELY, using db.remove:
  // 1. Delete at server
  // If no pathLeftover
  // 2a. Invalidate parent
  // 3a. Invalidate child
  // 4a. GET parent from server to cache the new, unlinked data
  // If pathleftover
  // 2b. GET the child to confirm and cache the new state


  var dbDelete = function () {
    var _ref4 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee3(req, res) {
      var urlObj, _rev, pieces, resourceId, pathLeftover, lookup;

      return _regenerator2.default.wrap(function _callee3$(_context3) {
        while (1) {
          switch (_context3.prev = _context3.next) {
            case 0:
              urlObj = url.parse(req.url);
              _rev = res.headers['x-oada-rev'];
              pieces = res.headers['content-location'].split('/');
              resourceId = pieces.slice(1, 3).join('/'); //returns resources/abc

              pathLeftover = pieces.length > 3 ? '/' + pieces.slice(3, pieces.length).join('/') : '';
              // If it is itself a resource, we only need to invalidate the cache entry for
              // the parent (which links to the child)

              _context3.prev = 5;
              _context3.next = 8;
              return getLookup({
                url: req.url,
                headers: req.headers
              });

            case 8:
              lookup = _context3.sent;
              _context3.next = 11;
              return db.remove(lookup);

            case 11:
              _context3.next = 15;
              break;

            case 13:
              _context3.prev = 13;
              _context3.t0 = _context3['catch'](5);

            case 15:
              if (pathLeftover) {
                _context3.next = 17;
                break;
              }

              return _context3.abrupt('return', deleteCheckParent(req, res));

            case 17:
              return _context3.abrupt('return', dbUpsert({
                url: urlObj.protocol + '//' + urlObj.host + '/' + resourceId,
                headers: req.headers,
                method: req.method
              }, {
                data: undefined,
                _valid: false,
                headers: { 'x-oada-rev': _rev }
              }));

            case 18:
            case 'end':
              return _context3.stop();
          }
        }
      }, _callee3, this, [[5, 13]]);
    }));

    return function dbDelete(_x4, _x5) {
      return _ref4.apply(this, arguments);
    };
  }();

  // Issue DELETE to server then update the db


  var _recursiveUpsert = function () {
    var _ref6 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee5(req, body) {
      var urlObj, lookup, newBody;
      return _regenerator2.default.wrap(function _callee5$(_context5) {
        while (1) {
          switch (_context5.prev = _context5.next) {
            case 0:
              urlObj = url.parse(req.url);

              if (!body._rev) {
                _context5.next = 8;
                break;
              }

              _context5.next = 4;
              return getLookup({
                url: req.url,
                headers: req.headers,
                _id: body._id
              });

            case 4:
              lookup = _context5.sent;
              newBody = replaceLinks(body, {
                url: req.url,
                headers: req.headers
              });
              _context5.next = 8;
              return dbUpsert({
                url: urlObj.protocol + '//' + urlObj.host + '/' + (body._id || lookup.doc.resourceId),
                headers: req.headers
              }, {
                data: newBody,
                headers: { 'x-oada-rev': newBody._rev }
              });

            case 8:
              if (!((typeof body === 'undefined' ? 'undefined' : (0, _typeof3.default)(body)) === 'object')) {
                _context5.next = 12;
                break;
              }

              return _context5.abrupt('return', Promise.map((0, _keys2.default)(body || {}), function (key) {
                if (key.charAt(0) === '_') return;
                if (!body[key]) return;
                return _recursiveUpsert({
                  url: req.url + '/' + key,
                  headers: req.headers
                }, body[key]);
              }));

            case 12:
              return _context5.abrupt('return');

            case 13:
            case 'end':
              return _context5.stop();
          }
        }
      }, _callee5, this);
    }));

    return function _recursiveUpsert(_x8, _x9) {
      return _ref6.apply(this, arguments);
    };
  }();

  var resetCache = function () {
    var _ref8 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee7() {
      return _regenerator2.default.wrap(function _callee7$(_context7) {
        while (1) {
          switch (_context7.prev = _context7.next) {
            case 0:
              if (!db) {
                _context7.next = 3;
                break;
              }

              _context7.next = 3;
              return db.destroy();

            case 3:
              db = undefined;
              request = undefined;
              expiration = undefined;

            case 6:
            case 'end':
              return _context7.stop();
          }
        }
      }, _callee7, this);
    }));

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

  var name = _ref.name,
      req = _ref.req,
      exp = _ref.exp;


  // name should be made unique across domains and users
  var db = db || new _pouchdb2.default(name);
  var request = req;
  var expiration = exp || 1000 * 60 * 60 * 24 * 2; //(ms/s)*(s/min)*(min/hr)*(hr/days)*days

  // Get the resource and merge data if its already in the db.
  function getUpsertDoc(req, res) {
    var urlObj = url.parse(req.url);
    var pieces = urlObj.path.split('/');
    var resourceId = pieces.slice(1, 3).join('/'); //returns resources/abc
    var pathLeftover = pieces.length > 3 ? '/' + pieces.slice(3, pieces.length).join('/') : '';
    var dbPut = {
      _id: resourceId,
      doc: {
        _valid: res._valid === undefined ? true : res._valid,
        _accessed: Date.now()
      }
      // ALL updates to existing docs (upserts) need to supply the current _rev.
    };return db.get(resourceId).then(function (result) {
      //If theres a path leftover, create an empty object, add a key to warn users
      //that the data is incomplete, and put the data at that path Leftover
      if (result.doc._NOT_COMPLETE_RESOURCE) dbPut.doc._NOT_COMPLETE_RESOURCE = true;
      dbPut._rev = result._rev;
      // If a falsey _valid value is given, return the invalidated resource.
      if (dbPut.doc._valid !== undefined && !dbPut.doc._valid) {
        return Promise.resolve(dbPut);
      }
      if (req.method && req.method.toLowerCase() === 'delete') {
        dbPut.doc.doc = dbPut.doc.doc || {};
        req.url = urlObj.protocol + '//' + urlObj.host + '/' + resourceId;
      } else {
        if (pathLeftover) {
          // merge the new data into the old at the path leftover, then return old
          var curData = {};
          try {
            // If the path doesn't exist in the db doc, make an empty object.
            curData = pointer.get(result.doc.doc, pathLeftover);
          } catch (err) {}
          var newData = _.merge(curData, res.data || {});
          pointer.set(result.doc.doc, pathLeftover, newData);
          dbPut.doc.doc = result.doc.doc;
        } else dbPut.doc.doc = _.merge(result.doc.doc, res.data || {});
      }
      return dbPut;
    }).catch(function (e) {
      // Else, resource was not in the db. 
      //console.log(e)
      if (req.method && req.method.toLowerCase() === 'delete') {
        // Deleting a resource that doesn't exist: do nothing.
      } else {
        if (pathLeftover) {
          //Execute the PUT and Warn users that the data is incomplete
          var doc = {};
          dbPut.doc._NOT_COMPLETE_RESOURCE = true;
          pointer.set(doc, pathLeftover, _.clone(res.data));
          dbPut.doc.doc = doc;
        } else dbPut.doc.doc = res.data;
      }
      return dbPut;
    });
  }

  function dbUpsert(req, res) {
    return getUpsertDoc(req, res).then(function (dbPut) {
      return db.put(dbPut) /*.then((result) => {
                           req.method = 'get';
                           console.log('regetting', req, res)
                           return getResFromDb(req, res)
                           })*/.catch(function (err) {
        if (err.name === 'conflict') {
          //TODO: avoid infinite loops with this type of call
          // If there is a conflict in the lookup, repeat the lookup (the HEAD
          // request likely took too long and the lookup was already created by
          // another simultaneous request
          return dbUpsert(req, res);
        }
        throw err;
      });
    });
  }

  function getResFromServer(req) {
    return request({
      method: 'GET',
      url: req.url,
      headers: req.headers
    }).then(function (res) {
      res.cached = false;
      return dbUpsert(req, res).then(function () {
        return res;
      });
    }).catch(function (err) {
      throw err;
    });
  }

  function getResFromDb(req, res) {
    var urlObj = url.parse(req.url);
    var pieces = urlObj.path.split('/');
    var resourceId = pieces.slice(1, 3).join('/'); //returns resources/abc
    var pathLeftover = pieces.length > 3 ? '/' + pieces.slice(3, pieces.length).join('/') : '';
    return db.get(resourceId).then(function (resource) {
      if (resource.doc._accessed + expiration <= Date.now() || !resource.doc._valid) {
        return getResFromServer(req);
      }
      //If no pathLeftover, it'll just return resource!
      return Promise.try(function () {
        var data = pointer.get(resource.doc.doc, pathLeftover);
        return {
          data: data,
          headers: {
            'x-oada-rev': data._rev,
            'content-location': resourceId + pathLeftover
          },
          status: 200,
          cached: res ? res.cached : true
        };
      });
    }).catch(function (err) {
      //console.log(err);
      return getResFromServer(req);
    });
  }function getLookup(req) {
    var urlObj = url.parse(req.url);
    var lookup = urlObj.host + urlObj.path;
    return db.get(lookup).catch(function () {
      //Not found. Go to the oada server, get the associated resource and path 
      //leftover, and save the lookup.
      return request({
        method: 'HEAD',
        url: req.url,
        headers: req.headers
      }).then(function (response) {
        //Save the url lookup for future use
        var pieces = response.headers['content-location'].split('/');
        var resourceId = pieces.slice(1, 3).join('/'); //returns resources/abc
        var pathLeftover = pieces.length > 3 ? '/' + pieces.slice(3, pieces.length).join('/') : '';
        if (req._id) {
          resourceId = req._id;
          pathLeftover = '';
        }
        return db.put({
          _id: urlObj.host + urlObj.path,
          doc: {
            resourceId: resourceId,
            pathLeftover: pathLeftover
          }
        }).then(function () {
          return getLookup(req);
        }).catch(function (err) {
          console.log('ERR');
          //TODO: avoid an infinite loop
          if (err.name === 'conflict') {
            // If there is a conflict in the lookup, repeat the lookup (the HEAD
            // request likely took too long and the lookup was already created by
            // another simultaneous request
            return getLookup(req);
          }
        });
      });
    });
  }

  // Ping for _rev update
  function checkChanges(req) {
    return request({
      method: 'HEAD',
      url: req.url,
      headers: req.headers
    }).then(function () {
      //compare to rev on hand
    });
  }

  // Create a queue of actual PUTs to make when online.
  // Resource breaks are known via setupTree. 
  // Do the puts, save out the resource IDs, and return to client
  // Create an index on the data to find those that need synced

  // Create a service that other apps can run which starts up and periodically 
  // checks if a connections has yet been made. A periodic service may also 
  // concievably check for updates to cached things.
  //
  // The cache should go "stale" after some period of time; However, if it cannot
  // establish a connection, it should remain valid, usable data.


  //TODO: First, get the _rev of the document to check against when the new rev
  // is determined.  Also, this function should compensate for a slow return time
  // from the PUT operation; it should repeat the GET process until it finds a new
  // _rev.


  // TODO: Need to update the cache for both the parent resource and child new
  // resource if one is created
  function put(req) {
    var urlObj = url.parse(req.url);
    return request(req).then(function (response) {
      var _rev = response.headers['x-oada-rev'];
      var pieces = response.headers['content-location'].split('/');
      var resourceId = pieces.slice(1, 3).join('/'); //returns resources/abc
      var pathLeftover = pieces.length > 3 ? '/' + pieces.slice(3, pieces.length).join('/') : '';
      // Invalidate the resource in the cache (if it is cached)
      return dbUpsert({
        url: urlObj.protocol + '//' + urlObj.host + '/' + resourceId,
        headers: req.headers
      }, {
        data: undefined,
        _valid: false,
        headers: { 'x-oada-rev': _rev }
      }).then(function () {
        // Now get the data to bring it back into the cache. While dbUpsert does 
        // much of this, the lookup has not necessarily been created yet.
        return get({
          headers: req.headers,
          url: urlObj.protocol + '//' + urlObj.host + '/' + resourceId,
          //url: urlObj.protocol+'//'+urlObj.host+'/'+resourceId+pathLeftover,
          method: 'get'
        }).then(function () {
          return response;
        });
      });
    });
  }function del(req) {
    var urlObj = url.parse(req.url);
    return request(req).then(function (response) {
      return dbDelete(req, response).then(function () {
        //it should return something that looks like a delete response
        return response;
      });
    }).catch(function (e) {
      // Handle offline case
      throw e;
    });
  }

  function replaceLinks(obj, req) {
    var ret = Array.isArray(obj) ? [] : {};
    if (!obj) return obj;
    (0, _keys2.default)(obj || {}).forEach(function () {
      var _ref5 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee4(key, i) {
        var val, lookup;
        return _regenerator2.default.wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                val = obj[key];

                if (!((typeof val === 'undefined' ? 'undefined' : (0, _typeof3.default)(val)) !== 'object' || !val)) {
                  _context4.next = 4;
                  break;
                }

                ret[key] = val; // keep it asntType: 'application/vnd.oada.harvest.1+json'
                return _context4.abrupt('return');

              case 4:
                if (!val._meta) {
                  _context4.next = 11;
                  break;
                }

                _context4.next = 7;
                return getLookup({
                  url: req.url + '/' + key,
                  headers: req.headers
                });

              case 7:
                lookup = _context4.sent;

                ret[key] = { _id: lookup.doc.resourceId };
                if (obj[key]._rev) ret[key]._rev = obj[key]._rev;
                return _context4.abrupt('return');

              case 11:
                ret[key] = replaceLinks(obj[key], {
                  url: req.url + '/' + key,
                  headers: req.headers
                }); // otherwise, recurse into the object

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

      return function (_x6, _x7) {
        return _ref5.apply(this, arguments);
      };
    }());
    return ret;
  }

  function findNullValue(obj, path, nullPath) {
    if ((typeof obj === 'undefined' ? 'undefined' : (0, _typeof3.default)(obj)) === 'object') {
      return Promise.map((0, _keys2.default)(obj || {}), function (key) {
        if (obj[key] === null) {
          nullPath = path + '/' + key;
          return nullPath;
        }
        return findNullValue(obj[key], path + '/' + key, nullPath).then(function (res) {
          nullPath = res || nullPath;
          return res || nullPath;
        });
      }).then(function () {
        return nullPath;
      });
    } else return Promise.resolve(undefined);
  }

  // Will this handle watches put on keys of a resource? i.e., no _id to be found
  function findDeepestResource(obj, path, deepestResource) {
    if ((typeof obj === 'undefined' ? 'undefined' : (0, _typeof3.default)(obj)) === 'object') {
      return Promise.map((0, _keys2.default)(obj || {}), function (key) {
        // _rev updates guaranteed to be present in change docs for affected resources
        if (key === '_rev') {
          deepestResource.path = path;
          deepestResource.data = obj;
        } else if (key.charAt(0) === '_') return deepestResource;
        return findDeepestResource(obj[key], path + '/' + key, deepestResource).then(function () {
          return deepestResource;
        });
      }).then(function () {
        return deepestResource;
      });
    }
    return Promise.resolve(deepestResource);
  }

  function handleWatchChange(payload) {
    var _this = this;

    var urlObj = url.parse(payload.request.url);
    // Give the change body an _id so the deepest resource can be found
    payload.response.change.body._id = payload.response.resourceId;
    return findDeepestResource(payload.response.change.body, '', {
      path: '',
      data: payload.response.change.body
    }).then(function () {
      var _ref7 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee6(deepestResource) {
        var nullPath, deletedPath, lookup;
        return _regenerator2.default.wrap(function _callee6$(_context6) {
          while (1) {
            switch (_context6.prev = _context6.next) {
              case 0:
                _context6.t0 = payload.response.change.type.toLowerCase();
                _context6.next = _context6.t0 === 'delete' ? 3 : _context6.t0 === 'merge' ? 13 : 15;
                break;

              case 3:
                _context6.next = 5;
                return findNullValue(deepestResource.data, '', '');

              case 5:
                nullPath = _context6.sent;
                deletedPath = deepestResource.path + nullPath;

                payload.nullPath = deletedPath;
                _context6.next = 10;
                return getLookup({
                  url: payload.request.url + deepestResource.path + nullPath,
                  header: payload.request.headers
                });

              case 10:
                lookup = _context6.sent;
                return _context6.abrupt('return', dbDelete({
                  url: payload.request.url + deepestResource.path + nullPath,
                  headers: payload.request.headers,
                  method: payload.response.change.type
                }, {
                  headers: {
                    'x-oada-rev': deepestResource.data._rev,
                    'content-location': '/' + lookup.doc.resourceId
                  }
                }).then(function () {
                  // Update revs on all parents all the way down to (BUT OMITTING) the 
                  // resource on which was the delete was called.
                  pointer.remove(payload.response.change.body, deepestResource.path || '/');
                  return _recursiveUpsert(payload.request, payload.response.change.body);
                }));

              case 13:
                return _context6.abrupt('return', _recursiveUpsert(payload.request, payload.response.change.body));

              case 15:
                return _context6.abrupt('return');

              case 16:
              case 'end':
                return _context6.stop();
            }
          }
        }, _callee6, _this);
      }));

      return function (_x10) {
        return _ref7.apply(this, arguments);
      };
    }()).catch(function (err) {
      return;
    });
  }

  var api = function handleRequest(req) {
    switch (req.method) {
      case 'get':
        return get(req);
      case 'delete':
        return del(req);
      case 'put':
        return put(req);
    }
  };

  return {
    api: api,
    db: db,
    resetCache: resetCache,
    handleWatchChange: handleWatchChange
  };
}