chore: save event as staging after validation

packages/core/src/events/m.room.power_levels.spec.ts

@@ -63,8 +63,7 @@ test("roomPowerLevelsEvent", async () => {
 		],
 		depth: 3,
 		prev_events: ["$tZRt2bwceX4sG913Ee67tJiwe-gk859kY2mCeYSncw8"],
-		sender: "@admin:hs1",
-		member: "@asd6:rc1",
+		members: ["@admin:hs1", "@asd6:rc1"],
 		ts: 1733107418713,
 	});
 

packages/core/src/events/m.room.power_levels.ts

@@ -31,21 +31,20 @@ interface RoomPowerLevelsEvent extends EventBase {
 
 export const roomPowerLevelsEvent = ({
 	roomId,
-	sender,
-	member,
+	members: usernames,
 	auth_events,
 	prev_events,
 	depth,
 	ts = Date.now(),
 }: {
 	roomId: string;
-	sender: string;
-	member: string;
+	members: [sender: string, ...member: string[]];
 	auth_events: string[];
 	prev_events: string[];
 	depth: number;
 	ts?: number;
 }) => {
+	const [sender, ...members] = usernames;
 	return createEventBase("m.room.power_levels", {
 		roomId,
 		sender,
@@ -54,7 +53,10 @@ export const roomPowerLevelsEvent = ({
 		depth,
 		ts,
 		content: {
-			users: { [sender]: 100, [member]: 100 },
+			users: {
+				[sender]: 100,
+				...Object.fromEntries(usernames.map((member) => [member, 100])),
+			},
 			users_default: 0,
 			events: {
 				"m.room.name": 50,

packages/fake/src/room.ts

@@ -46,8 +46,7 @@ export const fakeEndpoints = new Elysia({ prefix: "/fake" })
 			}
 
 			const { roomId, events } = await createRoom(
-				sender,
-				username,
+				[sender, username],
 				createSignedEvent(config.signingKey[0], config.name),
 				`!${createMediaId(18)}:${config.name}`,
 			);
@@ -112,8 +111,7 @@ export const fakeEndpoints = new Elysia({ prefix: "/fake" })
 				}
 
 				const { roomId: newRoomId, events } = await createRoom(
-					sender,
-					username,
+					[sender, username],
 					createSignedEvent(config.signingKey[0], config.name),
 					`!${createMediaId(18)}:${config.name}`,
 				);

packages/homeserver/src/authentication.spec.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
 import {
-	computeHash,
+	computeAndMergeHash,
 	extractSignaturesFromHeader,
 	generateId,
 	signRequest,
@@ -142,7 +142,7 @@ test("signRequest", async () => {
 });
 
 test("computeHash", async () => {
-	const result = computeHash({
+	const result = computeAndMergeHash({
 		auth_events: [
 			"$e0YmwnKseuHqsuF50ekjta7z5UpO-bDoq7y4R1NKMpI",
 			"$6_VX-xW821oaBwOuaaV_xoC6fD2iMg2QPWD4J7Bh3o4",

packages/homeserver/src/authentication.ts

@@ -31,7 +31,7 @@
 
 	if (Object.keys(rest).length) {
 		// it should never happen since the regex should match all the parameters
 		throw new Error("Invalid authorization header, unexpected parameters");
 	}
 
 	if ([origin, destination, key, signature].some((value) => !value)) {
@@ -132,7 +132,7 @@
 	};
 };
 
-export function computeHash<T extends Record<string, unknown>>(
+export function computeAndMergeHash<T extends Record<string, unknown>>(
 	content: T,
 ): HashedEvent<T> {
 	// remove the fields that are not part of the hash
@@ -146,19 +146,39 @@
 		...toHash
 	} = content as any;
 
+	const [algorithm, hash] = computeHash(toHash);
+
 	return {
 		...content,
 		hashes: {
-			sha256: toUnpaddedBase64(
-				crypto
-					.createHash("sha256")
-					.update(encodeCanonicalJson(toHash))
-					.digest(),
-			),
+			[algorithm]: hash,
 		},
 	};
 }
 
+export function computeHash<T extends Record<string, unknown>>(
+	content: T,
+	algorithm: "sha256" = "sha256",
+): ["sha256", string] {
+	// remove the fields that are not part of the hash
+	const {
+		age_ts,
+		unsigned,
+		signatures,
+		hashes,
+		outlier,
+		destinations,
+		...toHash
+	} = content as any;
+
+	return [
+		algorithm,
+		toUnpaddedBase64(
+			crypto.createHash(algorithm).update(encodeCanonicalJson(toHash)).digest(),
+		),
+	];
+}
+
 export function generateId<T extends object>(content: T): string {
 	// remove the fields that are not part of the hash
 	const { age_ts, unsigned, signatures, ...toHash } = pruneEventDict(

packages/homeserver/src/fixtures/ContextBuilder.ts

@@ -1,4 +1,6 @@
 import Elysia from "elysia";
+import Crypto from "node:crypto";
+
 import { type SigningKey, generateKeyPairsFromString } from "../keys";
 import { toUnpaddedBase64 } from "../binaryData";
 import type {
@@ -9,6 +11,8 @@
 import type { HomeServerRoutes } from "../app";
 import type { EventBase } from "@hs/core/src/events/eventBase";
 import type { EventStore } from "../plugins/mongodb";
+import { createRoom } from "../procedures/createRoom";
+import { createSignedEvent } from "@hs/core/src/events/utils/createSignedEvent";
 
 type MockedFakeRequest = <
 	M extends HomeServerRoutes["method"],
@@ -19,6 +23,28 @@
 	body: getAllResponsesByPath<HomeServerRoutes, M, U>["body"],
 ) => Promise<Request>;
 
+export function createMediaId(length: number) {
+	const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+	let result = "";
+	for (let i = 0; i < length; i++) {
+		const randomIndex = Crypto.randomInt(0, characters.length);
+		result += characters[randomIndex];
+	}
+	return result;
+}
+
+class MockedRoom {
+	private events: EventStore[] = [];
+	constructor(
+		private roomId: string,
+		events: EventStore[],
+	) {
+		for (const event of events) {
+			this.events.push(event);
+		}
+	}
+}
+
 export class ContextBuilder {
 	private config: any;
 	private mongo: any;
@@ -35,33 +61,33 @@
 		return new ContextBuilder(name);
 	}
 
 	public withName(name: string) {
 		this.name = name;
 		return this;
 	}
 
 	public withEvent(roomId: string, event: EventBase) {
 		const arr = this.events.get(roomId) || [];
 		arr.push({
 			_id: generateId(event),
 			event,
 		});
 		this.events.set(roomId, arr);
 		return this;
 	}
 
 	public withConfig(config: any) {
 		this.config = config;
 		return this;
 	}
 
 	public withMongo(mongo: any) {
 		this.mongo = mongo;
 		return this;
 	}
 
 	public withMutex(mutex: any) {
 		this.mutex = mutex;
 		return this;
 	}
 
@@ -75,8 +101,8 @@
 		return this;
 	}
 
 	public withRemoteSigningKey(remote: string, signingKey: SigningKey) {
 		this.remoteRemoteSigningKeys.set(remote, signingKey);
 		return this;
 	}
 
@@ -86,6 +112,7 @@
 		app: Elysia<any, any, any, any, any, any>;
 		instance: ContextBuilder;
 		makeRequest: MockedFakeRequest;
+		createRoom: (sender: string, ...members: string[]) => Promise<MockedRoom>;
 	}> {
 		const signature = await generateKeyPairsFromString(this.signingSeed);
 
@@ -116,13 +143,13 @@
 							?.filter((event) => eventIds.includes(event._id)) ?? []
 					);
 				},
 				createStagingEvent: async (event: EventBase) => {
 					const id = generateId(event);
 					this.events.get(event.room_id)?.push({
 						_id: id,
 						event,
 						staged: true,
 					});
 					return id;
 				},
 				createEvent: async (event: EventBase) => {
@@ -155,12 +182,25 @@
 				body: body && JSON.stringify(body),
 			});
 		};
+
 		return {
 			signature,
 			name: this.name,
 			app,
 			instance: this,
 			makeRequest,
+			createRoom: async (sender: string, ...members: string[]) => {
+				const { roomId, events } = await createRoom(
+					[sender, ...members],
+					createSignedEvent(config.signingKey[0], config.name),
+					`!${createMediaId(18)}:${config.name}`,
+				);
+
+				for (const { event } of events) {
+					this.withEvent(roomId, event);
+				}
+				return new MockedRoom(roomId, events);
+			},
 		};
 	}
 }

packages/homeserver/src/makeRequest.ts

@@ -1,5 +1,5 @@
 import type { HomeServerRoutes } from "./app";
-import { authorizationHeaders, computeHash } from "./authentication";
+import { authorizationHeaders, computeAndMergeHash } from "./authentication";
 import { resolveHostAddressByServerName } from "./helpers/server-discovery/discovery";
 import { extractURIfromURL } from "./helpers/url";
 import type { SigningKey } from "./keys";
@@ -50,7 +50,7 @@ export const makeSignedRequest = async <
 	const signedBody =
 		body &&
 		(await signJson(
-			computeHash({ ...body, signatures: {} }),
+			computeAndMergeHash({ ...body, signatures: {} }),
 			signingKey,
 			signingName,
 		));

packages/homeserver/src/mutex/Mutex.ts

@@ -1,7 +1,14 @@
 export class Mutex {
 	private map: Map<string, boolean> = new Map();
-	public async request(scope: string) {
+
+	public async request(scope: string, fail: true): Promise<Lock>;
+
+	public async request(scope: string): Promise<Lock | false>;
+	public async request(scope: string, fail?: true) {
 		if (this.map.has(scope)) {
+			if (fail) {
+				throw new Error("Mutex already locked");
+			}
 			return false;
 		}
 
@@ -20,4 +27,8 @@ export class Lock {
 	public async release() {
 		this.unlock();
 	}
+
+	[Symbol.dispose]() {
+		this.release();
+	}
 }

packages/homeserver/src/plugins/mongodb.ts

@@ -23,12 +23,18 @@ export interface Server {
 	// }[];
 }
 
+interface Room {
+	_id: string;
+	state: EventBase[];
+}
+
 export const routerWithMongodb = (db: Db) =>
 	new Elysia().decorate(
 		"mongo",
 		(() => {
 			const eventsCollection = db.collection<EventStore>("events");
 			const serversCollection = db.collection<Server>("servers");
+			const roomsCollection = db.collection<Room>("rooms");
 
 			const getLastEvent = async (roomId: string) => {
 				return eventsCollection.findOne(
@@ -37,6 +43,24 @@ export const routerWithMongodb = (db: Db) =>
 				);
 			};
 
+			const upsertRoom = async (roomId: string, state: EventBase[]) => {
+				await roomsCollection.findOneAndUpdate(
+					{ _id: roomId },
+					{
+						$set: {
+							_id: roomId,
+							state,
+						},
+					},
+					{ upsert: true },
+				);
+			};
+
+			const getEventsByIds = async (roomId: string, eventIds: string[]) => {
+				return eventsCollection
+					.find({ "event.room_id": roomId, "event._id": { $in: eventIds } })
+					.toArray();
+			};
 			const getDeepEarliestAndLatestEvents = async (
 				roomId: string,
 				earliest_events: string[],
@@ -165,6 +189,30 @@ export const routerWithMongodb = (db: Db) =>
 				return id;
 			};
 
+			const createEvent = async (event: EventBase) => {
+				const id = generateId(event);
+				await eventsCollection.insertOne({
+					_id: id,
+					event,
+				});
+
+				return id;
+			};
+
+			const removeEventFromStaged = async (roomId: string, id: string) => {
+				await eventsCollection.updateOne(
+					{ _id: id, "event.room_id": roomId },
+					{ $unset: { staged: 1 } },
+				);
+			};
+
+			const getOldestStagedEvent = async (roomId: string) => {
+				return eventsCollection.findOne(
+					{ staged: true, "event.room_id": roomId },
+					{ sort: { "event.origin_server_ts": 1 } },
+				);
+			};
+
 			return {
 				serversCollection,
 				getValidPublicKeyFromLocal,
@@ -175,7 +223,13 @@ export const routerWithMongodb = (db: Db) =>
 				getMissingEventsByDeep,
 				getLastEvent,
 				getAuthEvents,
+
+				removeEventFromStaged,
+				getEventsByIds,
+				getOldestStagedEvent,
 				createStagingEvent,
+				createEvent,
+				upsertRoom,
 			};
 		})(),
 	);

packages/homeserver/src/procedures/createRoom.spec.ts

@@ -11,8 +11,7 @@ test("createRoom", async () => {
 	const makeSignedEvent = createSignedEvent(signature, "hs1");
 
 	const { roomId, events } = await createRoom(
-		"@sender:hs1",
-		"username",
+		["@sender:hs1", "@username:hs1"],
 		makeSignedEvent,
 		"!roomId:hs1",
 	);

packages/homeserver/src/procedures/createRoom.ts

@@ -10,8 +10,7 @@ import { createRoomHistoryVisibilityEvent } from "@hs/core/src/events/m.room.his
 import { createRoomGuestAccessEvent } from "@hs/core/src/events/m.room.guest_access";
 
 export const createRoom = async (
-	sender: string,
-	username: string,
+	users: [sender: string, ...username: string[]],
 	makeSignedEvent: ReturnType<typeof createSignedEvent>,
 	roomId: string,
 ): Promise<{
@@ -23,6 +22,8 @@ export const createRoom = async (
 }> => {
 	// Create
 
+	const [sender, ...members] = users;
+
 	const createRoomSigned = createRoomCreateEvent(makeSignedEvent);
 
 	const createMemberRoomSigned = createRoomMemberEvent(makeSignedEvent);
@@ -62,8 +63,7 @@ export const createRoom = async (
 
 	const powerLevelsEvent = await createPowerLevelsRoomSigned({
 		roomId,
-		sender,
-		member: username,
+		members: [sender, ...members],
 		auth_events: [createEvent._id, memberEvent._id],
 		prev_events: [memberEvent._id],
 		depth: 3,