@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 pretty = require('prettyjson');
var Promise = require("bluebird");

var url = require("url");
var _ = require("lodash");
var pointer = require("json-pointer");
var OFFLINE = false;

function setupCache(_ref) {
  var getResFromServer = function () {
    var _ref2 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee(req) {
      var res;
      return _regenerator2.default.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              _context.next = 2;
              return request({
                method: 'GET',
                url: req.url,
                headers: req.headers
              });

            case 2:
              res = _context.sent;

              res.cached = false;
              req.data = res.data;
              _context.next = 7;
              return dbUpsert(req);

            case 7:
              return _context.abrupt("return", res);

            case 8:
            case "end":
              return _context.stop();
          }
        }
      }, _callee, this);
    }));

    return function getResFromServer(_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 event that the resource doesn't yet exist but will.
  // This is primarily for when links are created before the resource itself has been.


  // 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 _ref4 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee3(req) {
      var urlObj, newReq, lookup;
      return _regenerator2.default.wrap(function _callee3$(_context3) {
        while (1) {
          switch (_context3.prev = _context3.next) {
            case 0:
              urlObj = url.parse(req.url);
              newReq = _.cloneDeep(req);

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

              _context3.next = 5;
              return getLookup(req);

            case 5:
              lookup = _context3.sent;

              newReq.url = urlObj.protocol + '//' + urlObj.host + '/' + lookup.resourceId + lookup.pathLeftover;

            case 7:
              return _context3.abrupt("return", getResFromDb(newReq));

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

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

  // TODO: Need to update the cache for both the parent resource and child new
  // resource if one is created


  var put = function () {
    var _ref5 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee4(req, offline) {
      var urlObj, lookup, response;
      return _regenerator2.default.wrap(function _callee4$(_context4) {
        while (1) {
          switch (_context4.prev = _context4.next) {
            case 0:
              urlObj = url.parse(req.url);

              if (!offline) {
                _context4.next = 7;
                break;
              }

              _context4.next = 4;
              return getLookup({
                url: urlObj.protocol + '//' + urlObj.host + reqPieces.slice(0, reqPieces.length - 1).join('/'),
                headers: req.headers
              });

            case 4:
              lookup = _context4.sent;
              _context4.next = 13;
              break;

            case 7:
              _context4.next = 9;
              return request(req);

            case 9:
              response = _context4.sent;
              _context4.next = 12;
              return dbUpsert({
                url: response.headers['content-location'],
                data: req.data,
                _rev: response.headers['x-oada-rev'],
                // TODO: should it be invalidated until pulled from server?
                valid: false
              });

            case 12:
              return _context4.abrupt("return", response);

            case 13:
            case "end":
              return _context4.stop();
          }
        }
      }, _callee4, this);
    }));

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

  // Remove the deleted key from the parent resource optimistically using
  // put(). Also mark the parent invalid as the _rev update will affect it


  var updateParent = function () {
    var _ref6 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee5(req) {
      var urlObj, reqPieces, lookup;
      return _regenerator2.default.wrap(function _callee5$(_context5) {
        while (1) {
          switch (_context5.prev = _context5.next) {
            case 0:
              urlObj = url.parse(req.url);
              // Try to get the parent document

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

            case 4:
              lookup = _context5.sent;
              _context5.next = 7;
              return dbUpsert({
                url: '/' + lookup.resourceId + lookup.pathLeftover,
                method: 'delete',
                valid: false
              });

            case 7:
              return _context5.abrupt("return");

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

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

  // Issue DELETE to server then update the db


  var del = function () {
    var _ref7 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee6(req, offline) {
      var urlObj, res, lookup, response;
      return _regenerator2.default.wrap(function _callee6$(_context6) {
        while (1) {
          switch (_context6.prev = _context6.next) {
            case 0:
              urlObj = url.parse(req.url);
              // Handle resource deletion

              if (!/^\/resources/.test(urlObj.path)) {
                _context6.next = 7;
                break;
              }

              _context6.next = 4;
              return dbUpsert({
                url: req.url,
                method: req.method,
                _valid: false
              });

            case 4:
              res = _context6.sent;
              _context6.next = 20;
              break;

            case 7:
              _context6.prev = 7;
              _context6.next = 10;
              return getLookup({
                url: req.url,
                headers: req.headers
              });

            case 10:
              lookup = _context6.sent;
              _context6.next = 13;
              return db.remove(lookup);

            case 13:
              if (lookup.pathLeftover) {
                _context6.next = 16;
                break;
              }

              _context6.next = 16;
              return updateParent(req);

            case 16:
              _context6.next = 20;
              break;

            case 18:
              _context6.prev = 18;
              _context6.t0 = _context6["catch"](7);

            case 20:
              if (offline) {
                _context6.next = 26;
                break;
              }

              _context6.next = 23;
              return request(req);

            case 23:
              response = _context6.sent;
              _context6.next = 26;
              break;

            case 26:
              return _context6.abrupt("return", response || res);

            case 27:
            case "end":
              return _context6.stop();
          }
        }
      }, _callee6, this, [[7, 18]]);
    }));

    return function del(_x6, _x7) {
      return _ref7.apply(this, arguments);
    };
  }();

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

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

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

            case 4:
              lookup = _context8.sent;
              newBody = replaceLinks(body, {
                url: req.url,
                headers: req.headers
              });
              _context8.next = 8;
              return dbUpsert({
                url: '/' + (body._id || lookup.resourceId),
                data: newBody
              });

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

              return _context8.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 _context8.abrupt("return");

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

    return function _recursiveUpsert(_x10, _x11) {
      return _ref9.apply(this, arguments);
    };
  }();

  var resetCache = function () {
    var _ref11 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee10() {
      return _regenerator2.default.wrap(function _callee10$(_context10) {
        while (1) {
          switch (_context10.prev = _context10.next) {
            case 0:
              _context10.prev = 0;

              if (!db) {
                _context10.next = 4;
                break;
              }

              _context10.next = 4;
              return db.destroy();

            case 4:
              _context10.next = 10;
              break;

            case 6:
              _context10.prev = 6;
              _context10.t0 = _context10["catch"](0);

              console.log('Reset cache errored. db.destroy threw an error. Assuming the cache was already destroyed.', _context10.t0);
              return _context10.abrupt("return");

            case 10:
            case "end":
              return _context10.stop();
          }
        }
      }, _callee10, this, [[0, 6]]);
    }));

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

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

  // name should be made unique across domains and users
  var db = db || new _pouchdb2.default(name);
  // This fixes concurrent accesses 
  _pouchdb2.default.on('destroyed', function (dbName) {
    if (dbName === name) {
      db = new _pouchdb2.default(name);
    }
  });
  var request = req;
  var expiration = expires || 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 dbUpsert(req, waitTime) {
    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('/') : '';

    // Create the content to put in the cache
    var dbPut = {
      _id: resourceId,
      valid: req.valid === undefined ? true : req.valid,
      // TODO: This current resets this access date for e.g., every put
      // while offline. This doesn't seem right. I think this should only
      // get updated when we know we're upserting a new value from the server
      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.INCOMPLETE_RESOURCE) dbPut.INCOMPLETE_RESOURCE = true;
      dbPut._rev = result._rev;
      if (req.method && req.method.toLowerCase() === 'delete') {
        if (!pathLeftover) {
          return db.remove(result);
        } else if (pointer.has(dbPut.doc, pathLeftover)) {
          dbPut.doc = result.doc;
          pointer.remove(dbPut.doc, pathLeftover);
          return db.put(dbPut).then(function (rrr) {
            return rrr;
          }).catch(function (err) {
            if (err.status === 409) {
              waitTime = waitTime || 1000;
              return Promise.delay(waitTime).then(function () {
                if (waitTime > 16000) throw err;
                return dbUpsert(req, waitTime * 2);
              });
            }
            throw err;
          });
        }
      } else {
        if (pathLeftover) {
          // merge the new data into the old at the path leftover, then return old
          var curData = {};
          if (pointer.has(result.doc, pathLeftover)) curData = pointer.get(result.doc, pathLeftover);
          var newData = _.merge(curData, req.data || {});
          pointer.set(result.doc, pathLeftover, newData);
          dbPut.doc = result.doc;
        } else {
          dbPut.doc = _.merge(result.doc, req.data);
        }
      }

      if (req._rev) dbPut.doc._rev = req._rev;

      return db.put(dbPut).then(function (rrr) {
        return rrr;
      }).catch(function (err) {
        // retry 409s
        if (err.status === 409) {
          waitTime = waitTime || 1000;
          return Promise.delay(waitTime).then(function () {
            if (waitTime > 16000) throw err;
            return dbUpsert(req, waitTime * 2);
          });
        }
        throw err;
      });

      // Else, the resource was not in the cache. 
    }).catch(function (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
          dbPut.doc = {};
          dbPut.INCOMPLETE_RESOURCE = true;
          dbPut.valid = false;
          pointer.set(dbPut.doc, pathLeftover, _.clone(req.data));
        } else dbPut.doc = req.data;
      }

      if (req._rev) dbPut.doc._rev = req._rev;

      return db.put(dbPut).then(function (rrr) {
        return rrr;
      }).catch(function (err) {
        // retry 409s
        if (err.status === 409) {
          waitTime = waitTime || 1000;
          return Promise.delay(waitTime).then(function () {
            if (waitTime > 16000) throw err;
            return dbUpsert(req, waitTime * 2);
          });
        }
        throw err;
      });
    });
  }

  function getLookup(req) {
    var urlObj = url.parse(req.url);
    return db.get(urlObj.path).catch((0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2() {
      var resourceId, pathLeftover, response, pieces;
      return _regenerator2.default.wrap(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              if (!req._id) {
                _context2.next = 5;
                break;
              }

              resourceId = req._id;
              pathLeftover = '';
              _context2.next = 11;
              break;

            case 5:
              _context2.next = 7;
              return request({
                method: 'HEAD',
                url: req.url,
                headers: req.headers
              });

            case 7:
              response = _context2.sent;

              //Save the url lookup for future use
              pieces = response.headers['content-location'].split('/');

              resourceId = pieces.slice(1, 3).join('/'); //returns resources/abc
              pathLeftover = pieces.length > 3 ? '/' + pieces.slice(3, pieces.length).join('/') : '';

            case 11:
              return _context2.abrupt("return", db.put({
                _id: urlObj.path,
                resourceId: resourceId,
                pathLeftover: pathLeftover
              }).then(function () {
                return getLookup(req);
              }).catch(function (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);
                }
              }));

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

  // 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.

  function getResFromDb(req, offline) {
    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 (!offline && (resource.accessed + expiration <= Date.now() || !resource.valid)) {
        return getResFromServer(req);
      }
      //If no pathLeftover, it'll just return resource!
      if (pointer.has(resource.doc, pathLeftover)) {
        var data = pointer.get(resource.doc, pathLeftover);
        return {
          data: data,
          headers: {
            'x-oada-rev': data._rev,
            'content-location': resourceId + pathLeftover
          },
          status: 200,
          cached: true
        };
      } else {
        return getResFromServer(req);
      }
    }).catch(function (err) {
      if (!offline) return getResFromServer(req);
      return;
    });
  }

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

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

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

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

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

              case 7:
                lookup = _context7.sent;

                ret[key] = { _id: lookup.resourceId };
                if (obj[key]._rev) ret[key]._rev = obj[key]._rev;
                return _context7.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 _context7.stop();
            }
          }
        }, _callee7, this);
      }));

      return function (_x8, _x9) {
        return _ref8.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);
  }

  /*
   async function _upsertChangeArray(payload) {
     let urlObj = url.parse(payload.request.url);
     return Promise.map(payload.response.changes || [], async (change) => {
       if (change.type === 'merge') {
         return dbUpsert({
           url: urlObj.protocol+'//'+urlObj.host+'/'+change._id,
           data: change.body,
         })
       } else if (change.type === 'delete') {
         var nullPath = await findNullValue(change.body, '', '')
         return dbUpsert({
           url: urlObj.protocol+'//'+urlObj.host+'/'+change._id+nullPath,
           data: change.body,
         })
       }
     })
   }
  */

  // 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;
    //TODO: This should be unnecessary. The payload ought to specify the root
    //of the watch as a resource.
    return findDeepestResource(payload.response.change.body, '', {
      path: '',
      data: payload.response.change.body
    }).then(function () {
      var _ref10 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee9(deepestResource) {
        var nullPath, deletedPath, lookup;
        return _regenerator2.default.wrap(function _callee9$(_context9) {
          while (1) {
            switch (_context9.prev = _context9.next) {
              case 0:
                _context9.t0 = payload.response.change.type.toLowerCase();
                _context9.next = _context9.t0 === 'delete' ? 3 : _context9.t0 === 'merge' ? 13 : 15;
                break;

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

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

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

              case 10:
                lookup = _context9.sent;
                return _context9.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.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 _context9.abrupt("return", _recursiveUpsert(payload.request, payload.response.change.body));

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

              case 16:
              case "end":
                return _context9.stop();
            }
          }
        }, _callee9, _this);
      }));

      return function (_x12) {
        return _ref10.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
    //handleWatchChange: _upsertChangeArray,
  };
}