BC-7971 - introduce room members module

apps/server/src/migrations/mikro-orm/Migration202410041210124.ts

@@ -0,0 +1,29 @@
+import { Migration } from '@mikro-orm/migrations-mongodb';
+
+export class Migration202410041210124 extends Migration {
+	async up(): Promise<void> {
+		// Add ROOM_VIEWER role
+		await this.getCollection('roles').insertOne({
+			name: 'room_viewer',
+			permissions: ['ROOM_VIEW'],
+		});
+		console.info('Added ROOM_VIEWER role with ROOM_VIEW permission');
+
+		// Add ROOM_EDITOR role
+		await this.getCollection('roles').insertOne({
+			name: 'room_editor',
+			permissions: ['ROOM_VIEW', 'ROOM_EDIT'],
+		});
+		console.info('Added ROOM_EDITOR role with ROOM_VIEW and ROOM_EDIT permissions');
+	}
+
+	async down(): Promise<void> {
+		// Remove ROOM_VIEWER role
+		await this.getCollection('roles').deleteOne({ name: 'ROOM_VIEWER' });
+		console.info('Rollback: Removed ROOM_VIEWER role');
+
+		// Remove ROOM_EDITOR role
+		await this.getCollection('roles').deleteOne({ name: 'ROOM_EDITOR' });
+		console.info('Rollback: Removed ROOM_EDITOR role');
+	}
+}

apps/server/src/modules/group/index.ts

@@ -2,3 +2,4 @@ export { GroupModule } from './group.module';
 export { GroupConfig } from './group.config';
 export * from './domain';
 export { GroupService } from './service';
+export { GroupRepo } from './repo';

apps/server/src/modules/room-member/authorization/room-member.rule.spec.ts

