Regression: Matrix Federation regressions

apps/meteor/app/channel-settings/server/functions/saveRoomTopic.js

@@ -2,6 +2,7 @@ import { Meteor } from 'meteor/meteor';
 import { Match } from 'meteor/check';
 
 import { Rooms, Messages } from '../../../models/server';
+import { callbacks } from '../../../../lib/callbacks';
 
 export const saveRoomTopic = function (rid, roomTopic, user, sendMessage = true) {
 	if (!Match.test(rid, String)) {
@@ -14,5 +15,6 @@ export const saveRoomTopic = function (rid, roomTopic, user, sendMessage = true)
 	if (update && sendMessage) {
 		Messages.createRoomSettingsChangedWithTypeRoomIdMessageAndUser('room_changed_topic', rid, roomTopic, user);
 	}
+	callbacks.run('afterRoomTopicChange', { rid, topic: roomTopic });
 	return update;
 };

apps/meteor/app/federation-v2/client/Federation.ts

@@ -1,4 +1,5 @@
-import { ValueOf } from '@rocket.chat/core-typings';
+import { IRoom, IUser, ValueOf } from '@rocket.chat/core-typings';
+import { RoomType } from '@rocket.chat/apps-engine/definition/rooms';
 
 import { RoomMemberActions } from '../../../definition/IRoomTypeConfig';
 
@@ -9,6 +10,15 @@ const allowedActionsInFederatedRooms: ValueOf<typeof RoomMemberActions>[] = [
 	RoomMemberActions.LEAVE,
 ];
 
-export const actionAllowed = (action: ValueOf<typeof RoomMemberActions>): boolean => {
-	return allowedActionsInFederatedRooms.includes(action);
+export const actionAllowed = (room: Partial<IRoom>, action: ValueOf<typeof RoomMemberActions>): boolean => {
+	return room.t === RoomType.DIRECT_MESSAGE && action === RoomMemberActions.REMOVE_USER
+		? false
+		: allowedActionsInFederatedRooms.includes(action);
+};
+
+export const isEditableByTheUser = (user: IUser | undefined, room: IRoom | undefined): boolean => {
+	if (!user || !room) {
+		return false;
+	}
+	return user._id === room.u?._id;
 };

apps/meteor/app/federation-v2/server/application/RoomServiceReceiver.ts

@@ -11,6 +11,9 @@ import {
 	FederationRoomCreateInputDto,
 	FederationRoomChangeMembershipDto,
 	FederationRoomSendInternalMessageDto,
+	FederationRoomChangeJoinRulesDto,
+	FederationRoomChangeNameDto,
+	FederationRoomChangeTopicDto,
 } from './input/RoomReceiverDto';
 
 export class FederationRoomServiceReceiver {
@@ -189,4 +192,72 @@ export class FederationRoomServiceReceiver {
 
 		await this.rocketMessageAdapter.sendMessage(senderUser, text, federatedRoom);
 	}
+
+	public async changeJoinRules(roomJoinRulesChangeInput: FederationRoomChangeJoinRulesDto): Promise<void> {
+		const { externalRoomId, roomType } = roomJoinRulesChangeInput;
+
+		const federatedRoom = await this.rocketRoomAdapter.getFederatedRoomByExternalId(externalRoomId);
+		if (!federatedRoom) {
+			return;
+		}
+
+		if (federatedRoom.isDirectMessage()) {
+			return;
+		}
+
+		federatedRoom.setRoomType(roomType);
+		await this.rocketRoomAdapter.updateRoomType(federatedRoom);
+	}
+
+	public async changeRoomName(roomChangeNameInput: FederationRoomChangeNameDto): Promise<void> {
+		const { externalRoomId, normalizedRoomName, externalSenderId } = roomChangeNameInput;
+
+		const federatedRoom = await this.rocketRoomAdapter.getFederatedRoomByExternalId(externalRoomId);
+		if (!federatedRoom) {
+			return;
+		}
+
+		if (federatedRoom.isDirectMessage()) {
+			return;
+		}
+
+		if (federatedRoom.internalReference?.name === normalizedRoomName) {
+			return;
+		}
+
+		const federatedUser = await this.rocketUserAdapter.getFederatedUserByExternalId(externalSenderId);
+		if (!federatedUser) {
+			return;
+		}
+
+		federatedRoom.changeRoomName(normalizedRoomName);
+
+		await this.rocketRoomAdapter.updateRoomName(federatedRoom, federatedUser);
+	}
+
+	public async changeRoomTopic(roomChangeTopicInput: FederationRoomChangeTopicDto): Promise<void> {
+		const { externalRoomId, roomTopic, externalSenderId } = roomChangeTopicInput;
+
+		const federatedRoom = await this.rocketRoomAdapter.getFederatedRoomByExternalId(externalRoomId);
+		if (!federatedRoom) {
+			return;
+		}
+
+		if (federatedRoom.internalReference?.topic === roomTopic) {
+			return;
+		}
+
+		if (federatedRoom.isDirectMessage()) {
+			return;
+		}
+
+		const federatedUser = await this.rocketUserAdapter.getFederatedUserByExternalId(externalSenderId);
+		if (!federatedUser) {
+			return;
+		}
+
+		federatedRoom.changeRoomTopic(roomTopic);
+
+		await this.rocketRoomAdapter.updateRoomTopic(federatedRoom, federatedUser);
+	}
 }

apps/meteor/app/federation-v2/server/application/RoomServiceSender.ts

@@ -148,18 +148,50 @@ export class FederationRoomServiceSender {
 		}
 	}
 
-	public async canAddUsersToTheRoom(internalUser: IUser | string, internalRoom: IRoom): Promise<void> {
-		const newUserBeingAdded = typeof internalUser === 'string';
-		if (newUserBeingAdded) {
+	public async canAddUsersToTheRoom(internalUser: IUser | string, internalInviter: IUser, internalRoom: IRoom): Promise<void> {
+		if (!internalRoom.federated) {
 			return;
 		}
+		const tryingToAddNewFederatedUser = typeof internalUser === 'string';
+		if (tryingToAddNewFederatedUser) {
+			throw new Error('error-this-is-an-ee-feature');
+		}
 
-		if (!internalRoom.federated) {
+		const invitee = await this.rocketUserAdapter.getFederatedUserByInternalId((internalUser as IUser)._id);
+		const inviter = await this.rocketUserAdapter.getFederatedUserByInternalId((internalInviter as IUser)._id);
+		const externalRoom = await this.rocketRoomAdapter.getFederatedRoomByInternalId(internalRoom._id);
+		if (!externalRoom || !inviter) {
 			return;
 		}
 
-		const user = await this.rocketUserAdapter.getFederatedUserByInternalId((internalUser as IUser)._id);
-		if (user && !user.existsOnlyOnProxyServer && internalRoom.t !== RoomType.DIRECT_MESSAGE) {
+		const isARoomFromTheProxyServer = this.bridge.isRoomFromTheSameHomeserver(
+			externalRoom.externalId,
+			this.rocketSettingsAdapter.getHomeServerDomain(),
+		);
+		const isInviterFromTheProxyServer = this.bridge.isUserIdFromTheSameHomeserver(
+			inviter.externalId,
+			this.rocketSettingsAdapter.getHomeServerDomain(),
+		);
+
+		if (!isARoomFromTheProxyServer && !isInviterFromTheProxyServer) {
+			return;
+		}
+		if (invitee && !invitee.existsOnlyOnProxyServer && internalRoom.t !== RoomType.DIRECT_MESSAGE) {
+			throw new Error('error-this-is-an-ee-feature');
+		}
+	}
+
+	public async beforeCreateDirectMessageFromUI(internalUsers: (IUser | string)[]): Promise<void> {
+		const usernames = internalUsers.map((user) => {
+			if (typeof user === 'string') {
+				return user;
+			}
+			return user.username;
+		});
+		const isThereAnyFederatedUser =
+			usernames.some((username) => username?.includes(':')) ||
+			internalUsers.filter((user) => typeof user !== 'string').some((user) => (user as IUser).federated);
+		if (isThereAnyFederatedUser) {
 			throw new Error('error-this-is-an-ee-feature');
 		}
 	}

apps/meteor/app/federation-v2/server/application/input/RoomReceiverDto.ts

@@ -49,3 +49,19 @@ export class FederationRoomSendInternalMessageDto extends BaseRoom {
 
 	text: string;
 }
+
+export class FederationRoomChangeJoinRulesDto extends BaseRoom {
+	roomType: RoomType;
+}
+
+export class FederationRoomChangeNameDto extends BaseRoom {
+	normalizedRoomName: string;
+
+	externalSenderId: string;
+}
+
+export class FederationRoomChangeTopicDto extends BaseRoom {
+	roomTopic: string;
+
+	externalSenderId: string;
+}

apps/meteor/app/federation-v2/server/domain/FederatedRoom.ts

@@ -55,6 +55,34 @@ export class FederatedRoom {
 	}
 
 	public static buildRoomIdForDirectMessages(inviter: FederatedUser, invitee: FederatedUser): string {
-		return inviter.internalReference?._id + invitee.internalReference?._id;
+		if (!inviter.internalReference || !invitee.internalReference) {
+			throw new Error('Cannot create room Id without the user ids');
+		}
+		return [inviter.internalReference, invitee.internalReference]
+			.map(({ _id }) => _id)
+			.sort()
+			.join('');
+	}
+
+	public setRoomType(type: RoomType): void {
+		if (this.isDirectMessage()) {
+			throw new Error('Its not possible to change a direct message type');
+		}
+		this.internalReference.t = type;
+	}
+
+	public changeRoomName(name: string): void {
+		if (this.isDirectMessage()) {
+			throw new Error('Its not possible to change a direct message name');
+		}
+		this.internalReference.name = name;
+		this.internalReference.fname = name;
+	}
+
+	public changeRoomTopic(topic: string): void {
+		if (this.isDirectMessage()) {
+			throw new Error('Its not possible to change a direct message topic');
+		}
+		this.internalReference.topic = topic;
 	}
 }

apps/meteor/app/federation-v2/server/domain/IFederationBridge.ts

@@ -9,6 +9,7 @@ export interface IFederationBridge {
 	sendMessage(externalRoomId: string, externaSenderId: string, text: string): Promise<void>;
 	createUser(username: string, name: string, domain: string): Promise<string>;
 	isUserIdFromTheSameHomeserver(externalUserId: string, domain: string): boolean;
+	isRoomFromTheSameHomeserver(externalRoomId: string, domain: string): boolean;
 	leaveRoom(externalRoomId: string, externalUserId: string): Promise<void>;
 	kickUserFromRoom(externalRoomId: string, externalUserId: string, externalOwnerId: string): Promise<void>;
 }

apps/meteor/app/federation-v2/server/index.ts

@@ -4,8 +4,8 @@ export const FEDERATION_PROCESSING_CONCURRENCY = 1;
 
 const rocketSettingsAdapter = FederationFactory.buildRocketSettingsAdapter();
 rocketSettingsAdapter.initialize();
-const queueInstance = FederationFactory.buildQueue();
-const federation = FederationFactory.buildBridge(rocketSettingsAdapter, queueInstance);
+export const federationQueueInstance = FederationFactory.buildQueue();
+const federation = FederationFactory.buildBridge(rocketSettingsAdapter, federationQueueInstance);
 const rocketRoomAdapter = FederationFactory.buildRocketRoomAdapter();
 const rocketUserAdapter = FederationFactory.buildRocketUserAdapter();
 const rocketMessageAdapter = FederationFactory.buildRocketMessageAdapter();
@@ -31,13 +31,13 @@ FederationFactory.setupListeners(federationRoomServiceSender);
 let cancelSettingsObserver: Function;
 
 export const runFederation = async (): Promise<void> => {
+	federationQueueInstance.setHandler(federationEventsHandler.handleEvent.bind(federationEventsHandler), FEDERATION_PROCESSING_CONCURRENCY);
 	cancelSettingsObserver = rocketSettingsAdapter.onFederationEnabledStatusChanged(
 		federation.onFederationAvailabilityChanged.bind(federation),
 	);
 	if (!rocketSettingsAdapter.isFederationEnabled()) {
 		return;
 	}
-	queueInstance.setHandler(federationEventsHandler.handleEvent.bind(federationEventsHandler), FEDERATION_PROCESSING_CONCURRENCY);
 	await federation.start();
 	require('./infrastructure/rocket-chat/slash-commands');
 };

apps/meteor/app/federation-v2/server/infrastructure/Factory.ts

@@ -4,7 +4,14 @@ import { FederationRoomServiceReceiver } from '../application/RoomServiceReceive
 import { FederationRoomServiceSender } from '../application/RoomServiceSender';
 import { MatrixBridge } from './matrix/Bridge';
 import { MatrixEventsHandler } from './matrix/handlers';
-import { MatrixRoomCreatedHandler, MatrixRoomMembershipChangedHandler, MatrixRoomMessageSentHandler } from './matrix/handlers/Room';
+import {
+	MatrixRoomCreatedHandler,
+	MatrixRoomJoinRulesChangedHandler,
+	MatrixRoomMembershipChangedHandler,
+	MatrixRoomMessageSentHandler,
+	MatrixRoomNameChangedHandler,
+	MatrixRoomTopicChangedHandler,
+} from './matrix/handlers/Room';
 import { InMemoryQueue } from './queue/InMemoryQueue';
 import { RocketChatMessageAdapter } from './rocket-chat/adapters/Message';
 import { RocketChatRoomAdapter } from './rocket-chat/adapters/Room';
@@ -74,13 +81,16 @@ export class FederationFactory {
 	}
 
 	public static getEventHandlers(
-		roomServiceReceive: FederationRoomServiceReceiver,
+		roomServiceReceiver: FederationRoomServiceReceiver,
 		rocketSettingsAdapter: RocketChatSettingsAdapter,
 	): any[] {
 		return [
-			new MatrixRoomCreatedHandler(roomServiceReceive),
-			new MatrixRoomMembershipChangedHandler(roomServiceReceive, rocketSettingsAdapter),
-			new MatrixRoomMessageSentHandler(roomServiceReceive),
+			new MatrixRoomCreatedHandler(roomServiceReceiver),
+			new MatrixRoomMembershipChangedHandler(roomServiceReceiver, rocketSettingsAdapter),
+			new MatrixRoomMessageSentHandler(roomServiceReceiver),
+			new MatrixRoomJoinRulesChangedHandler(roomServiceReceiver),
+			new MatrixRoomNameChangedHandler(roomServiceReceiver),
+			new MatrixRoomTopicChangedHandler(roomServiceReceiver),
 		];
 	}
 
@@ -92,7 +102,10 @@ export class FederationFactory {
 			roomServiceSender.leaveRoom(FederationRoomSenderConverter.toAfterLeaveRoom(user._id, room._id, userWhoRemoved._id)),
 		);
 		FederationHooks.canAddTheUserToTheRoom((user: IUser | string, room: IRoom) => roomServiceSender.canAddThisUserToTheRoom(user, room));
-		FederationHooks.canAddUsersToTheRoom((user: IUser | string, room: IRoom) => roomServiceSender.canAddUsersToTheRoom(user, room));
+		FederationHooks.canAddUsersToTheRoom((user: IUser | string, inviter: IUser, room: IRoom) =>
+			roomServiceSender.canAddUsersToTheRoom(user, inviter, room),
+		);
+		FederationHooks.beforeCreateDirectMessage((members: (IUser | string)[]) => roomServiceSender.beforeCreateDirectMessageFromUI(members));
 	}
 
 	public static removeListeners(): void {

apps/meteor/app/federation-v2/server/infrastructure/matrix/Bridge.ts

@@ -159,6 +159,10 @@ export class MatrixBridge implements IFederationBridge {
 		this.bridgeInstance.getIntent(externalOwnerId).kick(externalRoomId, externalUserId);
 	}
 
+	public isRoomFromTheSameHomeserver(externalRoomId: string, domain: string): boolean {
+		return this.isUserIdFromTheSameHomeserver(externalRoomId, domain);
+	}
+
 	protected async createInstance(): Promise<void> {
 		bridgeLogger.info('Performing Dynamic Import of matrix-appservice-bridge');
 

apps/meteor/app/federation-v2/server/infrastructure/matrix/converters/RoomReceiver.ts

@@ -1,7 +1,10 @@
 import { RoomType } from '@rocket.chat/apps-engine/definition/rooms';
 
 import {
+	FederationRoomChangeJoinRulesDto,
 	FederationRoomChangeMembershipDto,
+	FederationRoomChangeNameDto,
+	FederationRoomChangeTopicDto,
 	FederationRoomCreateInputDto,
 	FederationRoomSendInternalMessageDto,
 } from '../../../application/input/RoomReceiverDto';
@@ -54,6 +57,35 @@ export class MatrixRoomReceiverConverter {
 		});
 	}
 
+	public static toRoomChangeJoinRulesDto(
+		externalEvent: IMatrixEvent<MatrixEventType.ROOM_JOIN_RULES_CHANGED>,
+	): FederationRoomChangeJoinRulesDto {
+		return Object.assign(new FederationRoomChangeJoinRulesDto(), {
+			...MatrixRoomReceiverConverter.getBasicRoomsFields(externalEvent.room_id),
+			roomType: MatrixRoomReceiverConverter.convertMatrixJoinRuleToRCRoomType(externalEvent.content?.join_rule),
+		});
+	}
+
+	public static toRoomChangeNameDto(externalEvent: IMatrixEvent<MatrixEventType.ROOM_NAME_CHANGED>): FederationRoomChangeNameDto {
+		return Object.assign(new FederationRoomChangeNameDto(), {
+			...MatrixRoomReceiverConverter.getBasicRoomsFields(externalEvent.room_id),
+			externalSenderId: externalEvent.sender,
+			normalizedRoomName: MatrixRoomReceiverConverter.normalizeRoomNameToRCFormat(externalEvent.content?.name),
+		});
+	}
+
+	public static toRoomChangeTopicDto(externalEvent: IMatrixEvent<MatrixEventType.ROOM_TOPIC_CHANGED>): FederationRoomChangeTopicDto {
+		return Object.assign(new FederationRoomChangeTopicDto(), {
+			...MatrixRoomReceiverConverter.getBasicRoomsFields(externalEvent.room_id),
+			externalSenderId: externalEvent.sender,
+			roomTopic: externalEvent.content?.topic,
+		});
+	}
+
+	private static normalizeRoomNameToRCFormat(matrixRoomName = ''): string {
+		return matrixRoomName.replace('@', '');
+	}
+
 	protected static convertMatrixUserIdFormatToRCFormat(matrixUserId = ''): string {
 		return matrixUserId.replace('@', '');
 	}

apps/meteor/app/federation-v2/server/infrastructure/matrix/definitions/IMatrixEventContent/index.ts

@@ -4,11 +4,13 @@ import { IMatrixEventContentAddMemberToRoom } from './IMatrixEventContentAddMemb
 import { IMatrixEventContentSendMessage } from './IMatrixEventContentSendMessage';
 import { IMatrixEventContentSetRoomJoinRules } from './IMatrixEventContentSetRoomJoinRules';
 import { IMatrixEventContentSetRoomName } from './IMatrixEventContentSetRoomName';
+import { IMatrixEventContentSetRoomTopic } from './IMatrixEventContentSetRoomTopic';
 
 export type EventContent = {
 	[MatrixEventType.ROOM_CREATED]: IMatrixEventContentCreateRoom;
 	[MatrixEventType.ROOM_MEMBERSHIP_CHANGED]: IMatrixEventContentAddMemberToRoom;
 	[MatrixEventType.ROOM_MESSAGE_SENT]: IMatrixEventContentSendMessage;
 	[MatrixEventType.ROOM_JOIN_RULES_CHANGED]: IMatrixEventContentSetRoomJoinRules;
 	[MatrixEventType.ROOM_NAME_CHANGED]: IMatrixEventContentSetRoomName;
+	[MatrixEventType.ROOM_TOPIC_CHANGED]: IMatrixEventContentSetRoomTopic;
 };