pubnub/lib/core/components/token_manager.js

Publish & Subscribe Real-time Messaging with PubNub

"use strict";

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

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

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

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

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

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

var _config = _interopRequireDefault(require("./config"));

var _flow_interfaces = require("../flow_interfaces");

var _default = function () {
  function _default(config, cbor) {
    (0, _classCallCheck2["default"])(this, _default);
    (0, _defineProperty2["default"])(this, "_config", void 0);
    (0, _defineProperty2["default"])(this, "_cbor", void 0);
    (0, _defineProperty2["default"])(this, "_userTokens", void 0);
    (0, _defineProperty2["default"])(this, "_spaceTokens", void 0);
    (0, _defineProperty2["default"])(this, "_userToken", void 0);
    (0, _defineProperty2["default"])(this, "_spaceToken", void 0);
    this._config = config;
    this._cbor = cbor;

    this._initializeTokens();
  }

  (0, _createClass2["default"])(_default, [{
    key: "_initializeTokens",
    value: function _initializeTokens() {
      this._userTokens = {};
      this._spaceTokens = {};
      this._userToken = undefined;
      this._spaceToken = undefined;
    }
  }, {
    key: "_setToken",
    value: function _setToken(token) {
      var _this = this;

      var tokenObject = this.parseToken(token);

      if (tokenObject && tokenObject.resources) {
        if (tokenObject.resources.users) {
          Object.keys(tokenObject.resources.users).forEach(function (id) {
            _this._userTokens[id] = token;
          });
        }

        if (tokenObject.resources.spaces) {
          Object.keys(tokenObject.resources.spaces).forEach(function (id) {
            _this._spaceTokens[id] = token;
          });
        }
      }

      if (tokenObject && tokenObject.patterns) {
        if (tokenObject.patterns.users && Object.keys(tokenObject.patterns.users).length > 0) {
          this._userToken = token;
        }

        if (tokenObject.patterns.spaces && Object.keys(tokenObject.patterns.spaces).length > 0) {
          this._spaceToken = token;
        }
      }
    }
  }, {
    key: "setToken",
    value: function setToken(token) {
      if (token && token.length > 0) {
        this._setToken(token);
      }
    }
  }, {
    key: "setTokens",
    value: function setTokens(tokens) {
      var _this2 = this;

      if (tokens && tokens.length && (0, _typeof2["default"])(tokens) === 'object') {
        tokens.forEach(function (token) {
          _this2.setToken(token);
        });
      }
    }
  }, {
    key: "getTokens",
    value: function getTokens(tokenDef) {
      var _this3 = this;

      var result = {
        users: {},
        spaces: {}
      };

      if (tokenDef) {
        if (tokenDef.user) {
          result.user = this._userToken;
        }

        if (tokenDef.space) {
          result.space = this._spaceToken;
        }

        if (tokenDef.users) {
          tokenDef.users.forEach(function (user) {
            result.users[user] = _this3._userTokens[user];
          });
        }

        if (tokenDef.space) {
          tokenDef.spaces.forEach(function (space) {
            result.spaces[space] = _this3._spaceTokens[space];
          });
        }
      } else {
        if (this._userToken) {
          result.user = this._userToken;
        }

        if (this._spaceToken) {
          result.space = this._spaceToken;
        }

        Object.keys(this._userTokens).forEach(function (user) {
          result.users[user] = _this3._userTokens[user];
        });
        Object.keys(this._spaceTokens).forEach(function (space) {
          result.spaces[space] = _this3._spaceTokens[space];
        });
      }

      return result;
    }
  }, {
    key: "getToken",
    value: function getToken(type, id) {
      var result;

      if (id) {
        if (type === 'user') {
          result = this._userTokens[id];
        } else if (type === 'space') {
          result = this._spaceTokens[id];
        }
      } else if (type === 'user') {
        result = this._userToken;
      } else if (type === 'space') {
        result = this._spaceToken;
      }

      return result;
    }
  }, {
    key: "extractPermissions",
    value: function extractPermissions(permissions) {
      var permissionsResult = {
        create: false,
        read: false,
        write: false,
        manage: false,
        "delete": false
      };

      if ((permissions & 16) === 16) {
        permissionsResult.create = true;
      }

      if ((permissions & 8) === 8) {
        permissionsResult["delete"] = true;
      }

      if ((permissions & 4) === 4) {
        permissionsResult.manage = true;
      }

      if ((permissions & 2) === 2) {
        permissionsResult.write = true;
      }

      if ((permissions & 1) === 1) {
        permissionsResult.read = true;
      }

      return permissionsResult;
    }
  }, {
    key: "parseToken",
    value: function parseToken(tokenString) {
      var _this4 = this;

      var parsed = this._cbor.decodeToken(tokenString);

      if (parsed !== undefined) {
        var userResourcePermissions = Object.keys(parsed.res.usr);
        var spaceResourcePermissions = Object.keys(parsed.res.spc);
        var channelResourcePermissions = Object.keys(parsed.res.chan);
        var groupResourcePermissions = Object.keys(parsed.res.grp);
        var userPatternPermissions = Object.keys(parsed.pat.usr);
        var spacePatternPermissions = Object.keys(parsed.pat.spc);
        var channelPatternPermissions = Object.keys(parsed.pat.chan);
        var groupPatternPermissions = Object.keys(parsed.pat.grp);
        var result = {
          version: parsed.v,
          timestamp: parsed.t,
          ttl: parsed.ttl
        };
        var userResources = userResourcePermissions.length > 0;
        var spaceResources = spaceResourcePermissions.length > 0;
        var channelResources = channelResourcePermissions.length > 0;
        var groupResources = groupResourcePermissions.length > 0;

        if (userResources || spaceResources || channelResources || groupResources) {
          result.resources = {};

          if (userResources) {
            result.resources.users = {};
            userResourcePermissions.forEach(function (id) {
              result.resources.users[id] = _this4.extractPermissions(parsed.res.usr[id]);
            });
          }

          if (spaceResources) {
            result.resources.spaces = {};
            spaceResourcePermissions.forEach(function (id) {
              result.resources.spaces[id] = _this4.extractPermissions(parsed.res.spc[id]);
            });
          }

          if (channelResources) {
            result.resources.channels = {};
            channelResourcePermissions.forEach(function (id) {
              result.resources.channels[id] = _this4.extractPermissions(parsed.res.chan[id]);
            });
          }

          if (groupResources) {
            result.resources.groups = {};
            groupResourcePermissions.forEach(function (id) {
              result.resources.groups[id] = _this4.extractPermissions(parsed.res.grp[id]);
            });
          }
        }

        var userPatterns = userPatternPermissions.length > 0;
        var spacePatterns = spacePatternPermissions.length > 0;
        var channelPatterns = channelPatternPermissions.length > 0;
        var groupPatterns = groupPatternPermissions.length > 0;

        if (userPatterns || spacePatterns || channelPatterns || groupPatterns) {
          result.patterns = {};

          if (userPatterns) {
            result.patterns.users = {};
            userPatternPermissions.forEach(function (id) {
              result.patterns.users[id] = _this4.extractPermissions(parsed.pat.usr[id]);
            });
          }

          if (spacePatterns) {
            result.patterns.spaces = {};
            spacePatternPermissions.forEach(function (id) {
              result.patterns.spaces[id] = _this4.extractPermissions(parsed.pat.spc[id]);
            });
          }

          if (channelPatterns) {
            result.patterns.channels = {};
            channelPatternPermissions.forEach(function (id) {
              result.patterns.channels[id] = _this4.extractPermissions(parsed.pat.chan[id]);
            });
          }

          if (groupPatterns) {
            result.patterns.groups = {};
            groupPatternPermissions.forEach(function (id) {
              result.patterns.groups[id] = _this4.extractPermissions(parsed.pat.grp[id]);
            });
          }
        }

        if (Object.keys(parsed.meta).length > 0) {
          result.meta = parsed.meta;
        }

        result.signature = parsed.sig;
        return result;
      } else {
        return undefined;
      }
    }
  }, {
    key: "clearTokens",
    value: function clearTokens() {
      this._initializeTokens();
    }
  }]);
  return _default;
}();

exports["default"] = _default;
module.exports = exports.default;
//# sourceMappingURL=token_manager.js.map