@verdant-web/server 4.1.0 → 4.2.0

package/src/connections/Presence.ts

@@ -7,89 +7,125 @@ import {
 import { UserProfiles } from '../Profiles.js';
 
 export type PresenceEvents = {
-	lost: (connectionKey: string, userId: string) => void;
+	lost: (userId: string) => void;
 };
 
-/**
- * Stores client presence in-memory for connected
- * clients
- */
-export class Presence extends EventSubscriber<PresenceEvents> {
-	private presences: Record<string, UserInfo<any, any>> = {};
-	private connectionToUser: Record<string, string> = {};
-	private userToConnection: Record<string, Set<string>> = {};
-	private keepalives = new Map<string, NodeJS.Timeout>();
+export type PresenceStorageItem = UserInfo<any, any> & { expiresAt: number };
 
-	constructor(readonly profiles: UserProfiles<any>) {
-		super();
-	}
+export interface PresenceStorage {
+	set: (
+		userId: string,
+		userInfo: UserInfoUpdate,
+		profile: any,
+		expiresAt: number,
+	) => Promise<UserInfo<any, any>>;
+	setExpiresAt: (userId: string, expiresAt: number) => Promise<void>;
+	get: (
+		userId: string,
+		time: number,
+	) => Promise<UserInfo<any, any> | undefined>;
+	remove: (userId: string) => Promise<void>;
+	all: () => Promise<Record<string, UserInfo<any, any>>>;
+	clear: () => Promise<void>;
+}
+
+const DEFAULT_EXPIRATION_TIME = 60 * 1000;
+
+export class PresenceMemoryStorage implements PresenceStorage {
+	private presences: Record<string, PresenceStorageItem> = {};
 
 	set = async (
-		connectionKey: string,
 		userId: string,
 		userInfo: UserInfoUpdate,
+		profile: any,
+		expiresAt: number,
 	) => {
 		if (!this.presences[userId]) {
 			this.presences[userId] = {
 				...userInfo,
-				profile: await this.profiles.get(userId),
+				expiresAt,
+				profile,
 				internal: userInfo.internal || initialInternalPresence,
 			};
 		} else {
 			Object.assign(this.presences[userId], userInfo);
 		}
-		this.connectionToUser[connectionKey] = userId;
-		this.userToConnection[userId] =
-			this.userToConnection[userId] || new Set<string>();
-		this.userToConnection[userId].add(connectionKey);
+		return this.presences[userId]!;
+	};
 
-		this.keepAlive(connectionKey);
+	setExpiresAt = async (userId: string, expiresAt: number) => {
+		const presence = this.presences[userId];
+		if (presence) {
+			presence.expiresAt = expiresAt;
+		}
+	};
 
-		return this.presences[userId]!;
+	get = async (userId: string, time: number) => {
+		const value = this.presences[userId];
+		if (value && value.expiresAt > time) {
+			return value;
+		}
+		return undefined;
 	};
 
-	keepAlive = (connectionKey: string, duration = 60 * 1000) => {
-		const existing = this.keepalives.get(connectionKey);
-		if (existing) {
-			clearTimeout(existing);
+	remove = async (userId: string) => {
+		delete this.presences[userId];
+		if (Object.keys(this.presences).length === 0) {
+			this.clear();
 		}
+	};
 
-		this.keepalives.set(
-			connectionKey,
-			setTimeout(() => {
-				this.removeConnection(connectionKey);
-				this.keepalives.delete(connectionKey);
-			}, duration),
-		);
+	all = async () => {
+		return this.presences;
 	};
 
-	get = (userId: string) => {
-		return this.presences[userId];
+	clear = async () => {
+		this.presences = {};
+	};
+}
+
+/**
+ * Stores client presence for connected
+ * clients
+ */
+export class Presence extends EventSubscriber<PresenceEvents> {
+	constructor(
+		readonly profiles: UserProfiles<any>,
+		readonly storage: PresenceStorage = new PresenceMemoryStorage(),
+	) {
+		super();
+	}
+
+	set = async (userId: string, userInfo: UserInfoUpdate) => {
+		const value = await this.storage.set(
+			userId,
+			userInfo,
+			await this.profiles.get(userId),
+			Date.now() + DEFAULT_EXPIRATION_TIME,
+		);
+
+		return value;
 	};
 
-	removeConnection = (connectionKey: string) => {
-		const userId = this.connectionToUser[connectionKey];
-		if (!userId) return;
+	keepAlive = (userId: string, duration = DEFAULT_EXPIRATION_TIME) => {
+		const time = Date.now() + duration;
+		this.storage.setExpiresAt(userId, time);
+	};
 
-		this.userToConnection[userId].delete(connectionKey);
-		if (this.userToConnection[userId].size === 0) {
-			delete this.presences[userId];
-			this.emit('lost', connectionKey, userId);
+	get = (userId: string) => {
+		return this.storage.get(userId, Date.now());
+	};
 
-			// memory cleanup
-			if (Object.keys(this.presences).length === 0) {
-				this.clear();
-			}
-		}
+	remove = async (userId: string) => {
+		await this.storage.remove(userId);
+		this.emit('lost', userId);
 	};
 
 	all = () => {
-		return this.presences;
+		return this.storage.all();
 	};
 
 	clear = () => {
-		this.presences = {};
-		this.connectionToUser = {};
-		this.userToConnection = {};
+		this.storage.clear();
 	};
 }

package/src/internals.ts

@@ -2,6 +2,7 @@ export { errorHandler } from './adapters/node/errorHandler.js';
 export { createHttpRouter as createHonoRouter } from './adapters/node/httpRouter.js';
 export { tokenMiddleware } from './adapters/node/tokenMiddleware.js';
 export { ClientConnectionManager } from './connections/ClientConnection.js';
+export type * from './connections/Presence.js';
 export { FileStorageLibraryDelegate } from './files/FileStorage.js';
 export type * from './libraries/generic.js';
 export { Library, type LibraryEvents } from './libraries/Library.js';

package/src/libraries/Library.test.ts

@@ -21,7 +21,13 @@ const profiles = new UserProfileLoader<{ id: string; name: string }>({
 	},
 });
 
-const baseOptions = async () => ({
+const baseOptions = async ({
+	onBroadcast,
+	onRespond,
+}: {
+	onBroadcast?: (message: ServerMessage, omitKeys?: string[]) => void;
+	onRespond?: (clientKey: string, message: ServerMessage) => void;
+} = {}) => ({
 	id: 'library-1',
 	profiles,
 	storage: await sqlShardStorage({
@@ -29,14 +35,22 @@ const baseOptions = async () => ({
 		fileDeleteExpirationDays: 7,
 		replicaTruancyMinutes: 60 * 24,
 	})('library-1'),
-	presence: new Presence({
-		get: async (userId: string) => {
-			return {
-				id: userId,
-				name: 'Alice',
-			};
-		},
-	}),
+	clientConnections: {
+		presence: new Presence({
+			get: async (userId: string) => {
+				return {
+					id: userId,
+					name: 'Alice',
+				};
+			},
+		}),
+		broadcast: vi.fn((message: ServerMessage, omitKeys?: string[]) => {
+			if (onBroadcast) onBroadcast(message, omitKeys);
+		}),
+		respond: vi.fn((clientKey: string, message: ServerMessage) => {
+			if (onRespond) onRespond(clientKey, message);
+		}),
+	} as any,
 });
 
 let time = 0;
@@ -80,11 +94,6 @@ function getAllReceivedReplicaOperations(replica: TestReplica) {
 describe('Library', () => {
 	describe('sync handling', () => {
 		it('should initialize a new library from a replica', async () => {
-			const sender: MessageSender = {
-				broadcast: vi.fn(),
-				respond: vi.fn((_: string, message: ServerMessage) => {}),
-			};
-
 			const tokenInfo: TokenInfo = {
 				libraryId: 'library-1',
 				syncEndpoint: 'http://localhost:3000/sync',
@@ -93,10 +102,9 @@ describe('Library', () => {
 				userId: 'user-1',
 			};
 
-			const library = new Library({
-				...(await baseOptions()),
-				sender,
-			});
+			const options = await baseOptions();
+
+			const library = new Library(options);
 
 			const messages: ClientMessage[] = [
 				{
@@ -146,7 +154,7 @@ describe('Library', () => {
 			);
 
 			// expect sender.broadcast for the operations, and a reply with sync response
-			expect(sender.broadcast).toHaveBeenCalledWith(
+			expect(options.clientConnections.broadcast).toHaveBeenCalledWith(
 				{
 					type: 'op-re',
 					baselines: [
@@ -187,16 +195,19 @@ describe('Library', () => {
 				['clientKey-1'],
 			);
 
-			expect(sender.respond).toHaveBeenCalledWith('clientKey-1', {
-				type: 'sync-resp',
-				operations: [],
-				baselines: [],
-				ackThisNonce: undefined,
-				ackedTimestamp: 'faketime-3',
-				globalAckTimestamp: undefined,
-				overwriteLocalData: false,
-				peerPresence: {},
-			});
+			expect(options.clientConnections.respond).toHaveBeenCalledWith(
+				'clientKey-1',
+				{
+					type: 'sync-resp',
+					operations: [],
+					baselines: [],
+					ackThisNonce: undefined,
+					ackedTimestamp: 'faketime-3',
+					globalAckTimestamp: undefined,
+					overwriteLocalData: false,
+					peerPresence: {},
+				},
+			);
 		});
 
 		it('should sync up to latest data, while also rebroadcasting concurrent new operations', async () => {
@@ -222,11 +233,24 @@ describe('Library', () => {
 				},
 			};
 
-			const library = new Library({
-				...(await baseOptions()),
-				sender,
+			const options = await baseOptions({
+				onBroadcast: (message: ServerMessage, omitKeys?: string[]) => {
+					replicas.forEach((replica) => {
+						if (!omitKeys?.includes(replica.key)) {
+							replica.messages.push(message);
+						}
+					});
+				},
+				onRespond: (clientKey: string, message: ServerMessage) => {
+					const replica = replicas.find((r) => r.key === clientKey);
+					if (replica) {
+						replica.messages.push(message);
+					}
+				},
 			});
 
+			const library = new Library(options);
+
 			// replica A sends a sync message to initialize library
 			const syncMessageA: ClientMessage = {
 				type: 'sync',
@@ -323,11 +347,6 @@ describe('Library', () => {
 		});
 
 		it('should reject syncs with data from read replicas', async () => {
-			const sender = {
-				broadcast: vi.fn(),
-				respond: vi.fn(),
-			};
-
 			const tokenInfo: TokenInfo = {
 				libraryId: 'library-1',
 				syncEndpoint: 'http://localhost:3000/sync',
@@ -336,10 +355,9 @@ describe('Library', () => {
 				userId: 'user-1',
 			};
 
-			const library = new Library({
-				...(await baseOptions()),
-				sender,
-			});
+			const options = await baseOptions();
+
+			const library = new Library(options);
 
 			const messages: ClientMessage[] = [
 				{
@@ -388,18 +406,16 @@ describe('Library', () => {
 				messages.map((m) => library.handleMessage(m, 'clientKey-1', tokenInfo)),
 			);
 
-			expect(sender.respond).toHaveBeenCalledOnce();
-			expect(sender.respond).toHaveBeenCalledWith('clientKey-1', {
-				type: 'forbidden',
-			});
+			expect(options.clientConnections.respond).toHaveBeenCalledOnce();
+			expect(options.clientConnections.respond).toHaveBeenCalledWith(
+				'clientKey-1',
+				{
+					type: 'forbidden',
+				},
+			);
 		});
 
 		it('should reject messages from a replica claimed by a user other than the one recorded on the server', async () => {
-			const sender = {
-				broadcast: vi.fn(),
-				respond: vi.fn((_: string, message: ServerMessage) => {}),
-			};
-
 			const tokenInfo: TokenInfo = {
 				libraryId: 'library-1',
 				syncEndpoint: 'http://localhost:3000/sync',
@@ -408,10 +424,9 @@ describe('Library', () => {
 				userId: 'user-1',
 			};
 
-			const library = new Library({
-				...(await baseOptions()),
-				sender,
-			});
+			const options = await baseOptions();
+
+			const library = new Library(options);
 
 			// purposefully do not await in order - these all come at the same time
 			await library.handleMessage(
@@ -427,7 +442,7 @@ describe('Library', () => {
 				'clientKey-1',
 				tokenInfo,
 			);
-			sender.respond.mockReset();
+			options.clientConnections.respond.mockReset();
 
 			// now try to send a message from a different user with the same replica
 			const tokenInfo2: TokenInfo = {
@@ -450,23 +465,19 @@ describe('Library', () => {
 
 			await library.handleMessage(message, 'clientKey-1', tokenInfo2);
 
-			expect(sender.respond).toHaveBeenCalledOnce();
-			expect(sender.respond).toHaveBeenCalledWith('clientKey-1', {
-				type: 'forbidden',
-			});
+			expect(options.clientConnections.respond).toHaveBeenCalledOnce();
+			expect(options.clientConnections.respond).toHaveBeenCalledWith(
+				'clientKey-1',
+				{
+					type: 'forbidden',
+				},
+			);
 		});
 	});
 
 	it('should fully destroy itself', async () => {
-		const sender = {
-			broadcast: vi.fn(),
-			respond: vi.fn(),
-		};
-
-		const library = new Library({
-			...(await baseOptions()),
-			sender,
-		});
+		const options = await baseOptions();
+		const library = new Library(options);
 
 		const opMessage: ClientMessage = {
 			type: 'op',

package/src/libraries/Library.ts

@@ -16,9 +16,8 @@ import {
 	rewriteAuthzOriginator,
 	SyncMessage,
 } from '@verdant-web/common';
-import { MessageSender } from '../connections/MessageSender.js';
-import { Presence } from '../connections/Presence.js';
 import { FileInfo, FileStorageLibraryDelegate } from '../files/FileStorage.js';
+import { ClientConnectionManager } from '../internals.js';
 import { Logger } from '../logger.js';
 import { Storage } from '../storage/Storage.js';
 import { TokenInfo } from '../TokenVerifier.js';
@@ -47,42 +46,44 @@ export interface LibraryFileInfo {
 
 export class Library {
 	private storage;
-	private sender;
 	private disableRebasing: boolean;
 	private fileStorage;
 	private events;
 	readonly id: string;
-	private presence: Presence;
+	private clientConnections: ClientConnectionManager;
+	private get presence() {
+		return this.clientConnections.presence;
+	}
+	private get sender() {
+		return this.clientConnections;
+	}
 
 	private log: Logger;
 
 	constructor({
 		storage,
-		sender,
 		log = () => {},
 		disableRebasing,
 		fileStorage,
 		events,
 		id,
-		presence,
+		clientConnections,
 	}: {
 		storage: Storage;
-		sender: MessageSender;
 		log?: Logger;
 		disableRebasing?: boolean;
 		fileStorage?: FileStorageLibraryDelegate;
 		events?: EventSubscriber<LibraryEvents>;
 		id: string;
-		presence: Presence;
+		clientConnections: ClientConnectionManager;
 	}) {
 		this.id = id;
 		this.storage = storage;
-		this.sender = sender;
 		this.log = log;
 		this.disableRebasing = !!disableRebasing;
 		this.fileStorage = fileStorage;
 		this.events = events;
-		this.presence = presence;
+		this.clientConnections = clientConnections;
 		this.presence.subscribe('lost', this.onPresenceLost);
 	}
 
@@ -490,13 +491,16 @@ export class Library {
 
 		// respond to client
 
+		const peerPresence = await this.presence.all();
+
 		this.log(
 			'info',
 			'Sending sync response with',
-			ops.length,
-			'operations and',
-			baselines.length,
-			'baselines',
+			{
+				ops: ops.length,
+				baselines: baselines.length,
+				peers: Object.keys(peerPresence),
+			},
 			'to client key',
 			clientKey,
 		);
@@ -511,7 +515,7 @@ export class Library {
 				baselines: this.removeBaselineExtras(baselines),
 				globalAckTimestamp:
 					(await this.storage.replicas.getGlobalAck()) ?? undefined,
-				peerPresence: this.presence.all(),
+				peerPresence,
 				// only request the client to overwrite local data if a reset is requested
 				// and there is data to overwrite it. otherwise the client may still
 				// send its own history to us.
@@ -578,7 +582,7 @@ export class Library {
 		clientKey: string,
 		_info: TokenInfo,
 	) => {
-		this.presence.removeConnection(clientKey);
+		await this.clientConnections.remove(clientKey);
 	};
 
 	private updateHighwater = async (
@@ -633,7 +637,7 @@ export class Library {
 		// for global ack, to determine consensus, also allow
 		// for all actively connected replicas to ack regardless of their
 		// type.
-		const activeReplicaIds = Object.values(this.presence.all()).map(
+		const activeReplicaIds = Object.values(await this.presence.all()).map(
 			(p) => p.replicaId,
 		);
 		const globalAck =
@@ -711,7 +715,7 @@ export class Library {
 		clientKey: string,
 		info: TokenInfo,
 	) => {
-		const updated = await this.presence.set(clientKey, info.userId, {
+		const updated = await this.presence.set(info.userId, {
 			presence: message.presence,
 			internal: message.internal,
 			replicaId: message.replicaId,
@@ -728,14 +732,13 @@ export class Library {
 		);
 	};
 
-	private onPresenceLost = async (replicaId: string, userId: string) => {
+	private onPresenceLost = async (userId: string) => {
 		this.log('info', 'User disconnected from all replicas:', userId);
 		this.sender.broadcast({
 			type: 'presence-offline',
-			replicaId,
 			userId,
 		});
-		if (Object.keys(this.presence.all()).length === 0) {
+		if (Object.keys(await this.presence.all()).length === 0) {
 			this.log('info', `All users have disconnected`);
 			// could happen - if the server is shutting down manually
 			if (!this.storage.open) {
@@ -803,7 +806,7 @@ export class Library {
 	};
 
 	getPresence = () => {
-		return Promise.resolve(this.presence.all());
+		return this.presence.all();
 	};
 
 	getInfo = async (): Promise<LibraryInfo | null> => {

package/src/libraries/singleNode.ts

@@ -75,8 +75,7 @@ export class SingleNodeLibraryManager {
 			storage,
 			id: libraryId,
 			events: this.events,
-			sender: clientConnections,
-			presence: clientConnections.presence,
+			clientConnections,
 			log: (level, ...args) =>
 				this.ctx.log?.(level, `[Library ${libraryId}]`, ...args),
 			fileStorage: this.ctx.fileStorage