svelte-adapter-uws-extensions 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-adapter-uws-extensions",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Redis and Postgres extensions for svelte-adapter-uws - distributed pub/sub, replay buffers, presence tracking, rate limiting, groups, and DB change notifications",
   "author": "Kevin Radziszewski",
   "license": "MIT",

package/redis/presence.js

@@ -20,8 +20,9 @@
 import { randomBytes } from 'node:crypto';
 
 /**
- * Lua script for atomic join: set this instance's field and check if
- * the user already exists on another instance (non-stale).
+ * Lua script for atomic join: set this instance's field, expire the key,
+ * check if the user already exists on another instance (non-stale),
+ * and return all hash entries so the caller can skip a separate HGETALL.
  *
  * KEYS[1] = hash key
  * ARGV[1] = field to set (instanceId|userKey)
@@ -29,9 +30,10 @@ import { randomBytes } from 'node:crypto';
  * ARGV[3] = "|userKey" suffix to match
  * ARGV[4] = now (ms)
  * ARGV[5] = presenceTtlMs
+ * ARGV[6] = presenceTtl (seconds, for EXPIRE)
  *
- * Returns 1 if this is the first live instance for the user (broadcast join),
- * 0 if another live instance already has this user.
+ * Returns {isFirst, field1, val1, field2, val2, ...} so a single round
+ * trip handles HSET + EXPIRE + dedup check + HGETALL.
  */
 const JOIN_SCRIPT = `
 local key = KEYS[1]
@@ -40,20 +42,29 @@ local value = ARGV[2]
 local suffix = ARGV[3]
 local now = tonumber(ARGV[4])
 local ttlMs = tonumber(ARGV[5])
+local ttlSec = tonumber(ARGV[6])
 
 redis.call('hset', key, field, value)
+redis.call('expire', key, ttlSec)
 
 local all = redis.call('hgetall', key)
+local isFirst = 1
 for i = 1, #all, 2 do
   local f = all[i]
   if f ~= field and #f >= #suffix and string.sub(f, -#suffix) == suffix then
     local ok, parsed = pcall(cjson.decode, all[i+1])
     if ok and parsed.ts and (now - parsed.ts) <= ttlMs then
-      return 0
+      isFirst = 0
+      break
     end
   end
 end
-return 1
+
+local result = {isFirst}
+for i = 1, #all do
+  result[#result + 1] = all[i]
+end
+return result
 `;
 
 /**
@@ -162,10 +173,27 @@ export function createPresence(client, options = {}) {
 	 */
 	const syncCounts = new Map();
 
+	/**
+	 * Dedup in-flight HGETALL requests for the same topic. Multiple callers
+	 * awaiting the same key share one Redis round trip.
+	 * @type {Map<string, Promise<Record<string, string>>>}
+	 */
+	const hgetallInflight = new Map();
+
 	function hashKey(topic) {
 		return client.key('presence:' + topic);
 	}
 
+	function coalesceHgetall(topic) {
+		const key = hashKey(topic);
+		let pending = hgetallInflight.get(key);
+		if (!pending) {
+			pending = redis.hgetall(key).finally(() => hgetallInflight.delete(key));
+			hgetallInflight.set(key, pending);
+		}
+		return pending;
+	}
+
 	function eventChannel(topic) {
 		return client.key('presence:events:' + topic);
 	}
