@frontegg/rest-api 3.1.78 → 3.1.79-alpha.10029056154

package/BaseApiClient.d.ts

@@ -0,0 +1,16 @@
+import { FetchClient } from './FetchClient';
+import { RequestOptions, UserJwtOptions } from './interfaces';
+export declare class BaseApiClient {
+    protected appName: string;
+    protected fetchClient: FetchClient;
+    protected constructor(appName: string);
+    protected get: <T>(url: string, params?: any, opts?: Pick<RequestOptions, "body" | "params" | "contentType" | "responseType" | "headers" | "credentials"> | undefined) => Promise<T>;
+    protected post: <T>(url: string, body?: any, opts?: Pick<RequestOptions, "body" | "params" | "contentType" | "responseType" | "headers" | "credentials"> | undefined) => Promise<T>;
+    protected patch: <T>(url: string, body?: any, opts?: Pick<RequestOptions, "body" | "params" | "contentType" | "responseType" | "headers" | "credentials"> | undefined) => Promise<T>;
+    protected put: <T>(url: string, body?: any, opts?: Pick<RequestOptions, "body" | "params" | "contentType" | "responseType" | "headers" | "credentials"> | undefined) => Promise<T>;
+    protected delete: <T>(url: string, body?: any, opts?: Pick<RequestOptions, "body" | "params" | "contentType" | "responseType" | "headers" | "credentials"> | undefined) => Promise<T>;
+    protected postDownload: <T>(url: string, body?: any, params?: any, opts?: Pick<RequestOptions, "body" | "params" | "contentType" | "responseType" | "headers" | "credentials"> | undefined) => Promise<T>;
+    protected extractHeadersFromOptions: (options?: UserJwtOptions) => {
+        Authorization?: string;
+    };
+}

package/BaseApiClient.js

@@ -0,0 +1,39 @@
+import { FetchClient } from './FetchClient';
+export class BaseApiClient {
+  constructor(appName) {
+    this.appName = void 0;
+    this.fetchClient = void 0;
+
+    this.get = async (url, params, opts) => {
+      return this.fetchClient.get(url, params, opts);
+    };
+
+    this.post = async (url, body, opts) => {
+      return this.fetchClient.post(url, body, opts);
+    };
+
+    this.patch = async (url, body, opts) => {
+      return this.fetchClient.patch(url, body, opts);
+    };
+
+    this.put = async (url, body, opts) => {
+      return this.fetchClient.put(url, body, opts);
+    };
+
+    this.delete = async (url, body, opts) => {
+      return this.fetchClient.delete(url, body, opts);
+    };
+
+    this.postDownload = async (url, body, params, opts) => {
+      return this.fetchClient.postDownload(url, body, params, opts);
+    };
+
+    this.extractHeadersFromOptions = (options = {}) => {
+      return this.fetchClient.extractHeadersFromOptions(options);
+    };
+
+    this.appName = appName;
+    this.fetchClient = new FetchClient(appName);
+  }
+
+}

package/ContextHolder/index.d.ts

@@ -1,5 +1,5 @@
 import { SessionContext, ContextOptions, RedirectOptions, RequestSource } from '../interfaces';
-import { IUserProfile } from "../users/interfaces";
+import { IUserProfile } from '../users/interfaces';
 /**
  * Entitlements config from frontegg provider
  */
