@frontegg/rest-api 6.0.1-alpha.4 → 7.28.0-alpha.0

package/directory/interfaces.d.ts

@@ -0,0 +1,30 @@
+export declare enum ScimConnectionSource {
+    FRONTEGG = "frontegg",
+    OKTA = "okta",
+    AZURE_AD = "azure-ad",
+    OTHER = "other"
+}
+export interface Scim2ConnectionConfigResponse {
+    id: string;
+    connectionName: string;
+    source: ScimConnectionSource;
+    syncToUserManagement: boolean;
+    createdAt: Date;
+    lastSync?: Date | null;
+}
+export interface Scim2CreateConnectionConfigRequest {
+    source: ScimConnectionSource;
+    connectionName?: string;
+    syncToUserManagement?: boolean;
+}
+export interface Scim2PatchConnectionConfigRequest {
+    syncToUserManagement?: boolean;
+}
+export interface Scim2CreateConnectionConfigResponse {
+    id: string;
+    connectionName: string;
+    token: string;
+}
+export interface Scim2CountResponse {
+    count: number;
+}

package/directory/interfaces.js

@@ -0,0 +1,7 @@
+export let ScimConnectionSource;
+(function (ScimConnectionSource) {
+  ScimConnectionSource["FRONTEGG"] = "frontegg";
+  ScimConnectionSource["OKTA"] = "okta";
+  ScimConnectionSource["AZURE_AD"] = "azure-ad";
+  ScimConnectionSource["OTHER"] = "other";
+})(ScimConnectionSource || (ScimConnectionSource = {}));

package/directory/package.json

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

package/entitlements/index.d.ts

@@ -0,0 +1,15 @@
+import { UserEntitlementsContext as UserEntitlementsResponseV2 } from '@frontegg/entitlements-javascript-commons';
+import { BaseApiClient } from '../BaseApiClient';
+export declare class EntitlementsApi extends BaseApiClient {
+    constructor(appName: string);
+    /**
+     * Load user entitlements data v2.
+     * Including all user permissions and features data.
+     * Now the final isEntitled response is not part of it, but includes the data needed to calculate it.
+     *
+     * `authorized user`
+     */
+    loadEntitlementsV2: () => Promise<UserEntitlementsResponseV2>;
+}
+declare const _default: EntitlementsApi;
+export default _default;

package/entitlements/index.js

@@ -0,0 +1,20 @@
+import { urls } from '../constants';
+import { BaseApiClient } from '../BaseApiClient';
+export class EntitlementsApi extends BaseApiClient {
+  constructor(appName) {
+    super(appName);
+    this.loadEntitlementsV2 = async () => {
+      return this.get(urls.entitlements.v2);
+    };
+  }
+
+  /**
+   * Load user entitlements data v2.
+   * Including all user permissions and features data.
+   * Now the final isEntitled response is not part of it, but includes the data needed to calculate it.
+   *
+   * `authorized user`
+   */
+}
+
+export default new EntitlementsApi('default');

package/entitlements/interfaces.d.ts

@@ -0,0 +1,13 @@
+export interface Entitlement {
+    isEntitled: boolean;
+    justification?: NotEntitledJustification;
+}
+export declare enum NotEntitledJustification {
+    MISSING_PERMISSION = "MISSING_PERMISSION",
+    MISSING_FEATURE = "MISSING_FEATURE",
+    BUNDLE_EXPIRED = "BUNDLE_EXPIRED"
+}
+/**
+ * entitlements feature flag
+ */
+export declare const ADMIN_PORTAL_ENTITLEMENTS_FF = "admin_portal_entitlements";

package/entitlements/interfaces.js

@@ -0,0 +1,11 @@
+export let NotEntitledJustification;
+
+/**
+ * entitlements feature flag
+ */
+(function (NotEntitledJustification) {
+  NotEntitledJustification["MISSING_PERMISSION"] = "MISSING_PERMISSION";
+  NotEntitledJustification["MISSING_FEATURE"] = "MISSING_FEATURE";
+  NotEntitledJustification["BUNDLE_EXPIRED"] = "BUNDLE_EXPIRED";
+})(NotEntitledJustification || (NotEntitledJustification = {}));
+export const ADMIN_PORTAL_ENTITLEMENTS_FF = 'admin_portal_entitlements';

