@frontegg/rest-api 2.10.83 → 6.0.1-alpha.1

package/ContextHolder.js

@@ -0,0 +1,80 @@
+export class ContextHolder {
+  constructor() {
+    this.context = null;
+    this.accessToken = null;
+    this.user = null;
+
+    this.onRedirectTo = path => window.location.href = path;
+
+    this.logout = () => window.location.href = '/account/logout';
+  }
+
+  static getInstance() {
+    if (!ContextHolder.instance) {
+      ContextHolder.instance = new ContextHolder();
+    }
+
+    return ContextHolder.instance;
+  }
+
+  static setContext(context) {
+    ContextHolder.getInstance().context = context;
+  }
+
+  static setAccessToken(accessToken) {
+    ContextHolder.getInstance().accessToken = accessToken;
+  }
+
+  static setUser(user) {
+    ContextHolder.getInstance().user = user;
+  }
+
+  static setOnRedirectTo(onRedirectTo) {
+    ContextHolder.getInstance().onRedirectTo = onRedirectTo;
+  }
+
+  static setLogout(logout, logoutUrl) {
+    ContextHolder.getInstance().logout = callback => {
+      if (!callback) {
+        ContextHolder.onRedirectTo(logoutUrl);
+      } else {
+        logout(callback);
+      }
+    };
+  }
+
+  static getContext() {
+    var _ContextHolder$getIns;
+
+    return (_ContextHolder$getIns = ContextHolder.getInstance().context) != null ? _ContextHolder$getIns : {
+      baseUrl: window.location.href,
+      tokenResolver: () => 'my-authentication-token',
+      logLevel: 'error'
+    };
+  }
+
+  static getAccessToken() {
+    return ContextHolder.getInstance().accessToken;
+  }
+
+  static getUser() {
+    return ContextHolder.getInstance().user;
+  }
+
+  static onRedirectTo(path, opts) {
+    return ContextHolder.getInstance().onRedirectTo(path, opts);
+  }
+
+  static logout(callback) {
+    return ContextHolder.getInstance().logout(callback);
+  }
+
+}
+ContextHolder.instance = void 0;
+export const FronteggContext = {
+  getContext: () => ContextHolder.getContext(),
+  getAccessToken: () => ContextHolder.getAccessToken(),
+  getUser: () => ContextHolder.getUser(),
+  onRedirectTo: (path, opts) => ContextHolder.onRedirectTo(path, opts),
+  logout: callback => ContextHolder.logout(callback)
+};

package/account-settings/index.js

@@ -0,0 +1,8 @@
+import { urls } from '../constants';
+import { Put, Get } from '../fetch';
+export async function updateSettings(body) {
+  return Put(urls.tenants.accountSettings.v1, body);
+}
+export async function getSettings() {
+  return Get(urls.tenants.accountSettings.v1);
+}

package/account-settings/interfaces.js

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

package/account-settings/package.json

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

package/audits/index.js

@@ -0,0 +1,21 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["endpoint", "headerProps"];
+import { Get, PostDownload } from '../fetch';
+import { urls } from '../constants';
+export async function getAudits(params) {
+  return Get(urls.audits.v1, params);
+}
+export async function getAuditsStats(params) {
+  return Get(`${urls.audits.v1}/stats`, params);
+}
+export async function exportAudits(params) {
+  const {
+    endpoint,
+    headerProps
+  } = params,
+        restParams = _objectWithoutPropertiesLoose(params, _excluded);
+
+  return PostDownload(`${urls.audits.v1}/export/${endpoint}`, {
+    properties: headerProps
+  }, restParams);
+}

package/audits/interfaces.js

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

package/audits/package.json

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

package/auth/enums.js

@@ -0,0 +1,18 @@
+export let SocialLoginProviders;
+
+(function (SocialLoginProviders) {
+  SocialLoginProviders["Microsoft"] = "microsoft";
+  SocialLoginProviders["Facebook"] = "facebook";
+  SocialLoginProviders["Google"] = "google";
+  SocialLoginProviders["Github"] = "github";
+})(SocialLoginProviders || (SocialLoginProviders = {}));
+
+export let AuthStrategyEnum;
+
+(function (AuthStrategyEnum) {
+  AuthStrategyEnum["EmailAndPassword"] = "EmailAndPassword";
+  AuthStrategyEnum["MagicLink"] = "MagicLink";
+  AuthStrategyEnum["Code"] = "Code";
+  AuthStrategyEnum["NoLocalAuthentication"] = "NoLocalAuthentication";
+  AuthStrategyEnum["SmsCode"] = "SmsCode";
+})(AuthStrategyEnum || (AuthStrategyEnum = {}));