@@ -7,63 +7,154 @@ export interface EntitlementsOptions {
     enabled?: boolean;
 }
 export declare class ContextHolder {
-    private static instance;
+    private static _apps;
     private context;
     private accessToken;
     private user;
     private requestSource;
-    private onRedirectTo;
-    private logout;
+    onRedirectTo: (path: string, opts?: RedirectOptions) => void;
+    logout: (callback?: () => void) => void;
     private entitlementsOptions;
     private appName;
     private sessionContext?;
     private basename;
     private constructor();
-    static getInstance(): ContextHolder;
-    static setContext(context: ContextOptions): void;
-    static setAccessToken(accessToken: string | null): void;
-    static setUser(user: IUserProfile | null): void;
-    static setBasename(basename: string | null): void;
-    static setRequestSource(requestSource: RequestSource | null): void;
-    static setOnRedirectTo(onRedirectTo: (path: string, opts?: RedirectOptions) => void): void;
-    static setLogout(logout: (callback?: () => void) => void, logoutUrl: string): void;
+    static default(): ContextHolder;
+    static for(appName: string): ContextHolder;
+    /**
+     * @deprecated - use ContextHolder.for(appName) / ContextHolder.default()  instead
+     * @param appName
+     */
+    static getInstance(appName?: string): ContextHolder;
+    static createInstance(appName?: string): ContextHolder;
+    /**
+     * @deprecated - use ContextHolder.for(appName).setContext instead
+     */
+    static setContext(context: ContextOptions, appName?: string): void;
+    setContext: (context: ContextOptions) => void;
+    /**
+     * @deprecated - use ContextHolder.for(appName).setAccessToken instead
+     */
+    static setAccessToken(accessToken: string | null, appName?: string): void;
+    setAccessToken: (accessToken: string | null) => void;
+    /**
+     * @deprecated - use ContextHolder.for(appName).setUser instead
+     */
+    static setUser(user: IUserProfile | null, appName?: string): void;
+    setUser: (user: IUserProfile | null) => void;
+    /**
+     * @deprecated - use ContextHolder.for(appName).setRequestSource instead
+     */
+    static setRequestSource(requestSource: RequestSource | null, appName?: string): void;
+    setRequestSource: (requestSource: RequestSource | null) => void;
+    /**
+     * @deprecated - use ContextHolder.for(appName).setOnRedirectTo instead
+     */
+    static setOnRedirectTo(onRedirectTo: (path: string, opts?: RedirectOptions) => void, appName?: string): void;
+    setOnRedirectTo: (onRedirectTo: (path: string, opts?: RedirectOptions | undefined) => void) => void;
+    /**
+     * @deprecated - use ContextHolder.for(appName).setLogout instead
+     */
+    static setLogout(logout: (callback?: () => void) => void, logoutUrl: string, appName?: string): void;
+    setLogout: (logout: (callback?: (() => void) | undefined) => void) => void;
     /**
      * App name should also be set for entitlements
+     * @deprecated - use ContextHolder.for(appName).setEntitlementsOptions instead
      * @param entitlementsOptions frontegg options entitlements config
+     * @param appName - app name
      */
-    static setEntitlementsOptions(entitlementsOptions: EntitlementsOptions): void;
+    static setEntitlementsOptions(entitlementsOptions: EntitlementsOptions, appName?: string): void;
+    setEntitlementsOptions: (entitlementsOptions: EntitlementsOptions) => void;
     /**
+     * @deprecated - use ContextHolder.for(appName).setSessionContext instead
      * @param sessionContext frontegg options SessionContext config
+     * @param appName - app name
+     */
+    static setSessionContext(sessionContext: SessionContext, appName?: string): void;
+    setSessionContext: (sessionContext: SessionContext) => void;
+    /**
+     * @deprecated - use ContextHolder.for(appName).setAppName instead
+     */
+    static setAppName(appName: string): void;
+    setAppName: (appName: string) => void;
+    /**
+     * @deprecated - use ContextHolder.for(appName).getContext instead
      */
-    static setSessionContext(sessionContext: SessionContext): void;
+    static getContext(appName?: string): ContextOptions;
+    getContext: () => ContextOptions;
+    /**
+     * @deprecated - use ContextHolder.for(appName).getAccessToken instead
+     */
+    static getAccessToken(appName?: string): string | null;
+    getAccessToken: () => string | null;
+    /**
+     * @deprecated - use ContextHolder.for(appName).requestSource instead
+     */
+    static getRequestSource(appName?: string): RequestSource | null;
+    getRequestSource: () => RequestSource | null;
+    /**
+     * @deprecated - use ContextHolder.for(appName).getBasename instead
+     */
+    static getBasename(appName?: string): string | null;
+    getBasename(): string | null;
+    /**
+     * @deprecated - use ContextHolder.for(appName).setBasename instead
+     */
+    static setBasename(basename: string | null, appName?: string): void;
+    setBasename(basename: string | null): void;
     /**
-     * @param appName for feature flags e.g.
+     * @deprecated - use ContextHolder.for(appName).getUser instead
      */
-    static setAppName(appName: string | null): void;
-    static getContext(): ContextOptions;
-    static getAccessToken(): string | null;
-    static getRequestSource(): RequestSource | null;
-    static getUser(): IUserProfile | null;
-    static getBasename(): string | null;
-    static onRedirectTo(path: string, opts?: RedirectOptions): void;
-    static logout(callback?: () => void): void;
+    static getUser(appName?: string): IUserProfile | null;
+    getUser: () => IUserProfile | null;
     /**
+     * @deprecated - use ContextHolder.for(appName).onRedirectTo instead
+     */
+    static onRedirectTo(path: string, opts?: RedirectOptions, appName?: string): void;
+    /**
+     * @deprecated - use ContextHolder.for(appName).logout instead
+     */
+    static logout(callback?: () => void, appName?: string): void;
+    /**
+     * @deprecated - use ContextHolder.for(appName).shouldLoadEntitlements instead
      * @returns shouldLoadEntitlements. Default to false.
      */
-    static shouldLoadEntitlements(): boolean;
+    static shouldLoadEntitlements(appName?: string): boolean;
+    shouldLoadEntitlements: () => boolean;
     /**
-   * @returns isSessionPerTenantEnabled. Default to false.
-   */
-    static isSessionPerTenantEnabled(): boolean;
+     * @deprecated - use ContextHolder.for(appName).isSessionPerTenantEnabled instead
+     * @returns isSessionPerTenantEnabled. Default to false.
+     */
+    static isSessionPerTenantEnabled(appName?: string): boolean;
+    isSessionPerTenantEnabled: () => boolean;
     /**
+     * @deprecated - use ContextHolder.for(appName).getAppName instead
      * @returns app name value
      */
-    static getAppName(): string | null;
+    static getAppName(appName?: string): string | null;
+    getAppName: () => string | null;
 }
