@frontegg/rest-api 3.1.75 → 3.1.76-alpha.9502349697

package/node/ContextHolder/index.js

@@ -19,114 +19,219 @@ class ContextHolder {
     this.entitlementsOptions = null;
     this.appName = null;
     this.sessionContext = void 0;
+
+    this.setContext = context => {
+      this.context = context;
+    };
+
+    this.setAccessToken = accessToken => {
+      this.accessToken = accessToken;
+    };
+
+    this.setUser = user => {
+      this.user = user;
+    };
+
+    this.setRequestSource = requestSource => {
+      this.requestSource = requestSource;
+    };
+
+    this.setOnRedirectTo = onRedirectTo => {
+      this.onRedirectTo = onRedirectTo;
+    };
+
+    this.setLogout = logout => {
+      this.logout = logout;
+    };
+
+    this.setEntitlementsOptions = entitlementsOptions => {
+      this.entitlementsOptions = entitlementsOptions;
+    };
+
+    this.setSessionContext = sessionContext => {
+      this.sessionContext = sessionContext;
+    };
+
+    this.setAppName = appName => {
+      this.appName = appName;
+    };
+
+    this.getContext = () => {
+      var _this$context;
+
+      return (_this$context = this.context) != null ? _this$context : {
+        baseUrl: window.location.href,
+        tokenResolver: () => 'my-authentication-token',
+        logLevel: 'error'
+      };
+    };
+
+    this.getAccessToken = () => {
+      return this.accessToken;
+    };
+
+    this.getRequestSource = () => {
+      return this.requestSource;
+    };
+
+    this.getUser = () => {
+      return this.user;
+    };
+
+    this.shouldLoadEntitlements = () => {
+      var _this$entitlementsOpt;
+
+      return ((_this$entitlementsOpt = this.entitlementsOptions) == null ? void 0 : _this$entitlementsOpt.enabled) || false;
+    };
+
+    this.isSessionPerTenantEnabled = () => {
+      var _this$sessionContext;
+
+      return ((_this$sessionContext = this.sessionContext) == null ? void 0 : _this$sessionContext.enableSessionPerTenant) || false;
+    };
+
+    this.getAppName = () => {
+      return this.appName;
+    };
+  }
+
+  static default() {
+    return ContextHolder.getInstance(DEFAULT_APP_NAME);
+  }
+
+  static for(appName) {
+    return ContextHolder.getInstance(appName);
   }
 
