sendit-sdk/dist/sendit-oauth2-server.js

Sendit sdk for integrating to sendit system

'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _config = require('./config');

var _caller = require('./caller');

var _type = require('./type');

var _url = require('url');

var _url2 = _interopRequireDefault(_url);

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

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { return step("next", value); }, function (err) { return step("throw", err); }); } } return step("next"); }); }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var SenditOauth2Server = exports.SenditOauth2Server = function () {
  function SenditOauth2Server(clientId, secret, redirectUri) {
    _classCallCheck(this, SenditOauth2Server);

    this.clientId = clientId;
    this.secret = secret;
    this.redirectUri = redirectUri;
  }

  _createClass(SenditOauth2Server, [{
    key: 'issueToken',
    value: function () {
      var _ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee(type, params) {
        var response;
        return regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                response = void 0;
                _context.t0 = type;
                _context.next = _context.t0 === _type.grantType.CODE ? 4 : _context.t0 === _type.grantType.PASSWORD ? 8 : _context.t0 === _type.grantType.REFRESH_TOKEN ? 12 : 16;
                break;

              case 4:
                _context.next = 6;
                return (0, _caller.caller)(_url2.default.resolve(_config.config.authorizeUri, '/oauth/token'), {
                  method: 'POST',
                  headers: {
                    'Content-Type': 'application/x-www-form-urlencoded'
                  },
                  body: {
                    grant_type: type,
                    client_id: this.clientId,
                    client_secret: this.secret,
                    redirect_uri: this.redirectUri,
                    code: params.code
                  }
                });

              case 6:
                response = _context.sent;
                return _context.abrupt('return', response.response);

              case 8:
                _context.next = 10;
                return (0, _caller.caller)(_url2.default.resolve(_config.config.authorizeUri, '/oauth/token'), {
                  method: 'POST',
                  headers: {
                    'Content-Type': 'application/x-www-form-urlencoded'
                  },
                  body: {
                    grant_type: type,
                    client_id: this.clientId,
                    client_secret: this.secret,
                    username: params.username,
                    password: params.password,
                    scope: params.scope || ''
                  }
                });

              case 10:
                response = _context.sent;
                return _context.abrupt('return', response.response);

              case 12:
                _context.next = 14;
                return (0, _caller.caller)(_url2.default.resolve(_config.config.authorizeUri, '/oauth/token'), {
                  method: 'POST',
                  headers: {
                    'Content-Type': 'application/x-www-form-urlencoded'
                  },
                  body: {
                    grant_type: type,
                    client_id: this.clientId,
                    client_secret: this.secret,
                    refresh_token: params.refreshToken
                  }
                });

              case 14:
                response = _context.sent;
                return _context.abrupt('return', response.response);

              case 16:
                throw new Error('Could not use this function with provided grant type');

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

      function issueToken(_x, _x2) {
        return _ref.apply(this, arguments);
      }

      return issueToken;
    }()
  }, {
    key: 'renewAccessToken',
    value: function renewAccessToken(refreshToken) {
      return this.issueToken(_type.grantType.REFRESH_TOKEN, { refreshToken: refreshToken });
    }
  }, {
    key: 'verifyToken',
    value: function () {
      var _ref2 = _asyncToGenerator(regeneratorRuntime.mark(function _callee2(token) {
        var response;
        return regeneratorRuntime.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                _context2.next = 2;
                return (0, _caller.caller)(_url2.default.resolve(_config.config.authorizeUri, '/oauth/token/verify'), {
                  method: 'GET',
                  headers: {
                    Authorization: 'Bearer ' + token
                  }
                });

              case 2:
                response = _context2.sent;
                return _context2.abrupt('return', response.response);

              case 4:
              case 'end':
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function verifyToken(_x3) {
        return _ref2.apply(this, arguments);
      }

      return verifyToken;
    }()
  }]);

  return SenditOauth2Server;
}();