package/entitlements/package.json

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

package/error.js

@@ -4,9 +4,7 @@ export class FronteggApiError extends Error {
     this._statusCode = void 0;
     this._statusCode = statusCode;
   }
-
   get statusCode() {
     return this._statusCode;
   }
-
 }

package/feature-flags/index.d.ts

@@ -0,0 +1,18 @@
+import { IFeatureFlagsAttributes } from './interfaces';
+import { BaseApiClient } from '../BaseApiClient';
+export declare class FeatureFlags {
+    private _flags;
+    private static _instances;
+    constructor();
+    static getInstance(name?: string): FeatureFlags;
+    static set(featureFlags?: IFeatureFlagsAttributes, name?: string): FeatureFlags;
+    static getFeatureFlags(flags: string[], name: string): boolean[];
+    get flags(): IFeatureFlagsAttributes;
+    set(featureFlags?: IFeatureFlagsAttributes): void;
+}
+export declare class FeatureFlagsApi extends BaseApiClient {
+    constructor(appName: string);
+    loadFeatureFlags: () => Promise<IFeatureFlagsAttributes>;
+}
+declare const _default: FeatureFlagsApi;
+export default _default;

package/feature-flags/index.js

@@ -0,0 +1,44 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { urls } from '../constants';
+import { BaseApiClient } from '../BaseApiClient';
+const defaultFeatureFlags = {
+  flags: {}
+};
+export class FeatureFlags {
+  constructor() {
+    var _defaultFeatureFlags$;
+    this._flags = {};
+    this._flags = (_defaultFeatureFlags$ = defaultFeatureFlags.flags) != null ? _defaultFeatureFlags$ : {};
+  }
+  static getInstance(name = 'default') {
+    return this._instances[name];
+  }
+  static set(featureFlags, name = 'default') {
+    const featureFlagsInstance = new FeatureFlags();
+    featureFlagsInstance.set(featureFlags);
+    FeatureFlags._instances[name] = featureFlagsInstance;
+    return featureFlagsInstance;
+  }
+  static getFeatureFlags(flags, name) {
+    const featureFlagsInstance = this.getInstance(name);
+    return flags.map(flag => (featureFlagsInstance == null ? void 0 : featureFlagsInstance._flags[flag]) === 'on');
+  }
+  get flags() {
+    var _this$flags;
+    return (_this$flags = this.flags) != null ? _this$flags : {};
+  }
+  set(featureFlags) {
+    var _defaultFeatureFlags$2;
+    this._flags = _extends({}, (_defaultFeatureFlags$2 = defaultFeatureFlags == null ? void 0 : defaultFeatureFlags.flags) != null ? _defaultFeatureFlags$2 : {}, featureFlags != null ? featureFlags : {});
+  }
+}
+FeatureFlags._instances = {};
+export class FeatureFlagsApi extends BaseApiClient {
+  constructor(appName) {
+    super(appName);
+    this.loadFeatureFlags = async () => {
+      return this.get(urls.featureFlags.v1);
+    };
+  }
+}
+export default new FeatureFlagsApi('default');

package/feature-flags/interfaces.d.ts

@@ -0,0 +1,5 @@
+export type IFeatureFlagsAttribute = 'on' | 'off';
+export type IFeatureFlagsAttributes = Record<string, IFeatureFlagsAttribute>;
+export type FronteggFeatureFlags = {
+    flags?: IFeatureFlagsAttributes;
+};

package/feature-flags/interfaces.js

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

package/feature-flags/package.json

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

package/groups/enums.d.ts

@@ -0,0 +1,9 @@
+export declare enum GroupRelations {
+    roles = "roles",
+    users = "users",
+    rolesAndUsers = "rolesAndUsers"
+}
+export declare enum GroupManagedByEnum {
+    FRONTEGG = "frontegg",
+    SCIM2 = "scim2"
+}

package/groups/enums.js

@@ -0,0 +1,11 @@
+export let GroupRelations;
+(function (GroupRelations) {
+  GroupRelations["roles"] = "roles";
+  GroupRelations["users"] = "users";
+  GroupRelations["rolesAndUsers"] = "rolesAndUsers";
+})(GroupRelations || (GroupRelations = {}));
+export let GroupManagedByEnum;
+(function (GroupManagedByEnum) {
+  GroupManagedByEnum["FRONTEGG"] = "frontegg";
+  GroupManagedByEnum["SCIM2"] = "scim2";
+})(GroupManagedByEnum || (GroupManagedByEnum = {}));