package/auth/index.js

@@ -0,0 +1,398 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
+const _excluded = ["type"],
+      _excluded2 = ["type"];
+import { getTenants } from '../tenants';
+export * from './secutiry-poilicy';
+export * from './enums';
+import { urls } from '../constants';
+import { ContextHolder } from '../ContextHolder';
+import { Delete, Get, Patch, Post, Put } from '../fetch';
+import { jwtDecode } from '../jwt';
+export async function generateLoginResponse(loginResponse) {
+  if (!loginResponse.accessToken) {
+    return loginResponse;
+  }
+
+  ContextHolder.setAccessToken(loginResponse.accessToken);
+  const me = await Get(`${urls.identity.users.v2}/me`);
+  const decodedContent = loginResponse.accessToken ? jwtDecode(loginResponse.accessToken) : {};
+
+  const user = _extends({}, loginResponse, decodedContent, me);
+
+  ContextHolder.setUser(user);
+  return user;
+}
+export async function generateLoginResponseV2(loginResponse) {
+  if (!loginResponse.accessToken) {
+    return {
+      user: loginResponse
+    };
+  }
+
+  ContextHolder.setAccessToken(loginResponse.accessToken);
+  const [me, tenants] = await Promise.all([Get(`${urls.identity.users.v2}/me`), getTenants()]);
+  const decodedContent = loginResponse.accessToken ? jwtDecode(loginResponse.accessToken) : {};
+
+  const user = _extends({}, loginResponse, decodedContent, me);
+
+  ContextHolder.setUser(user);
+  return {
+    user,
+    tenants
+  };
+}
+export async function generateLoginResponseFromOAuthResponse(oauthResponse) {
+  ContextHolder.setAccessToken(oauthResponse.id_token);
+  const me = await Get(`${urls.identity.users.v2}/me`);
+  const decodedContent = oauthResponse.id_token ? jwtDecode(oauthResponse.id_token) : {};
+
+  const user = _extends({
+    mfaRequired: false,
+    accessToken: oauthResponse.id_token,
+    refreshToken: oauthResponse.refresh_token
+  }, decodedContent, me);
+
+  ContextHolder.setUser(user);
+  return user;
+}
+export async function preLogin(body) {
+  try {
+    const {
+      address
+    } = await Post(`${urls.identity.auth.v1}/user/saml/prelogin`, body);
+    return address;
+  } catch {
+    return null;
+  }
+}
+export async function preLoginWithIdpType(body) {
+  return Post(`${urls.identity.auth.v1}/user/saml/prelogin`, body);
+}
+export async function postLogin(body) {
+  const data = await Post(`${urls.identity.auth.v1}/user/saml/postlogin`, body);
+  return generateLoginResponse(data);
+}
+export async function oidcPostLogin(body) {
+  const data = await Post(`${urls.identity.auth.v1}/user/oidc/postlogin`, body);
+  return generateLoginResponse(data);
+}
+export async function login(body) {
+  const data = await Post(`${urls.identity.auth.v1}/user`, body);
+  return generateLoginResponse(data);
+}
+export async function loginWithMfa(body) {
+  const data = await Post(`${urls.identity.auth.v1}/user/mfa/verify`, body);
+  return generateLoginResponse(data);
+}
+export async function activateAccount(body) {
+  return Post(`${urls.identity.users.v1}/activate`, body);
+}
+export async function getActivateAccountStrategy(params) {
+  return Get(`${urls.identity.users.v1}/activate/strategy`, params);
+}
+export async function resendActivationEmail(body) {
+  return Post(`${urls.identity.users.v1}/activate/reset`, body);
+}
+export async function acceptInvitation(body) {
+  return Post(`${urls.identity.users.v1}/invitation/accept`, body);
+}
+export async function refreshToken() {
+  const data = await Post(`${urls.identity.auth.v1}/user/token/refresh`);
+  return generateLoginResponse(data);
+}
+export async function refreshTokenV2() {
+  const data = await Post(`${urls.identity.auth.v1}/user/token/refresh`);
+  return generateLoginResponseV2(data);
+}
+export async function logout() {
+  return Post(`${urls.identity.auth.v1}/logout`);
+}
+export async function forgotPassword(body) {
+  return Post(`${urls.identity.users.v1}/passwords/reset`, body);
+}
+export async function resetPassword(body) {
+  return Post(`${urls.identity.users.v1}/passwords/reset/verify`, body);
+}
+export async function loadPasswordConfig(params) {
+  return Get(`${urls.identity.users.v1}/passwords/config`, params);
+}
+export async function recoverMfaToken(body) {
+  return Post(`${urls.identity.auth.v1}/user/mfa/recover`, body);
+}
+export async function enrollMfa() {
+  return Post(`${urls.identity.users.v1}/mfa/enroll`);
+}
+export async function verifyMfa(body) {
+  return Post(`${urls.identity.users.v1}/mfa/enroll/verify`, body);
+}
+export async function disableMfa(body) {
+  return Post(`${urls.identity.users.v1}/mfa/disable`, body);
+}
+export async function getSamlConfiguration() {
+  return Get(`${urls.team.sso.v1}/saml/configurations`);
+}
+export async function updateSamlConfiguration(body) {
+  return Post(`${urls.team.sso.v1}/saml/configurations`, body);
+}
+export async function getSamlVendorConfiguration() {
+  return Get(`${urls.team.sso.v1}/saml/configurations/vendor-config`);
+}
+export async function updateSamlVendorMetadata(body) {
+  return Put(`${urls.team.sso.v1}/saml/configurations/metadata`, body);
+}
+export async function validateSamlDomain() {
+  return Put(`${urls.team.sso.v1}/saml/validations/domain`);
+}
+export async function getSamlRoles() {
+  return Get(`${urls.team.sso.v1}/saml/configurations/roles/default`);
+}
+export async function getSamlRolesGroups() {
+  return Get(`${urls.team.sso.v2}/saml/configurations/groups`);
+}
+export async function updateSamlRoles({
+  roleIds
+}) {
+  return Post(`${urls.team.sso.v1}/saml/configurations/roles/default`, {
+    roleIds
+  });
+}
+export async function createSamlGroup({
+  roleIds,
+  group
+}) {
+  return Post(`${urls.team.sso.v2}/saml/configurations/groups`, {
+    group,
+    roleIds
+  });
+}
+export async function updateSamlGroup({
+  roleIds,
+  group,
+  id
+}) {
+  return Patch(`${urls.team.sso.v2}/saml/configurations/groups/${id}`, {
+    group,
+    roleIds
+  });
+}
+export async function deleteSamlGroup({
+  id
+}) {
+  return Delete(`${urls.team.sso.v2}/saml/configurations/groups/${id}`);
+}
+export async function getOidcConfiguration() {
+  return Get(`${urls.team.sso.v1}/oidc/configurations`);
+}
+export async function getSSOPublicConfiguration() {
+  return Get(`${urls.team.sso.v2}/configurations/public`);
+}
+export async function getSocialLoginProviders() {
+  return Get(urls.identity.sso.v1);
+}
+export async function getSocialLoginProvidersV2() {
+  return Get(urls.identity.sso.v2);
+}
+export async function loginViaSocialLogin({
+  provider,
+  code,
+  redirectUri,
+  codeVerifier,
+  metadata,
+  invitationToken,
+  state
+}) {
+  const params = {
+    code
+  };
+
+  if (redirectUri) {
+    params.redirectUri = redirectUri;
+  }
+
+  if (codeVerifier) {
+    params.code_verifier = codeVerifier;
+  }
+
+  if (state) {
+    params.state = state;
+  }
+
+  return Post(`${urls.identity.auth.v1}/user/sso/${provider}/postlogin`, {
+    metadata,
+    invitationToken
+  }, {
+    params
+  });
+}
+export async function getVendorConfig() {
+  return Get(`${urls.identity.configurations.v1}/public`);
+}
+export async function signUpUser(body) {
+  const {
+    shouldActivate,
+    authResponse,
+    userId,
+    tenantId
+  } = await Post(`${urls.identity.users.v1}/signUp`, body);
+  const loginResponse = !shouldActivate && authResponse ? await generateLoginResponse(authResponse) : undefined;
+  return {
+    shouldActivate,
+    user: loginResponse,
+    userId,
+    tenantId
+  };
+}
+export async function getCurrentUserSessions() {
+  const sessions = await Get(urls.identity.users.sessions.currentUser.v1);
+  return sessions;
+}
+export async function deleteSessionForUser(id) {
+  await Delete(`${urls.identity.users.sessions.currentUser.v1}/${id}`);
+}
+export async function deleteAllSessionsForUser() {
+  await Delete(`${urls.identity.users.sessions.currentUser.v1}/all`);
+}
+export async function getUserApiTokensData() {
+  return Get(urls.identity.users.apiTokens.v1);
+}
+export async function getTenantApiTokensData() {
+  return Get(urls.identity.tenants.apiTokens.v1);
+}
+export async function updateUserApiTokensData(body) {
+  return Post(urls.identity.users.apiTokens.v1, body);
+}
+export async function updateTenantApiTokensData(body) {
+  return Post(urls.identity.tenants.apiTokens.v2, body);
+}
+export async function deleteTenantApiToken({
+  tokenId
+}) {
+  return Delete(`${urls.identity.tenants.apiTokens.v1}/${tokenId}`);
+}
+export async function deleteUserApiToken({
+  tokenId
+}) {
+  return Delete(`${urls.identity.users.apiTokens.v1}/${tokenId}`);
+}
+export async function getUserById({
+  userId
+}) {
+  return Get(`${urls.identity.users.v1}/${userId}`);
+}
+export async function checkIfAllowToRememberMfaDevice(mfaToken) {
+  return Get(`${urls.identity.configurations.v1}/mfa-policy/allow-remember-device`, {
+    mfaToken
+  });
+}
+export async function passwordlessPreLogin(_ref) {
+  let {
+    type
+  } = _ref,
+      body = _objectWithoutPropertiesLoose(_ref, _excluded);
+
+  return Post(`${urls.identity.auth.v1}/passwordless/${type.toLocaleLowerCase()}/prelogin`, body);
+}
+export async function passwordlessPostLogin(_ref2) {
+  let {
+    type
+  } = _ref2,
+      body = _objectWithoutPropertiesLoose(_ref2, _excluded2);
+
+  return Post(`${urls.identity.auth.v1}/passwordless/${type.toLocaleLowerCase()}/postlogin`, body);
+}
+export async function verifyInviteToken({
+  token
+}) {
+  return Post(urls.identity.tenants.invites.verify.v1, {
+    token
+  });
+}
+export async function getSSOConfigurations() {
+  return Get(`${urls.team.sso.v1}/configurations`);
+}
+export async function createSSOConfiguration(body) {
+  return Post(`${urls.team.sso.v1}/configurations`, body);
+}
+export async function updateSSOConfiguration(ssoConfigId, body) {
+  return Patch(`${urls.team.sso.v1}/configurations/${ssoConfigId}`, body);
+}
+export async function deleteSSOConfiguration(ssoConfigId) {
+  return Delete(`${urls.team.sso.v1}/configurations/${ssoConfigId}`);
+}
+export async function createSSOConfigurationByMetadata(body) {
+  return Post(`${urls.team.sso.v1}/configurations/metadata`, body);
+}
+export async function updateSSOConfigurationByMetadata(ssoConfigId, body) {
+  return Put(`${urls.team.sso.v1}/configurations/${ssoConfigId}/metadata`, body);
+}
+export async function createSSODomain(ssoConfigId, body) {
+  return Post(`${urls.team.sso.v1}/configurations/${ssoConfigId}/domains`, body);
+}
+export async function deleteSSODomain(ssoConfigId, domainId) {
+  return Delete(`${urls.team.sso.v1}/configurations/${ssoConfigId}/domains/${domainId}`);
+}
+export async function validateSSODomain(ssoConfigId, domainId) {
+  return Put(`${urls.team.sso.v1}/configurations/${ssoConfigId}/domains/${domainId}/validate`);
+}
+export async function getSSODefaultRoles(ssoConfigId) {
+  return Get(`${urls.team.sso.v1}/configurations/${ssoConfigId}/roles`);
+}
+export async function setSSODefaultRoles(ssoConfigId, body) {
+  return Put(`${urls.team.sso.v1}/configurations/${ssoConfigId}/roles`, body);
+}
+export async function createSSOGroup(ssoConfigId, body) {
+  return Post(`${urls.team.sso.v1}/configurations/${ssoConfigId}/groups`, body);
+}
+export async function updateSSOGroup(ssoConfigId, {
+  roleIds,
+  group,
+  id
+}) {
+  return Patch(`${urls.team.sso.v1}/configurations/${ssoConfigId}/groups/${id}`, {
+    group,
+    roleIds
+  });
+}
+export async function deleteSSOGroup(ssoConfigId, groupId) {
+  return Delete(`${urls.team.sso.v1}/configurations/${ssoConfigId}/groups/${groupId}`);
+}
+export async function getSSOGroups(ssoConfigId) {
+  return Get(`${urls.team.sso.v1}/configurations/${ssoConfigId}/groups`);
+}
+export async function preLoginV2(body) {
+  return Post(`${urls.identity.auth.v2}/user/sso/prelogin`, body);
+}
+export async function oidcPostLoginV2(body) {
+  const data = await Post(`${urls.identity.auth.v2}/user/oidc/postlogin`, body);
+  return generateLoginResponse(data);
+}
+export async function exchangeOAuthTokens(body) {
+  const data = await Post(`${urls.oauth.v1}/token`, body);
+  return generateLoginResponseFromOAuthResponse(data);
+}
+export async function resetPhoneNumber(body) {
+  return Post(`${urls.identity.users.v1}/phone/reset`, body);
+}
+export async function verifyResetPhoneNumber(body) {
+  return Post(`${urls.identity.users.v1}/phone/reset/verify`, body);
+}
+export async function changePhoneNumber(body) {
+  return Put(`${urls.identity.users.v1}/phone/change`, body);
+}
+export async function webAuthnPreLogin(body) {
+  return Post(`${urls.identity.auth.v1}/webauthn/prelogin`, body);
+}
+export async function webAuthnPostLogin(body) {
+  return Post(`${urls.identity.auth.v1}/webauthn/postlogin`, body);
+}
+export async function webAuthnCreateNewDeviceSession() {
+  return Post(urls.identity.webAuthnDevices.v1);
+}
+export async function verifyNewDeviceSession(body) {
+  return Post(`${urls.identity.webAuthnDevices.v1}/verify`, body);
+}
+export async function getVendorPublicAuthStrategiesConfig() {
+  return Get(`${urls.identity.configurations.v1}/auth/strategies/public`);
+}
+;

