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

package/fetch.js

@@ -0,0 +1,265 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { ContextHolder } from './ContextHolder';
+import { fronteggHeaders } from './interfaces';
+import { FronteggApiError } from './error';
+import { GENERIC_ERROR_MESSAGE } from './constants';
+export function 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;
+}
+
+async function prepareUrl(context, url, params) {
+  const baseUrl = getBaseUrl(context, url);
+  const paramsToSend = await 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;
+}
+
+export function getMetadataHeaders(context) {
+  var _context$metadataHead, _context$metadataHead2;
+
+  const headers = {};
+
+  if (context != null && (_context$metadataHead = context.metadataHeaders) != null && _context$metadataHead.fronteggSdkVersion) {
+    headers[fronteggHeaders.fronteggSdkVersion] = context.metadataHeaders.fronteggSdkVersion;
+  }
+
+  if (context != null && (_context$metadataHead2 = context.metadataHeaders) != null && _context$metadataHead2.framework) {
+    headers[fronteggHeaders.frameWork] = context.metadataHeaders.framework;
+  }
+
+  return headers;
+}
+export function getScopedTenant() {
+  const urlParams = new URLSearchParams(window.location.search);
+  const scopedTenant = urlParams.get('tenantId');
+
+  if (scopedTenant) {
+    return scopedTenant;
+  }
+
+  return null;
+}
+
+async function buildRequestHeaders(context, contentType) {
+  var _context$tokenResolve;
+
+  const headers = getMetadataHeaders(context);
+  const authToken = await ((_context$tokenResolve = context == null ? void 0 : context.tokenResolver) != null ? _context$tokenResolve : ContextHolder.getAccessToken)();
+  const requestSource = ContextHolder.getRequestSource();
+  const scopedTenant = getScopedTenant();
+
+  if (contentType) {
+    headers[fronteggHeaders.contentType] = contentType;
+  }
+
+  if (requestSource) {
+    headers[fronteggHeaders.source] = requestSource;
+  }
+
+  if (authToken) {
+    headers.Authorization = `Bearer ${authToken}`;
+  }
+
+  if (scopedTenant) {
+    headers[fronteggHeaders.scopedTenant] = scopedTenant;
+  }
+
+  for (const additionalHeader of await getAdditionalHeaders(context)) {
+    headers[`${additionalHeader.key}`] = `${additionalHeader.value}`;
+  }
+
+  return headers;
+}
+
+async function buildQueryParams(context, params) {
+  if (!params) {
+    params = {};
+  }
+
+  const additionalQueryParams = await 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;
+}
+
+async function getAdditionalQueryParams(context) {
+  let output = [];
+
+  if (context.additionalQueryParamsResolver) {
+    output = await context.additionalQueryParamsResolver();
+  }
+
+  return output;
+}
+
+async function getAdditionalHeaders(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;
+}
+
+const sendRequest = async opts => {
+  var _opts$method, _ref, _opts$credentials;
+
+  const context = ContextHolder.getContext();
+  const headers = await buildRequestHeaders(context, opts.contentType);
+  const url = await prepareUrl(context, 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: _extends({}, 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 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 FronteggApiError(isJsonResponse ? errorMessage : 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();
+  }
+};
+
+export const Get = async (url, params, opts) => sendRequest(_extends({
+  url,
+  method: 'GET',
+  contentType: 'application/json',
+  params
+}, opts));
+export const Post = async (url, body, opts) => sendRequest(_extends({
+  url,
+  method: 'POST',
+  contentType: 'application/json',
+  body
+}, opts));
+export const Patch = async (url, body, opts) => sendRequest(_extends({
+  url,
+  method: 'PATCH',
+  contentType: 'application/json',
+  body
+}, opts));
+export const Put = async (url, body, opts) => sendRequest(_extends({
+  url,
+  method: 'PUT',
+  contentType: 'application/json',
+  body
+}, opts));
+export const Delete = async (url, body, opts) => sendRequest(_extends({
+  url,
+  method: 'DELETE',
+  contentType: 'application/json',
+  body
+}, opts));
+export const PostDownload = async (url, body, params, opts) => sendRequest(_extends({
+  url,
+  method: 'POST',
+  contentType: 'application/json',
+  responseType: 'blob',
+  body,
+  params
+}, opts));
+export const extractHeadersFromOptions = (options = {}) => _extends({}, options.jwt ? {
+  Authorization: options.jwt
+} : {});

package/groups/index.d.ts

@@ -1,73 +1,49 @@
-import { ICreateGroup, ICreateGroupResponse, IGetGroup, IGetGroupQueryOptions, IGetGroupsByIds, IGroupConfigResponse, IGroupResponse, IUpdateGroup, IUpdateGroupConfig, IUpdateGroupRoles, IUpdateGroupUsers } from './interfaces';
-import { BaseApiClient } from '../BaseApiClient';
-export declare class GroupsApi extends BaseApiClient {
-    constructor(appName: string);
-    /**
-     * Get group by given id
-     * @param groupId - The ID of the group to retrieve
-     * @param query - Optional query parameters
-     */
-    getGroupById: ({ groupId }: IGetGroup, query?: IGetGroupQueryOptions | undefined) => Promise<IGroupResponse>;
-    /**
-     * Get all tenant groups
-     * @param query - Optional query parameters
-     */
-    getGroups: (query?: IGetGroupQueryOptions | undefined) => Promise<IGroupResponse[]>;
-    /**
-     * Get groups by ids
-     * @param body - Request body containing group IDs
-     * @param params - Optional query parameters
-     */
-    getGroupsByIds: (body: IGetGroupsByIds, params?: IGetGroupQueryOptions | undefined) => Promise<IGroupResponse[]>;
-    /**
-     * Create new group
-     * @param body - Request body to create a group
-     */
-    createGroup: (body: ICreateGroup) => Promise<ICreateGroupResponse>;
-    /**
-     * Update existing group by Id
-     * @param groupId - The ID of the group to update
-     * @param body - Request body containing update data
-     */
-    updateGroup: ({ groupId, ...body }: IUpdateGroup) => Promise<void>;
-    /**
-     * Delete existing group by Id
-     * @param groupId - The ID of the group to delete
-     */
-    deleteGroup: (groupId: string) => Promise<void>;
-    /**
-     * Add roles to existing group
-     * @param groupId - The ID of the group
-     * @param body - Request body containing roles to add
-     */
-    addRolesToGroup: (groupId: string, body: IUpdateGroupRoles) => Promise<void>;
-    /**
-     * Delete roles from existing group
-     * @param groupId - The ID of the group
-     * @param body - Request body containing roles to delete
-     */
-    deleteRolesFromGroup: (groupId: string, body: IUpdateGroupRoles) => Promise<void>;
-    /**
-     * Add users to existing group
-     * @param groupId - The ID of the group
-     * @param body - Request body containing users to add
-     */
-    addUsersToGroup: (groupId: string, body: IUpdateGroupUsers) => Promise<void>;
-    /**
-     * Delete users from existing group
-     * @param groupId - The ID of the group
-     * @param body - Request body containing users to delete
-     */
-    deleteUsersFromGroup: (groupId: string, body: IUpdateGroupUsers) => Promise<void>;
-    /**
-     * Get or create default groups configuration
-     */
-    getGroupConfiguration: () => Promise<IGroupConfigResponse>;
-    /**
-     * Create or update groups configuration
-     * @param body - Request body to update group configuration
-     */
-    updateGroupConfiguration: (body: IUpdateGroupConfig) => Promise<IGroupConfigResponse>;
-}
-declare const _default: GroupsApi;
-export default _default;
+import { ICreateGroup, ICreateGroupResponse, IGetGroup, IGetGroupQueryOptions, IGetGroupsByIds, IGroupConfigResponse, IGroupResponse, IUpdateGroup, IUpdateGroupConfig, IUpdateGroupRoles, IUpdateGroupUsers } from "./interfaces";
+/**
+ * Get group by given id
+ */
+export declare function getGroupById({ groupId }: IGetGroup, query?: IGetGroupQueryOptions): Promise<IGroupResponse>;
+/**
+ * Get all tenant groups
+ */
+export declare function getGroups(query?: IGetGroupQueryOptions): Promise<IGroupResponse[]>;
+/**
+ * Get groups by ids
+ */
+export declare function getGroupsByIds(body: IGetGroupsByIds, params?: IGetGroupQueryOptions): Promise<IGroupResponse[]>;
+/**
+ * Create new group
+ */
+export declare function createGroup(body: ICreateGroup): Promise<ICreateGroupResponse>;
+/**
+ * Update existing group by Id
+ */
+export declare function updateGroup({ groupId, ...body }: IUpdateGroup): Promise<void>;
+/**
+ * Delete existing group by Id
+ */
+export declare function deleteGroup(groupId: string): Promise<void>;
+/**
+ * Add roles to existing group
+ */
+export declare function addRolesToGroup(groupId: string, body: IUpdateGroupRoles): Promise<void>;
+/**
+ * Delete roles from existing group
+ */
+export declare function deleteRolesFromGroup(groupId: string, body: IUpdateGroupRoles): Promise<void>;
+/**
+ * Add users to existing group
+ */
+export declare function addUsersToGroup(groupId: string, body: IUpdateGroupUsers): Promise<void>;
+/**
+ * Delete users from existing group
+ */
+export declare function deleteUsersFromGroup(groupId: string, body: IUpdateGroupUsers): Promise<void>;
+/**
+ * Get or create default groups configuration
+ */
+export declare function getGroupConfiguration(): Promise<IGroupConfigResponse>;
+/**
+ * Create or update groups configuration
+ */
+export declare function updateGroupConfiguration(body: IUpdateGroupConfig): Promise<IGroupConfigResponse>;

package/groups/index.js

@@ -1,69 +1,50 @@
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 import _extends from "@babel/runtime/helpers/esm/extends";
 const _excluded = ["groupId"];
-import { urls } from '../constants';
-import { BaseApiClient } from '../BaseApiClient';
-export class GroupsApi extends BaseApiClient {
-  constructor(appName) {
-    super(appName);
-
-    this.getGroupById = async ({
-      groupId
-    }, query) => {
-      return this.get(`${urls.identity.groups.v1}/${groupId}`, _extends({}, query));
-    };
-
-    this.getGroups = async query => {
-      return this.get(`${urls.identity.groups.v1}`, _extends({}, query));
-    };
-
-    this.getGroupsByIds = async (body, params) => {
-      return this.post(`${urls.identity.groups.getByIds.v1}`, body, {
-        params
-      });
-    };
-
-    this.createGroup = async body => {
-      return this.post(`${urls.identity.groups.v1}`, body);
-    };
-
-    this.updateGroup = async _ref => {
-      let {
-        groupId
-      } = _ref,
-          body = _objectWithoutPropertiesLoose(_ref, _excluded);
-
-      return this.patch(`${urls.identity.groups.v1}/${groupId}`, body);
-    };
-
-    this.deleteGroup = async groupId => {
-      return this.delete(`${urls.identity.groups.v1}/${groupId}`);
-    };
-
-    this.addRolesToGroup = async (groupId, body) => {
-      return this.post(`${urls.identity.groups.v1}/${groupId}/roles`, body);
-    };
-
-    this.deleteRolesFromGroup = async (groupId, body) => {
-      return this.delete(`${urls.identity.groups.v1}/${groupId}/roles`, body);
-    };
-
-    this.addUsersToGroup = async (groupId, body) => {
-      return this.post(`${urls.identity.groups.v1}/${groupId}/users`, body);
-    };
-
-    this.deleteUsersFromGroup = async (groupId, body) => {
-      return this.delete(`${urls.identity.groups.v1}/${groupId}/users`, body);
-    };
-
-    this.getGroupConfiguration = async () => {
-      return this.get(`${urls.identity.groups.configurations.v1}`);
-    };
-
-    this.updateGroupConfiguration = async body => {
-      return this.post(`${urls.identity.groups.configurations.v1}`, body);
-    };
-  }
+import { urls } from "../constants";
+import { Delete, Get, Patch, Post } from "../fetch";
+export async function getGroupById({
+  groupId
+}, query) {
+  return Get(`${urls.identity.groups.v1}/${groupId}`, _extends({}, query));
+}
+export async function getGroups(query) {
+  return Get(`${urls.identity.groups.v1}`, _extends({}, query));
+}
+export async function getGroupsByIds(body, params) {
+  return Post(`${urls.identity.groups.getByIds.v1}`, body, {
+    params
+  });
+}
+export async function createGroup(body) {
+  return Post(`${urls.identity.groups.v1}`, body);
+}
+export async function updateGroup(_ref) {
+  let {
+    groupId
+  } = _ref,
+      body = _objectWithoutPropertiesLoose(_ref, _excluded);
 
+  return Patch(`${urls.identity.groups.v1}/${groupId}`, body);
+}
+export async function deleteGroup(groupId) {
+  return Delete(`${urls.identity.groups.v1}/${groupId}`);
+}
+export async function addRolesToGroup(groupId, body) {
+  return Post(`${urls.identity.groups.v1}/${groupId}/roles`, body);
+}
+export async function deleteRolesFromGroup(groupId, body) {
+  return Delete(`${urls.identity.groups.v1}/${groupId}/roles`, body);
+}
+export async function addUsersToGroup(groupId, body) {
+  return Post(`${urls.identity.groups.v1}/${groupId}/users`, body);
+}
+export async function deleteUsersFromGroup(groupId, body) {
+  return Delete(`${urls.identity.groups.v1}/${groupId}/users`, body);
+}
+export async function getGroupConfiguration() {
+  return Get(`${urls.identity.groups.configurations.v1}`);
 }
-export default new GroupsApi('default');
+export async function updateGroupConfiguration(body) {
+  return Post(`${urls.identity.groups.configurations.v1}`, body);
+}

package/impersonate/index.d.ts

@@ -1,17 +1,8 @@
-import { IImpersonate, IImpersonateResponse } from './interfaces';
-import { BaseApiClient } from '../BaseApiClient';
+import { IImpersonate, IImpersonateResponse } from "./interfaces";
 /**
- * UsersApi class provides methods for handling user and impersonation-related API requests.
+ * impersonating user should be called after creating actor token that contains information about impersonation.
+ * ``impersonate`` should contain impersonated user info (userId, tenantId, and vendorId) and the actor token that was created for him to perform impersonation.
+ *
+ * @throws exception if impersonation failed
  */
-export declare class ImpersonateApi extends BaseApiClient {
-    constructor(appName: string);
-    /**
-     * Impersonating user should be called after creating actor token that contains information about impersonation.
-     * `impersonate` should contain impersonated user info (userId, tenantId, and vendorId) and the actor token that was created for him to perform impersonation.
-     *
-     * @throws exception if impersonation failed
-     */
-    impersonate: (body: IImpersonate) => Promise<IImpersonateResponse>;
-}
-declare const _default: ImpersonateApi;
-export default _default;
+export declare function impersonate(body: IImpersonate): Promise<IImpersonateResponse>;

package/impersonate/index.js

@@ -1,13 +1,5 @@
-import { urls } from '../constants';
-import { BaseApiClient } from '../BaseApiClient';
-export class ImpersonateApi extends BaseApiClient {
-  constructor(appName) {
-    super(appName);
-
-    this.impersonate = async body => {
-      return this.post(`${urls.identity.impersonate.v1}`, body);
-    };
-  }
-
-}
-export default new ImpersonateApi('default');
+import { urls } from "../constants";
+import { Post } from "../fetch";
+export async function impersonate(body) {
+  return Post(`${urls.identity.impersonate.v1}`, body);
+}