package/groups/index.d.ts

@@ -0,0 +1,73 @@
+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) => Promise<IGroupResponse>;
+    /**
+     * Get all tenant groups
+     * @param query - Optional query parameters
+     */
+    getGroups: (query?: IGetGroupQueryOptions) => Promise<IGroupResponse[]>;
+    /**
+     * Get groups by ids
+     * @param body - Request body containing group IDs
+     * @param params - Optional query parameters
+     */
+    getGroupsByIds: (body: IGetGroupsByIds, params?: IGetGroupQueryOptions) => 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;

package/groups/index.js

@@ -0,0 +1,62 @@
+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);
+    };
+  }
+
+  /**
+   * Get group by given id
+   * @param groupId - The ID of the group to retrieve
+   * @param query - Optional query parameters
+   */
+}
+
+export default new GroupsApi('default');

package/groups/interfaces.d.ts

@@ -0,0 +1,64 @@
+import { IRole } from '../roles/interfaces';
+import { GroupManagedByEnum, GroupRelations } from './enums';
+export type IGetGroup = {
+    groupId: string;
+};
+export type IGroupUser = {
+    id: string;
+    email: string;
+    name: string;
+    profilePictureUrl: string | null;
+    activatedForTenant?: boolean;
+    createdAt: Date;
+};
+export type IGroupResponse = {
+    id: string;
+    name: string;
+    color?: string;
+    description?: string;
+    metadata?: string;
+    roles?: IRole[];
+    users?: IGroupUser[];
+    managedBy: GroupManagedByEnum;
+};
+export type ICreateGroup = {
+    name: string;
+    color?: string;
+    description?: string;
+    metadata?: string;
+};
+export type ICreateGroupResponse = {
+    id: string;
+    name: string;
+    color?: string;
+    description?: string;
+    metadata?: string;
+    managedBy: GroupManagedByEnum;
+};
+export type IUpdateGroup = {
+    groupId: string;
+    name?: string;
+    color?: string;
+    description?: string;
+    metadata?: string;
+};
+export type IUpdateGroupConfig = {
+    enabled?: boolean;
+    rolesEnabled?: boolean;
+};
+export type IGroupConfigResponse = {
+    enabled: boolean;
+    rolesEnabled: boolean;
+};
+export type IUpdateGroupRoles = {
+    roleIds: string[];
+};
+export type IUpdateGroupUsers = {
+    userIds: string[];
+};
+export type IGetGroupQueryOptions = {
+    _groupsRelations?: GroupRelations;
+};
+export type IGetGroupsByIds = {
+    groupsIds: string[];
+};

package/groups/interfaces.js

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

package/groups/package.json

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

package/impersonate/index.d.ts

@@ -0,0 +1,17 @@
+import { IImpersonate, IImpersonateResponse } from './interfaces';
+import { BaseApiClient } from '../BaseApiClient';
+/**
+ * UsersApi class provides methods for handling user and impersonation-related API requests.
+ */
+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;

package/impersonate/index.js

@@ -0,0 +1,23 @@
+import { urls } from '../constants';
+import { BaseApiClient } from '../BaseApiClient';
+
+/**
+ * UsersApi class provides methods for handling user and impersonation-related API requests.
+ */
+export class ImpersonateApi extends BaseApiClient {
+  constructor(appName) {
+    super(appName);
+    this.impersonate = async body => {
+      return this.post(`${urls.identity.impersonate.v1}`, body);
+    };
+  }
+
+  /**
+   * 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 default new ImpersonateApi('default');

package/impersonate/interfaces.d.ts

@@ -0,0 +1,12 @@
+export type IImpersonate = {
+    impersonatedUserId: string;
+    actorToken: string;
+    redirectUrl?: string;
+};
+export type IImpersonateResponse = {
+    accessToken: string;
+    tokenType: string;
+    refreshToken: string;
+    expiresIn: number;
+    expires: string;
+};

package/impersonate/interfaces.js

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

package/impersonate/package.json

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