matrix-nodejs-homeserver 0.0.0-stage → 0.3.1

package/dist/api/rtc.d.ts

@@ -0,0 +1,23 @@
+//#region src/api/rtc.d.ts
+export interface TurnOptions {
+  uris: string[];
+  /** coturn `static-auth-secret`: time-limited credentials are derived from it. */
+  sharedSecret?: string;
+  /** Static credentials, when not using a shared secret. */
+  username?: string;
+  password?: string;
+  /** Credential lifetime in seconds. Default: 86400. */
+  ttlSeconds?: number;
+  /** Whether guests may obtain credentials. Default: false. */
+  allowGuests?: boolean;
+}
+export interface RtcOptions {
+  /** VoIP TURN servers. */
+  turn?: TurnOptions;
+  /**
+   * MatrixRTC transports (MSC4143), e.g. `[{ type: "livekit", livekit_service_url: "https://lk-jwt.example.com" }]`.
+   * Advertised at /rtc/transports and in /.well-known/matrix/client.
+   */
+  transports?: Record<string, unknown>[];
+}
+//#endregion

package/dist/api/rtc.js

@@ -0,0 +1,66 @@
+import { errors } from "../core/errors.js";
+import { string } from "../vendor/zod/v4/classic/schemas.js";
+import { body, fail } from "../http/input.js";
+import { procedure } from "../http/procedure.js";
+import { createHmac } from "node:crypto";
+//#region src/api/rtc.ts
+function registerRtcRoutes(r) {
+	r.client("GET", "/voip/turnServer", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			const s = ctx.session;
+			const turn = ctx.hs.config.rtc.turn;
+			if (!turn || !turn.uris.length) return {};
+			if (s.isGuest && !turn.allowGuests) throw errors.forbidden("Guests may not use TURN");
+			const ttl = turn.ttlSeconds ?? 86400;
+			if (turn.sharedSecret) {
+				const username = `${Math.floor(Date.now() / 1e3) + ttl}:${s.userId}`;
+				return {
+					username,
+					password: createHmac("sha1", turn.sharedSecret).update(username).digest("base64"),
+					uris: turn.uris,
+					ttl
+				};
+			}
+			return {
+				username: turn.username ?? "",
+				password: turn.password ?? "",
+				uris: turn.uris,
+				ttl
+			};
+		}
+	}));
+	const transports = async (ctx) => {
+		await ctx.auth();
+		return { rtc_transports: ctx.hs.config.rtc.transports ?? [] };
+	};
+	r.client("GET", "/rtc/transports", procedure({ handler: transports }), ["v1"]);
+	r.get("/_matrix/client/unstable/org.matrix.msc4143/rtc/transports", procedure({ handler: transports }));
+	const base = "/_matrix/client/unstable/org.matrix.msc4140/delayed_events";
+	r.get(base, procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			const s = ctx.session;
+			return { delayed_events: await ctx.hs.delayedEvents.list(s.userId) };
+		}
+	}));
+	r.post(`${base}/:delayId`, procedure({
+		auth: "user",
+		input: body({ action: string(fail("M_MISSING_PARAM", "Missing action")) }),
+		handler: async (ctx) => {
+			const s = ctx.session;
+			await ctx.hs.delayedEvents.update(s.userId, ctx.params.delayId, ctx.input.action);
+			return {};
+		}
+	}));
+	r.post(`${base}/:delayId/:action`, procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			const s = ctx.session;
+			await ctx.hs.delayedEvents.update(s.userId, ctx.params.delayId, ctx.params.action);
+			return {};
+		}
+	}));
+}
+//#endregion
+export { registerRtcRoutes };

package/dist/api/search.js

