matrix-nodejs-homeserver 0.3.2 → 0.3.3

package/README.md

@@ -1,5 +1,6 @@
 # matrix-nodejs-homeserver
 
+[![Complement](https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fk18k%2Fmatrix-nodejs-homeserver%2Fcomplement-results%2Fbadges%2Fcomplement.json)](https://github.com/k18k/matrix-nodejs-homeserver/actions/workflows/ci.yml)
 [![Load test: SQLite](https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fk18k%2Fmatrix-nodejs-homeserver%2Floadtest-results%2Fbadges%2Fsqlite.json)](https://github.com/k18k/matrix-nodejs-homeserver/actions/workflows/loadtest.yml)
 [![Load test: Postgres](https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fk18k%2Fmatrix-nodejs-homeserver%2Floadtest-results%2Fbadges%2Fpg-nocluster.json)](https://github.com/k18k/matrix-nodejs-homeserver/actions/workflows/loadtest.yml)
 [![Load test: Postgres cluster, 1 node](https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fk18k%2Fmatrix-nodejs-homeserver%2Floadtest-results%2Fbadges%2Fpg-cluster-1.json)](https://github.com/k18k/matrix-nodejs-homeserver/actions/workflows/loadtest.yml)
@@ -65,12 +66,21 @@ mysqlAdapter(mysql.createPool(uri));                 // mysql2/promise
 memoryAdapter();                                     // tests / demos
 ```
 
+SQLite runs in WAL mode with `synchronous = NORMAL`: a commit survives a crash of the process,
+but a power loss can roll back the last few. Pass `sqliteAdapter(db, { synchronous: "full" })`
+to wait for the disk on every commit, at the cost of blocking the event loop each time.
+
 Tables are created on startup. Writes for each event are atomic: SQLite uses
 `BEGIN IMMEDIATE`, Postgres and MySQL use a dedicated pooled connection, and the
 memory adapter keeps an undo log.
 
+The Postgres adapter prepares its statements on each connection and reuses them. Behind a
+pooler that does not support prepared statements (PgBouncer before 1.21, or in transaction
+mode without `max_prepared_statements`), pass `postgresAdapter(pool, { preparedStatements: false })`.
+
 To use another store, implement `DatabaseAdapter` (`create`, `upsert`, `findOne`,
-`findMany`, `update`, `delete`, `max`, and optionally `migrate` and `transaction`).
+`findMany`, `update`, `delete`, `max`, and optionally `migrate`, `transaction`,
+`findManyBatch` and `upsertMany`).
 The exported `schema` describes every model. If your driver can run parameterised
 SQL, `sqlAdapter({ dialect, executor, transaction })` handles the SQL generation for you.
 
@@ -459,6 +469,7 @@ Live status, updated after every Complement run (full or targeted) with
 
 | Run | Top-level | Subtests | Note |
 |---|---|---|---|
+| 10 | 214 / 214 | 851 / 851 | load-test fixes #25–#35: batched /sync reads, sync concurrency limit, Postgres lock leases, group commit (248ac8d) |
 | 9 | 214 / 214 | 851 / 851 | zod, procedures, M/UNSTABLE, SSO confirmation, outbound address policy, admin guard (ec5aa79) |
 | 8 | 214 / 214 | 851 / 851 | Complement runs in a Go container (no submodule, no local Go); account locking/suspension, policy servers, 3PIDs, legacy sync endpoints |
 | 7 | 214 / 214 | 851 / 851 | All Complement tests pass (previous full run: 211/214). Fallback keys stored apart from one-time keys; user directory public-room rules; MSC4311 create event required from v12 |
@@ -513,18 +524,34 @@ Latest results: 1000 users online in 25 rooms (40 per room), 50 messages/s, 30 s
 
 | Setup | req/s | send | /sync | join | delivery | messages delivered | failed |
 |---|---|---|---|---|---|---|---|
-| SQLite, 1 process (before #28–#35) | ~800 | 46 ms / 0.69 s | 0.50 s / 2.4 s | 61 ms / 0.15 s | 0.58 s / 0.78 s | 5,816 | 0% |
-| Postgres, no cluster | 404 | 49 ms / 71 ms | 2.6 s / 3.6 s | 18 ms / 27 ms | 4.6 s / 6.5 s | 56,297 | 0% |
-| Postgres, cluster, 1 node | 314 | 81 ms / 124 ms | 2.8 s / 4.4 s | 50 ms / 70 ms | 5.2 s / 7.5 s | 52,071 | 0% |
-| Postgres, cluster, 5 nodes | 840 | 118 ms / 197 ms | 0.90 s / 1.4 s | 86 ms / 151 ms | 1.6 s / 2.3 s | 58,298 | 0% |
+| SQLite, 1 process | 662 | 97 ms / 0.16 s | 0.87 s / 1.6 s | 10 ms / 91 ms | 1.64 s / 2.70 s | 53,935 | 0% |
+| Postgres, no cluster | 670 | 15 ms / 19 ms | 1.1 s / 1.8 s | 14 ms / 23 ms | 1.76 s / 2.31 s | 58,667 | 0% |
+| Postgres, cluster, 1 node | 593 | 27 ms / 38 ms | 1.3 s / 2.0 s | 36 ms / 51 ms | 1.96 s / 2.57 s | 58,493 | 0% |
+| Postgres, cluster, 5 nodes | 871 | 60 ms / 88 ms | 0.50 s / 1.1 s | 62 ms / 119 ms | 0.70 s / 1.09 s | 59,298 | 0% |
 
 What the load tests found and fixed so far: presence written on every `/sync` (#26), one commit
 per push notification (#27), a missing index (#28), Postgres cluster locks that could deadlock
 the pool (#29), stream writes serialized per instance (#30), `/sync` reading every change on the
 server (#31) and every joined room (#33), lock handover by polling (#32). Then `/sync` reads were batched
 (#34) and a process builds at most four sync responses at once (#35), so sends no longer queue
-behind the syncs a message wakes. A Postgres node now builds ~330 syncs/s here; delivery time is
-syncs waiting for their turn, and more nodes shorten it.
+behind the syncs a message wakes.
+
+Since 0.3.2 (#38–#45), Postgres delivery time fell by about 55% on one node and 50% on five:
+- changed rooms are built concurrently, with fewer reads each (#38);
+- push notifications of a message are written in one statement (#39);
+- Postgres statements are prepared once per connection (#40);
+- push rules are no longer copied per member (#41);
+- to-device acknowledgements run only when needed (#42);
+- reads issued at the same moment by concurrent requests share one statement (#43);
+- presence and device-list changes are found through a stream index (#44);
+- batched reads take half as long to plan (#45).
+
+On SQLite, commits no longer wait for an fsync (#46). Database calls also yield to the event
+loop (#47): before that, a wave of syncs could hold it for seconds, sends took 0.74 s and the
+server took in only about 40% of the messages the scenario sends.
+
+With every user receiving about two messages a second, delivery time is how long it takes a
+process to rebuild every user's `/sync` in turn: about 750 per second per Postgres node here.
 <!-- loadtest-results:end -->
 
 ## License

package/dist/api/slidingsync.js

@@ -421,10 +421,10 @@ async function buildExtensions(hs, s, ext, since, to, roomIds, next) {
 			else if (roomIds.includes(r.room_id) || since !== null) (rooms[r.room_id] ??= []).push(ev);
 		}
 		if (since === null && !global.some((e) => e.type === M.PUSH_RULES)) {
-			const { loadRules } = await import("../core/pushrules.js");
+			const { readOnlyRules } = await import("../core/pushrules.js");
 			global.push({
 				type: M.PUSH_RULES,
-				content: { global: await loadRules(hs, userId) }
+				content: { global: await readOnlyRules(hs, userId) }
 			});
 		}
 		out.account_data = {

package/dist/api/sync.js

@@ -2,26 +2,27 @@ import { M, UNSTABLE } from "../core/m.js";
 import { eventIdOf, splitStateKey, stateKey, toClientEvent } from "../core/events.js";
 import { errors } from "../core/errors.js";
 import { getState } from "../core/authrules.js";
-import { loadRules } from "../core/pushrules.js";
+import { readOnlyRules } from "../core/pushrules.js";
 import { inviteDecision } from "../core/invitefilter.js";
 import { deviceListChangesQuery } from "../core/keys.js";
 import { body } from "../http/input.js";
 import { procedure } from "../http/procedure.js";
-import { matchesFilter, roomAllowed, validateSyncFilter } from "./filters.js";
 import { readBatch } from "../storage/batch.js";
+import { matchesFilter, roomAllowed, validateSyncFilter } from "./filters.js";
 import { Semaphore } from "../core/semaphore.js";
 import { fullProfile } from "../core/profile.js";
 //#region src/api/sync.ts
 function parseSyncToken(raw) {
 	if (!raw) return null;
-	const m = /^s(\d+)(?:_(\d+))?$/.exec(raw);
+	const m = /^s(\d+)(?:_(\d+))?(_a)?$/.exec(raw);
 	if (!m) throw errors.invalidParam("Invalid since token");
 	return {
 		pos: Number(m[1]),
-		toDevice: Number(m[2] ?? m[1])
+		toDevice: Number(m[2] ?? m[1]),
+		ack: !!m[3]
 	};
 }
-const formatToken = (t) => `s${t.pos}_${t.toDevice}`;
+const formatToken = (t) => `s${t.pos}_${t.toDevice}${t.ack ? "_a" : ""}`;
 async function loadFilter(hs, userId, raw) {
 	if (!raw) return {};
 	if (raw.trim().startsWith("{")) {
@@ -88,6 +89,8 @@ async function roomTimeline(hs, p, roomId, since, upTo) {
 		operator: "gt",
 		value: since
 	});
+	const sinceIdsRead = since !== null ? snapshotAt(hs, roomId, since).then((id) => hs.rooms.snapshotIds(id)) : Promise.resolve({});
+	const scanned = [];
 	const events = [];
 	let limited = false;
 	let cursor = upTo;
@@ -106,6 +109,7 @@ async function roomTimeline(hs, p, roomId, since, upTo) {
 			limit: batchSize
 		});
 		if (rows.length === 0) break;
+		scanned.push(...rows);
 		const stored = rows.map((r) => hs.rooms.rowToStored(r));
 		const visible = await hs.rooms.filterVisible(p.session.userId, roomId, stored);
 		const ok = new Map(visible.map((v) => [v.pdu.event_id, v]));
@@ -143,25 +147,50 @@ async function roomTimeline(hs, p, roomId, since, upTo) {
 		events.splice(0, lastGap);
 		limited = true;
 	}
-	if (!limited && events.length) limited = (await hs.db.findMany("events", {
-		where: [...where.filter((c) => c.operator !== "lte"), {
-			field: "stream",
-			operator: "lt",
-			value: events[0].stream
-		}],
-		limit: 1,
-		fields: ["stream"]
-	})).length > 0;
 	const startPos = events.length ? Math.min(...events.map((e) => e.stream)) - 1 : upTo;
-	const startState = await hs.rooms.stateAtSnapshot(await snapshotAt(hs, roomId, startPos));
+	const newestAtOrBefore = async (pos) => {
+		const row = scanned.find((r) => r.stream <= pos);
+		if (row) return row;
+		return (await hs.db.findMany("events", {
+			where: [{
+				field: "room_id",
+				value: roomId
+			}, {
+				field: "stream",
+				operator: "lte",
+				value: pos
+			}],
+			sortBy: {
+				field: "stream",
+				direction: "desc"
+			},
+			limit: 1,
+			fields: ["stream", "state_snapshot"]
+		}))[0] ?? null;
+	};
+	const [atStart, atEnd] = await Promise.all([newestAtOrBefore(startPos), startPos === upTo ? null : newestAtOrBefore(upTo)]);
+	const startSnapshot = atStart?.state_snapshot ?? 0;
+	const endSnapshot = startPos === upTo ? startSnapshot : atEnd?.state_snapshot ?? 0;
+	if (!limited && events.length) {
+		if (events[0].stream === startPos + 1) limited = atStart !== null && (since === null || atStart.stream > since);
+		else limited = (await hs.db.findMany("events", {
+			where: [...where.filter((c) => c.operator !== "lte"), {
+				field: "stream",
+				operator: "lt",
+				value: events[0].stream
+			}],
+			limit: 1,
+			fields: ["stream"]
+		})).length > 0;
+	}
+	const [startState, endState] = await Promise.all([hs.rooms.stateAtSnapshot(startSnapshot), hs.rooms.stateAtSnapshot(endSnapshot)]);
 	const timelineIds = new Set(events.map((e) => e.pdu.event_id));
-	const endState = await hs.rooms.stateAtSnapshot(await snapshotAt(hs, roomId, upTo));
 	for (const [key, ev] of endState) {
 		if (timelineIds.has(ev.event_id) || startState.get(key)?.event_id === ev.event_id) continue;
 		if (events.some((e) => e.pdu.state_key !== void 0 && stateKey(e.pdu.type, e.pdu.state_key) === key)) continue;
 		startState.set(key, ev);
 	}
-	const sinceIds = since !== null ? await hs.rooms.snapshotIds(await snapshotAt(hs, roomId, since)) : {};
+	const sinceIds = await sinceIdsRead;
 	const sf = p.filter.room?.state;
 	const lazy = !!sf?.lazy_load_members;
 	const senders = new Set(events.map((e) => e.pdu.sender));
@@ -181,15 +210,12 @@ async function roomTimeline(hs, p, roomId, since, upTo) {
 		if (member && matchesFilter(sf, member)) state.push(member);
 	}
 	const stateAfter = [];
-	if (p.useStateAfter) {
-		const endState = await hs.rooms.stateAtSnapshot(await snapshotAt(hs, roomId, upTo));
-		for (const [key, ev] of endState) {
-			if (sinceIds[key] === ev.event_id) continue;
-			const [type, sk] = splitStateKey(key);
-			if (!matchesFilter(sf, ev)) continue;
-			if (lazy && type === M.ROOM.MEMBER && !senders.has(sk)) continue;
-			stateAfter.push(ev);
-		}
+	if (p.useStateAfter) for (const [key, ev] of endState) {
+		if (sinceIds[key] === ev.event_id) continue;
+		const [type, sk] = splitStateKey(key);
+		if (!matchesFilter(sf, ev)) continue;
+		if (lazy && type === M.ROOM.MEMBER && !senders.has(sk)) continue;
+		stateAfter.push(ev);
 	}
 	return {
 		stateAfter,
@@ -369,6 +395,23 @@ async function changesSince(hs, p, memberships, since, accountRows) {
 		memberChanges
 	};
 }
+/** Presence or device-list changes after a token read without a user filter, at most (#44). */
+const RECENT_CHANGES = 500;
+/** How many of a sync's joined rooms are built at once (#38). */
+const JOINED_ROOMS_AT_ONCE = 8;
+/** `fn` over `items` with at most `limit` running at once; results in input order. */
+async function mapConcurrently(items, limit, fn) {
+	const out = [];
+	let next = 0;
+	const worker = async () => {
+		while (next < items.length) {
+			const i = next++;
+			out[i] = await fn(items[i]);
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+	return out;
+}
 async function buildSync(hs, p) {
 	const userId = p.session.userId;
 	const since = p.since?.pos ?? null;
@@ -380,7 +423,7 @@ async function buildSync(hs, p) {
 		field: "device_id",
 		value: p.session.deviceId
 	}];
-	const acknowledged = p.since ? hs.db.delete("to_device", [...deviceWhere, {
+	const acknowledged = p.since?.ack ? hs.db.delete("to_device", [...deviceWhere, {
 		field: "stream",
 		operator: "lte",
 		value: p.since.toDevice
@@ -469,39 +512,14 @@ async function buildSync(hs, p) {
 	const leave = {};
 	const knock = {};
 	let empty = true;
+	const joinedBuilds = [];
 	for (const m of memberships) {
 		if (m.stream > p.to || !roomAllowed(p.filter, m.room_id)) continue;
 		const roomId = m.room_id;
 		const changed = since === null || m.stream > since;
 		if (m.membership === "join") {
 			if (changes && !changed && !changes.touched.has(roomId) && hs.typing.typingSince(roomId, since) === null) continue;
-			if (!p.filter.room?.state?.lazy_load_members && await hs.partialState.isPartial(roomId)) continue;
-			const completedAt = await hs.partialState.completedAt(roomId);
-			const initial = since === null || p.fullState || m.stream > since || completedAt !== null && completedAt > since && completedAt <= p.to;
-			const { timeline, state, stateAfter, timelineEvents } = await roomTimeline(hs, p, roomId, initial ? null : since, p.to);
-			const ephemeral = await roomEphemeral(hs, p, roomId, changes ? changes.receipts.get(roomId) ?? [] : void 0);
-			const roomAccountData = await accountData(hs, p, roomId, changes ? changes.accountData.get(roomId) ?? [] : void 0);
-			if (!initial && timelineEvents.length === 0 && state.length === 0 && stateAfter.length === 0 && ephemeral.length === 0 && roomAccountData.length === 0) continue;
-			join[roomId] = {
-				timeline,
-				...p.useStateAfter ? { [p.stateAfterKey ?? "state_after"]: { events: stateAfter.map((e) => toClientEvent(e, { includeRoomId: false })) } } : { state: { events: state.map((e) => toClientEvent(e, { includeRoomId: false })) } },
-				ephemeral: { events: ephemeral },
-				account_data: { events: roomAccountData },
-				summary: await roomSummary(hs, roomId, userId)
-			};
-			const counts = await hs.push.unreadCounts(userId, roomId);
-			if (p.filter.room?.timeline?.unread_thread_notifications) {
-				join[roomId].unread_notifications = counts.room;
-				if (Object.keys(counts.threads).length) join[roomId].unread_thread_notifications = counts.threads;
-			} else {
-				const total = { ...counts.room };
-				for (const t of Object.values(counts.threads)) {
-					total.notification_count += t.notification_count;
-					total.highlight_count += t.highlight_count;
-				}
-				join[roomId].unread_notifications = total;
-			}
-			empty = false;
+			joinedBuilds.push(m);
 		} else if (m.membership === "invite") {
 			if (!changed && !p.fullState) continue;
 			const pdu = await hs.rooms.getPdu(m.event_id);
@@ -533,10 +551,49 @@ async function buildSync(hs, p) {
 			empty = false;
 		}
 	}
+	const joinedRoom = async (m) => {
+		const roomId = m.room_id;
+		if (!p.filter.room?.state?.lazy_load_members && await hs.partialState.isPartial(roomId)) return null;
+		const completedAt = await hs.partialState.completedAt(roomId);
+		const initial = since === null || p.fullState || m.stream > since || completedAt !== null && completedAt > since && completedAt <= p.to;
+		const [{ timeline, state, stateAfter, timelineEvents }, ephemeral, roomAccountData, summary, counts] = await Promise.all([
+			roomTimeline(hs, p, roomId, initial ? null : since, p.to),
+			roomEphemeral(hs, p, roomId, changes ? changes.receipts.get(roomId) ?? [] : void 0),
+			accountData(hs, p, roomId, changes ? changes.accountData.get(roomId) ?? [] : void 0),
+			roomSummary(hs, roomId, userId),
+			hs.push.unreadCounts(userId, roomId)
+		]);
+		if (!initial && timelineEvents.length === 0 && state.length === 0 && stateAfter.length === 0 && ephemeral.length === 0 && roomAccountData.length === 0) return null;
+		const room = {
+			timeline,
+			...p.useStateAfter ? { [p.stateAfterKey ?? "state_after"]: { events: stateAfter.map((e) => toClientEvent(e, { includeRoomId: false })) } } : { state: { events: state.map((e) => toClientEvent(e, { includeRoomId: false })) } },
+			ephemeral: { events: ephemeral },
+			account_data: { events: roomAccountData },
+			summary
+		};
+		if (p.filter.room?.timeline?.unread_thread_notifications) {
+			room.unread_notifications = counts.room;
+			if (Object.keys(counts.threads).length) room.unread_thread_notifications = counts.threads;
+		} else {
+			const total = { ...counts.room };
+			for (const t of Object.values(counts.threads)) {
+				total.notification_count += t.notification_count;
+				total.highlight_count += t.highlight_count;
+			}
+			room.unread_notifications = total;
+		}
+		return room;
+	};
+	const built = await mapConcurrently(joinedBuilds, JOINED_ROOMS_AT_ONCE, joinedRoom);
+	joinedBuilds.forEach((m, i) => {
+		if (!built[i]) return;
+		join[m.room_id] = built[i];
+		empty = false;
+	});
 	const globalAccountData = await accountData(hs, p, "", changes ? changes.accountData.get("") ?? [] : void 0);
 	if (since === null && !globalAccountData.some((e) => e.type === M.PUSH_RULES)) globalAccountData.push({
 		type: M.PUSH_RULES,
-		content: { global: await loadRules(hs, userId) }
+		content: { global: await readOnlyRules(hs, userId) }
 	});
 	if (globalAccountData.length) empty = false;
 	await acknowledged;
@@ -557,19 +614,38 @@ async function buildSync(hs, p) {
 		}
 	}
 	const sharingList = [...sharing];
-	const [presenceRows = [], newlySharedPresence = [], deviceRows] = await readBatch(hs.db, [
-		{
-			model: "presence",
-			opts: { where: [{
-				field: "user_id",
-				operator: "in",
-				value: wantPresence ? sharingList : []
-			}, ...since !== null ? [{
+	const recent = (model) => ({
+		model,
+		opts: {
+			where: [{
 				field: "stream",
 				operator: "gt",
 				value: since
-			}] : []] }
-		},
+			}],
+			sortBy: {
+				field: "stream",
+				direction: "asc"
+			},
+			limit: 501
+		}
+	});
+	const presenceQuery = since === null ? {
+		model: "presence",
+		opts: { where: [{
+			field: "user_id",
+			operator: "in",
+			value: wantPresence ? sharingList : []
+		}] }
+	} : wantPresence ? recent("presence") : {
+		model: "presence",
+		opts: { where: [{
+			field: "user_id",
+			operator: "in",
+			value: []
+		}] }
+	};
+	let [presenceRows = [], newlySharedPresence = [], deviceRows] = await readBatch(hs.db, [
+		presenceQuery,
 		{
 			model: "presence",
 			opts: { where: [{
@@ -578,11 +654,21 @@ async function buildSync(hs, p) {
 				value: [...newlyShared]
 			}] }
 		},
-		...since !== null ? [{
-			model: "device_list_changes",
-			opts: deviceListChangesQuery(sharing, since)
-		}] : []
+		...since !== null ? [recent("device_list_changes")] : []
 	]);
+	if (since !== null) {
+		if (presenceRows.length > RECENT_CHANGES) presenceRows = await hs.db.findMany("presence", { where: [{
+			field: "user_id",
+			operator: "in",
+			value: sharingList
+		}, {
+			field: "stream",
+			operator: "gt",
+			value: since
+		}] });
+		else presenceRows = presenceRows.filter((r) => sharing.has(r.user_id));
+		if (deviceRows.length > RECENT_CHANGES) deviceRows = await hs.db.findMany("device_list_changes", deviceListChangesQuery(sharing, since));
+	}
 	if (wantPresence) {
 		const seen = /* @__PURE__ */ new Set();
 		for (const row of [...presenceRows, ...newlySharedPresence]) {
@@ -609,7 +695,8 @@ async function buildSync(hs, p) {
 	const body = {
 		next_batch: formatToken({
 			pos: p.to,
-			toDevice: nextToDevice
+			toDevice: nextToDevice,
+			ack: toDevice.length > 0
 		}),
 		rooms: Object.fromEntries(Object.entries({
 			join,

package/dist/core/push.js

@@ -3,8 +3,9 @@ import { M, UNSTABLE } from "./m.js";
 import { splitStateKey, toClientEvent } from "./events.js";
 import { getState, powerLevels, userLevel } from "./authrules.js";
 import { globMatch, globSearchWords } from "./glob.js";
-import { KINDS, loadRules } from "./pushrules.js";
+import { KINDS, readOnlyRules } from "./pushrules.js";
 import { isSubscribed } from "../api/threadsubs.js";
+import { upsertMany } from "../storage/batch.js";
 //#region src/core/push.ts
 /** Look up a dotted path; `\.` escapes a literal dot in a key (e.g. `content.m\.relates_to`). */
 function valueAtPath(obj, path) {
@@ -109,7 +110,7 @@ var PushService = class {
 		const notified = [];
 		for (const userId of members) {
 			if (userId === event.sender || !this.hs.isLocalUser(userId)) continue;
-			const actions = evaluateRules(await loadRules(this.hs, userId), {
+			const actions = evaluateRules(await readOnlyRules(this.hs, userId), {
 				event,
 				userId,
 				displayName: getState(state, M.ROOM.MEMBER, userId)?.content?.displayname ?? null,
@@ -136,9 +137,7 @@ var PushService = class {
 			});
 		}
 		if (notified.length === 0) return;
-		await this.hs.transaction(async (db) => {
-			for (const n of notified) await db.upsert("notifications", n.row);
-		});
+		await this.hs.transaction((db) => upsertMany(db, "notifications", notified.map((n) => n.row)));
 		const pushers = await this.hs.db.findMany("pushers", { where: [{
 			field: "user_id",
 			operator: "in",
@@ -179,21 +178,28 @@ var PushService = class {
 	async unreadCounts(userId, roomId) {
 		const read = await this.readPositions(userId, roomId);
 		const unthreaded = read.unthreaded;
-		const rows = await this.hs.db.findMany("notifications", { where: [
-			{
-				field: "user_id",
-				value: userId
-			},
-			{
-				field: "room_id",
-				value: roomId
-			},
-			{
-				field: "stream",
-				operator: "gt",
-				value: unthreaded
-			}
-		] });
+		const rows = await this.hs.db.findMany("notifications", {
+			where: [
+				{
+					field: "user_id",
+					value: userId
+				},
+				{
+					field: "room_id",
+					value: roomId
+				},
+				{
+					field: "stream",
+					operator: "gt",
+					value: unthreaded
+				}
+			],
+			fields: [
+				"stream",
+				"thread_id",
+				"highlight"
+			]
+		});
 		const room = {
 			notification_count: 0,
 			highlight_count: 0

package/dist/core/pushrules.js

@@ -131,14 +131,33 @@ function cacheFor(hs) {
 	}
 	return c;
 }
+/** A user's push rules, as a copy the caller may change. */
 async function loadRules(hs, userId) {
+	return structuredClone(await readOnlyRules(hs, userId));
+}
+/**
+* A user's push rules, shared and frozen: for callers that only read them.
+*
+* https://github.com/k18k/matrix-nodejs-homeserver/issues/41: push evaluation copied every
+* member's rules for every message, about 6% of the CPU under load, though it only reads them.
+* The cached rulesets are deep-frozen, so a caller that tries to change one fails loudly instead
+* of changing everyone's.
+*/
+async function readOnlyRules(hs, userId) {
 	const cached = cacheFor(hs).get(userId);
-	if (cached) return structuredClone(cached);
-	const rules = await readRules(hs, userId);
+	if (cached) return cached;
+	const rules = deepFreeze(await readRules(hs, userId));
 	const cache = cacheFor(hs);
 	if (cache.size > 5e3) cache.clear();
 	cache.set(userId, rules);
-	return structuredClone(rules);
+	return rules;
+}
+function deepFreeze(value) {
+	if (value && typeof value === "object" && !Object.isFrozen(value)) {
+		Object.freeze(value);
+		for (const v of Object.values(value)) deepFreeze(v);
+	}
+	return value;
 }
 async function readRules(hs, userId) {
 	const row = await hs.db.findOne("account_data", [
@@ -162,7 +181,7 @@ async function readRules(hs, userId) {
 	return rules;
 }
 async function saveRules(hs, userId, rules) {
-	cacheFor(hs).set(userId, structuredClone(rules));
+	cacheFor(hs).set(userId, deepFreeze(structuredClone(rules)));
 	hs.cluster.publish("pushrules", {
 		from: hs.instanceId,
 		userId
@@ -226,4 +245,4 @@ async function copyRules(hs, userId, oldRoomId, newRoomId) {
 	if (changed) await saveRules(hs, userId, rules);
 }
 //#endregion
-export { KINDS, copyRoomPushRules, defaultRules, loadRules, saveRules, withRulesLock };
+export { KINDS, copyRoomPushRules, defaultRules, loadRules, readOnlyRules, saveRules, withRulesLock };

package/dist/homeserver.js

@@ -13,6 +13,7 @@ import { KeyService } from "./core/keys.js";
 import { Notifier } from "./core/notifier.js";
 import { StreamManager, localCluster, newInstanceId } from "./core/cluster.js";
 import { TypingService } from "./core/typing.js";
+import { coalesceReads } from "./storage/batch.js";
 import { PushService } from "./core/push.js";
 import { SsoService } from "./core/sso.js";
 import { AdminService } from "./core/admin.js";
@@ -125,7 +126,7 @@ var Homeserver = class extends EventEmitter {
 			}
 		};
 		const db = options.databaseAdapter;
-		if (db && typeof db.findOne === "function") this.db = db;
+		if (db && typeof db.findOne === "function") this.db = coalesceReads(db);
 		else {
 			this.logger.warn("No database adapter given; using in-memory storage (data is lost on restart)");
 			this.db = memoryAdapter();

package/dist/storage/batch.js

@@ -7,5 +7,76 @@ function readBatch(db, queries) {
 	if (db.findManyBatch) return db.findManyBatch(queries);
 	return Promise.all(queries.map((query) => db.findMany(query.model, query.opts)));
 }
+/** Upsert several rows: in a few statements when the adapter can (`upsertMany`), otherwise one by one. */
+async function upsertMany(db, model, rows) {
+	if (rows.length === 0) return;
+	if (db.upsertMany) return db.upsertMany(model, rows);
+	for (const row of rows) await db.upsert(model, row);
+}
+/** At most this many reads go into one coalesced statement. */
+const MAX_COALESCED = 32;
+/**
+* An adapter whose reads (`findMany`, `findOne`) issued within one turn of the event loop are
+* sent together, through `findManyBatch`. Writes and transactions go straight to `db`. Adapters
+* without `findManyBatch` are returned as they are.
+*
+* https://github.com/k18k/matrix-nodejs-homeserver/issues/43: under load, most of the homeserver's
+* and the database's CPU went to the per-statement cost (a socket write, a round trip, parsing)
+* of many small reads issued at the same moment by concurrent requests. Nothing is kept between
+* turns: this merges requests, it does not cache results. A read waits for at most the rest of
+* the current turn. If a coalesced statement fails, its reads are run one by one, so a bad read
+* fails alone.
+*/
+function coalesceReads(db) {
+	if (!db.findManyBatch) return db;
+	let queue = [];
+	const runAlone = (read) => db.findMany(read.query.model, read.query.opts).then(read.resolve, read.reject);
+	const run = async (reads) => {
+		if (reads.length === 1) return runAlone(reads[0]);
+		let results;
+		try {
+			results = await db.findManyBatch(reads.map((r) => r.query), { prepare: false });
+		} catch {
+			for (const read of reads) runAlone(read);
+			return;
+		}
+		reads.forEach((read, i) => read.resolve(results[i]));
+	};
+	const flush = () => {
+		const reads = queue;
+		queue = [];
+		for (let i = 0; i < reads.length; i += MAX_COALESCED) run(reads.slice(i, i + MAX_COALESCED));
+	};
+	const enqueue = (query) => new Promise((resolve, reject) => {
+		if (queue.length === 0) setImmediate(flush);
+		queue.push({
+			query,
+			resolve,
+			reject
+		});
+	});
+	return {
+		findMany: (model, opts) => enqueue({
+			model,
+			opts
+		}),
+		findOne: async (model, where) => (await enqueue({
+			model,
+			opts: {
+				where,
+				limit: 1
+			}
+		}))[0] ?? null,
+		findManyBatch: (queries, options) => db.findManyBatch(queries, options),
+		create: (model, data) => db.create(model, data),
+		upsert: (model, data) => db.upsert(model, data),
+		...db.upsertMany ? { upsertMany: (model, rows) => db.upsertMany(model, rows) } : {},
+		update: (model, where, data) => db.update(model, where, data),
+		delete: (model, where) => db.delete(model, where),
+		max: (model, field) => db.max(model, field),
+		...db.migrate ? { migrate: (schema) => db.migrate(schema) } : {},
+		...db.transaction ? { transaction: (fn) => db.transaction(fn) } : {}
+	};
+}
 //#endregion
-export { readBatch };
+export { coalesceReads, readBatch, upsertMany };

package/dist/storage/schema.js

@@ -192,7 +192,11 @@ const schema = {
 			ts: n
 		},
 		primaryKey: ["user_id", "event_id"],
-		indexes: [["user_id", "room_id"], ["user_id", "stream"]]
+		indexes: [[
+			"user_id",
+			"room_id",
+			"stream"
+		], ["user_id", "stream"]]
 	},
 	sso_identities: {
 		fields: {
@@ -397,7 +401,8 @@ const schema = {
 			last_active_ts: n,
 			stream: n
 		},
-		primaryKey: ["user_id"]
+		primaryKey: ["user_id"],
+		indexes: [["stream"]]
 	},
 	media: {
 		fields: {

package/dist/storage/sql.d.ts

@@ -2,8 +2,10 @@ import { DatabaseAdapter, Row } from "./types.js";
 //#region src/storage/sql.d.ts
 export type SqlDialect = "sqlite" | "postgres" | "mysql";
 export interface SqlExecutor {
-  /** Run a query that returns rows. */
-  query(sql: string, params: unknown[]): Promise<Row[]>;
+  /** Run a query that returns rows; `prepare: false` when the statement is not worth preparing for reuse. */
+  query(sql: string, params: unknown[], options?: {
+    prepare?: boolean;
+  }): Promise<Row[]>;
   /** Run a statement; resolve with the number of affected rows. */
   execute(sql: string, params: unknown[]): Promise<number>;
 }
@@ -36,9 +38,20 @@ export interface SqliteDatabaseLike {
 /** SQLite adapter for `node:sqlite` (`new DatabaseSync(path)`) or `better-sqlite3`. */
 export declare function sqliteAdapter(db: SqliteDatabaseLike, options?: {
   tablePrefix?: string;
+  /**
+   * When commits reach the disk (SQLite's `synchronous`). `"normal"` (the default): at
+   * checkpoints; a commit survives a crash of the process, and a power loss or operating
+   * system crash can roll back the most recent ones, without corrupting the database.
+   * `"full"`: on every commit, which blocks the event loop for an fsync each time.
+   */
+  synchronous?: "normal" | "full";
 }): DatabaseAdapter;
 interface PgQueryable {
-  query(text: string, values?: unknown[]): Promise<{
+  query(config: {
+    text: string;
+    values?: unknown[];
+    name?: string;
+  }): Promise<{
     rows: Row[];
     rowCount: number | null;
   }>;
@@ -53,6 +66,12 @@ export interface PgPoolLike extends PgQueryable {
 /** PostgreSQL adapter for `pg` (node-postgres). Pass a `Pool` to get transactions. */
 export declare function postgresAdapter(pool: PgPoolLike, options?: {
   tablePrefix?: string;
+  /**
+   * Prepare statements on each connection and reuse them (default true). Turn off behind a
+   * connection pooler that does not support prepared statements, such as PgBouncer before 1.21
+   * or in transaction mode without `max_prepared_statements`.
+   */
+  preparedStatements?: boolean;
 }): DatabaseAdapter;
 interface MysqlQueryable {
   query(sql: string, values?: unknown[]): Promise<[any, unknown]>;

package/dist/storage/sql.js

@@ -1,5 +1,8 @@
+import { createHash } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/storage/sql.ts
+/** Parameters per statement for multi-row writes: within SQLite's (32766), Postgres' and MySQL's (65535) limits. */
+const MAX_PARAMS = 4e3;
 const OPS = {
 	eq: "=",
 	ne: "<>",
@@ -60,6 +63,12 @@ function sqlAdapter({ dialect, executor: rootExecutor, tablePrefix = "", transac
 		return out;
 	};
 	const placeholder = (i) => dialect === "postgres" ? `$${i}` : "?";
+	const limitClause = (limit, params) => {
+		const n = Math.max(0, Math.floor(limit));
+		if (dialect === "mysql") return ` LIMIT ${n}`;
+		params.push(n);
+		return ` LIMIT ${placeholder(params.length)}`;
+	};
 	const buildWhere = (model, where = [], params) => {
 		if (where.length === 0) return "";
 		return ` WHERE ${where.map((w) => {
@@ -67,6 +76,10 @@ function sqlAdapter({ dialect, executor: rootExecutor, tablePrefix = "", transac
 			if (op === "in") {
 				const values = w.value;
 				if (values.length === 0) return "1=0";
+				if (dialect === "postgres") {
+					params.push(values.map((v) => toDb(model, w.field, v)));
+					return `${q(w.field)} = ANY(${placeholder(params.length)})`;
+				}
 				const ph = values.map((v) => {
 					params.push(toDb(model, w.field, v));
 					return placeholder(params.length);
@@ -83,11 +96,15 @@ function sqlAdapter({ dialect, executor: rootExecutor, tablePrefix = "", transac
 	};
 	const build = (executor, inTx) => {
 		const insert = async (model, data, mode) => {
-			const fields = Object.keys(data).filter((k) => data[k] !== void 0);
-			const params = fields.map((f) => toDb(model, f, data[f]));
+			const rows = Array.isArray(data) ? data : [data];
+			const fields = Object.keys(rows[0]).filter((k) => rows[0][k] !== void 0);
+			const params = [];
+			const values = rows.map((row) => `(${fields.map((f) => {
+				params.push(toDb(model, f, row[f]));
+				return placeholder(params.length);
+			}).join(", ")})`);
 			const cols = fields.map(q).join(", ");
-			const ph = fields.map((_, i) => placeholder(i + 1)).join(", ");
-			let sql = `INSERT INTO ${t(model)} (${cols}) VALUES (${ph})`;
+			let sql = `INSERT INTO ${t(model)} (${cols}) VALUES ${values.join(", ")}`;
 			if (mode === "upsert") {
 				const pk = schema[model]?.primaryKey ?? [];
 				const rest = fields.filter((f) => !pk.includes(f));
@@ -123,6 +140,20 @@ function sqlAdapter({ dialect, executor: rootExecutor, tablePrefix = "", transac
 			},
 			create: (model, data) => insert(model, data, "insert"),
 			upsert: (model, data) => insert(model, data, "upsert"),
+			async upsertMany(model, rows) {
+				const pk = schema[model]?.primaryKey ?? [];
+				const byKey = /* @__PURE__ */ new Map();
+				for (const row of rows) byKey.set(JSON.stringify(pk.map((f) => row[f])), row);
+				const groups = /* @__PURE__ */ new Map();
+				for (const row of byKey.values()) {
+					const shape = Object.keys(row).filter((k) => row[k] !== void 0).join("\0");
+					groups.set(shape, [...groups.get(shape) ?? [], row]);
+				}
+				for (const group of groups.values()) {
+					const perStatement = Math.max(1, Math.floor(MAX_PARAMS / Object.keys(group[0]).length));
+					for (let i = 0; i < group.length; i += perStatement) await insert(model, group.slice(i, i + perStatement), "upsert");
+				}
+			},
 			async findOne(model, where) {
 				const params = [];
 				const rows = await executor.query(`SELECT * FROM ${t(model)}${buildWhere(model, where, params)} LIMIT 1`, params);
@@ -132,25 +163,26 @@ function sqlAdapter({ dialect, executor: rootExecutor, tablePrefix = "", transac
 				const params = [];
 				let sql = `SELECT ${opts.fields?.length ? opts.fields.map(q).join(", ") : "*"} FROM ${t(model)}${buildWhere(model, opts.where, params)}`;
 				if (opts.sortBy) sql += ` ORDER BY ${q(opts.sortBy.field)} ${opts.sortBy.direction === "asc" ? "ASC" : "DESC"}`;
-				if (opts.limit !== void 0) sql += ` LIMIT ${Math.max(0, Math.floor(opts.limit))}`;
+				if (opts.limit !== void 0) sql += limitClause(opts.limit, params);
 				return (await executor.query(sql, params)).map((r) => fromDb(model, r));
 			},
-			...dialect === "postgres" ? { async findManyBatch(queries) {
+			...dialect === "postgres" ? { async findManyBatch(queries, options) {
 				if (queries.length === 0) return [];
 				const params = [];
 				const parts = queries.map(({ model, opts = {} }, i) => {
 					const fields = opts.fields?.length && opts.sortBy && !opts.fields.includes(opts.sortBy.field) ? [...opts.fields, opts.sortBy.field] : opts.fields;
 					let inner = `SELECT ${fields?.length ? fields.map(q).join(", ") : "*"} FROM ${t(model)}${buildWhere(model, opts.where, params)}`;
-					const order = opts.sortBy ? `${q(opts.sortBy.field)} ${opts.sortBy.direction === "asc" ? "ASC" : "DESC"}` : "";
-					if (order) inner += ` ORDER BY ${order}`;
-					if (opts.limit !== void 0) inner += ` LIMIT ${Math.max(0, Math.floor(opts.limit))}`;
-					return `SELECT ${i} AS i, row_number() OVER (${order ? `ORDER BY ${order.replace(/^"/, "b.\"")}` : ""}) AS n, to_jsonb(b) AS r FROM (${inner}) b`;
+					const direction = opts.sortBy?.direction === "asc" ? "ASC" : "DESC";
+					if (opts.sortBy) inner += ` ORDER BY ${q(opts.sortBy.field)} ${direction}`;
+					if (opts.limit !== void 0) inner += limitClause(opts.limit, params);
+					return `SELECT ${i} AS i, (SELECT json_agg(b${opts.sortBy ? ` ORDER BY b.${q(opts.sortBy.field)} ${direction}` : ""}) FROM (${inner}) b) AS r`;
 				});
-				const rows = await executor.query(`${parts.join(" UNION ALL ")} ORDER BY i, n`, params);
+				const rows = await executor.query(parts.join(" UNION ALL "), params, options);
 				const out = queries.map(() => []);
 				for (const row of rows) {
-					const r = typeof row.r === "string" ? JSON.parse(row.r) : row.r;
-					out[Number(row.i)].push(fromDb(queries[Number(row.i)].model, r));
+					const list = typeof row.r === "string" ? JSON.parse(row.r) : row.r;
+					const model = queries[Number(row.i)].model;
+					out[Number(row.i)] = (list ?? []).map((r) => fromDb(model, r));
 				}
 				return out;
 			} } : {},
@@ -175,21 +207,36 @@ function sqlAdapter({ dialect, executor: rootExecutor, tablePrefix = "", transac
 	};
 	return build(rootExecutor, false);
 }
+/** How long SQLite statements may run back to back before yielding to the event loop (#47). */
+const YIELD_AFTER_MS = 10;
+/** Prepared statements an SQLite adapter keeps (#40). */
+const STATEMENT_CACHE = 500;
 /** SQLite adapter for `node:sqlite` (`new DatabaseSync(path)`) or `better-sqlite3`. */
 function sqliteAdapter(db, options = {}) {
 	try {
 		db.exec("PRAGMA journal_mode = WAL");
+		db.exec(`PRAGMA synchronous = ${options.synchronous === "full" ? "FULL" : "NORMAL"}`);
 	} catch {}
 	const cache = /* @__PURE__ */ new Map();
 	const stmt = (sql) => {
 		let s = cache.get(sql);
-		if (!s) cache.set(sql, s = db.prepare(sql));
+		if (s) cache.delete(sql);
+		else s = db.prepare(sql);
+		cache.set(sql, s);
+		if (cache.size > STATEMENT_CACHE) cache.delete(cache.keys().next().value);
 		return s;
 	};
 	const inTransaction = new AsyncLocalStorage();
 	let gate = Promise.resolve();
+	let lastYield = performance.now();
 	const waitGate = async () => {
-		if (!inTransaction.getStore()) await gate;
+		if (inTransaction.getStore()) return;
+		await gate;
+		if (performance.now() - lastYield > YIELD_AFTER_MS) {
+			await new Promise((resolve) => setImmediate(resolve));
+			lastYield = performance.now();
+			await gate;
+		}
 	};
 	const executor = {
 		async query(sql, params) {
@@ -229,29 +276,80 @@ function sqliteAdapter(db, options = {}) {
 		}
 	});
 }
-const pgExecutor = (conn) => ({
-	async query(sql, params) {
-		return (await conn.query(sql, params)).rows;
-	},
-	async execute(sql, params) {
-		return (await conn.query(sql, params)).rowCount ?? 0;
-	}
-});
+/**
+* https://github.com/k18k/matrix-nodejs-homeserver/issues/40: unnamed statements are parsed and
+* planned by Postgres on every call, which took most of its CPU under load. Named ones are prepared
+* once per connection and reused. Statement texts depend only on the code (lists and limits are
+* parameters), so there are a few hundred of them; past `MAX_PREPARED` distinct texts, further
+* ones run unnamed, which bounds the memory both node-postgres and Postgres keep per connection.
+*/
+const MAX_PREPARED = 2e3;
+function statementNamer(enabled) {
+	let names = /* @__PURE__ */ new Map();
+	let generation = 0;
+	return {
+		name(sql) {
+			if (!enabled) return void 0;
+			let name = names.get(sql);
+			if (!name && names.size < MAX_PREPARED) names.set(sql, name = `m${generation}_${createHash("sha1").update(sql).digest("base64url")}`);
+			return name;
+		},
+		reset() {
+			names = /* @__PURE__ */ new Map();
+			generation++;
+		}
+	};
+}
+/**
+* A prepared `SELECT *` fails once its table has gained a column, for example when another node of
+* a cluster migrated the schema during a rolling update. Then the statements are prepared again
+* under new names and the query is retried once.
+*/
+const isStalePlan = (err) => err?.code === "0A000" && /cached plan/.test(String(err.message));
+const pgExecutor = (conn, namer) => {
+	const run = async (sql, params, prepare = true) => {
+		const name = () => prepare ? namer.name(sql) : void 0;
+		try {
+			return await conn.query({
+				text: sql,
+				values: params,
+				name: name()
+			});
+		} catch (err) {
+			if (!isStalePlan(err)) throw err;
+			namer.reset();
+			return conn.query({
+				text: sql,
+				values: params,
+				name: name()
+			});
+		}
+	};
+	return {
+		async query(sql, params, options) {
+			return (await run(sql, params, options?.prepare)).rows;
+		},
+		async execute(sql, params) {
+			return (await run(sql, params)).rowCount ?? 0;
+		}
+	};
+};
 /** PostgreSQL adapter for `pg` (node-postgres). Pass a `Pool` to get transactions. */
 function postgresAdapter(pool, options = {}) {
+	const namer = statementNamer(options.preparedStatements ?? true);
 	return sqlAdapter({
 		dialect: "postgres",
 		tablePrefix: options.tablePrefix,
-		executor: pgExecutor(pool),
+		executor: pgExecutor(pool, namer),
 		transaction: pool.connect ? async (fn) => {
 			const client = await pool.connect();
 			try {
-				await client.query("BEGIN");
-				const result = await fn(pgExecutor(client));
-				await client.query("COMMIT");
+				await client.query({ text: "BEGIN" });
+				const result = await fn(pgExecutor(client, namer));
+				await client.query({ text: "COMMIT" });
 				return result;
 			} catch (err) {
-				await client.query("ROLLBACK").catch(() => {});
+				await client.query({ text: "ROLLBACK" }).catch(() => {});
 				throw err;
 			} finally {
 				client.release();

package/dist/storage/types.d.ts

@@ -21,6 +21,14 @@ export interface WhereClause {
   operator?: Operator;
 }
 export type Row = Record<string, any>;
+/** How a `findManyBatch` is run. */
+export interface BatchOptions {
+  /**
+   * The combination of reads is a one-off (as when unrelated reads are coalesced), so preparing
+   * the statement for reuse would only fill the database's statement cache. Default true.
+   */
+  prepare?: boolean;
+}
 /** One read of a `findManyBatch`. */
 export interface BatchQuery {
   model: string;
@@ -50,12 +58,18 @@ export interface DatabaseAdapter {
    * an adapter that talks to a database server can send them in one round trip. Without it,
    * callers run the reads separately (see `readBatch`).
    */
-  findManyBatch?(queries: BatchQuery[]): Promise<Row[][]>;
+  findManyBatch?(queries: BatchQuery[], options?: BatchOptions): Promise<Row[][]>;
   /** Create tables / collections for the given schema. Must be idempotent. */
   migrate?(schema: Schema): Promise<void>;
   create(model: string, data: Row): Promise<void>;
   /** Insert or replace by primary key. */
   upsert(model: string, data: Row): Promise<void>;
+  /**
+   * `upsert` for several rows at once (the last row wins when two share a primary key). Optional;
+   * an adapter that talks to a database server can write them in a few statements. Without it,
+   * callers upsert the rows one by one (see `upsertMany`).
+   */
+  upsertMany?(model: string, rows: Row[]): Promise<void>;
   findOne(model: string, where: WhereClause[]): Promise<Row | null>;
   findMany(model: string, options?: FindManyOptions): Promise<Row[]>;
   update(model: string, where: WhereClause[], data: Row): Promise<number>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matrix-nodejs-homeserver",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "A framework- and database-agnostic Matrix homeserver library for Node.js",
   "keywords": [
     "chat",