+/**
+ * Frontegg context to be used in the application
+ *
+ * @deprecated use ContextHolder.for instead
+ */
 export declare const FronteggContext: {
     getContext: () => ContextOptions;
     getAccessToken: () => string | null;
+    setAccessToken: (accessToken: string | null) => void;
     getUser: () => IUserProfile | null;
-    onRedirectTo: (path: string, opts: RedirectOptions) => void;
+    setUser: (user: IUserProfile | null) => void;
+    onRedirectTo: (path: string, opts?: RedirectOptions | undefined) => void;
+    setOnRedirectTo: (onRedirectTo: (path: string, opts?: RedirectOptions | undefined) => void) => void;
     logout: (callback?: (() => void) | undefined) => void;
+    getRequestSource: () => RequestSource | null;
+    setRequestSource: (requestSource: RequestSource | null) => void;
+    isSessionPerTenantEnabled: () => boolean;
+    shouldLoadEntitlements: () => boolean;
+    getAppName: () => string | null;
+    setEntitlementsOptions: (entitlementsOptions: EntitlementsOptions) => void;
+    setSessionContext: (sessionContext: SessionContext) => void;
+    getBasename: () => string | null;
+    setBasename: (basename: string | null) => void;
 };

package/ContextHolder/index.js

@@ -13,119 +13,234 @@ export class ContextHolder {
     this.appName = null;
     this.sessionContext = void 0;
     this.basename = null;
+
+    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_APP_NAME) {
+    ContextHolder.for(appName).accessToken = accessToken;
   }
 
