unleash-server/dist/test/fixtures/fake-access-store.js

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

import { RoleName, RoleType, } from '../../lib/types/index.js';
import FakeRoleStore from './fake-role-store.js';
export class FakeAccessStore {
    constructor(roleStore, config) {
        this.userToRoleMap = new Map();
        this.rolePermissions = new Map();
        this.availablePermissions = [];
        this.fakeRolesStore = roleStore ?? new FakeRoleStore();
        this.availablePermissions = config?.availablePermissions ?? [];
    }
    getProjectUserAndGroupCountsForRole(_roleId) {
        throw new Error('Method not implemented.');
    }
    getAllProjectRolesForUser(_userId, _project) {
        throw new Error('Method not implemented.');
    }
    addAccessToProject(_roles, _groups, _users, _projectId, _createdBy) {
        throw new Error('Method not implemented.');
    }
    addGroupToRole(_groupId, _roleId, _created_by, _projectId) {
        throw new Error('Method not implemented.');
    }
    updateUserProjectRole(_userId, _roleId, _projectId) {
        throw new Error('Method not implemented.');
    }
    removeUserFromRole(_userId, _roleId, _projectId) {
        throw new Error('Method not implemented.');
    }
    wipePermissionsFromRole(_role_id) {
        throw new Error('Method not implemented.');
    }
    unlinkUserRoles(_userId) {
        throw new Error('Method not implemented.');
    }
    getRoleByName(_name) {
        throw new Error('Method not implemented.');
    }
    getProjectUsersForRole(_roleId, _projectId) {
        throw new Error('Method not implemented.');
    }
    getProjectUsers(_projectId) {
        throw new Error('Method not implemented.');
    }
    getProjectRoles() {
        throw new Error('Method not implemented.');
    }
    addEnvironmentPermissionsToRole(_role_id, _permissions) {
        return Promise.resolve(undefined);
    }
    getAvailablePermissions() {
        return Promise.resolve(this.availablePermissions);
    }
    getPermissionsForUser(_userId) {
        return Promise.resolve([]);
    }
    getPermissionsForRole(roleId) {
        const found = this.rolePermissions.get(roleId) ?? [];
        return Promise.resolve(found);
    }
    getRoles() {
        return Promise.resolve([]);
    }
    getRoleWithId(_id) {
        throw new Error('Method not implemented.');
    }
    getRolesForProject(_projectId) {
        throw new Error('Method not implemented.');
    }
    removeRolesForProject(_projectId) {
        throw new Error('Method not implemented.');
    }
    async getRolesForUserId(userId) {
        const roleId = this.userToRoleMap.get(userId);
        const found = roleId === undefined
            ? undefined
            : await this.fakeRolesStore.get(roleId);
        if (found) {
            return Promise.resolve([found]);
        }
        else {
            return Promise.resolve([]);
        }
    }
    getUserIdsForRole(_roleId, _projectId) {
        throw new Error('Method not implemented.');
    }
    getGroupIdsForRole(_roleId, _projectId) {
        throw new Error('Method not implemented.');
    }
    addUserToRole(userId, roleId) {
        this.userToRoleMap.set(userId, roleId);
        return Promise.resolve(undefined);
    }
    addPermissionsToRole(role_id, permissions, environment) {
        this.rolePermissions.set(role_id, (environment
            ? permissions.map((p) => ({ ...p, environment }))
            : permissions));
        return Promise.resolve(undefined);
    }
    removePermissionFromRole(_roleId, _permission, _projectId) {
        throw new Error('Method not implemented.');
    }
    getRootRoleForAllUsers() {
        throw new Error('Method not implemented.');
    }
    delete(_key) {
        return Promise.resolve(undefined);
    }
    deleteAll() {
        return Promise.resolve(undefined);
    }
    destroy() { }
    exists(_key) {
        return Promise.resolve(false);
    }
    get(_key) {
        throw new Error('Not implemented yet');
    }
    getAll() {
        return Promise.resolve([]);
    }
    getRootRoles() {
        return Promise.resolve([]);
    }
    removeRolesOfTypeForUser(_userId, _roleTypes) {
        return Promise.resolve(undefined);
    }
    cloneEnvironmentPermissions(_sourceEnvironment, _destinationEnvironment) {
        return Promise.resolve(undefined);
    }
    clearUserPersonalAccessTokens(_userId) {
        return Promise.resolve(undefined);
    }
    unlinkUserGroups(_userId) {
        return Promise.resolve(undefined);
    }
    clearPublicSignupUserTokens(_userId) {
        return Promise.resolve(undefined);
    }
    getProjectRolesForGroup(_projectId, _groupId) {
        throw new Error('Method not implemented.');
    }
    getProjectRolesForUser(_projectId, _userId) {
        throw new Error('Method not implemented.');
    }
    setProjectRolesForGroup(_projectId, _groupId, _roles, _createdBy) {
        throw new Error('Method not implemented.');
    }
    setProjectRolesForUser(_projectId, _userId, _roles) {
        throw new Error('Method not implemented.');
    }
    removeUserAccess(_projectId, _userId) {
        throw new Error('Method not implemented.');
    }
    removeGroupAccess(_projectId, _groupId) {
        throw new Error('Method not implemented.');
    }
    getUserAccessOverview() {
        throw new Error('Method not implemented.');
    }
    getRootRoleForUser(userId) {
        const roleId = this.userToRoleMap.get(userId);
        if (roleId !== undefined) {
            return Promise.resolve(this.fakeRolesStore.get(roleId));
        }
        else {
            return Promise.resolve({
                id: -1,
                name: RoleName.VIEWER,
                type: RoleType.ROOT,
            });
        }
    }
}
export default FakeAccessStore;
//# sourceMappingURL=fake-access-store.js.map