@@ -0,0 +1,223 @@
+import { createMock } from '@golevelup/ts-jest';
+import { Test, TestingModule } from '@nestjs/testing';
+import { Role, User } from '@shared/domain/entity';
+import { groupEntityFactory, roleFactory, setupEntities, userFactory } from '@shared/testing';
+import { AuthorizationHelper, AuthorizationInjectionService } from '@src/modules/authorization';
+import { RoomMemberEntity } from '@src/modules/room-member';
+import { roomMemberEntityFactory } from '@src/modules/room-member/testing';
+import { Permission, RoleName } from '@shared/domain/interface';
+import { Action, AuthorizationContext } from '@src/modules/authorization/domain/type';
+import { RoomMemberRule } from './room-member.rule';
+
+describe('RoomMemberRule', () => {
+	let module: TestingModule;
+	let rule: RoomMemberRule;
+	let injectionService: AuthorizationInjectionService;
+
+	beforeAll(async () => {
+		await setupEntities();
+
+		module = await Test.createTestingModule({
+			providers: [
+				RoomMemberRule,
+				{
+					provide: AuthorizationHelper,
+					useValue: createMock<AuthorizationHelper>(),
+				},
+				AuthorizationInjectionService,
+			],
+		}).compile();
+
+		rule = module.get(RoomMemberRule);
+		injectionService = await module.get(AuthorizationInjectionService);
+	});
+
+	afterAll(async () => {
+		await module.close();
+	});
+
+	beforeEach(() => {
+		jest.clearAllMocks();
+	});
+
+	describe('injection', () => {
+		it('should inject itself into authorisation module', () => {
+			expect(injectionService.getAuthorizationRules()).toContain(rule);
+		});
+	});
+
+	describe('isApplicable', () => {
+		describe('when the entity is applicable', () => {
+			const setup = () => {
+				const user: User = userFactory.buildWithId();
+				const roomMember: RoomMemberEntity = roomMemberEntityFactory.build({});
+
+				return {
+					user,
+					roomMember,
+				};
+			};
+
+			it('should return true', () => {
+				const { user, roomMember } = setup();
+
+				const result = rule.isApplicable(user, roomMember);
+
+				expect(result).toEqual(true);
+			});
+		});
+
+		describe('when the entity is not applicable', () => {
+			const setup = () => {
+				const user: User = userFactory.buildWithId();
+
+				return {
+					user,
+				};
+			};
+
+			it('should return false', () => {
+				const { user } = setup();
+
+				const result = rule.isApplicable(user, user);
+
+				expect(result).toEqual(false);
+			});
+		});
+	});
+
+	describe('hasPermission', () => {
+		describe('when the user has no permission', () => {
+			const setup = () => {
+				const role: Role = roleFactory.buildWithId();
+				const user: User = userFactory.buildWithId();
+				const userGroupEntity = groupEntityFactory.buildWithId({
+					users: [{ role, user }],
+					organization: undefined,
+					externalSource: undefined,
+				});
+
+				const roomMember = roomMemberEntityFactory.build({ userGroup: userGroupEntity });
+
+				return {
+					user,
+					roomMember,
+				};
+			};
+
+			it('should not allow read', () => {
+				const { roomMember, user } = setup();
+				const context: AuthorizationContext = {
+					action: Action.read,
+					requiredPermissions: [],
+				};
+				const result = rule.hasPermission(user, roomMember, context);
+
+				expect(result).toEqual(false);
+			});
+
+			it('should not allow write', () => {
+				const { roomMember, user } = setup();
+				const context: AuthorizationContext = {
+					action: Action.write,
+					requiredPermissions: [],
+				};
+				const result = rule.hasPermission(user, roomMember, context);
+
+				expect(result).toEqual(false);
+			});
+		});
+
+		describe('when user has ROOM_EDITOR role', () => {
+			const setup = () => {
+				const role = roleFactory.buildWithId({
+					name: RoleName.ROOM_EDITOR,
+					permissions: [Permission.ROOM_EDIT, Permission.ROOM_VIEW],
+				});
+				const user = userFactory.buildWithId();
+				const userGroupEntity = groupEntityFactory.buildWithId({
+					users: [{ role, user }],
+					organization: undefined,
+					externalSource: undefined,
+				});
+
+				const roomMember = roomMemberEntityFactory.build({ userGroup: userGroupEntity });
+
+				return { user, roomMember };
+			};
+
+			it('should allow read', () => {
+				const { user, roomMember } = setup();
+				const context = { action: Action.read, requiredPermissions: [] };
+				const result = rule.hasPermission(user, roomMember, context);
+				expect(result).toEqual(true);
+			});
+
+			it('should allow write', () => {
+				const { user, roomMember } = setup();
+				const context = { action: Action.write, requiredPermissions: [] };
+				const result = rule.hasPermission(user, roomMember, context);
+				expect(result).toEqual(true);
+			});
+		});
+
+		describe('when user has ROOM_VIEWER role', () => {
+			const setup = () => {
+				const role = roleFactory.buildWithId({ name: RoleName.ROOM_VIEWER, permissions: [Permission.ROOM_VIEW] });
+				const user = userFactory.buildWithId();
+				const userGroupEntity = groupEntityFactory.buildWithId({
+					users: [{ role, user }],
+					organization: undefined,
+					externalSource: undefined,
+				});
+
+				const roomMember = roomMemberEntityFactory.build({ userGroup: userGroupEntity });
+
+				return { user, roomMember };
+			};
+
+			it('should allow read', () => {
+				const { user, roomMember } = setup();
+				const context = { action: Action.read, requiredPermissions: [] };
+				const result = rule.hasPermission(user, roomMember, context);
+				expect(result).toEqual(true);
+			});
+
+			it('should not allow write', () => {
+				const { user, roomMember } = setup();
+				const context = { action: Action.write, requiredPermissions: [] };
+				const result = rule.hasPermission(user, roomMember, context);
+				expect(result).toEqual(false);
+			});
+		});
+
+		describe('when user is not room member', () => {
+			const setup = () => {
+				const user = userFactory.buildWithId();
+				const userGroupEntity = groupEntityFactory.buildWithId({
+					users: [],
+					organization: undefined,
+					externalSource: undefined,
+				});
+
+				const roomMember = roomMemberEntityFactory.build({ userGroup: userGroupEntity });
+
+				return { user, roomMember };
+			};
+
+			it('should not allow read', () => {
+				const { user, roomMember } = setup();
+				const context = { action: Action.read, requiredPermissions: [] };
+				const result = rule.hasPermission(user, roomMember, context);
+				expect(result).toEqual(false);
+			});
+
+			it('should not allow write', () => {
+				const { user, roomMember } = setup();
+				const context = { action: Action.write, requiredPermissions: [] };
+				const result = rule.hasPermission(user, roomMember, context);
+				expect(result).toEqual(false);
+			});
+		});
+	});
+});

apps/server/src/modules/room-member/authorization/room-member.rule.ts

