@frontegg/rest-api 2.10.88 → 3.0.1

package/jwt.js

@@ -0,0 +1,105 @@
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _wrapNativeSuper from "@babel/runtime/helpers/esm/wrapNativeSuper";
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+export var InvalidCharacterError = function (_Error) {
+  _inherits(InvalidCharacterError, _Error);
+
+  var _super = _createSuper(InvalidCharacterError);
+
+  function InvalidCharacterError(message) {
+    _classCallCheck(this, InvalidCharacterError);
+
+    return _super.call(this, message);
+  }
+
+  return _createClass(InvalidCharacterError);
+}(_wrapNativeSuper(Error));
+
+function polyfill(input) {
+  var str = String(input).replace(/=+$/, '');
+
+  if (str.length % 4 === 1) {
+    throw new InvalidCharacterError("'atob' failed: The string to be decoded is not correctly encoded.");
+  }
+
+  var output = '';
+
+  for (var bc = 0, bs, buffer, idx = 0; buffer = str.charAt(idx++); ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer, bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0) {
+    buffer = chars.indexOf(buffer);
+  }
+
+  return output;
+}
+
+var atob = typeof window !== 'undefined' && window.atob && window.atob.bind(window) || polyfill;
+
+function b64DecodeUnicode(str) {
+  return decodeURIComponent(atob(str).replace(/(.)/g, function (m, p) {
+    var code = p.charCodeAt(0).toString(16).toUpperCase();
+
+    if (code.length < 2) {
+      code = '0' + code;
+    }
+
+    return '%' + code;
+  }));
+}
+
+var base64UrlDecode = function base64UrlDecode(str) {
+  var output = str.replace(/-/g, '+').replace(/_/g, '/');
+
+  switch (output.length % 4) {
+    case 0:
+      break;
+
+    case 2:
+      output += '==';
+      break;
+
+    case 3:
+      output += '=';
+      break;
+
+    default:
+      throw new Error('Illegal base64url string!');
+  }
+
+  try {
+    return b64DecodeUnicode(output);
+  } catch (err) {
+    return atob(output);
+  }
+};
+
+export var InvalidTokenError = function (_Error2) {
+  _inherits(InvalidTokenError, _Error2);
+
+  var _super2 = _createSuper(InvalidTokenError);
+
+  function InvalidTokenError(message) {
+    _classCallCheck(this, InvalidTokenError);
+
+    return _super2.call(this, message);
+  }
+
+  return _createClass(InvalidTokenError);
+}(_wrapNativeSuper(Error));
+export var jwtDecode = function jwtDecode(token) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var pos = !!options.header ? 0 : 1;
+
+  try {
+    return JSON.parse(base64UrlDecode(token.split('.')[pos]));
+  } catch (e) {
+    throw new InvalidTokenError('Invalid token specified: ' + e.message);
+  }
+};

package/metadata/index.js