-  static getInstance() {
-    if (!ContextHolder.instance) {
-      ContextHolder.instance = new ContextHolder();
+  static getInstance(appName = 'default') {
+    if (!ContextHolder._apps) {
+      ContextHolder._apps = {};
     }
 
-    return ContextHolder.instance;
+    if (ContextHolder._apps[appName]) {
+      return ContextHolder._apps[appName];
+    }
+
+    ContextHolder._apps[appName] = new ContextHolder();
+    return ContextHolder._apps[appName];
   }
 
-  static setContext(context) {
-    ContextHolder.getInstance().context = context;
+  static createInstance(appName = 'default') {
+    ContextHolder._apps[appName] = new ContextHolder();
+    ContextHolder._apps[appName].appName = appName;
+    return ContextHolder._apps[appName];
   }
 
-  static setAccessToken(accessToken) {
-    ContextHolder.getInstance().accessToken = accessToken;
+  static setContext(context, appName = 'default') {
+    ContextHolder.for(appName).context = context;
   }
 
-  static setUser(user) {
-    ContextHolder.getInstance().user = user;
+  static setAccessToken(accessToken, appName = 'default') {
+    ContextHolder.for(appName).accessToken = accessToken;
   }
 
-  static setRequestSource(requestSource) {
-    ContextHolder.getInstance().requestSource = requestSource;
+  static setUser(user, appName = 'default') {
+    ContextHolder.for(appName).user = user;
   }
 
-  static setOnRedirectTo(onRedirectTo) {
-    ContextHolder.getInstance().onRedirectTo = onRedirectTo;
+  static setRequestSource(requestSource, appName = 'default') {
+    ContextHolder.for(appName).requestSource = requestSource;
   }
 
-  static setLogout(logout, logoutUrl) {
-    ContextHolder.getInstance().logout = callback => {
+  static setOnRedirectTo(onRedirectTo, appName = 'default') {
+    ContextHolder.for(appName).onRedirectTo = onRedirectTo;
+  }
+
+  static setLogout(logout, logoutUrl, appName = 'default') {
+    const context = ContextHolder.for(appName);
+
+    context.logout = callback => {
       if (!callback) {
-        ContextHolder.onRedirectTo(logoutUrl);
+        context.onRedirectTo(logoutUrl, undefined);
       } else {
         logout(callback);
       }
     };
   }
 
-  static setEntitlementsOptions(entitlementsOptions) {
-    ContextHolder.getInstance().entitlementsOptions = entitlementsOptions;
+  static setEntitlementsOptions(entitlementsOptions, appName = 'default') {
+    ContextHolder.for(appName).entitlementsOptions = entitlementsOptions;
   }
 
-  static setSessionContext(sessionContext) {
-    const instance = ContextHolder.getInstance();
-    instance.sessionContext = sessionContext;
+  static setSessionContext(sessionContext, appName = 'default') {
+    ContextHolder.for(appName).sessionContext = sessionContext;
   }
 
   static setAppName(appName) {
-    ContextHolder.getInstance().appName = appName;
+    ContextHolder.for(appName).appName = appName;
   }
 
-  static getContext() {
-    var _ContextHolder$getIns;
+  static getContext(appName = 'default') {
+    var _ContextHolder$for$co;
 
-    return (_ContextHolder$getIns = ContextHolder.getInstance().context) != null ? _ContextHolder$getIns : {
+    return (_ContextHolder$for$co = ContextHolder.for(appName).context) != null ? _ContextHolder$for$co : {
       baseUrl: window.location.href,
       tokenResolver: () => 'my-authentication-token',
       logLevel: 'error'
     };
   }
 
-  static getAccessToken() {
-    return ContextHolder.getInstance().accessToken;
+  static getAccessToken(appName = 'default') {
+    return ContextHolder.for(appName).accessToken;
   }
 
-  static getRequestSource() {
-    return ContextHolder.getInstance().requestSource;
+  static getRequestSource(appName = 'default') {
+    return ContextHolder.for(appName).requestSource;
   }
 
-  static getUser() {
-    return ContextHolder.getInstance().user;
+  static getUser(appName = 'default') {
+    return ContextHolder.for(appName).user;
   }
 
-  static onRedirectTo(path, opts) {
-    return ContextHolder.getInstance().onRedirectTo(path, opts);
+  static onRedirectTo(path, opts, appName = 'default') {
+    return ContextHolder.for(appName).onRedirectTo(path, opts);
   }
 
-  static logout(callback) {
-    return ContextHolder.getInstance().logout(callback);
+  static logout(callback, appName = 'default') {
+    return ContextHolder.for(appName).logout(callback);
   }
 
-  static shouldLoadEntitlements() {
-    var _ContextHolder$getIns2;
+  static shouldLoadEntitlements(appName = 'default') {
+    var _ContextHolder$for$en;
 
-    return ((_ContextHolder$getIns2 = ContextHolder.getInstance().entitlementsOptions) == null ? void 0 : _ContextHolder$getIns2.enabled) || false;
+    return ((_ContextHolder$for$en = ContextHolder.for(appName).entitlementsOptions) == null ? void 0 : _ContextHolder$for$en.enabled) || false;
   }
 
-  static isSessionPerTenantEnabled() {
-    var _ContextHolder$getIns3;
+  static isSessionPerTenantEnabled(appName = 'default') {
+    var _ContextHolder$for$se;
 
-    return ((_ContextHolder$getIns3 = ContextHolder.getInstance().sessionContext) == null ? void 0 : _ContextHolder$getIns3.enableSessionPerTenant) || false;
+    return ((_ContextHolder$for$se = ContextHolder.for(appName).sessionContext) == null ? void 0 : _ContextHolder$for$se.enableSessionPerTenant) || false;
   }
 
-  static getAppName() {
-    return ContextHolder.getInstance().appName;
+  static getAppName(appName = 'default') {
+    return ContextHolder.for(appName).appName;
   }
 
 }
 
 exports.ContextHolder = ContextHolder;
-ContextHolder.instance = void 0;
+ContextHolder._apps = void 0;
+const DEFAULT_APP_NAME = 'default';
 const FronteggContext = {
-  getContext: () => ContextHolder.getContext(),
-  getAccessToken: () => ContextHolder.getAccessToken(),
-  getUser: () => ContextHolder.getUser(),
-  onRedirectTo: (path, opts) => ContextHolder.onRedirectTo(path, opts),
-  logout: callback => ContextHolder.logout(callback)
+  getContext: () => ContextHolder.getContext(DEFAULT_APP_NAME),
+  getAccessToken: () => ContextHolder.getAccessToken(DEFAULT_APP_NAME),
+  setAccessToken: accessToken => ContextHolder.setAccessToken(accessToken, DEFAULT_APP_NAME),
+  getUser: () => ContextHolder.getUser(DEFAULT_APP_NAME),
+  setUser: user => ContextHolder.setUser(user, DEFAULT_APP_NAME),
+  onRedirectTo: (path, opts) => ContextHolder.onRedirectTo(path, opts, DEFAULT_APP_NAME),
+  setOnRedirectTo: onRedirectTo => ContextHolder.setOnRedirectTo(onRedirectTo, DEFAULT_APP_NAME),
+  logout: callback => ContextHolder.logout(callback, DEFAULT_APP_NAME),
+  getRequestSource: () => ContextHolder.getRequestSource(DEFAULT_APP_NAME),
+  setRequestSource: requestSource => ContextHolder.setRequestSource(requestSource, DEFAULT_APP_NAME),
+  isSessionPerTenantEnabled: () => ContextHolder.isSessionPerTenantEnabled(DEFAULT_APP_NAME),
+  shouldLoadEntitlements: () => ContextHolder.shouldLoadEntitlements(DEFAULT_APP_NAME),
+  getAppName: () => ContextHolder.getAppName(DEFAULT_APP_NAME),
+  setEntitlementsOptions: entitlementsOptions => ContextHolder.setEntitlementsOptions(entitlementsOptions, DEFAULT_APP_NAME),
+  setSessionContext: sessionContext => ContextHolder.setSessionContext(sessionContext, DEFAULT_APP_NAME)
 };
 exports.FronteggContext = FronteggContext;

package/node/FetchClient.js

@@ -0,0 +1,326 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.FetchClient = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _ContextHolder = require("./ContextHolder");
+
+var _error = require("./error");
+
+var _constants = require("./constants");
+
+var _interfaces = require("./interfaces");
+
+class FetchClient {
+  constructor(appName) {
+    this.appName = void 0;
+
+    this.getFronteggContext = () => {
+      return _ContextHolder.ContextHolder.for(this.appName);
+    };
+
+    this.prepareUrl = async (url, params) => {
+      const context = this.getFronteggContext().getContext();
+      const baseUrl = this.getContextBaseUrl(url);
+      const paramsToSend = await this.buildQueryParams(context, params);
+      let finalUrl = url.startsWith('http') ? url : `${baseUrl}${url}`;
+      const hasKeys = Object.keys(paramsToSend).length > 0;
+
+      if (paramsToSend && hasKeys) {
+        const urlParams = new URLSearchParams(paramsToSend);
+        finalUrl += `?${urlParams}`;
+      }
+
+      return finalUrl;
+    };
+
+    this.buildQueryParams = async (context, params) => {
+      if (!params) {
+        params = {};
+      }
+
+      const additionalQueryParams = await this.getAdditionalQueryParams(context);
+
+      for (const queryParam of additionalQueryParams) {
+        params[queryParam.key] = queryParam.value;
+      }
+
+      const keys = Object.keys(params);
+
+      for (const key of keys) {
+        const value = params[key];
+        params[key] = typeof value === 'object' ? JSON.stringify(value) : value;
+      }
+
+      return params;
+    };
+
+    this.getAdditionalQueryParams = async context => {
+      let output = [];
+
+      if (context.additionalQueryParamsResolver) {
+        output = await context.additionalQueryParamsResolver();
+      }
+
+      return output;
+    };
+
+    this.getAdditionalHeaders = async context => {
+      let output = [];
+
+      if (context.additionalHeadersResolver) {
+        output = await context.additionalHeadersResolver();
+      }
+
+      if (context.tenantResolver) {
+        const resolvedTenantResult = await context.tenantResolver();
+
+        if (!!(resolvedTenantResult != null && resolvedTenantResult.tenant)) {
+          output.push({
+            key: 'frontegg-login-alias',
+            value: resolvedTenantResult.tenant
+          });
+        }
+      }
+
+      if (context.appId) {
+        output.push({
+          key: 'frontegg-requested-application-id',
+          value: context.appId
+        });
+      }
+
+      return output;
+    };
+
+    this.buildRequestHeaders = async contentType => {
+      var _context$tokenResolve;
+
+      const fronteggContext = this.getFronteggContext();
+      const context = fronteggContext.getContext();
+      const headers = FetchClient.getMetadataHeaders(context);
+      const authToken = await ((_context$tokenResolve = context == null ? void 0 : context.tokenResolver) != null ? _context$tokenResolve : fronteggContext.getAccessToken)();
+      const requestSource = fronteggContext.getRequestSource();
+      const scopedTenant = FetchClient.getScopedTenant();
+
+      if (contentType) {
+        headers[_interfaces.fronteggHeaders.contentType] = contentType;
+      }
+
+      if (requestSource) {
+        headers[_interfaces.fronteggHeaders.source] = requestSource;
+      }
+
+      if (authToken) {
+        headers.Authorization = `Bearer ${authToken}`;
+      }
+
+      if (scopedTenant) {
+        headers[_interfaces.fronteggHeaders.scopedTenant] = scopedTenant;
+      }
+
+      for (const additionalHeader of await this.getAdditionalHeaders(context)) {
+        headers[`${additionalHeader.key}`] = `${additionalHeader.value}`;
+      }
+
+      return headers;
+    };
+
+    this.sendRequest = async opts => {
+      var _opts$method, _ref, _opts$credentials;
+
+      const context = this.getFronteggContext().getContext();
+      const headers = await this.buildRequestHeaders(opts.contentType);
+      const url = await this.prepareUrl(opts.url, opts.params);
+      const response = await fetch(url, {
+        body: opts.body ? opts.contentType === 'application/json' ? JSON.stringify(opts.body) : opts.body : null,
+        method: (_opts$method = opts.method) != null ? _opts$method : 'GET',
+        headers: (0, _extends2.default)({}, headers, opts.headers),
+        credentials: (_ref = (_opts$credentials = opts.credentials) != null ? _opts$credentials : context.requestCredentials) != null ? _ref : 'same-origin'
+      });
+
+      if (response.status === 302) {
+        window.location.href = await response.text();
+        return new Promise(() => {});
+      }
+
+      if (!response.ok) {
+        var _context$logLevel, _context$logLevel2;
+
+        if (response.status === 413) {
+          throw new _error.FronteggApiError('Error request is too large', response.status);
+        }
+
+        let errorMessage;
+        let isJsonResponse = true;
+
+        try {
+          errorMessage = await response.text();
+          errorMessage = JSON.parse(errorMessage);
+        } catch (e) {
+          isJsonResponse = false;
+        }
+
+        if (errorMessage.errors) {
+          errorMessage = errorMessage.errors.join(', ');
+        } else if (typeof errorMessage !== 'string') {
+          errorMessage = `Error ${response.status} - ${response.statusText}`;
+        }
+
+        if (response.status >= 400 && response.status < 500 && ['warn'].includes((_context$logLevel = context.logLevel) != null ? _context$logLevel : '')) console.warn(errorMessage);else if (response.status === 500 && ['warn', 'error'].includes((_context$logLevel2 = context.logLevel) != null ? _context$logLevel2 : '')) console.error(errorMessage);
+        throw new _error.FronteggApiError(isJsonResponse ? errorMessage : _constants.GENERIC_ERROR_MESSAGE, response.status);
+      }
+
+      if (!opts.responseType || opts.responseType === 'json') {
+        try {
+          return await response.json();
+        } catch (e) {
+          return {};
+        }
+      } else if (opts.responseType === 'blob') {
+        const {
+          outputFileName
+        } = opts.params;
+        return await response.blob().then(blob => URL.createObjectURL(blob)).then(url => {
+          const tempLink = document.createElement('a');
+          tempLink.href = url;
+          tempLink.setAttribute('download', outputFileName || 'output');
+          tempLink.click();
+        });
+      } else {
+        return await response.text();
+      }
+    };
+
+    this.get = async (url, params, opts) => this.sendRequest((0, _extends2.default)({
+      url,
+      method: 'GET',
+      contentType: 'application/json',
+      params
+    }, opts));
+
+    this.post = async (url, body, opts) => this.sendRequest((0, _extends2.default)({
+      url,
+      method: 'POST',
+      contentType: 'application/json',
+      body
+    }, opts));
+
+    this.patch = async (url, body, opts) => this.sendRequest((0, _extends2.default)({
+      url,
+      method: 'PATCH',
+      contentType: 'application/json',
+      body
+    }, opts));
+
+    this.put = async (url, body, opts) => this.sendRequest((0, _extends2.default)({
+      url,
+      method: 'PUT',
+      contentType: 'application/json',
+      body
+    }, opts));
+
+    this.delete = async (url, body, opts) => this.sendRequest((0, _extends2.default)({
+      url,
+      method: 'DELETE',
+      contentType: 'application/json',
+      body
+    }, opts));
+
+    this.postDownload = async (url, body, params, opts) => this.sendRequest((0, _extends2.default)({
+      url,
+      method: 'POST',
+      contentType: 'application/json',
+      responseType: 'blob',
+      body,
+      params
+    }, opts));
+
+    this.extractHeadersFromOptions = (options = {}) => (0, _extends2.default)({}, options.jwt ? {
+      Authorization: options.jwt
+    } : {});
+
+    this.getBaseUrl = (context, url, withFronteggPrefix = true) => {
+      return FetchClient.getBaseUrl(context, url, withFronteggPrefix);
+    };
+
+    this.getContextBaseUrl = (url, withFronteggPrefix = true) => {
+      const context = this.getFronteggContext().getContext();
+      return this.getBaseUrl(context, url, withFronteggPrefix);
+    };
+
+    this.getMetadataHeaders = context => {
+      return FetchClient.getMetadataHeaders(context);
+    };
+
+    this.getContextMetadataHeaders = () => {
+      const context = this.getFronteggContext().getContext();
+      return FetchClient.getMetadataHeaders(context);
+    };
+
+    this.appName = appName;
+  }
+
+}
+
+exports.FetchClient = FetchClient;
+
+FetchClient.getBaseUrl = (context, url, withFronteggPrefix = true) => {
+  let baseUrl;
+
+  if (typeof context.baseUrl === 'function') {
+    baseUrl = context.baseUrl(url);
+  } else {
+    baseUrl = context.baseUrl;
+  }
+
+  const prefix = context.urlPrefix || 'frontegg';
+  const removePrefix = prefix === 'frontegg' && !withFronteggPrefix;
+
+  if (!baseUrl.endsWith('/')) {
+    baseUrl += '/';
+  }
+
+  if (!baseUrl.endsWith(prefix) && !removePrefix) {
+    baseUrl += prefix;
+  }
+
+  return baseUrl;
+};
+
+FetchClient.getMetadataHeaders = context => {
+  var _context$metadataHead, _context$metadataHead2;
+
+  const headers = {};
+
+  if (context != null && (_context$metadataHead = context.metadataHeaders) != null && _context$metadataHead.fronteggSdkVersion) {
+    headers[_interfaces.fronteggHeaders.fronteggSdkVersion] = context.metadataHeaders.fronteggSdkVersion;
+  }
+
+  if (context != null && (_context$metadataHead2 = context.metadataHeaders) != null && _context$metadataHead2.framework) {
+    headers[_interfaces.fronteggHeaders.frameWork] = context.metadataHeaders.framework;
+  }
+
+  return headers;
+};
+
+FetchClient.getScopedTenant = () => {
+  const urlParams = new URLSearchParams(window.location.search);
+  const scopedTenant = urlParams.get('tenantId');
+
+  if (scopedTenant) {
+    return scopedTenant;
+  }
+
+  return null;
+};
+
+var _default = new FetchClient('default');
+
+exports.default = _default;

package/node/account-settings/index.js

@@ -3,26 +3,37 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getPublicSettings = getPublicSettings;
-exports.getSettings = getSettings;
-exports.updateSettings = updateSettings;
+exports.default = exports.AccountSettingsApi = void 0;
 
 var _constants = require("../constants");
 
-var _fetch = require("../fetch");
+var _BaseApiClient = require("../BaseApiClient");
 
-async function updateSettings(body, options) {
-  return (0, _fetch.Put)(_constants.urls.tenants.accountSettings.v1, body, {
-    headers: (0, _fetch.extractHeadersFromOptions)(options)
-  });
-}
+class AccountSettingsApi extends _BaseApiClient.BaseApiClient {
+  constructor(appName) {
+    super(appName);
+
+    this.updateSettings = async (body, options) => {
+      return this.put(_constants.urls.tenants.accountSettings.v1, body, {
+        headers: this.extractHeadersFromOptions(options)
+      });
+    };
+
+    this.getSettings = async options => {
+      return this.get(_constants.urls.tenants.accountSettings.v1, undefined, {
+        headers: this.extractHeadersFromOptions(options)
+      });
+    };
+
+    this.getPublicSettings = async () => {
+      return this.get(`${_constants.urls.tenants.accountSettings.v1}/public`);
+    };
+  }
 
-async function getSettings(options) {
-  return (0, _fetch.Get)(_constants.urls.tenants.accountSettings.v1, undefined, {
-    headers: (0, _fetch.extractHeadersFromOptions)(options)
-  });
 }
 
-async function getPublicSettings() {
-  return (0, _fetch.Get)(`${_constants.urls.tenants.accountSettings.v1}/public`);
-}
+exports.AccountSettingsApi = AccountSettingsApi;
+
+var _default = new AccountSettingsApi('default');
+
+exports.default = _default;