@@ -333,24 +361,49 @@ export function createPresence(client, options = {}) {
 			// Subscribe to cross-instance events for this topic
 			await subscribeToTopic(topic, platform);
 
+			// Guard: if ws was closed during the async gap, leave() already
+			// cleaned local state -- undo any Redis write and bail out.
+			if (!wsTopics.has(ws)) return;
+
+			// all will hold the raw hash entries for the initial list.
+			// When prevCount === 0 the Lua script returns them inline
+			// (no separate HGETALL needed). Otherwise we coalesce so
+			// N connections joining the same topic share one round trip.
+			let all;
+
 			if (prevCount === 0) {
-				// New user on this instance -- check if globally new via atomic Lua
+				// New user on this instance -- single Lua call does
+				// HSET + EXPIRE + dedup check + returns all entries.
 				const now = Date.now();
 				const field = compoundField(key);
 				const value = JSON.stringify({ data, ts: now });
 				const suffix = '|' + key;
-				const isFirstGlobally = await redis.eval(
+				const result = await redis.eval(
 					JOIN_SCRIPT, 1, hashKey(topic),
-					field, value, suffix, now, presenceTtlMs
+					field, value, suffix, now, presenceTtlMs, presenceTtl
 				);
-				await redis.expire(hashKey(topic), presenceTtl);
+
+				// Guard: if ws closed while awaiting Redis, remove the field
+				// we just set and bail -- leave() already cleaned local state.
+				if (!wsTopics.has(ws)) {
+					await redis.hdel(hashKey(topic), field).catch(() => {});
+					return;
+				}
+
+				// Parse result: [isFirst, field1, val1, field2, val2, ...]
+				const isFirstGlobally = result[0];
+				all = {};
+				for (let i = 1; i < result.length; i += 2) {
+					all[result[i]] = result[i + 1];
+				}
 
 				if (isFirstGlobally === 1) {
-					// No other live instance has this user -- broadcast join
 					const payload = { key, data };
 					platform.publish('__presence:' + topic, 'join', payload);
 					await publishEvent(topic, 'join', payload);
 				}
+			} else {
+				all = await coalesceHgetall(topic);
 			}
 
 			// Subscribe ws to presence channel (may have closed during async gap)
@@ -361,7 +414,6 @@ export function createPresence(client, options = {}) {
 			}
 
 			// Send current list to this connection
-			const all = await redis.hgetall(hashKey(topic));
 			const entries = parseEntries(all);
 			const list = [];
 			for (const [userKey, entry] of entries) {
@@ -446,7 +498,18 @@ export function createPresence(client, options = {}) {
 			}
 
 			// --- Leave all topics ---
+			// Phase 1: Synchronous cleanup of ALL local state before any async
+			// work. This prevents the heartbeat from refreshing dead entries and
+			// lets concurrent join() calls detect the closed ws via wsTopics.
 			const connTopics = wsTopics.get(ws);
+			wsTopics.delete(ws);
+
+			const syncTopics = syncObservers.get(ws);
+			syncObservers.delete(ws);
+
+			/** @type {Array<{ topic: string, key: string, data: Record<string, any>, needsUnsub: boolean }>} */
+			const pendingLeaves = [];
+
 			if (connTopics) {
 				for (const [topic, { key, data }] of connTopics) {
 					const counts = localCounts.get(topic);
@@ -456,65 +519,72 @@ export function createPresence(client, options = {}) {
 					if (current <= 1) {
 						counts.delete(key);
 
-						// Clean up local data for this user on this topic
 						const topicData = localData.get(topic);
 						if (topicData) {
 							topicData.delete(key);
 							if (topicData.size === 0) localData.delete(topic);
 						}
 
+						let needsUnsub = false;
 						if (counts.size === 0) {
 							localCounts.delete(topic);
 							activeTopics.delete(topic);
-							// Unsubscribe from Redis channel if no sync observers remain
 							if (!syncCounts.has(topic)) {
-								await unsubscribeFromTopic(topic);
+								needsUnsub = true;
 							}
 						}
 
-						// Atomically remove this instance's field and check if user
-						// is still present on another instance (ignoring stale entries)
-						const field = compoundField(key);
-						const suffix = '|' + key;
-						const now = Date.now();
-						const userGone = await redis.eval(
-							LEAVE_SCRIPT, 1, hashKey(topic), field, suffix, now, presenceTtlMs
-						);
-
-						if (userGone === 1) {
-							// No other instance has this user -- broadcast leave
-							const payload = { key, data };
-							platform.publish('__presence:' + topic, 'leave', payload);
-							await publishEvent(topic, 'leave', payload);
-						}
+						pendingLeaves.push({ topic, key, data, needsUnsub });
 					} else {
 						counts.set(key, current - 1);
 					}
 				}
-				wsTopics.delete(ws);
 			}
 
-			// Handle sync-only observers
-			const syncTopics = syncObservers.get(ws);
 			if (syncTopics) {
 				for (const topic of syncTopics) {
 					const count = (syncCounts.get(topic) || 1) - 1;
 					if (count <= 0) {
 						syncCounts.delete(topic);
-						// Unsubscribe from Redis channel if no joined users remain
-						if (!localCounts.has(topic)) {
-							await unsubscribeFromTopic(topic);
-						}
 					} else {
 						syncCounts.set(topic, count);
 					}
 				}
-				syncObservers.delete(ws);
+			}
+
+			// Phase 2: Async Redis cleanup. Local state is already clean so
+			// the heartbeat will not refresh any of these entries.
+			for (const { topic, key, data, needsUnsub } of pendingLeaves) {
+				if (needsUnsub) {
+					await unsubscribeFromTopic(topic);
+				}
+
+				const field = compoundField(key);
+				const suffix = '|' + key;
+				const now = Date.now();
+				const userGone = await redis.eval(
+					LEAVE_SCRIPT, 1, hashKey(topic), field, suffix, now, presenceTtlMs
+				);
+
+				if (userGone === 1) {
+					const payload = { key, data };
+					platform.publish('__presence:' + topic, 'leave', payload);
+					await publishEvent(topic, 'leave', payload);
+				}
+			}
+
+			// Async unsubscribe for sync-only observer topics
+			if (syncTopics) {
+				for (const topic of syncTopics) {
+					if (!syncCounts.has(topic) && !localCounts.has(topic)) {
+						await unsubscribeFromTopic(topic);
+					}
+				}
 			}
 		},
 
 		async sync(ws, topic, platform) {
-			const all = await redis.hgetall(hashKey(topic));
+			const all = await coalesceHgetall(topic);
 			const presenceTopic = '__presence:' + topic;
 			const entries = parseEntries(all);
 			const list = [];