matrix-nodejs-homeserver 0.3.3 → 0.3.5

package/dist/core/cluster.js

@@ -80,6 +80,11 @@ function localCluster() {
 }
 const WRITER_TTL_MS = 3e4;
 /**
+* A stream position held longer than this holds back /sync for everyone: it is logged with where
+* it was allocated (https://github.com/k18k/matrix-nodejs-homeserver/issues/48).
+*/
+const SLOW_LEASE_MS = 5e3;
+/**
 * Stream positions with multiple writers. Positions are allocated from a global
 * sequence; readers only see positions up to which every writer has finished, so
 * an event committed late with a lower position can never be skipped by /sync.
@@ -99,11 +104,16 @@ var StreamManager = class {
 	lastPos = 0;
 	heartbeat;
 	positionCache = null;
+	highestAllocated = 0;
+	/** Called after a write of this instance completed, when the position may have moved (#50). */
+	onAdvance = () => {};
 	publishing = Promise.resolve();
 	nextPublish = null;
-	constructor(cluster, instanceId) {
+	warn;
+	constructor(cluster, instanceId, warn = () => {}) {
 		this.cluster = cluster;
 		this.instanceId = instanceId;
+		this.warn = warn;
 		this.heartbeat = setInterval(() => void this.flush().catch(() => {}), WRITER_TTL_MS / 3);
 		this.heartbeat.unref?.();
 	}
@@ -146,10 +156,14 @@ var StreamManager = class {
 			await this.flush();
 			id = await this.cluster.nextId("stream");
 			this.inflight.add(id);
+			if (id > this.highestAllocated) this.highestAllocated = id;
 		} finally {
 			this.allocating--;
 		}
 		let finished = false;
+		const site = /* @__PURE__ */ new Error("stream position allocated here");
+		const slow = setTimeout(() => this.warn(`Stream position ${id} held for over ${SLOW_LEASE_MS} ms; /sync waits for it`, site), SLOW_LEASE_MS);
+		slow.unref?.();
 		const timer = setTimeout(() => void lease.done(), 6e4);
 		timer.unref?.();
 		const lease = {
@@ -158,9 +172,11 @@ var StreamManager = class {
 				if (finished) return;
 				finished = true;
 				clearTimeout(timer);
+				clearTimeout(slow);
 				this.inflight.delete(id);
 				await this.flush();
 				this.positionCache = null;
+				this.onAdvance();
 			}
 		};
 		return lease;
@@ -178,9 +194,16 @@ var StreamManager = class {
 	async backfillId() {
 		return -await this.cluster.nextId("backfill");
 	}
-	/** The highest position below which everything is persisted, cluster-wide. */
-	async position() {
-		if (this.positionCache && Date.now() - this.positionCache.at < 20) return this.positionCache.value;
+	/** The highest position this instance has allocated: an upper bound of its changes so far. */
+	get lastAllocated() {
+		return this.highestAllocated;
+	}
+	/**
+	* The highest position below which everything is persisted, cluster-wide. `fresh` skips the
+	* 20 ms cache, for a caller that knows a change has completed elsewhere.
+	*/
+	async position(fresh = false) {
+		if (!fresh && this.positionCache && Date.now() - this.positionCache.at < 20) return this.positionCache.value;
 		let pos = await this.cluster.currentId("stream");
 		for (const [, w] of await this.cluster.entries("writer:")) if (w?.busy) pos = Math.min(pos, w.pos);
 		if (this.inflight.size) pos = Math.min(pos, Math.min(...this.inflight) - 1);
@@ -190,6 +213,23 @@ var StreamManager = class {
 		};
 		return pos;
 	}
+	/**
+	* Resolve once the position has reached `pos` (true), or false after `timeoutMs` or on abort.
+	* For a request woken by a change that another write in flight still keeps out of sight
+	* (https://github.com/k18k/matrix-nodejs-homeserver/issues/50). It checks again at growing
+	* intervals: writes finish in milliseconds, and the position may be held by another instance.
+	*/
+	async waitFor(pos, timeoutMs, signal) {
+		const deadline = Date.now() + timeoutMs;
+		let delay = 5;
+		for (;;) {
+			if (await this.position(true) >= pos) return true;
+			const left = deadline - Date.now();
+			if (left <= 0 || signal?.aborted) return false;
+			await new Promise((resolve) => setTimeout(resolve, Math.min(delay, left)));
+			delay = Math.min(delay * 2, 200);
+		}
+	}
 	async advanceTo(value) {
 		await this.cluster.advance("stream", value);
 	}

package/dist/core/keys.js

@@ -438,8 +438,10 @@ var KeyService = class {
 				if (m.membership === "join") {
 					for (const u of members) if (u !== userId) changed.add(u);
 				} else for (const u of members) if (!sharing.has(u)) left.add(u);
-			} else if (m.membership === "join") changed.add(m.user_id);
-			else if (!sharing.has(m.user_id)) left.add(m.user_id);
+			} else if (m.membership === "join") {
+				const ev = await this.hs.rooms.getEvent(m.event_id);
+				if (ev && ev.stream > since) changed.add(m.user_id);
+			} else if (!sharing.has(m.user_id)) left.add(m.user_id);
 		}
 		for (const u of left) changed.delete(u);
 		return {

package/dist/core/notifier.d.ts

@@ -1,17 +1,63 @@
 import { ClusterAdapter } from "./cluster.js";
 //#region src/core/notifier.d.ts
+/** A registration for wake-ups from the moment it was made (see `Notifier.listen`). */
+export interface Listener {
+  /**
+   * The stream position of this user's latest wake-up before the listener was registered (0 if
+   * none is remembered): the change may not have been visible to the build that preceded it.
+   */
+  readonly recent: number;
+  /**
+   * Resolve with the position of the first wake-up since registration (at once if there was one
+   * already), or null after `timeoutMs` or on abort.
+   */
+  wait(timeoutMs: number, signal?: AbortSignal): Promise<number | null>;
+  /** Stop listening; a pending `wait` resolves with null. */
+  cancel(): void;
+}
 /**
  * Wakes long-polling `/sync` requests when something relevant happens. Notifications
  * are broadcast through the cluster adapter so waiters on other instances wake too.
+ *
+ * https://github.com/k18k/matrix-nodejs-homeserver/issues/50: every wake-up carries the stream
+ * position of its change, or an upper bound of it. Writes can complete out of order, so a change
+ * may be committed while an earlier write still holds the position below it. As in Synapse
+ * (`Notifier._notify_pending_new_room_events`), such a wake-up is held here until the position
+ * reaches it: a request is only woken for changes it can see.
  */
 export declare class Notifier {
-  private waiters;
+  private listeners;
+  /** Each user's latest wake-up position, oldest first (re-inserted on update). */
+  private recent;
   private cluster;
   private instanceId;
-  constructor(cluster: ClusterAdapter, instanceId: string);
-  notify(userIds: Iterable<string>): void;
+  private lastAllocated;
+  private position;
+  /** Wake-ups whose change is beyond the position known to be visible. */
+  private held;
+  /** The highest position known to be visible. */
+  private visible;
+  private release;
+  /**
+   * `lastAllocated`: the highest stream position this instance has allocated (an upper bound of
+   * its changes); `position`: the position below which everything is visible.
+   */
+  constructor(cluster: ClusterAdapter, instanceId: string, lastAllocated?: () => number, position?: (fresh: boolean) => Promise<number>);
+  /**
+   * Wake `userIds`. `pos` is the stream position of the change; without it, the highest position
+   * this instance has allocated stands in, which is never below it.
+   */
+  notify(userIds: Iterable<string>, pos?: number): void;
+  /** The position may have moved (a write of this instance completed): release what it covers. */
+  advanced(): void;
+  /** Wake now if the change is visible, otherwise once the position reaches it. */
+  private hold;
+  private scheduleRelease;
+  private releaseHeld;
   private wakeLocal;
   notifyAll(): void;
+  listen(userId: string): Listener;
+  /** Wait for a wake-up of `userId` (for callers that do not track positions). */
   wait(userId: string, timeoutMs: number, signal?: AbortSignal): Promise<void>;
 }
 //#endregion

package/dist/core/notifier.js

@@ -1,53 +1,150 @@
 //#region src/core/notifier.ts
+/** Users whose latest wake-up position is remembered (#50); the oldest are forgotten first. */
+const RECENT_USERS = 1e5;
+/** How soon held wake-ups are looked at again while the position has not reached them. */
+const RELEASE_RETRY_MS = 10;
 /**
 * Wakes long-polling `/sync` requests when something relevant happens. Notifications
 * are broadcast through the cluster adapter so waiters on other instances wake too.
+*
+* https://github.com/k18k/matrix-nodejs-homeserver/issues/50: every wake-up carries the stream
+* position of its change, or an upper bound of it. Writes can complete out of order, so a change
+* may be committed while an earlier write still holds the position below it. As in Synapse
+* (`Notifier._notify_pending_new_room_events`), such a wake-up is held here until the position
+* reaches it: a request is only woken for changes it can see.
 */
 var Notifier = class {
-	waiters = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Map();
+	/** Each user's latest wake-up position, oldest first (re-inserted on update). */
+	recent = /* @__PURE__ */ new Map();
 	cluster;
 	instanceId;
-	constructor(cluster, instanceId) {
+	lastAllocated;
+	position;
+	/** Wake-ups whose change is beyond the position known to be visible. */
+	held = [];
+	/** The highest position known to be visible. */
+	visible = 0;
+	release = null;
+	/**
+	* `lastAllocated`: the highest stream position this instance has allocated (an upper bound of
+	* its changes); `position`: the position below which everything is visible.
+	*/
+	constructor(cluster, instanceId, lastAllocated = () => 0, position = async () => Number.POSITIVE_INFINITY) {
 		this.cluster = cluster;
 		this.instanceId = instanceId;
+		this.lastAllocated = lastAllocated;
+		this.position = position;
 		cluster.subscribe("notify", (msg) => {
-			if (msg?.from !== this.instanceId && Array.isArray(msg?.users)) this.wakeLocal(msg.users);
+			if (msg?.from !== this.instanceId && Array.isArray(msg?.users)) this.hold(msg.users, Number(msg.pos) || 0);
 		});
 	}
-	notify(userIds) {
+	/**
+	* Wake `userIds`. `pos` is the stream position of the change; without it, the highest position
+	* this instance has allocated stands in, which is never below it.
+	*/
+	notify(userIds, pos) {
 		const users = [...userIds];
 		if (!users.length) return;
-		this.wakeLocal(users);
+		const at = pos ?? this.lastAllocated();
+		this.hold(users, at);
 		this.cluster.publish("notify", {
 			from: this.instanceId,
-			users
+			users,
+			pos: at
 		}).catch(() => {});
 	}
-	wakeLocal(userIds) {
+	/** The position may have moved (a write of this instance completed): release what it covers. */
+	advanced() {
+		if (this.held.length) this.scheduleRelease(0);
+	}
+	/** Wake now if the change is visible, otherwise once the position reaches it. */
+	hold(users, pos) {
+		if (pos <= this.visible) return this.wakeLocal(users, pos);
+		this.held.push({
+			users,
+			pos
+		});
+		this.scheduleRelease(0);
+	}
+	scheduleRelease(delay) {
+		if (this.release) return;
+		this.release = setTimeout(() => {
+			this.release = null;
+			this.releaseHeld().catch(() => this.scheduleRelease(RELEASE_RETRY_MS));
+		}, delay);
+		this.release.unref?.();
+	}
+	async releaseHeld() {
+		const highest = Math.max(...this.held.map((h) => h.pos));
+		let pos = await this.position(false);
+		if (pos < highest) pos = await this.position(true);
+		if (pos > this.visible) this.visible = pos;
+		const due = this.held.filter((h) => h.pos <= this.visible);
+		this.held = this.held.filter((h) => h.pos > this.visible);
+		for (const h of due) this.wakeLocal(h.users, h.pos);
+		if (this.held.length) this.scheduleRelease(RELEASE_RETRY_MS);
+	}
+	wakeLocal(userIds, pos) {
 		for (const u of userIds) {
-			const set = this.waiters.get(u);
+			const previous = this.recent.get(u) ?? 0;
+			this.recent.delete(u);
+			this.recent.set(u, Math.max(previous, pos));
+			if (this.recent.size > RECENT_USERS) this.recent.delete(this.recent.keys().next().value);
+			const set = this.listeners.get(u);
 			if (!set) continue;
-			this.waiters.delete(u);
-			for (const wake of set) wake();
+			this.listeners.delete(u);
+			for (const wake of set) wake(pos);
 		}
 	}
 	notifyAll() {
-		this.wakeLocal([...this.waiters.keys()]);
-	}
-	wait(userId, timeoutMs, signal) {
-		return new Promise((resolve) => {
-			let set = this.waiters.get(userId);
-			if (!set) this.waiters.set(userId, set = /* @__PURE__ */ new Set());
-			const done = () => {
-				clearTimeout(timer);
-				set.delete(done);
-				signal?.removeEventListener("abort", done);
-				resolve();
-			};
-			const timer = setTimeout(done, timeoutMs);
-			signal?.addEventListener("abort", done, { once: true });
-			set.add(done);
-		});
+		for (const [u, set] of this.listeners) {
+			this.listeners.delete(u);
+			for (const wake of set) wake(0);
+		}
+	}
+	listen(userId) {
+		let woken = null;
+		let resolveWait = null;
+		let set = this.listeners.get(userId);
+		if (!set) this.listeners.set(userId, set = /* @__PURE__ */ new Set());
+		const onWake = (pos) => {
+			woken = Math.max(woken ?? 0, pos);
+			resolveWait?.(woken);
+		};
+		set.add(onWake);
+		const remove = () => {
+			const current = this.listeners.get(userId);
+			current?.delete(onWake);
+			if (current && current.size === 0) this.listeners.delete(userId);
+		};
+		return {
+			recent: this.recent.get(userId) ?? 0,
+			wait: (timeoutMs, signal) => {
+				if (woken !== null) return Promise.resolve(woken);
+				return new Promise((resolve) => {
+					const done = (result) => {
+						clearTimeout(timer);
+						signal?.removeEventListener("abort", aborted);
+						resolveWait = null;
+						remove();
+						resolve(result);
+					};
+					const aborted = () => done(null);
+					const timer = setTimeout(() => done(null), timeoutMs);
+					signal?.addEventListener("abort", aborted, { once: true });
+					resolveWait = (pos) => done(pos);
+				});
+			},
+			cancel: () => {
+				remove();
+				resolveWait?.(null);
+			}
+		};
+	}
+	/** Wait for a wake-up of `userId` (for callers that do not track positions). */
+	async wait(userId, timeoutMs, signal) {
+		await this.listen(userId).wait(timeoutMs, signal);
 	}
 };
 //#endregion

package/dist/core/oauth.js

@@ -89,7 +89,8 @@ var OAuthDelegation = class {
 			deviceId,
 			accessToken: token,
 			isGuest: false,
-			isAdmin: !!user.is_admin || scopes.includes(this.options.adminScope ?? "urn:synapse:admin:*")
+			isAdmin: !!user.is_admin || scopes.includes(this.options.adminScope ?? "urn:synapse:admin:*"),
+			oauth: true
 		};
 		const ttl = this.options.cacheTtlMs ?? 6e4;
 		const exp = typeof claims.exp === "number" ? claims.exp * 1e3 : Infinity;

package/dist/core/oauthserver.d.ts

@@ -0,0 +1,141 @@
+import { Homeserver } from "../homeserver.js";
+//#region src/core/oauthserver.d.ts
+export interface OAuthServerOptions {
+  /**
+   * Keep the legacy login API (`/login`, `/register`) next to the OAuth 2.0 API. Its `m.login.sso`
+   * flow then goes through the same web login and is marked `oauth_aware_preferred`. Default: true.
+   */
+  legacyApi?: boolean;
+  /** Lifetime of access tokens issued through the OAuth 2.0 API, in ms. Default: 5 minutes. */
+  accessTokenLifetimeMs?: number;
+  /** Shown on the login and registration pages: the server's terms of service and privacy policy. */
+  termsUrl?: string;
+  policyUrl?: string;
+  /** How long a browser stays logged in to the web pages, in ms. Default: 7 days. */
+  webSessionLifetimeMs?: number;
+}
+/** An OAuth error response (RFC 6749 section 5.2, RFC 7591 section 3.2.2). */
+export declare class OAuthError extends Error {
+  readonly error: string;
+  readonly description: string;
+  readonly status: number;
+  constructor(error: string, description: string, status?: number);
+}
+export interface ClientMetadata {
+  client_id: string;
+  client_uri: string;
+  client_name?: string;
+  logo_uri?: string;
+  tos_uri?: string;
+  policy_uri?: string;
+  redirect_uris: string[];
+  response_types: string[];
+  grant_types: string[];
+  token_endpoint_auth_method: "none";
+  application_type: "web" | "native";
+}
+/** A validated authorization request, waiting for the user to log in and consent. */
+export interface PendingGrant {
+  clientId: string;
+  redirectUri: string;
+  responseMode: "query" | "fragment";
+  state?: string;
+  scope: string;
+  deviceId: string;
+  codeChallenge: string;
+  nonce?: string;
+  /** The client asked for the registration page (`prompt=create`). */
+  create: boolean;
+}
+export interface DeviceGrant {
+  clientId: string;
+  scope: string;
+  deviceId: string;
+  userCode: string;
+  status: "pending" | "approved" | "denied";
+  userId?: string;
+  lastPoll: number;
+  expires: number;
+}
+export interface TokenResponse {
+  access_token: string;
+  token_type: "Bearer";
+  expires_in: number;
+  refresh_token: string;
+  scope: string;
+  id_token?: string;
+}
+export declare class OAuthServer {
+  private hs;
+  readonly options: OAuthServerOptions;
+  /** The issuer identifier: the public base URL with a trailing slash. */
+  readonly issuer: string;
+  constructor(hs: Homeserver, options: OAuthServerOptions, publicBaseUrl: string);
+  get legacyApi(): boolean;
+  get accessTokenLifetimeMs(): number;
+  /** Absolute URL of a path under the OAuth prefix. */
+  url(path: string): string;
+  get accountManagementUri(): string;
+  /** Authorization server metadata (RFC 8414), served at `/_matrix/client/v1/auth_metadata`. */
+  metadata(): Record<string, unknown>;
+  /** The server's signing key as a JWK set (RFC 8037), for ID tokens. */
+  jwks(): {
+    keys: Record<string, string>[];
+  };
+  /**
+   * Register a client. Each login registers again (the spec asks clients to), so identical
+   * metadata gets the same client ID, derived from it, instead of a new row every time.
+   */
+  registerClient(raw: Record<string, unknown>): Promise<ClientMetadata>;
+  client(clientId: string | null): Promise<ClientMetadata | null>;
+  /** Delete old registrations that no token uses (the spec forbids deleting ones in use). */
+  prune(): Promise<void>;
+  /**
+   * Check an authorization request. Problems with the client or the redirect URI are thrown as
+   * `OAuthError` with `redirect: false` semantics (shown to the user: RFC 6749 section 4.1.2.1
+   * forbids redirecting to an unverified URI); the rest come back as `{ error }` to redirect.
+   */
+  checkAuthorizationRequest(params: URLSearchParams): Promise<{
+    client: ClientMetadata;
+    grant: PendingGrant;
+  } | {
+    client: ClientMetadata;
+    redirect: string;
+    error: OAuthError;
+  }>;
+  /** The client's redirect URI with the response parameters (and RFC 9207 `iss`). */
+  callbackUrl(redirectUri: string, mode: "query" | "fragment", params: Record<string, string | undefined>): string;
+  saveGrant(grant: PendingGrant): Promise<string>;
+  grant(id: string): Promise<PendingGrant | null>;
+  /** The user approved: issue a code and return where the browser goes next. */
+  approveGrant(id: string, grant: PendingGrant, userId: string, authTime: number): Promise<string>;
+  denyGrant(id: string, grant: PendingGrant): Promise<string>;
+  token(params: URLSearchParams, clientId: string | null): Promise<TokenResponse>;
+  private exchangeCode;
+  private issue;
+  private tokenResponse;
+  /** An OpenID Connect ID token (EdDSA with the server's signing key). */
+  private idToken;
+  startDeviceGrant(clientId: string | null, scope: string | null): Promise<{
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    verification_uri_complete: string;
+    expires_in: number;
+    interval: number;
+  }>;
+  /** The device grant a user code belongs to (typed in any case, with or without the dash). */
+  deviceGrantByUserCode(raw: string): Promise<{
+    deviceCode: string;
+    grant: DeviceGrant;
+  } | null>;
+  decideDeviceGrant(deviceCode: string, grant: DeviceGrant, userId: string, approve: boolean): Promise<void>;
+  private pollDevice;
+  /**
+   * Revoke an access or refresh token (RFC 7009). The spec revokes both tokens of the pair; a
+   * logout through this endpoint ends the device's session like `/logout` does. Unknown tokens
+   * are not an error.
+   */
+  revoke(token: string | null): Promise<void>;
+}
+//#endregion