@@ -0,0 +1,166 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { Get } from '../fetch';
+
+function getMetadata(_x) {
+  return _getMetadata.apply(this, arguments);
+}
+
+function _getMetadata() {
+  _getMetadata = _asyncToGenerator(_regeneratorRuntime.mark(function _callee5(body) {
+    var _data$rows, _data$rows2;
+
+    var data;
+    return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            _context5.next = 2;
+            return Get('/metadata', body);
+
+          case 2:
+            data = _context5.sent;
+
+            if (!(data != null && (_data$rows = data.rows) != null && _data$rows[0])) {
+              _context5.next = 5;
+              break;
+            }
+
+            return _context5.abrupt("return", data == null ? void 0 : (_data$rows2 = data.rows) == null ? void 0 : _data$rows2[0]);
+
+          case 5:
+            throw new Error("metadata not found: ".concat(body.entityName));
+
+          case 6:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  }));
+  return _getMetadata.apply(this, arguments);
+}
+
+function getIpMetadata(_x2) {
+  return _getIpMetadata.apply(this, arguments);
+}
+
+function _getIpMetadata() {
+  _getIpMetadata = _asyncToGenerator(_regeneratorRuntime.mark(function _callee6(ip) {
+    var data;
+    return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            _context6.next = 2;
+            return Get("/metadata/ip/".concat(ip));
+
+          case 2:
+            data = _context6.sent;
+
+            if (!data) {
+              _context6.next = 5;
+              break;
+            }
+
+            return _context6.abrupt("return", data);
+
+          case 5:
+            throw new Error("ip metadata not found");
+
+          case 6:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee6);
+  }));
+  return _getIpMetadata.apply(this, arguments);
+}
+
+export var getNotificationsMetadata = function () {
+  var _ref = _asyncToGenerator(_regeneratorRuntime.mark(function _callee() {
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            return _context.abrupt("return", getMetadata({
+              entityName: 'notifications'
+            }));
+
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function getNotificationsMetadata() {
+    return _ref.apply(this, arguments);
+  };
+}();
+export var getSamlMetadata = function () {
+  var _ref2 = _asyncToGenerator(_regeneratorRuntime.mark(function _callee2() {
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            return _context2.abrupt("return", getMetadata({
+              entityName: 'saml'
+            }));
+
+          case 1:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function getSamlMetadata() {
+    return _ref2.apply(this, arguments);
+  };
+}();
+export var getAuditsMetadata = function () {
+  var _ref3 = _asyncToGenerator(_regeneratorRuntime.mark(function _callee3() {
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            return _context3.abrupt("return", getMetadata({
+              entityName: 'audits'
+            }));
+
+          case 1:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+
+  return function getAuditsMetadata() {
+    return _ref3.apply(this, arguments);
+  };
+}();
+export var getIpAdressMetadata = function () {
+  var _ref4 = _asyncToGenerator(_regeneratorRuntime.mark(function _callee4(ip) {
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            return _context4.abrupt("return", getIpMetadata(ip));
+
+          case 1:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+
+  return function getIpAdressMetadata(_x3) {
+    return _ref4.apply(this, arguments);
+  };
+}();

package/metadata/interfaces.js

@@ -0,0 +1 @@
+export {};

package/metadata/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "main": "../node/metadata/index.js",
+  "types": "./index.d.ts"
+}

package/node/ContextHolder.js

@@ -0,0 +1,126 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FronteggContext = exports.ContextHolder = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var ContextHolder = function () {
+  function ContextHolder() {
+    (0, _classCallCheck2["default"])(this, ContextHolder);
+    this.context = null;
+    this.accessToken = null;
+    this.user = null;
+
+    this.onRedirectTo = function (path) {
+      return window.location.href = path;
+    };
+
+    this.logout = function () {
+      return window.location.href = '/account/logout';
+    };
+  }
+
+  (0, _createClass2["default"])(ContextHolder, null, [{
+    key: "getInstance",
+    value: function getInstance() {
+      if (!ContextHolder.instance) {
+        ContextHolder.instance = new ContextHolder();
+      }
+
+      return ContextHolder.instance;
+    }
+  }, {
+    key: "setContext",
+    value: function setContext(context) {
+      ContextHolder.getInstance().context = context;
+    }
+  }, {
+    key: "setAccessToken",
+    value: function setAccessToken(accessToken) {
+      ContextHolder.getInstance().accessToken = accessToken;
+    }
+  }, {
+    key: "setUser",
+    value: function setUser(user) {
+      ContextHolder.getInstance().user = user;
+    }
+  }, {
+    key: "setOnRedirectTo",
+    value: function setOnRedirectTo(onRedirectTo) {
+      ContextHolder.getInstance().onRedirectTo = onRedirectTo;
+    }
+  }, {
+    key: "setLogout",
+    value: function setLogout(logout, logoutUrl) {
+      ContextHolder.getInstance().logout = function (callback) {
+        if (!callback) {
+          ContextHolder.onRedirectTo(logoutUrl);
+        } else {
+          logout(callback);
+        }
+      };
+    }
+  }, {
+    key: "getContext",
+    value: function getContext() {
+      var _ContextHolder$getIns;
+
+      return (_ContextHolder$getIns = ContextHolder.getInstance().context) != null ? _ContextHolder$getIns : {
+        baseUrl: window.location.href,
+        tokenResolver: function tokenResolver() {
+          return 'my-authentication-token';
+        },
+        logLevel: 'error'
+      };
+    }
+  }, {
+    key: "getAccessToken",
+    value: function getAccessToken() {
+      return ContextHolder.getInstance().accessToken;
+    }
+  }, {
+    key: "getUser",
+    value: function getUser() {
+      return ContextHolder.getInstance().user;
+    }
+  }, {
+    key: "onRedirectTo",
+    value: function onRedirectTo(path, opts) {
+      return ContextHolder.getInstance().onRedirectTo(path, opts);
+    }
+  }, {
+    key: "logout",
+    value: function logout(callback) {
+      return ContextHolder.getInstance().logout(callback);
+    }
+  }]);
+  return ContextHolder;
+}();
+
+exports.ContextHolder = ContextHolder;
+ContextHolder.instance = void 0;
+var FronteggContext = {
+  getContext: function getContext() {
+    return ContextHolder.getContext();
+  },
+  getAccessToken: function getAccessToken() {
+    return ContextHolder.getAccessToken();
+  },
+  getUser: function getUser() {
+    return ContextHolder.getUser();
+  },
+  onRedirectTo: function onRedirectTo(path, opts) {
+    return ContextHolder.onRedirectTo(path, opts);
+  },
+  logout: function logout(callback) {
+    return ContextHolder.logout(callback);
+  }
+};
+exports.FronteggContext = FronteggContext;

package/node/account-settings/index.js

@@ -0,0 +1,61 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSettings = getSettings;
+exports.updateSettings = updateSettings;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _constants = require("../constants");
+
+var _fetch = require("../fetch");
+
+function updateSettings(_x) {
+  return _updateSettings.apply(this, arguments);
+}
+
+function _updateSettings() {
+  _updateSettings = (0, _asyncToGenerator2["default"])(_regenerator["default"].mark(function _callee(body) {
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            return _context.abrupt("return", (0, _fetch.Put)(_constants.urls.tenants.accountSettings.v1, body));
+
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _updateSettings.apply(this, arguments);
+}
+
+function getSettings() {
+  return _getSettings.apply(this, arguments);
+}
+
+function _getSettings() {
+  _getSettings = (0, _asyncToGenerator2["default"])(_regenerator["default"].mark(function _callee2() {
+    return _regenerator["default"].wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            return _context2.abrupt("return", (0, _fetch.Get)(_constants.urls.tenants.accountSettings.v1));
+
+          case 1:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _getSettings.apply(this, arguments);
+}

package/node/account-settings/interfaces.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/node/audits/index.js

@@ -0,0 +1,90 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.exportAudits = exportAudits;
+exports.getAudits = getAudits;
+exports.getAuditsStats = getAuditsStats;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _fetch = require("../fetch");
+
+var _constants = require("../constants");
+
+function getAudits(_x) {
+  return _getAudits.apply(this, arguments);
+}
+
+function _getAudits() {
+  _getAudits = (0, _asyncToGenerator2["default"])(_regenerator["default"].mark(function _callee(params) {
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            return _context.abrupt("return", (0, _fetch.Get)(_constants.urls.audits.v1, params));
+
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _getAudits.apply(this, arguments);
+}
+
+function getAuditsStats(_x2) {
+  return _getAuditsStats.apply(this, arguments);
+}
+
+function _getAuditsStats() {
+  _getAuditsStats = (0, _asyncToGenerator2["default"])(_regenerator["default"].mark(function _callee2(params) {
+    return _regenerator["default"].wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            return _context2.abrupt("return", (0, _fetch.Get)("".concat(_constants.urls.audits.v1, "/stats"), params));
+
+          case 1:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _getAuditsStats.apply(this, arguments);
+}
+
+function exportAudits(_x3) {
+  return _exportAudits.apply(this, arguments);
+}
+
+function _exportAudits() {
+  _exportAudits = (0, _asyncToGenerator2["default"])(_regenerator["default"].mark(function _callee3(params) {
+    var endpoint, headerProps, restParams;
+    return _regenerator["default"].wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            endpoint = params.endpoint, headerProps = params.headerProps, restParams = (0, _objectWithoutProperties2["default"])(params, ["endpoint", "headerProps"]);
+            return _context3.abrupt("return", (0, _fetch.PostDownload)("".concat(_constants.urls.audits.v1, "/export/").concat(endpoint), {
+              properties: headerProps
+            }, restParams));
+
+          case 2:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _exportAudits.apply(this, arguments);
+}

package/node/audits/interfaces.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/node/auth/enums.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SocialLoginProviders = exports.AuthStrategyEnum = void 0;
+var SocialLoginProviders;
+exports.SocialLoginProviders = SocialLoginProviders;
+
+(function (SocialLoginProviders) {
+  SocialLoginProviders["Microsoft"] = "microsoft";
+  SocialLoginProviders["Facebook"] = "facebook";
+  SocialLoginProviders["Google"] = "google";
+  SocialLoginProviders["Github"] = "github";
+})(SocialLoginProviders || (exports.SocialLoginProviders = SocialLoginProviders = {}));
+
+var AuthStrategyEnum;
+exports.AuthStrategyEnum = AuthStrategyEnum;
+
+(function (AuthStrategyEnum) {
+  AuthStrategyEnum["EmailAndPassword"] = "EmailAndPassword";
+  AuthStrategyEnum["MagicLink"] = "MagicLink";
+  AuthStrategyEnum["Code"] = "Code";
+  AuthStrategyEnum["NoLocalAuthentication"] = "NoLocalAuthentication";
+  AuthStrategyEnum["SmsCode"] = "SmsCode";
+})(AuthStrategyEnum || (exports.AuthStrategyEnum = AuthStrategyEnum = {}));