unleash-server/dist/lib/services/access-service.d.ts

Unleash is an enterprise ready feature toggles service. It provides different strategies for handling feature toggles.

import User, { IProjectUser, IUser } from '../types/user';
import { IAccessInfo, IRole, IRoleWithPermissions, IRoleWithProject, IUserPermission, IUserRole } from '../types/stores/access-store';
import { IUnleashStores } from '../types/stores';
import { IAvailablePermissions, ICustomRole, IPermission, IRoleData, IUserWithRole, RoleName } from '../types/model';
import { IGroupModelWithProjectRole } from '../types/group';
import { GroupService } from './group-service';
interface IRoleCreation {
    name: string;
    description: string;
    permissions?: IPermission[];
}
export interface IRoleValidation {
    name: string;
    description?: string;
    permissions?: Pick<IPermission, 'id' | 'environment'>[];
}
interface IRoleUpdate {
    id: number;
    name: string;
    description: string;
    permissions?: IPermission[];
}
export declare class AccessService {
    private store;
    private userStore;
    private roleStore;
    private groupService;
    private environmentStore;
    private logger;
    constructor({ accessStore, userStore, roleStore, environmentStore, }: Pick<IUnleashStores, 'accessStore' | 'userStore' | 'roleStore' | 'environmentStore'>, { getLogger }: {
        getLogger: Function;
    }, groupService: GroupService);
    /**
     * Used to check if a user has access to the requested resource
     *
     * @param user
     * @param permission
     * @param projectId
     */
    hasPermission(user: User, permission: string, projectId?: string, environment?: string): Promise<boolean>;
    getPermissionsForUser(user: IUser): Promise<IUserPermission[]>;
    getPermissions(): Promise<IAvailablePermissions>;
    addUserToRole(userId: number, roleId: number, projectId: string): Promise<void>;
    addGroupToRole(groupId: number, roleId: number, createdBy: string, projectId: string): Promise<void>;
    addAccessToProject(users: IAccessInfo[], groups: IAccessInfo[], projectId: string, roleId: number, createdBy: string): Promise<void>;
    getRoleByName(roleName: string): Promise<IRole>;
    setUserRootRole(userId: number, role: number | RoleName): Promise<void>;
    getUserRootRoles(userId: number): Promise<IRoleWithProject[]>;
    removeUserFromRole(userId: number, roleId: number, projectId: string): Promise<void>;
    removeGroupFromRole(groupId: number, roleId: number, projectId: string): Promise<void>;
    updateUserProjectRole(userId: number, roleId: number, projectId: string): Promise<void>;
    updateGroupProjectRole(userId: number, roleId: number, projectId: string): Promise<void>;
    addPermissionToRole(roleId: number, permission: string, environment?: string): Promise<void>;
    removePermissionFromRole(roleId: number, permission: string, environment?: string): Promise<void>;
    getRoles(): Promise<IRole[]>;
    getRole(id: number): Promise<IRoleWithPermissions>;
    getRoleData(roleId: number): Promise<IRoleData>;
    getProjectRoles(): Promise<IRole[]>;
    getRolesForProject(projectId: string): Promise<IRole[]>;
    getRolesForUser(userId: number): Promise<IRole[]>;
    wipeUserPermissions(userId: number): Promise<void[]>;
    getUsersForRole(roleId: number): Promise<IUser[]>;
    getProjectUsersForRole(roleId: number, projectId?: string): Promise<IProjectUser[]>;
    getProjectRoleAccess(projectId: string): Promise<[IRole[], IUserWithRole[], IGroupModelWithProjectRole[]]>;
    createDefaultProjectRoles(owner: IUser, projectId: string): Promise<void>;
    removeDefaultProjectRoles(owner: User, projectId: string): Promise<void>;
    getRootRoleForAllUsers(): Promise<IUserRole[]>;
    getRootRoles(): Promise<IRole[]>;
    resolveRootRole(rootRole: number | RoleName): Promise<IRole>;
    getRootRole(roleName: RoleName): Promise<IRole>;
    getAllRoles(): Promise<ICustomRole[]>;
    createRole(role: IRoleCreation): Promise<ICustomRole>;
    updateRole(role: IRoleUpdate): Promise<ICustomRole>;
    deleteRole(id: number): Promise<void>;
    validateRoleIsUnique(roleName: string, existingId?: number): Promise<void>;
    validateRoleIsNotBuiltIn(roleId: number): Promise<void>;
    validateRole(role: IRoleValidation, existingId?: number): Promise<IRoleCreation>;
    isChangeRequestsEnabled(project: string, environment: string): Promise<boolean>;
}
export {};