package/auth/interfaces.js

@@ -0,0 +1,15 @@
+export * from './secutiry-poilicy/interfaces';
+;
+;
+;
+;
+;
+;
+;
+export let SecondaryAuthStrategy;
+
+(function (SecondaryAuthStrategy) {
+  SecondaryAuthStrategy["WebAuthnPlatform"] = "WebAuthnPlatform";
+  SecondaryAuthStrategy["WebAuthnCrossPlatform"] = "WebAuthnCrossPlatform";
+  SecondaryAuthStrategy["SmsCode"] = "SmsCode";
+})(SecondaryAuthStrategy || (SecondaryAuthStrategy = {}));

package/auth/package.json

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

package/auth/secutiry-poilicy/index.js

@@ -0,0 +1,48 @@
+import { Get, Patch, Post } from '../../fetch';
+import { urls } from '../../constants';
+export async function getGlobalSecurityPolicy() {
+  return Get(urls.identity.configurations.v1);
+}
+export async function getMfaPolicy() {
+  return Get(`${urls.identity.configurations.v1}/mfa-policy`);
+}
+export async function getVendorMfaPolicy() {
+  return Get(`${urls.identity.configurations.v1}/mfa-policy/vendor`);
+}
+export async function saveMfaPolicy(body) {
+  if (body.id) {
+    return Patch(`${urls.identity.configurations.v1}/mfa-policy`, body);
+  } else {
+    return Post(`${urls.identity.configurations.v1}/mfa-policy`, body);
+  }
+}
+export async function getLockoutPolicy() {
+  return Get(`${urls.identity.configurations.v1}/lockout-policy`);
+}
+export async function saveLockoutPolicy(body) {
+  if (body.id) {
+    return Patch(`${urls.identity.configurations.v1}/lockout-policy`, body);
+  } else {
+    return Post(`${urls.identity.configurations.v1}/lockout-policy`, body);
+  }
+}
+export async function getCaptchaPolicy() {
+  try {
+    return await Get(`${urls.identity.configurations.v1}/captcha-policy/public`);
+  } catch {
+    return null;
+  }
+}
+export async function getPasswordHistoryPolicy() {
+  return Get(`${urls.identity.configurations.v1}/password-history-policy`);
+}
+export async function savePasswordHistoryPolicy(body) {
+  if (body.id) {
+    return Patch(`${urls.identity.configurations.v1}/password-history-policy`, body);
+  } else {
+    return Post(`${urls.identity.configurations.v1}/password-history-policy`, body);
+  }
+}
+export async function getPasswordConfigPolicy() {
+  return Get(`${urls.identity.configurations.v1}/password`);
+}

package/auth/secutiry-poilicy/interfaces.js

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