@@ -0,0 +1,161 @@
+import { isObject } from "../core/json.js";
+import { M } from "../core/m.js";
+import { getState } from "../core/authrules.js";
+import { looseObject, string, unknown } from "../vendor/zod/v4/classic/schemas.js";
+import { body, fail } from "../http/input.js";
+import { procedure } from "../http/procedure.js";
+import { matchesFilter } from "./filters.js";
+import { paginate, topoToken } from "./rooms.js";
+//#region src/api/search.ts
+const DEFAULT_KEYS = [
+	"content.body",
+	"content.name",
+	"content.topic"
+];
+function valueAt(obj, path) {
+	return path.split(".").reduce((o, k) => isObject(o) ? o[k] : void 0, obj);
+}
+function registerSearchRoutes(r) {
+	const missingTerm = fail("M_BAD_JSON", "Missing search_categories.room_events.search_term");
+	const searchBody = body({ search_categories: looseObject({ room_events: looseObject({
+		search_term: string(missingTerm),
+		keys: unknown().optional(),
+		filter: unknown().optional(),
+		order_by: unknown().optional()
+	}, missingTerm) }, missingTerm) });
+	r.client("POST", "/search", procedure({
+		auth: "user",
+		input: searchBody,
+		handler: async (ctx) => {
+			const s = ctx.session;
+			const hs = ctx.hs;
+			const criteria = ctx.input.search_categories.room_events;
+			const terms = criteria.search_term.toLowerCase().split(/\s+/).filter(Boolean);
+			const keys = Array.isArray(criteria.keys) && criteria.keys.length ? criteria.keys : DEFAULT_KEYS;
+			const filter = isObject(criteria.filter) ? criteria.filter : {};
+			const limit = Math.min(filter.limit ?? 10, 100);
+			const orderBy = criteria.order_by === "recent" ? "recent" : "rank";
+			const offset = Number.parseInt(ctx.query.get("next_batch") ?? "0", 10) || 0;
+			let rooms = await hs.rooms.roomsForUser(s.userId);
+			if (filter.rooms) rooms = rooms.filter((r) => filter.rooms.includes(r));
+			if (filter.not_rooms) rooms = rooms.filter((r) => !filter.not_rooms.includes(r));
+			const hits = [];
+			for (const roomId of rooms) {
+				const rows = await hs.db.findMany("events", {
+					where: [{
+						field: "room_id",
+						value: roomId
+					}],
+					sortBy: {
+						field: "stream",
+						direction: "desc"
+					}
+				});
+				const candidates = [];
+				for (const row of rows) {
+					if (row.state_key !== null || !matchesFilter(filter, row.json)) continue;
+					let rank = 0;
+					const words = [];
+					for (const key of keys) {
+						const v = valueAt(row.json, key);
+						if (typeof v === "string") words.push(...v.toLowerCase().split(/[^\p{L}\p{N}]+/u));
+					}
+					if (terms.every((t) => words.includes(t))) for (const t of terms) rank += words.filter((w) => w === t).length;
+					if (rank > 0) candidates.push({
+						ev: hs.rooms.rowToStored(row),
+						rank
+					});
+				}
+				const visible = new Set((await hs.rooms.filterVisible(s.userId, roomId, candidates.map((c) => c.ev))).map((v) => v.pdu.event_id));
+				hits.push(...candidates.filter((c) => visible.has(c.ev.pdu.event_id)));
+			}
+			hits.sort((a, b) => orderBy === "rank" && b.rank !== a.rank ? b.rank - a.rank : b.ev.stream - a.ev.stream);
+			const page = hits.slice(offset, offset + limit);
+			const viewer = {
+				userId: s.userId,
+				deviceId: s.deviceId
+			};
+			const ec = isObject(criteria.event_context) ? criteria.event_context : null;
+			const results = [];
+			for (const hit of page) {
+				const result = {
+					rank: hit.rank,
+					result: hs.rooms.formatEvent(hit.ev, viewer)
+				};
+				if (ec) {
+					const roomId = hit.ev.pdu.room_id;
+					const here = {
+						depth: hit.ev.pdu.depth,
+						stream: hit.ev.stream
+					};
+					const before = await paginate(hs, s.userId, roomId, {
+						from: here,
+						to: null,
+						dir: "b",
+						limit: ec.before_limit ?? 5
+					});
+					const after = await paginate(hs, s.userId, roomId, {
+						from: here,
+						to: null,
+						dir: "f",
+						limit: ec.after_limit ?? 5
+					});
+					const context = {
+						events_before: before.events.map((e) => hs.rooms.formatEvent(e, viewer)),
+						events_after: after.events.map((e) => hs.rooms.formatEvent(e, viewer)),
+						start: before.end ?? topoToken(before.events.at(-1) ?? hit.ev),
+						end: topoToken(after.events.at(-1) ?? hit.ev)
+					};
+					if (ec.include_profile) {
+						const state = await hs.rooms.currentState(roomId);
+						const profile_info = {};
+						for (const e of [
+							...before.events,
+							hit.ev,
+							...after.events
+						]) {
+							const m = getState(state, M.ROOM.MEMBER, e.pdu.sender)?.content;
+							profile_info[e.pdu.sender] = {
+								displayname: m?.displayname,
+								avatar_url: m?.avatar_url
+							};
+						}
+						context.profile_info = profile_info;
+					}
+					result.context = context;
+				}
+				results.push(result);
+			}
+			const out = {
+				results,
+				count: hits.length,
+				highlights: terms
+			};
+			if (page.length === limit && offset + limit <= hits.length) out.next_batch = String(offset + limit);
+			if (criteria.include_state) {
+				out.state = {};
+				for (const roomId of new Set(page.map((h) => h.ev.pdu.room_id))) out.state[roomId] = [...(await hs.rooms.currentState(roomId)).values()].map((e) => hs.rooms.formatEvent({
+					pdu: e,
+					stream: 0,
+					snapshot: 0,
+					txnId: null,
+					txnToken: null
+				}));
+			}
+			if (criteria.groupings?.group_by?.some?.((g) => g?.key === "room_id")) {
+				const groups = {};
+				hits.forEach((h, i) => {
+					(groups[h.ev.pdu.room_id] ??= {
+						results: [],
+						order: i,
+						next_batch: null
+					}).results.push(h.ev.pdu.event_id);
+				});
+				out.groups = { room_id: groups };
+			}
+			return { search_categories: { room_events: out } };
+		}
+	}));
+}
+//#endregion
+export { registerSearchRoutes };