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

"use strict";

/* Copyright 2018 Open Ag Data Alliance
 *
 * Licensed under the Apache License, Version 2.0 (the 'License');
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an 'AS IS' BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * @author Servio Palacios, Samuel Noel
 * Token API for Handling Tokens in the Cache Library - Super Class.
 * @module src/token
 */

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

var _regenerator2 = _interopRequireDefault(_regenerator);

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

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck");

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require("babel-runtime/helpers/createClass");

var _createClass3 = _interopRequireDefault(_createClass2);

var _pouchdb = require("pouchdb");

var _pouchdb2 = _interopRequireDefault(_pouchdb);

var _http = require("http");

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

var Promise = require("bluebird");

var urlLib = require("url");
var _ = require("lodash");
//const debug = require("debug")("oada-cache:token");
var crypto = require("crypto");
var oadaIdClient = require("@oada/oada-id-client");

var Token = function () {
  function Token() {
    var param = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    (0, _classCallCheck3.default)(this, Token);

    var self = this;
    self._token = param.token || null;
    self._domain = param.domain || "localhost";
    self._options = param.options;

    // creating database nae based on the domain
    // ensured one to one correspondence with the domain
    // i.e., token belongs to that domain
    var hash = crypto.createHash("sha256");
    hash.update(self._domain);
    self._name = hash.digest("hex");

    self._isSet = self._token ? true : false;
    self._tokenDB = new _pouchdb2.default(this._name);
    self._id = "OadaTokenID";
    self._rev = null;
    self.token = self._token ? self._token : "";
  } //constructor

  /**
   * searches for a local db and a doc
   */


  (0, _createClass3.default)(Token, [{
    key: "checkTokenDB",
    value: function () {
      var _ref = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee() {
        var result, doc;
        return _regenerator2.default.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                result = null;
                _context.prev = 1;
                _context.next = 4;
                return this._tokenDB.get(this._id);

              case 4:
                doc = _context.sent;

                //      debug("received document ->", doc);
                result = doc.token;
                this._rev = doc._rev;
                _context.next = 12;
                break;

              case 9:
                _context.prev = 9;
                _context.t0 = _context["catch"](1);
                return _context.abrupt("return", result);

              case 12:
                return _context.abrupt("return", result);

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

      function checkTokenDB() {
        return _ref.apply(this, arguments);
      }

      return checkTokenDB;
    }() //checkTokenDB

    /**
     * if token was provided then it sets the .token in the constructor -> returns that value
     * sets the pouch db if it does not exist
     */

  }, {
    key: "setup",
    value: function () {
      var _ref2 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2(_expired) {
        var TOKEN, urlObj, result, gat;
        return _regenerator2.default.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                // Get a token
                TOKEN = null; //returned to the chache library

                if (!this.isSet()) {
                  _context2.next = 5;
                  break;
                }

                TOKEN = this.token;
                _context2.next = 23;
                break;

              case 5:
                _context2.next = 7;
                return this.checkTokenDB();

              case 7:
                TOKEN = _context2.sent;

                if (!(!TOKEN || _expired)) {
                  _context2.next = 23;
                  break;
                }

                //local cache does not have a token
                urlObj = urlLib.parse(this._domain);
                result = void 0;
                // Open the browser and the login popup

                if (!(typeof window === "undefined")) {
                  _context2.next = 17;
                  break;
                }

                _context2.next = 14;
                return oadaIdClient.node(urlObj.host, this._options);

              case 14:
                result = _context2.sent;
                _context2.next = 21;
                break;

              case 17:
                // the library itself detects a browser environment and delivers .browser
                gat = Promise.promisify(oadaIdClient.getAccessToken);
                _context2.next = 20;
                return gat(urlObj.host, this._options);

              case 20:
                result = _context2.sent;

              case 21:
                TOKEN = result.access_token;
                //        debug("setup token -> access token:", result.access_token);
                this.put(TOKEN);

              case 23:
                return _context2.abrupt("return", TOKEN);

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

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

      return setup;
    }() //setup

    /**
     * fetches the token from the this._tokenDB or
     * setups the new database and retrieves the new token to be used
     */

  }, {
    key: "get",
    value: function () {
      var _ref3 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee3() {
        return _regenerator2.default.wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                return _context3.abrupt("return", this.setup());

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

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

      return get;
    }()

    /**
     * searches for the token in the this._tokenDB
     * if present, the it sends the current _rev
     * if not present (404), it creates a new document in the created this._tokenDB
     * @param {string} _token
     */

  }, {
    key: "put",
    value: function () {
      var _ref4 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee4(_token) {
        var TOKEN, response, _response;

        return _regenerator2.default.wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                // get token from local cache
                TOKEN = this.checkTokenDB();
                _context4.prev = 1;

                if (!TOKEN) {
                  _context4.next = 9;
                  break;
                }

                _context4.next = 5;
                return this._tokenDB.put({
                  _id: this._id,
                  _rev: this._rev,
                  token: _token
                });

              case 5:
                response = _context4.sent;

                this.token = _token;
                _context4.next = 13;
                break;

              case 9:
                _context4.next = 11;
                return this._tokenDB.put({
                  _id: this._id,
                  token: _token
                });

              case 11:
                _response = _context4.sent;

                this.token = _token;

              case 13:
                _context4.next = 17;
                break;

              case 15:
                _context4.prev = 15;
                _context4.t0 = _context4["catch"](1);

              case 17:
              case "end":
                return _context4.stop();
            }
          }
        }, _callee4, this, [[1, 15]]);
      }));

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

      return put;
    }() //put

  }, {
    key: "renew",
    value: function () {
      var _ref5 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee5() {
        return _regenerator2.default.wrap(function _callee5$(_context5) {
          while (1) {
            switch (_context5.prev = _context5.next) {
              case 0:
                this._isSet = false;
                return _context5.abrupt("return", this.setup(true));

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

      function renew() {
        return _ref5.apply(this, arguments);
      }

      return renew;
    }()
  }, {
    key: "cleanUp",
    value: function () {
      var _ref6 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee6() {
        return _regenerator2.default.wrap(function _callee6$(_context6) {
          while (1) {
            switch (_context6.prev = _context6.next) {
              case 0:
                _context6.prev = 0;
                _context6.next = 3;
                return this._tokenDB.destroy();

              case 3:
                //await this._tokenDB.close();
                this._isSet = false;
                _context6.next = 9;
                break;

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

                console.log("deleting token from cache", _context6.t0);

              case 9:
              case "end":
                return _context6.stop();
            }
          }
        }, _callee6, this, [[0, 6]]);
      }));

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

      return cleanUp;
    }() //cleanUp

  }, {
    key: "isSet",
    value: function isSet() {
      return this._isSet;
    }
  }]);
  return Token;
}(); //class

/* exporting the module */


module.exports = Token;