feat: add room invites support

packages/federation-sdk/src/repositories/event.repository.ts

@@ -13,6 +13,7 @@ import type {
 	Collection,
 	FindCursor,
 	FindOptions,
+	InsertOneResult,
 	UpdateResult,
 	WithId,
 } from 'mongodb';
@@ -405,6 +406,23 @@ export class EventRepository {
 		);
 	}
 
+	insertOutlierEvent(
+		eventId: EventID,
+		event: Pdu,
+		origin: string,
+	): Promise<InsertOneResult<EventStore>> {
+		return this.collection.insertOne({
+			_id: eventId,
+			event,
+			createdAt: new Date(),
+			origin,
+			stateId: '' as StateID,
+			nextEventId: '',
+			outlier: true,
+			partial: false,
+		});
+	}
+
 	async updateNextEventReferences(
 		newEventId: EventID,
 		previousEventIds: EventID[],

packages/federation-sdk/src/sdk.ts

@@ -83,6 +83,14 @@ export class FederationSDK {
 		return this.eventService.getEventById(...args);
 	}
 
+	makeLeave(...args: Parameters<typeof this.roomService.makeLeave>) {
+		return this.roomService.makeLeave(...args);
+	}
+
+	sendLeave(...args: Parameters<typeof this.roomService.sendLeave>) {
+		return this.roomService.sendLeave(...args);
+	}
+
 	leaveRoom(...args: Parameters<typeof this.roomService.leaveRoom>) {
 		return this.roomService.leaveRoom(...args);
 	}
@@ -141,8 +149,12 @@ export class FederationSDK {
 		return this.eventAuthorizationService.verifyRequestSignature(...args);
 	}
 
-	joinUser(...args: Parameters<typeof this.roomService.joinUser>) {
-		return this.roomService.joinUser(...args);
+	acceptInvite(...args: Parameters<typeof this.roomService.acceptInvite>) {
+		return this.roomService.acceptInvite(...args);
+	}
+
+	rejectInvite(...args: Parameters<typeof this.roomService.rejectInvite>) {
+		return this.roomService.rejectInvite(...args);
 	}
 
 	getLatestRoomState2(

packages/federation-sdk/src/services/federation.service.ts

@@ -98,6 +98,50 @@ export class FederationService {
 		}
 	}
 
+	async makeLeave(
+		domain: string,
+		roomId: string,
+		userId: string,
+	): Promise<{ event: Pdu; room_version: string }> {
+		try {
+			const uri = FederationEndpoints.makeLeave(roomId, userId);
+			return await this.requestService.get<{
+				event: Pdu;
+				room_version: string;
+			}>(domain, uri);
+		} catch (error: any) {
+			this.logger.error({ msg: 'makeLeave failed', err: error });
+			throw error;
+		}
+	}
+
+	async sendLeave(leaveEvent: PersistentEventBase): Promise<void> {
+		try {
+			const uri = FederationEndpoints.sendLeave(
+				leaveEvent.roomId,
+				leaveEvent.eventId,
+			);
+
+			const residentServer = leaveEvent.roomId.split(':').pop();
+
+			if (!residentServer) {
+				this.logger.debug({ msg: 'invalid room_id', event: leaveEvent.event });
+				throw new Error(
+					`invalid room_id ${leaveEvent.roomId}, no server_name part`,
+				);
+			}
+
+			await this.requestService.put<void>(
+				residentServer,
+				uri,
+				leaveEvent.event,
+			);
+		} catch (error: any) {
+			this.logger.error({ msg: 'sendLeave failed', err: error });
+			throw error;
+		}
+	}
+
 	/**
 	 * Send a transaction to a remote server
 	 */

packages/federation-sdk/src/services/invite.service.ts

@@ -1,4 +1,4 @@
-import { EventBase, createLogger } from '@rocket.chat/federation-core';
+import { createLogger } from '@rocket.chat/federation-core';
 import {
 	EventID,
 	PduForType,
@@ -9,24 +9,13 @@ import {
 	UserID,
 	extractDomainFromId,
 } from '@rocket.chat/federation-room';
-import { singleton } from 'tsyringe';
+import { delay, inject, singleton } from 'tsyringe';
+import { EventRepository } from '../repositories/event.repository';
 import { ConfigService } from './config.service';
 import { EventAuthorizationService } from './event-authorization.service';
 import { EventEmitterService } from './event-emitter.service';
-import { EventService } from './event.service';
 import { FederationService } from './federation.service';
-import {
-	RoomInfoNotReadyError,
-	StateService,
-	UnknownRoomError,
-} from './state.service';
-// TODO: Have better (detailed/specific) event input type
-export type ProcessInviteEvent = {
-	event: EventBase;
-	invite_room_state: unknown;
-	room_version: string;
-};
-
+import { StateService } from './state.service';
 export class NotAllowedError extends Error {
 	constructor(message: string) {
 		super(message);
@@ -44,6 +33,8 @@ export class InviteService {
 		private readonly configService: ConfigService,
 		private readonly eventAuthorizationService: EventAuthorizationService,
 		private readonly emitterService: EventEmitterService,
+		@inject(delay(() => EventRepository))
+		private readonly eventRepository: EventRepository,
 	) {}
 
 	/**
@@ -110,11 +101,6 @@ export class InviteService {
 			// without it join events will not be processed if /event/{eventId} causes problems
 			void federationService.sendEventToAllServersInRoom(inviteEvent);
 
-			this.emitterService.emit('homeserver.matrix.membership', {
-				event_id: inviteEvent.eventId,
-				event: inviteEvent.event,
-			});
-
 			return {
 				event_id: inviteEvent.eventId,
 				event: PersistentEventFactory.createFromRawEvent(
@@ -145,11 +131,6 @@ export class InviteService {
 		// let everyone know
 		void federationService.sendEventToAllServersInRoom(inviteEvent);
 
-		this.emitterService.emit('homeserver.matrix.membership', {
-			event_id: inviteEvent.eventId,
-			event: inviteEvent.event,
-		});
-
 		return {
 			event_id: inviteEvent.eventId,
 			event: PersistentEventFactory.createFromRawEvent(
@@ -196,10 +177,8 @@ export class InviteService {
 
 	async processInvite(
 		event: PduForType<'m.room.member'>,
-		roomId: RoomID,
 		eventId: EventID,
 		roomVersion: RoomVersion,
-		authenticatedServer: string,
 		strippedStateEvents: PduForType<
 			| 'm.room.create'
 			| 'm.room.name'
@@ -209,15 +188,9 @@ export class InviteService {
 			| 'm.room.canonical_alias'
 			| 'm.room.encryption'
 		>[],
-	) {
-		// SPEC: when a user invites another user on a different homeserver, a request to that homeserver to have the event signed and verified must be made
+	): Promise<PersistentEventBase<RoomVersion, 'm.room.member'>> {
 		await this.shouldProcessInvite(strippedStateEvents);
 
-		const residentServer = roomId.split(':').pop();
-		if (!residentServer) {
-			throw new Error(`Invalid roomId ${roomId}`);
-		}
-
 		const inviteEvent =
 			PersistentEventFactory.createFromRawEvent<'m.room.member'>(
 				event,
@@ -228,28 +201,59 @@ export class InviteService {
 			throw new Error(`Invalid eventId ${eventId}`);
 		}
 
-		await this.stateService.signEvent(inviteEvent);
+		const { residentServer } = inviteEvent;
 
-		// we are the host of the server
 		if (residentServer === this.configService.serverName) {
 			await this.eventAuthorizationService.checkAclForInvite(
-				roomId,
-				authenticatedServer,
+				event.room_id,
+				residentServer,
 			);
 
-			// attempt to persist the invite event as we already have the state
-
 			await this.stateService.handlePdu(inviteEvent);
 
-			// we do not send transaction here
-			// the asking server will handle the transactions
+			return inviteEvent;
+		}
 
-			this.emitterService.emit('homeserver.matrix.membership', {
-				event_id: inviteEvent.eventId,
-				event: inviteEvent.event,
-			});
+		const invitedServer = extractDomainFromId(event.state_key);
+		if (!invitedServer) {
+			throw new Error(
+				`invalid state_key ${event.state_key}, no server_name part`,
+			);
+		}
+		if (invitedServer !== this.configService.serverName) {
+			throw new Error(
+				`Cannot sign invite for user ${event.state_key}: user does not belong to this server (${this.configService.serverName})`,
+			);
+		}
+
+		await this.stateService.signEvent(inviteEvent);
+
+		// we have no specific structure to store the invite_room_state received on the invite route,
+		// so we store it in the unsigned section of the invite event.
+		inviteEvent.event.unsigned.invite_room_state = strippedStateEvents;
+
+		// check if we are already in the room, if so we can handlePdu because we have the state and should save
+		// the invite in the state as well
+		const createEvent = await this.eventRepository.findByRoomIdAndType(
+			event.room_id,
+			'm.room.create',
+		);
+		if (createEvent) {
+			await this.stateService.handlePdu(inviteEvent);
+		} else {
+			// otherwise we save as outlier only so we can deal with it later
+			await this.eventRepository.insertOutlierEvent(
+				inviteEvent.eventId,
+				inviteEvent.event,
+				residentServer,
+			);
 		}
 
+		this.emitterService.emit('homeserver.matrix.membership', {
+			event_id: inviteEvent.eventId,
+			event: inviteEvent.event,
+		});
+
 		// we are not the host of the server
 		// so being the origin of the user, we sign the event and send it to the asking server, let them handle the transactions
 		return inviteEvent;

packages/federation-sdk/src/services/room.service.spec.ts

@@ -10,6 +10,7 @@ import {
 import { container } from 'tsyringe';
 import { federationSDK, init } from '..';
 import { AppConfig, ConfigService } from './config.service';
+import { RoomService } from './room.service';
 import { StateService } from './state.service';
 
 describe('RoomService', async () => {
@@ -38,11 +39,13 @@ describe('RoomService', async () => {
 		signingKey: '',
 		serverName: 'example.com',
 	} as AppConfig);
-	const stateService = container
-		.register(ConfigService, {
-			useValue: configService,
-		})
-		.resolve(StateService);
+
+	container.register(ConfigService, {
+		useValue: configService,
+	});
+
+	const stateService = container.resolve(StateService);
+	const roomService = container.resolve(RoomService);
 
 	const createRoom = async (
 		username: room.UserID,
@@ -212,7 +215,7 @@ describe('RoomService', async () => {
 
 			expect(imtialStateKeys).toEqual(expectedStateKeys);
 
-			await federationSDK.joinUser(roomCreateEvent, secondaryUsername);
+			await roomService.joinUser(roomId, username, secondaryUsername);
 
 			const state = await stateService.getLatestRoomState(roomId);
 
@@ -312,7 +315,7 @@ describe('RoomService', async () => {
 
 			const roomId = roomCreateEvent.roomId;
 
-			await federationSDK.joinUser(roomCreateEvent, secondaryUsername);
+			await roomService.joinUser(roomId, username, secondaryUsername);
 
 			expect(
 				await stateService.getLatestRoomState(roomId).then((state) => {
@@ -339,4 +342,72 @@ describe('RoomService', async () => {
 			});
 		});
 	});
+
+	describe('acceptInvite', () => {
+		it('should accept invite and join user to room correctly', async () => {
+			const username = '@alice:example.com' as room.UserID;
+			const invitedUsername = '@bob:example.com' as room.UserID;
+			const { roomCreateEvent } = await createRoom(username, 'invite');
+			const roomId = roomCreateEvent.roomId;
+
+			await federationSDK.inviteUserToRoom(invitedUsername, roomId, username);
+
+			const stateBeforeAccept = await stateService.getLatestRoomState(roomId);
+			const inviteMemberEvent = stateBeforeAccept.get(
+				`m.room.member:${invitedUsername}`,
+			) as PersistentEventBase<RoomVersion, 'm.room.member'> | undefined;
+
+			expect(inviteMemberEvent?.getContent().membership).toBe('invite');
+
+			await federationSDK.acceptInvite(roomId, invitedUsername);
+
+			const stateAfterAccept = await stateService.getLatestRoomState(roomId);
+			const joinMemberEvent = stateAfterAccept.get(
+				`m.room.member:${invitedUsername}`,
+			) as PersistentEventBase<RoomVersion, 'm.room.member'>;
+
+			expect(joinMemberEvent.getContent().membership).toBe('join');
+			expect([...stateAfterAccept.keys()]).toEqual(
+				expect.arrayContaining([
+					'm.room.create:',
+					`m.room.member:${username}`,
+					`m.room.member:${invitedUsername}`,
+				]),
+			);
+		});
+	});
+
+	describe('rejectInvite', () => {
+		it('should reject invite and leave room correctly', async () => {
+			const username = '@alice:example.com' as room.UserID;
+			const invitedUsername = '@bob:example.com' as room.UserID;
+			const { roomCreateEvent } = await createRoom(username, 'invite');
+			const roomId = roomCreateEvent.roomId;
+
+			await federationSDK.inviteUserToRoom(invitedUsername, roomId, username);
+
+			const stateBeforeReject = await stateService.getLatestRoomState(roomId);
+			const inviteMemberEvent = stateBeforeReject.get(
+				`m.room.member:${invitedUsername}`,
+			) as PersistentEventBase<RoomVersion, 'm.room.member'> | undefined;
+
+			expect(inviteMemberEvent?.getContent().membership).toBe('invite');
+
+			await federationSDK.rejectInvite(roomId, invitedUsername);
+
+			const stateAfterReject = await stateService.getLatestRoomState(roomId);
+			const leaveMemberEvent = stateAfterReject.get(
+				`m.room.member:${invitedUsername}`,
+			) as PersistentEventBase<RoomVersion, 'm.room.member'>;
+
+			expect(leaveMemberEvent.getContent().membership).toBe('leave');
+			expect([...stateAfterReject.keys()]).toEqual(
+				expect.arrayContaining([
+					'm.room.create:',
+					`m.room.member:${username}`,
+					`m.room.member:${invitedUsername}`,
+				]),
+			);
+		});
+	});
 });