browser-sdk/dist/esm/oidc/UserManager.js

javascript SDK for the lightelligence-platform

"use strict";

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

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

var OIDC = _interopRequireWildcard(require("oidc-client"));

/**
 * @typedef jsonService
 * @property {Function} postForm
 * @property {XMLHttpRequest} _XMLHttpRequest
 * @property {Array<string>} _contentTypes
 */

/**
 * @typedef jsonServicePostFormPayload
 * @property {Object<string>} headers
 */

/**
 * @typedef tokenClient
 * @property {jsonService} _jsonService
 * @property {Function} exchangeRefreshToken
 */

/**
 * User Manager
 *
 * Just a wrapper around OIDC.UserManager
 * https://github.com/IdentityModel/oidc-client-js/blob/dev/src/UserManager.js
 */
class UserManager extends OIDC.UserManager {
  constructor(settings) {
    super(settings);
    /**
     * We access the tokenClient which is part of the UserManager
     *
     * https://github.com/IdentityModel/oidc-client-js/blob/dev/src/UserManager.js#L45
     *
     * @type tokenClient
     */

    var tokenClient = this._tokenClient; // eslint-disable-line

    /**
     * We need to access the JSONService instance in order to modify the
     * XMLHTTPRequest to accept headers.
     *
     * https://github.com/IdentityModel/oidc-client-js/blob/dev/src/JsonService.js#L99
     */

    var jsonService = tokenClient._jsonService; // eslint-disable-line

    /** @type Array<string> */

    var allowedContentTypes = jsonService._contentTypes; // eslint-disable-line

    /**
     * Checks if a content type is one of the allowed ones
     *
     * @param contentType
     * @returns {string}
     */

    var isAllowedContentType = contentType => allowedContentTypes.find(item => contentType.startsWith(item));
    /**
     * Replaces postForm method of the jsonService.
     * https://github.com/IdentityModel/oidc-client-js/blob/dev/src/JsonService.js#L99
     *
     * @param {string} url
     * @param {jsonServicePostFormPayload} payload
     */


    jsonService.postForm = (url, payload) => {
      /** @type XMLHttpRequest */
      var XMLHttpRequest = jsonService._XMLHttpRequest; // eslint-disable-line

      if (!url) {
        OIDC.Log.error('JsonService.postForm: No url passed');
        throw new Error('url');
      }

      OIDC.Log.debug('JsonService.postForm, url: ', url);
      return new Promise((resolve, reject) => {
        var req = new XMLHttpRequest();
        req.open('POST', url);

        req.onload = () => {
          OIDC.Log.debug('JsonService.postForm: HTTP response received, status', req.status);

          if (req.status !== 200 && req.status !== 400) {
            return reject(Error("".concat(req.statusText, " ( ").concat(req.status, " )")));
          }

          var contentType = req.getResponseHeader('Content-Type');

          if (!contentType || !isAllowedContentType(contentType)) {
            if (req.status === 200) {
              return reject(Error("Invalid response Content-Type: ".concat(contentType, ", from URL: ").concat(url)));
            }

            return reject(Error("".concat(req.statusText, " ( ").concat(req.status, " )")));
          }

          try {
            var responsePayload = JSON.parse(req.responseText);

            if (req.status === 200) {
              return resolve(responsePayload);
            }

            if (responsePayload && responsePayload.error) {
              OIDC.Log.error('JsonService.postForm: Error from server: ', responsePayload.error);
              return reject(new Error(responsePayload.error));
            }
          } catch (error) {
            OIDC.Log.error('JsonService.postForm: Error parsing JSON response', error.message);
            return reject(error);
          }

          return reject(Error("".concat(req.statusText, " ( ").concat(req.status, " )")));
        };

        req.onerror = () => {
          OIDC.Log.error('JsonService.postForm: network error');
          reject(Error('Network Error'));
        };

        var body = Object.entries(payload).filter((_ref) => {
          var [key] = _ref;
          return key !== 'headers';
        }).map(pair => pair.map(encodeURIComponent)).map((_ref2) => {
          var [key, value] = _ref2;
          return "".concat(key, "=").concat(value);
        }).join('&');
        req.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
        Object.entries(payload.headers || {}).forEach((_ref3) => {
          var [name, value] = _ref3;
          req.setRequestHeader(name, value);
        });
        req.send(body);
      });
    };
  }
  /**
   * Change the tenant id
   *
   * @param {string} tenantId  Changes the users's tenant
   * @returns {Promise<User>}
   */


  changeTenant(tenantId) {
    var _this = this;

    return (0, _asyncToGenerator2.default)(function* () {
      /** @type {tokenClient} */
      var tokenClient = _this._tokenClient; // eslint-disable-line

      var user = yield _this.getUser();

      if (!user || !user.refresh_token) {
        throw new Error('changeTenant: No refresh token');
      }

      if (!user.profile) {
        throw new Error('changeTenant: No profile loaded for the user');
      }

      var result = yield tokenClient.exchangeRefreshToken({
        refresh_token: user.refresh_token,
        headers: {
          'X-Requested-With': tenantId
        }
      });

      if (!result || !result.access_token || !result.refresh_token || !result.expires_in) {
        throw new Error('changeTenant: Error while changing tenant');
      }

      user.access_token = result.access_token;
      user.refresh_token = result.refresh_token;
      user.expires_in = result.expires_in;
      user.profile.tenant = tenantId;
      yield _this.storeUser(user);

      _this.events.load(user);

      return user;
    })();
  }

}

exports.default = UserManager;