feat(federation): add room invites support

apps/meteor/app/api/server/v1/rooms.ts

@@ -1,4 +1,4 @@
-import { Media, MeteorError, Team } from '@rocket.chat/core-services';
+import { FederationMatrix, Media, MeteorError, Team } from '@rocket.chat/core-services';
 import type { IRoom, IUpload } from '@rocket.chat/core-typings';
 import { isPrivateRoom, isPublicRoom } from '@rocket.chat/core-typings';
 import { Messages, Rooms, Users, Uploads, Subscriptions } from '@rocket.chat/models';
@@ -15,6 +15,9 @@ import {
 	isRoomsMembersOrderedByRoleProps,
 	isRoomsChangeArchivationStateProps,
 	isRoomsHideProps,
+	isRoomsInviteProps,
+	validateBadRequestErrorResponse,
+	validateUnauthorizedErrorResponse,
 } from '@rocket.chat/rest-typings';
 import { Meteor } from 'meteor/meteor';
 
@@ -1073,7 +1076,37 @@ export const roomEndpoints = API.v1.get(
 	},
 );
 
-type RoomEndpoints = ExtractRoutesFromAPI<typeof roomEndpoints>;
+const roomInviteEndpoints = API.v1.post(
+	'rooms.invite',
+	{
+		authRequired: true,
+		body: isRoomsInviteProps,
+		response: {
+			400: validateBadRequestErrorResponse,
+			401: validateUnauthorizedErrorResponse,
+			200: ajv.compile<void>({
+				type: 'object',
+				properties: {
+					success: { type: 'boolean', enum: [true] },
+				},
+				required: ['success'],
+				additionalProperties: false,
+			}),
+		},
+	},
+	async function action() {
+		const { roomId, action } = this.bodyParams;
+
+		try {
+			await FederationMatrix.handleInvite(roomId, this.userId, action);
+			return API.v1.success();
+		} catch (error) {
+			return API.v1.failure({ error: `Failed to handle invite: ${error instanceof Error ? error.message : String(error)}` });
+		}
+	},
+);
+
+type RoomEndpoints = ExtractRoutesFromAPI<typeof roomEndpoints> & ExtractRoutesFromAPI<typeof roomInviteEndpoints>;
 
 declare module '@rocket.chat/rest-typings' {
 	// eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-empty-interface

apps/meteor/app/lib/lib/MessageTypes.ts

@@ -29,6 +29,14 @@ export const MessageTypesValues: Array<{ key: MessageTypesValuesType; i18nLabel:
 		key: 'au', // added user
 		i18nLabel: 'Message_HideType_au',
 	},
+	{
+		key: 'ui', // user invited to room
+		i18nLabel: 'Message_HideType_ui',
+	},
+	{
+		key: 'uir', // user rejected invitation to room
+		i18nLabel: 'Message_HideType_uir',
+	},
 	{
 		key: 'added-user-to-team',
 		i18nLabel: 'Message_HideType_added_user_to_team',

apps/meteor/app/lib/server/functions/acceptRoomInvite.ts

@@ -0,0 +1,61 @@
+import { Apps, AppEvents } from '@rocket.chat/apps';
+import { AppsEngineException } from '@rocket.chat/apps-engine/definition/exceptions';
+import { Message } from '@rocket.chat/core-services';
+import type { IUser, IRoom, ISubscription } from '@rocket.chat/core-typings';
+import { Subscriptions, Users } from '@rocket.chat/models';
+import { Meteor } from 'meteor/meteor';
+
+import { callbacks } from '../../../../lib/callbacks';
+import { notifyOnSubscriptionChangedById } from '../lib/notifyListener';
+
+/**
+ * Accepts a room invite when triggered by internal events such as federation
+ * or third-party callbacks. Performs the necessary database updates and triggers
+ * safe callbacks, ensuring no propagation loops are created during external event
+ * processing.
+ */
+
+// TODO this funcion is pretty much the same as the one in addUserToRoom.ts, we should probably
+// unify them at some point
+export const performAcceptRoomInvite = async (
+	room: IRoom,
+	subscription: ISubscription,
+	user: IUser & { username: string },
+): Promise<void> => {
+	if (subscription.status !== 'INVITED' || !subscription.inviter) {
+		throw new Meteor.Error('error-not-invited', `User was not invited to this room ${subscription.status}`);
+	}
+	const inviter = await Users.findOneById(subscription.inviter._id);
+
+	await callbacks.run('beforeJoinRoom', user, room);
+
+	await callbacks.run('beforeAddedToRoom', { user, inviter }, room);
+
+	try {
+		await Apps.self?.triggerEvent(AppEvents.IPreRoomUserJoined, room, user, inviter);
+	} catch (error: any) {
+		if (error.name === AppsEngineException.name) {
+			throw new Meteor.Error('error-app-prevented', error.message);
+		}
+
+		throw error;
+	}
+
+	await Subscriptions.acceptInvitationById(subscription._id);
+
+	void notifyOnSubscriptionChangedById(subscription._id, 'updated');
+
+	await Message.saveSystemMessage('uj', room._id, user.username, user);
+
+	if (room.t === 'c' || room.t === 'p') {
+		process.nextTick(async () => {
+			// Add a new event, with an optional inviter
+			await callbacks.run('afterAddedToRoom', { user, inviter }, room);
+
+			// Keep the current event
+			await callbacks.run('afterJoinRoom', user, room);
+
+			void Apps.self?.triggerEvent(AppEvents.IPostRoomUserJoined, room, user, inviter);
+		});
+	}
+};

apps/meteor/app/lib/server/functions/addUserToRoom.ts

@@ -1,18 +1,16 @@
 import { Apps, AppEvents } from '@rocket.chat/apps';
 import { AppsEngineException } from '@rocket.chat/apps-engine/definition/exceptions';
-import { Message, Team } from '@rocket.chat/core-services';
-import { type IUser } from '@rocket.chat/core-typings';
+import { Team, Room } from '@rocket.chat/core-services';
+import { isRoomNativeFederated, type IUser } from '@rocket.chat/core-typings';
 import { Subscriptions, Users, Rooms } from '@rocket.chat/models';
 import { Meteor } from 'meteor/meteor';
 
 import { RoomMemberActions } from '../../../../definition/IRoomTypeConfig';
 import { callbacks } from '../../../../lib/callbacks';
 import { beforeAddUserToRoom } from '../../../../lib/callbacks/beforeAddUserToRoom';
-import { getSubscriptionAutotranslateDefaultConfig } from '../../../../server/lib/getSubscriptionAutotranslateDefaultConfig';
 import { roomCoordinator } from '../../../../server/lib/rooms/roomCoordinator';
 import { settings } from '../../../settings/server';
-import { getDefaultSubscriptionPref } from '../../../utils/lib/getDefaultSubscriptionPref';
-import { notifyOnRoomChangedById, notifyOnSubscriptionChangedById } from '../lib/notifyListener';
+import { notifyOnRoomChangedById } from '../lib/notifyListener';
 
 /**
  * This function adds user to the given room.
@@ -49,6 +47,12 @@ export const addUserToRoom = async (
 		throw new Meteor.Error('user-not-found');
 	}
 
+	// Check if user is already in room
+	const subscription = await Subscriptions.findOneByRoomIdAndUserId(rid, userToBeAdded._id);
+	if (subscription) {
+		return;
+	}
+
 	if (
 		!(await roomDirectives.allowMemberAction(room, RoomMemberActions.JOIN, userToBeAdded._id)) &&
 		!(await roomDirectives.allowMemberAction(room, RoomMemberActions.INVITE, userToBeAdded._id))
@@ -66,12 +70,6 @@ export const addUserToRoom = async (
 
 	await callbacks.run('beforeAddedToRoom', { user: userToBeAdded, inviter });
 
-	// Check if user is already in room
-	const subscription = await Subscriptions.findOneByRoomIdAndUserId(rid, userToBeAdded._id);
-	if (subscription || !userToBeAdded) {
-		return;
-	}
-
 	try {
 		await Apps.self?.triggerEvent(AppEvents.IPreRoomUserJoined, room, userToBeAdded, inviter);
 	} catch (error: any) {
@@ -81,6 +79,12 @@ export const addUserToRoom = async (
 
 		throw error;
 	}
+
+	// for federation rooms we stop here since everything else will be handled by the federation invite flow
+	if (isRoomNativeFederated(room)) {
+		return;
+	}
+
 	// TODO: are we calling this twice?
 	if (room.t === 'c' || room.t === 'p' || room.t === 'l') {
 		// Add a new event, with an optional inviter
@@ -90,50 +94,16 @@ export const addUserToRoom = async (
 		await callbacks.run('beforeJoinRoom', userToBeAdded, room);
 	}
 
-	const autoTranslateConfig = getSubscriptionAutotranslateDefaultConfig(userToBeAdded);
-
-	const { insertedId } = await Subscriptions.createWithRoomAndUser(room, userToBeAdded as IUser, {
+	await Room.createUserSubscription({
+		room,
 		ts: now,
-		open: !createAsHidden,
-		alert: createAsHidden ? false : !skipAlertSound,
-		unread: 1,
-		userMentions: 1,
-		groupMentions: 0,
-		...autoTranslateConfig,
-		...getDefaultSubscriptionPref(userToBeAdded as IUser),
+		inviter,
+		userToBeAdded,
+		createAsHidden,
+		skipAlertSound,
+		skipSystemMessage,
 	});
 
-	if (insertedId) {
-		void notifyOnSubscriptionChangedById(insertedId, 'inserted');
-	}
-
-	if (!userToBeAdded.username) {
-		throw new Meteor.Error('error-invalid-user', 'Cannot add an user to a room without a username');
-	}
-
-	if (!skipSystemMessage) {
-		if (inviter) {
-			const extraData = {
-				ts: now,
-				u: {
-					_id: inviter._id,
-					username: inviter.username,
-				},
-			};
-			if (room.teamMain) {
-				await Message.saveSystemMessage('added-user-to-team', rid, userToBeAdded.username, userToBeAdded, extraData);
-			} else {
-				await Message.saveSystemMessage('au', rid, userToBeAdded.username, userToBeAdded, extraData);
-			}
-		} else if (room.prid) {
-			await Message.saveSystemMessage('ut', rid, userToBeAdded.username, userToBeAdded, { ts: now });
-		} else if (room.teamMain) {
-			await Message.saveSystemMessage('ujt', rid, userToBeAdded.username, userToBeAdded, { ts: now });
-		} else {
-			await Message.saveSystemMessage('uj', rid, userToBeAdded.username, userToBeAdded, { ts: now });
-		}
-	}
-
 	if (room.t === 'c' || room.t === 'p') {
 		process.nextTick(async () => {
 			// Add a new event, with an optional inviter

apps/meteor/app/lib/server/functions/createDirectRoom.ts

@@ -44,9 +44,8 @@ export async function createDirectRoom(
 	members: IUser[] | string[],
 	roomExtraData: Partial<IRoom> = {},
 	options: {
-		creator?: string;
+		creator?: IUser['_id'];
 		subscriptionExtra?: ISubscriptionExtraData;
-		federatedRoomId?: string;
 	},
 ): Promise<ICreatedRoom> {
 	const maxUsers = settings.get<number>('DirectMesssage_maxUsers') || 1;
@@ -155,15 +154,37 @@ export async function createDirectRoom(
 			{ projection: { 'username': 1, 'settings.preferences': 1 } },
 		).toArray();
 
+		const creatorUser = roomMembers.find((member) => member._id === options?.creator);
+		if (roomExtraData.federated && !creatorUser) {
+			throw new Meteor.Error('error-creator-not-in-room', 'The creator user must be part of the direct room');
+		}
+
 		for await (const member of membersWithPreferences) {
 			const otherMembers = sortedMembers.filter(({ _id }) => _id !== member._id);
+
+			const subscriptionStatus: Partial<ISubscription> =
+				roomExtraData.federated && options.creator !== member._id && creatorUser
+					? {
+							status: 'INVITED',
+							inviter: {
+								_id: creatorUser._id,
+								username: creatorUser.username,
+								name: creatorUser.name,
+							},
+							open: true,
+							unread: 1,
+							userMentions: 1,
+						}
+					: {};
+
 			const { modifiedCount, upsertedCount } = await Subscriptions.updateOne(
 				{ rid, 'u._id': member._id },
 				{
 					...(options?.creator === member._id && { $set: { open: true } }),
 					$setOnInsert: generateSubscription(getFname(otherMembers), getName(otherMembers), member, {
 						...options?.subscriptionExtra,
 						...(options?.creator !== member._id && { open: members.length > 2 }),
+						...subscriptionStatus,
 					}),
 				},
 				{ upsert: true },
@@ -181,7 +202,6 @@ export async function createDirectRoom(
 		await callbacks.run('afterCreateDirectRoom', insertedRoom, {
 			members: roomMembers,
 			creatorId: options?.creator,
-			mrid: options?.federatedRoomId,
 		});
 
 		void Apps.self?.triggerEvent(AppEvents.IPostRoomCreate, insertedRoom);