@shadow-js/realtime 1.0.1 → 1.0.3

package/dist/dev/server/hub.js

@@ -9,11 +9,8 @@ const MAX_PUMP_BUFFER = 1e4;
 const ID_BYTES = 16;
 /** A random id: 128 bits, base64url. */
 function randomId() {
-	const bytes = new Uint8Array(ID_BYTES);
-	crypto.getRandomValues(bytes);
-	let text = "";
-	for (const byte of bytes) text += String.fromCharCode(byte);
-	return btoa(text).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+	const bytes = crypto.getRandomValues(new Uint8Array(ID_BYTES));
+	return btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
 function encodeFrame(frame) {
 	return JSON.stringify(frame);
@@ -43,10 +40,20 @@ function createHubCore(options = {}) {
 	const limits = resolveLimits(options.limits);
 	const now = options.now ?? Date.now;
 	const ownsAdapter = options.adapter === void 0;
-	const adapter = options.adapter ?? memoryAdapter({ now });
+	const adapter = options.adapter ?? memoryAdapter({
+		now,
+		onError: (error, context) => report(error, {
+			where: `memory.${context.where}`,
+			channel: context.channel
+		})
+	});
 	const rules = [];
 	const conns = /* @__PURE__ */ new Map();
 	const chans = /* @__PURE__ */ new Map();
+	/** Subscribes whose rules are being awaited: a revoke issued meanwhile marks them, so the grant cannot outlive it. */
+	const judging = /* @__PURE__ */ new Set();
+	/** The tail of each channel's presence joins that are queued or running; an entry leaves when its chain is idle. */
+	const joinChains = /* @__PURE__ */ new Map();
 	let heartbeat;
 	let closing = false;
 	let beating = false;
@@ -104,9 +111,21 @@ function createHubCore(options = {}) {
 				where: "transport.send",
 				connection: conn.id
 			});
+			onTransport(conn, "transport.close", () => conn.transport.close(1011, "write failed"));
 		}
 		closeConnection(conn);
 	}
+	/** Runs a call on the transport; a transport that is already gone throws, which is only reported. */
+	function onTransport(conn, where, call) {
+		try {
+			call();
+		} catch (error) {
+			report(error, {
+				where,
+				connection: conn.id
+			});
+		}
+	}
 	function sendFrame(conn, frame) {
 		send(conn, encodeFrame(frame));
 	}
@@ -117,22 +136,18 @@ function createHubCore(options = {}) {
 			...n === void 0 ? {} : { n },
 			...channel === void 0 ? {} : { c: channel },
 			code,
-			...message === void 0 ? {} : { msg: message }
+			...message === void 0 || message === "" ? {} : { msg: message }
 		});
 	}
 	/** Sends a final frame, closes the transport and releases the connection. */
 	function drop(conn, code, reason) {
 		if (conn.closed) return;
-		try {
-			conn.transport.send(encodeFrame({
-				t: "bye",
-				code,
-				why: reason
-			}));
-		} catch {}
-		try {
-			conn.transport.close(code, reason);
-		} catch {}
+		onTransport(conn, "transport.send", () => conn.transport.send(encodeFrame({
+			t: "bye",
+			code,
+			why: reason
+		})));
+		onTransport(conn, "transport.close", () => conn.transport.close(code, reason));
 		closeConnection(conn);
 	}
 	function channelState(name) {
@@ -151,23 +166,16 @@ function createHubCore(options = {}) {
 		}
 		return chan;
 	}
