matrix-nodejs-homeserver 0.0.0-stage → 0.2.0

package/dist/api/relationships.js

@@ -0,0 +1,264 @@
+import { isObject } from "../core/json.js";
+import { toClientEvent } from "../core/events.js";
+import { errors } from "../core/errors.js";
+import { getState } from "../core/authrules.js";
+import { body } from "../http/input.js";
+import { createHash } from "node:crypto";
+//#region src/api/relationships.ts
+function parseRequest(body) {
+	if (!isObject(body) || typeof body.event_id !== "string") throw errors.badJson("event_id is required");
+	const num = (v, d, max) => Number.isInteger(v) && v >= 0 ? Math.min(v, max) : d;
+	return {
+		event_id: body.event_id,
+		room_id: typeof body.room_id === "string" ? body.room_id : void 0,
+		max_depth: num(body.max_depth, 3, 50),
+		max_breadth: num(body.max_breadth, 10, 100),
+		limit: Math.max(num(body.limit, 100, 1e3), 1),
+		depth_first: body.depth_first === true,
+		recent_first: body.recent_first !== false,
+		include_parent: body.include_parent === true,
+		include_children: body.include_children === true,
+		direction: body.direction === "up" ? "up" : "down"
+	};
+}
+function relationshipOf(pdu) {
+	const rel = pdu.content?.["m.relationship"];
+	return isObject(rel) && typeof rel.event_id === "string" && typeof rel.rel_type === "string" ? {
+		event_id: rel.event_id,
+		rel_type: rel.rel_type
+	} : null;
+}
+/** Index an event's `m.relationship` edge (idempotent). */
+async function recordEdge(hs, pdu) {
+	const rel = relationshipOf(pdu);
+	if (!rel || !pdu.event_id) return;
+	await hs.db.upsert("event_edges", {
+		event_id: pdu.event_id,
+		room_id: pdu.room_id,
+		parent_id: rel.event_id,
+		rel_type: rel.rel_type,
+		ts: pdu.origin_server_ts ?? 0,
+		depth: pdu.depth ?? 0
+	});
+}
+async function children(hs, eventId, recentFirst) {
+	const rows = await hs.db.findMany("event_edges", { where: [{
+		field: "parent_id",
+		value: eventId
+	}] });
+	rows.sort((a, b) => (a.ts - b.ts || a.depth - b.depth || a.event_id.localeCompare(b.event_id)) * (recentFirst ? -1 : 1));
+	return rows;
+}
+async function childrenSummary(hs, eventId) {
+	const rows = await children(hs, eventId, false);
+	const counts = {};
+	for (const r of rows) counts[r.rel_type] = (counts[r.rel_type] ?? 0) + 1;
+	const ids = rows.map((r) => r.event_id).sort();
+	return {
+		children: counts,
+		children_hash: createHash("sha256").update(ids.join("")).digest("base64").replace(/=+$/, "")
+	};
+}
+/** Walk the local tree. `missing` collects referenced events this server does not have. */
+async function walk(hs, req, canSee, missing) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	let limited = false;
+	const push = async (id) => {
+		if (seen.has(id)) return false;
+		seen.add(id);
+		const pdu = await hs.rooms.getPdu(id);
+		if (!pdu) {
+			missing.add(id);
+			return false;
+		}
+		if (!await canSee(pdu)) return false;
+		if (out.length >= req.limit) {
+			limited = true;
+			return false;
+		}
+		out.push(pdu);
+		return true;
+	};
+	const root = await hs.rooms.getPdu(req.event_id);
+	if (!root) {
+		missing.add(req.event_id);
+		return {
+			events: out,
+			limited,
+			root: null
+		};
+	}
+	if (!await canSee(root)) throw errors.forbidden("You cannot see this event");
+	await push(req.event_id);
+	const parentId = relationshipOf(root)?.event_id;
+	if (req.include_parent && parentId) await push(parentId);
+	if (req.include_children) for (const c of await children(hs, req.event_id, req.recent_first)) await push(c.event_id);
+	if (req.direction === "up") {
+		let current = root;
+		for (let depth = 0; current && depth < req.max_depth; depth++) {
+			const up = relationshipOf(current)?.event_id;
+			if (!up) break;
+			if (!seen.has(up)) await push(up);
+			current = await hs.rooms.getPdu(up);
+		}
+	} else {
+		const queue = [{
+			id: req.event_id,
+			depth: 0
+		}];
+		while (queue.length && !limited) {
+			const { id, depth } = req.depth_first ? queue.pop() : queue.shift();
+			if (depth >= req.max_depth) continue;
+			const kids = (await children(hs, id, req.recent_first)).slice(0, req.max_breadth);
+			const next = [];
+			for (const kid of kids) {
+				if (seen.has(kid.event_id)) continue;
+				if (await push(kid.event_id)) next.push({
+					id: kid.event_id,
+					depth: depth + 1
+				});
+			}
+			if (req.depth_first) queue.push(...next.reverse());
+			else queue.push(...next);
+		}
+	}
+	return {
+		events: out,
+		limited,
+		root
+	};
+}
+async function withChildren(hs, pdu) {
+	return {
+		...pdu,
+		unsigned: {
+			...pdu.unsigned,
+			...await childrenSummary(hs, pdu.event_id)
+		}
+	};
+}
+/** Ask the room's other servers for part of the tree and store what they return. */
+async function fetchRemote(hs, roomId, req, remoteHashes) {
+	const version = await hs.rooms.roomVersion(roomId);
+	if (!version || !hs.federation.enabled) return false;
+	const servers = [...hs.federation.serversInRoom(await hs.rooms.currentState(roomId))].filter((s) => s !== hs.serverName);
+	for (const server of servers) {
+		let res;
+		try {
+			res = await hs.federation.client.request(server, "POST", "/_matrix/federation/unstable/event_relationships", { body: {
+				...req,
+				room_id: roomId
+			} });
+		} catch (err) {
+			hs.logger.debug("event_relationships fetch failed", server, err);
+			continue;
+		}
+		if (!isObject(res) || !Array.isArray(res.events)) continue;
+		await hs.federation.storeOutliers(roomId, version, [...Array.isArray(res.auth_chain) ? res.auth_chain : [], ...res.events]);
+		for (const raw of res.events) {
+			if (!isObject(raw)) continue;
+			const id = hs.federation.computeEventId(raw, version);
+			const pdu = id ? await hs.rooms.getPdu(id) : null;
+			if (!pdu) continue;
+			await recordEdge(hs, pdu);
+			if (typeof raw.unsigned?.children_hash === "string") remoteHashes.set(pdu.event_id, raw.unsigned.children_hash);
+		}
+		return true;
+	}
+	return false;
+}
+function registerRelationshipRoutes(r) {
+	r.post("/_matrix/client/unstable/event_relationships", { input: body({}) }, async (ctx) => {
+		const s = await ctx.auth();
+		const hs = ctx.hs;
+		const req = parseRequest(ctx.input);
+		const roomOf = async () => req.room_id ?? (await hs.rooms.getPdu(req.event_id))?.room_id ?? null;
+		const roomId = await roomOf();
+		if (!roomId) throw errors.forbidden("Unknown event");
+		if (await hs.rooms.membership(roomId, s.userId) !== "join") {
+			if (getState(await hs.rooms.currentState(roomId), "m.room.history_visibility")?.content?.history_visibility !== "world_readable") throw errors.forbidden("You are not in this room");
+		}
+		const canSee = async (pdu) => {
+			if (pdu.room_id !== roomId) return false;
+			const ev = await hs.rooms.getEvent(pdu.event_id);
+			if (!ev) return true;
+			return (await hs.rooms.filterVisible(s.userId, roomId, [ev])).length > 0;
+		};
+		const asked = /* @__PURE__ */ new Set();
+		const remoteHashes = /* @__PURE__ */ new Map();
+		let result = {
+			events: [],
+			limited: false,
+			root: null
+		};
+		for (let round = 0; round < 4; round++) {
+			const missing = /* @__PURE__ */ new Set();
+			result = await walk(hs, req, canSee, missing);
+			const wanted = [];
+			for (const id of missing) {
+				if (asked.has(id)) continue;
+				asked.add(id);
+				wanted.push(id === req.event_id ? req : {
+					...req,
+					event_id: id,
+					direction: "up",
+					include_parent: false,
+					include_children: false
+				});
+			}
+			for (const pdu of result.events) {
+				const remote = remoteHashes.get(pdu.event_id);
+				if (!remote || asked.has(`children:${pdu.event_id}`)) continue;
+				if (remote !== (await childrenSummary(hs, pdu.event_id)).children_hash) {
+					asked.add(`children:${pdu.event_id}`);
+					wanted.push({
+						...req,
+						event_id: pdu.event_id,
+						direction: "down",
+						max_depth: 1,
+						include_parent: false,
+						include_children: false
+					});
+				}
+			}
+			if (!wanted.length) break;
+			for (const w of wanted) await fetchRemote(hs, roomId, w, remoteHashes);
+		}
+		if (!result.root) throw errors.notFound("Event not found");
+		const events = [];
+		for (const pdu of result.events) events.push(toClientEvent(await withChildren(hs, pdu)));
+		return {
+			events,
+			limited: result.limited,
+			next_batch: null
+		};
+	});
+}
+/** Server side of `/_matrix/federation/unstable/event_relationships`. */
+async function relationshipsForServer(hs, origin, body, authChainOf) {
+	const req = parseRequest(body);
+	const root = await hs.rooms.getPdu(req.event_id);
+	if (!root) throw errors.notFound("Event not found");
+	const roomId = root.room_id;
+	if (!hs.federation.serversInRoom(await hs.rooms.currentState(roomId)).has(origin)) throw errors.forbidden("Server is not in this room");
+	const result = await walk(hs, req, async (pdu) => pdu.room_id === roomId, /* @__PURE__ */ new Set());
+	const version = await hs.rooms.roomVersion(roomId);
+	const events = [];
+	for (const pdu of result.events) {
+		const wire = hs.federation.toFederationPdu(pdu, version);
+		wire.unsigned = {
+			...wire.unsigned,
+			...await childrenSummary(hs, pdu.event_id)
+		};
+		events.push(wire);
+	}
+	const chain = await authChainOf(result.events.map((p) => p.event_id));
+	return {
+		events,
+		limited: result.limited,
+		auth_chain: chain.map((p) => hs.federation.toFederationPdu(p, version))
+	};
+}
+//#endregion
+export { recordEdge, registerRelationshipRoutes, relationshipOf, relationshipsForServer };