@@ -0,0 +1,35 @@
+import { Injectable } from '@nestjs/common';
+import { User } from '@shared/domain/entity';
+import { Permission } from '@shared/domain/interface';
+import { RoomMemberEntity } from '@src/modules/room-member';
+import { AuthorizationHelper } from '@src/modules/authorization/domain/service/authorization.helper';
+import { Action, AuthorizationContext, Rule } from '@src/modules/authorization/domain/type';
+import { AuthorizationInjectionService } from '@src/modules/authorization/domain/service/authorization-injection.service';
+
+@Injectable()
+export class RoomMemberRule implements Rule<RoomMemberEntity> {
+	constructor(
+		// TODO: check if we can remove this
+		private readonly authorizationHelper: AuthorizationHelper,
+		authorisationInjectionService: AuthorizationInjectionService
+	) {
+		authorisationInjectionService.injectAuthorizationRule(this);
+	}
+
+	public isApplicable(user: User, object: unknown): boolean {
+		const isMatched = object instanceof RoomMemberEntity;
+
+		return isMatched;
+	}
+
+	public hasPermission(user: User, object: RoomMemberEntity, context: AuthorizationContext): boolean {
+		const { action } = context;
+		const userPermissionsForThisRoom = object.userGroup.users
+			.filter((group) => group.user.id === user.id)
+			.flatMap((group) => group.role.permissions);
+		if (action === Action.read) {
+			return userPermissionsForThisRoom.includes(Permission.ROOM_VIEW);
+		}
+		return userPermissionsForThisRoom.includes(Permission.ROOM_EDIT);
+	}
+}

apps/server/src/modules/room-member/do/room-member.do.ts

@@ -0,0 +1,39 @@
+import { ObjectId } from '@mikro-orm/mongodb';
+import { AuthorizableObject, DomainObject } from '@shared/domain/domain-object';
+import { EntityId } from '@shared/domain/types';
+import { GroupEntity } from '@src/modules/group/entity/group.entity';
+
+export interface RoomMemberProps extends AuthorizableObject {
+	id: EntityId;
+	roomId: ObjectId;
+	userGroup: GroupEntity;
+	createdAt: Date;
+	updatedAt: Date;
+}
+
+export type RoomMemberCreateProps = Pick<RoomMemberProps, 'roomId'>;
+export type RoomMemberUpdateProps = RoomMemberCreateProps;
+
+export class RoomMember extends DomainObject<RoomMemberProps> {
+	public constructor(props: RoomMemberProps) {
+		super(props);
+	}
+
+	public getProps(): RoomMemberProps {
+		// Note: Propagated hotfix. Will be resolved with mikro-orm update. Look at the comment in board-node.do.ts.
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+		// @ts-ignore
+		const { domainObject, ...copyProps } = this.props;
+
+		return copyProps;
+	}
+
+	public get roomId(): ObjectId {
+		return this.props.roomId;
+	}
+
+	public get userGroup(): GroupEntity {
+		return this.props.userGroup;
+	}
+}

apps/server/src/modules/room-member/index.ts

@@ -0,0 +1,6 @@
+import { RoomMemberEntity } from './repo/entity';
+import { RoomMemberRepo } from './repo/room-member.repo';
+import { RoomMemberService } from './service/room-member.service';
+
+export * from './room-member.module';
+export { RoomMemberEntity, RoomMemberRepo, RoomMemberService };

apps/server/src/modules/room-member/repo/entity/index.ts

@@ -0,0 +1 @@
+export * from './room-member.entity';

apps/server/src/modules/room-member/repo/entity/room-member.entity.ts

@@ -0,0 +1,18 @@
+import { Entity, Index, OneToOne, Property } from '@mikro-orm/core';
+import { ObjectId } from '@mikro-orm/mongodb';
+import { BaseEntityWithTimestamps } from '@shared/domain/entity/base.entity';
+import { GroupEntity } from '@src/modules/group/entity/group.entity';
+import { RoomMember, RoomMemberProps } from '../../do/room-member.do';
+
+@Entity({ tableName: 'room-members' })
+export class RoomMemberEntity extends BaseEntityWithTimestamps implements RoomMemberProps {
+	@Property()
+	@Index()
+	roomId!: ObjectId;
+
+	@OneToOne(() => GroupEntity, { owner: true, orphanRemoval: true })
+	userGroup!: GroupEntity;
+
+	@Property({ persist: false })
+	domainObject: RoomMember | undefined;
+}