-  static setBasename(basename) {
-    ContextHolder.getInstance().basename = basename;
+  static setUser(user, appName = 'default') {
+    ContextHolder.for(appName).user = user;
   }
 
-  static setRequestSource(requestSource) {
-    ContextHolder.getInstance().requestSource = requestSource;
+  static setRequestSource(requestSource, appName = 'default') {
+    ContextHolder.for(appName).requestSource = requestSource;
   }
 
-  static setOnRedirectTo(onRedirectTo) {
-    ContextHolder.getInstance().onRedirectTo = onRedirectTo;
+  static setOnRedirectTo(onRedirectTo, appName = 'default') {
+    ContextHolder.for(appName).onRedirectTo = onRedirectTo;
   }
 
-  static setLogout(logout, logoutUrl) {
-    ContextHolder.getInstance().logout = callback => {
+  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(appName = 'default') {
+    return ContextHolder.for(appName).requestSource;
+  }
+
+  static getBasename(appName = 'default') {
+    return ContextHolder.for(appName).basename;
+  }
+
+  getBasename() {
+    return this.basename;
   }
 
-  static getRequestSource() {
-    return ContextHolder.getInstance().requestSource;
+  static setBasename(basename, appName = DEFAULT_APP_NAME) {
+    ContextHolder.for(appName).basename = basename;
   }
 
-  static getUser() {
-    return ContextHolder.getInstance().user;
+  setBasename(basename) {
+    this.basename = basename;
   }
 
-  static getBasename() {
-    return ContextHolder.getInstance().basename;
+  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;
   }
 
 }
-ContextHolder.instance = void 0;
+ContextHolder._apps = void 0;
+const DEFAULT_APP_NAME = 'default';
 export 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),
+  getBasename: () => ContextHolder.getBasename(DEFAULT_APP_NAME),
+  setBasename: basename => ContextHolder.setBasename(basename, DEFAULT_APP_NAME)
 };

package/FetchClient.d.ts

@@ -0,0 +1,42 @@
+import { ContextOptions, RequestOptions, UserJwtOptions } from './interfaces';
+/**
+ * FetchClient is a class that wrap around the fetch API to make requests.
+ * It is used by the BaseApiClient to make requests to the server
+ */
+export declare class FetchClient {
+    private appName;
+    constructor(appName: string);
+    private getFronteggContext;
+    private prepareUrl;
+    private buildQueryParams;
+    private getAdditionalQueryParams;
+    private getAdditionalHeaders;
+    private buildRequestHeaders;
+    sendRequest: (opts: RequestOptions) => Promise<any>;
+    get: (url: string, params?: any, opts?: Pick<RequestOptions, "body" | "params" | "contentType" | "responseType" | "headers" | "credentials"> | undefined) => Promise<any>;
+    post: (url: string, body?: any, opts?: Pick<RequestOptions, "body" | "params" | "contentType" | "responseType" | "headers" | "credentials"> | undefined) => Promise<any>;
+    patch: (url: string, body?: any, opts?: Pick<RequestOptions, "body" | "params" | "contentType" | "responseType" | "headers" | "credentials"> | undefined) => Promise<any>;
+    put: (url: string, body?: any, opts?: Pick<RequestOptions, "body" | "params" | "contentType" | "responseType" | "headers" | "credentials"> | undefined) => Promise<any>;
+    delete: (url: string, body?: any, opts?: Pick<RequestOptions, "body" | "params" | "contentType" | "responseType" | "headers" | "credentials"> | undefined) => Promise<any>;
+    postDownload: (url: string, body?: any, params?: any, opts?: any) => Promise<any>;
+    extractHeadersFromOptions: (options?: UserJwtOptions) => {
+        Authorization?: string;
+    };
+    /** @deprecated use getContextBaseUrl instead */
+    static getBaseUrl: (context: ContextOptions, url: string, withFronteggPrefix?: boolean) => string;
+    /** @deprecated use getContextBaseUrl instead */
+    getBaseUrl: (context: ContextOptions, url: string, withFronteggPrefix?: boolean) => string;
+    getContextBaseUrl: (url: string, withFronteggPrefix?: boolean) => string;
+    static getMetadataHeaders: (context: ContextOptions) => Record<string, string>;
+    /** @deprecated - use getContextMetadataHeaders instead */
+    getMetadataHeaders: (context: ContextOptions) => Record<string, string>;
+    getContextMetadataHeaders: () => Record<string, string>;
+    static getScopedTenant: () => string | null;
+}
+declare const _default: FetchClient;
+/**
+ * import FetchClient and use it to make requests to the server for specific application
+ * @param appName - the application name to make requests for
+ * @deprecated - use FetchClient directly
+ */
+export default _default;