-	async function ensureAdapterSub(chan) {
-		if (chan.adapterSub === void 0) {
-			chan.adapterSub = adapter.subscribe(chan.name, (message) => onMessage(chan, message));
-			chan.adapterSub.catch(() => {
-				chan.adapterSub = void 0;
-			});
-		}
-		await chan.adapterSub;
-	}
-	async function ensurePresenceSub(chan) {
-		if (chan.presenceSub === void 0) {
-			chan.presenceSub = adapter.presenceSubscribe(chan.name, (event) => onPresence(chan, event));
-			chan.presenceSub.catch(() => {
-				chan.presenceSub = void 0;
+	/** Opens one of the channel's two adapter feeds once; a failed attempt is forgotten so the next caller retries. */
+	async function ensureFeed(chan, key, open) {
+		if (chan[key] === void 0) {
+			const opened = open();
+			chan[key] = opened;
+			opened.catch(() => {
+				chan[key] = void 0;
 			});
 		}
-		await chan.presenceSub;
+		await chan[key];
 	}
 	function onMessage(chan, message) {
 		for (const sub of chan.subs) {
@@ -250,6 +258,10 @@ function createHubCore(options = {}) {
 	}
 	function onPresence(chan, event) {
 		for (const sub of chan.subs) {
+			if (sub.joined && event.op !== "leave" && event.member.id === sub.conn.id && event.member.v > sub.version) {
+				sub.version = event.member.v;
+				sub.state = event.member.s;
+			}
 			if (!sub.active || !sub.joined && !sub.watch) continue;
 			if (sub.presenceQueue !== void 0) sub.presenceQueue.push(event);
 			else sendPresence(sub, event);
@@ -322,9 +334,19 @@ function createHubCore(options = {}) {
 		if (conn.subs.has(name)) return fail(conn, n, "conflict", name, "already subscribed");
 		if (conn.subs.size >= limits.maxChannelsPerConnection) return fail(conn, n, "limit", name, "too many channels on this connection");
 		const found = match(name);
-		if (found === void 0 || !await allowed(found.rule, "subscribe", name, found.params, conn.identity)) return fail(conn, n, identityDenied(conn), name);
+		if (found === void 0) return fail(conn, n, identityDenied(conn), name);
 		const wantsPresence = frame.hasPresence || frame.watch === true;
-		if (wantsPresence && !await allowed(found.rule, "presence", name, found.params, conn.identity)) return fail(conn, n, identityDenied(conn), name);
+		const pending = {
+			conn,
+			channel: name,
+			revoked: false
+		};
+		judging.add(pending);
+		try {
+			if (!await allowed(found.rule, "subscribe", name, found.params, conn.identity) || wantsPresence && !await allowed(found.rule, "presence", name, found.params, conn.identity) || pending.revoked) return fail(conn, n, identityDenied(conn), name);
+		} finally {
+			judging.delete(pending);
+		}
 		if (frame.hasPresence && byteLength(JSON.stringify(frame.presence ?? null)) > limits.maxStateBytes) return fail(conn, n, "too_large", name, "the presence state is too large");
 		if (conn.closed) return;
 		const chan = channelState(name);
@@ -338,6 +360,7 @@ function createHubCore(options = {}) {
 			watch: frame.watch === true,
 			joined: false,
 			version: 0,
+			state: null,
 			lastSeq: 0,
 			lastAt: now(),
 			pumping: true,
@@ -350,9 +373,9 @@ function createHubCore(options = {}) {
 		conn.subs.set(name, sub);
 		chan.subs.add(sub);
 		try {
-			await ensureAdapterSub(chan);
+			await ensureFeed(chan, "adapterSub", () => adapter.subscribe(chan.name, (message) => onMessage(chan, message)));
 			if (wantsPresence) {
-				await ensurePresenceSub(chan);
+				await ensureFeed(chan, "presenceSub", () => adapter.presenceSubscribe(chan.name, (event) => onPresence(chan, event)));
 				startHeartbeat();
 			}
 			const probe = await adapter.history(name, Number.MAX_SAFE_INTEGER, 0);
@@ -398,18 +421,35 @@ function createHubCore(options = {}) {
 			}
 		}
 	}
-	async function joinPresence(sub, state) {
+	/** Joins one at a time per channel: the capacity check reads the set, so two joins in flight would both see room. */
+	function joinPresence(sub, state) {
+		const name = sub.channel.name;
+		const run = (joinChains.get(name) ?? Promise.resolve()).then(() => joinOne(sub, state));
+		const settle = () => {
+			if (joinChains.get(name) === tail) joinChains.delete(name);
+		};
+		const tail = run.then(settle, settle);
+		joinChains.set(name, tail);
+		return run;
+	}
+	async function joinOne(sub, state) {
+		if (!sub.active) return;
 		if ((await adapter.presenceList(sub.channel.name)).length >= limits.maxPresenceMembers) throw new RealtimeError("limit", "the presence set is full");
 		sub.version = 1;
+		sub.state = state;
 		sub.joined = true;
 		startHeartbeat();
-		const member = {
+		await adapter.presenceSet(sub.channel.name, memberOf(sub), limits.presenceTtlMs);
+	}
+	/** The presence member a joined subscription stands for. */
+	function memberOf(sub) {
+		const { user } = sub.conn.identity;
+		return {
 			id: sub.conn.id,
-			...sub.conn.identity.user === void 0 ? {} : { u: sub.conn.identity.user },
-			s: state,
-			v: 1
+			...user === void 0 ? {} : { u: user },
+			s: sub.state,
+			v: sub.version
 		};
-		await adapter.presenceSet(sub.channel.name, member, limits.presenceTtlMs);
 	}
 	async function syncPresence(sub) {
 		const members = await adapter.presenceList(sub.channel.name);
@@ -435,14 +475,9 @@ function createHubCore(options = {}) {
 		if (byteLength(JSON.stringify(frame.s)) > limits.maxStateBytes) return fail(conn, void 0, "too_large", frame.c, "the presence state is too large");
 		if (!conn.publishBucket.take(now())) return limit(conn, void 0, frame.c);
 		sub.version += 1;
-		const member = {
-			id: conn.id,
-			...conn.identity.user === void 0 ? {} : { u: conn.identity.user },
-			s: frame.s,
-			v: sub.version
-		};
+		sub.state = frame.s;
 		try {
-			await adapter.presenceSet(frame.c, member, limits.presenceTtlMs);
+			await adapter.presenceSet(frame.c, memberOf(sub), limits.presenceTtlMs);
 		} catch (error) {
 			report(error, {
 				where: "presenceSet",
@@ -472,7 +507,7 @@ function createHubCore(options = {}) {
 				history: found.rule.history ?? limits.history,
 				historyTtlMs: limits.historyTtlMs,
 				idempotencyTtlMs: limits.idempotencyTtlMs,
-				...frame.k === void 0 ? {} : { key: frame.k }
+				...frame.k === void 0 ? {} : { key: `${frame.k}/${conn.identity.user === void 0 ? "a" : `u:${conn.identity.user}`}` }
 			});
 			counters.published += result.duplicate ? 0 : 1;
 			if (n !== void 0) sendFrame(conn, {
@@ -541,14 +576,20 @@ function createHubCore(options = {}) {
 			}
 		})();
 	}
+	/** Answers a frame that cannot be handled; a peer that keeps sending them is dropped. */
+	function refuseFrame(conn, n, code, why) {
+		fail(conn, n, code, void 0, why);
+		if (conn.invalid.hit(now())) drop(conn, 1008, "too many invalid frames");
+	}
 	async function handle(conn, text) {
 		const decoded = decodeClientFrame(text, limits.maxMessageBytes);
 		if (!decoded.ok) {
-			fail(conn, decoded.n, decoded.code, void 0, decoded.why);
-			if (conn.invalid.hit(now())) drop(conn, 1008, "too many invalid frames");
+			refuseFrame(conn, decoded.n, decoded.code, decoded.why);
 			return;
 		}
 		const frame = decoded.frame;
+		const n = "n" in frame ? frame.n : void 0;
+		if ((frame.t === "sub" || frame.t === "unsub") && !conn.controlBucket.take(now()) && frame.t === "sub") return limit(conn, n, frame.c);
 		try {
 			switch (frame.t) {
 				case "hello": return;
@@ -570,7 +611,6 @@ function createHubCore(options = {}) {
 				case "pres": return await setPresence(conn, frame);
 			}
 		} catch (error) {
-			const n = "n" in frame ? frame.n : void 0;
 			const channel = "c" in frame ? frame.c : void 0;
 			if (error instanceof RealtimeError) fail(conn, n, error.code, channel);
 			else {
@@ -664,12 +704,7 @@ function createHubCore(options = {}) {
 			for (const ref of missing) {
 				const sub = conns.get(ref.id)?.subs.get(ref.channel);
 				if (sub === void 0 || !sub.joined) continue;
-				await adapter.presenceSet(ref.channel, {
-					id: ref.id,
-					...sub.conn.identity.user === void 0 ? {} : { u: sub.conn.identity.user },
-					s: null,
-					v: sub.version
-				}, limits.presenceTtlMs);
+				await adapter.presenceSet(ref.channel, memberOf(sub), limits.presenceTtlMs);
 			}
 			for (const channel of watched) await adapter.presenceReap(channel);
 		} catch (error) {
@@ -702,6 +737,7 @@ function createHubCore(options = {}) {
 				subs: /* @__PURE__ */ new Map(),
 				queue: [],
 				publishBucket: connectOptions.publishBucket ?? new TokenBucket(limits.publishesPerSecond, limits.publishBurst, now()),
+				controlBucket: new TokenBucket(limits.publishesPerSecond, Math.max(limits.publishBurst, limits.maxChannelsPerConnection), now()),
 				stateless: connectOptions.stateless === true,
 				waiters: [],
 				invalid: new WindowCounter(10, 6e4),
@@ -726,6 +762,10 @@ function createHubCore(options = {}) {
 				done,
 				receive(text) {
 					if (conn.closed) return;
+					if (byteLength(text) > limits.maxMessageBytes) {
+						refuseFrame(conn, void 0, "too_large");
+						return;
+					}
 					if (conn.queue.length >= limits.maxQueuedFrames) {
 						drop(conn, 1013, "too many frames waiting");
 						return;
@@ -764,7 +804,7 @@ function createHubCore(options = {}) {
 				history: found?.rule.history ?? limits.history,
 				historyTtlMs: limits.historyTtlMs,
 				idempotencyTtlMs: limits.idempotencyTtlMs,
-				...publishOptions.key === void 0 ? {} : { key: publishOptions.key }
+				...publishOptions.key === void 0 ? {} : { key: `${publishOptions.key}/s` }
 			});
 			counters.published += result.duplicate ? 0 : 1;
 			return result;
@@ -776,24 +816,32 @@ function createHubCore(options = {}) {
 			if (byteLength(JSON.stringify(state)) > limits.maxStateBytes) throw new RealtimeError("too_large", "the presence state is too large");
 			const member = (await adapter.presenceList(channel)).find((item) => item.id === connectionId);
 			if (member === void 0 || member.u !== identity.user) throw new RealtimeError("forbidden", "that connection is not yours");
+			const local = conns.get(connectionId)?.subs.get(channel);
+			const version = Math.max(member.v, local?.version ?? 0) + 1;
+			if (local?.joined === true) {
+				local.version = version;
+				local.state = state;
+			}
 			await adapter.presenceSet(channel, {
 				id: member.id,
 				u: member.u,
 				s: state,
-				v: member.v + 1
+				v: version
 			}, limits.presenceTtlMs);
 		},
 		revoke(target) {
 			if (target.user === void 0 && target.connection === void 0 && target.channel === void 0) throw new TypeError("revoke needs a user, a connection or a channel.");
+			const hit = (conn, channel) => (target.connection === void 0 || conn.id === target.connection) && (target.user === void 0 || conn.identity.user === target.user) && (target.channel === void 0 || channel === target.channel);
 			let count = 0;
-			for (const conn of [...conns.values()]) {
-				if (target.connection !== void 0 && conn.id !== target.connection) continue;
-				if (target.user !== void 0 && conn.identity.user !== target.user) continue;
-				for (const sub of [...conn.subs.values()]) {
-					if (target.channel !== void 0 && sub.channel.name !== target.channel) continue;
-					removeSub(sub, "revoked");
-					count += 1;
-				}
+			for (const item of judging) {
+				if (item.revoked || !hit(item.conn, item.channel)) continue;
+				item.revoked = true;
+				count += 1;
+			}
+			for (const conn of [...conns.values()]) for (const sub of [...conn.subs.values()]) {
+				if (!hit(conn, sub.channel.name)) continue;
+				removeSub(sub, "revoked");
+				count += 1;
 			}
 			return count;
 		},