@verdant-web/server 3.3.11 → 4.0.1

package/src/adapters/node/httpRouter.ts

@@ -0,0 +1,139 @@
+import { ClientMessage, VerdantError } from '@verdant-web/common';
+import { Hono } from 'hono';
+import { Readable } from 'stream';
+import { SingleNodeLibraryManager } from '../../libraries/singleNode.js';
+import { errorHandler } from './errorHandler.js';
+import { tokenMiddleware } from './tokenMiddleware.js';
+
+export function createHttpRouter(core: SingleNodeLibraryManager) {
+	const mw = tokenMiddleware(core.tokenVerifier);
+	const app = new Hono<any>()
+		.onError(errorHandler)
+		.use('*', async (c, next) => {
+			core.log('debug', 'Incoming request', {
+				method: c.req.method,
+				path: c.req.path,
+			});
+			await next();
+		})
+		.post('/', mw, async (ctx) => {
+			const key = ctx.get('key');
+			const info = ctx.get('tokenInfo');
+
+			const microserver = await core.get(info.libraryId);
+
+			const finish = microserver.onRequest?.(key, ctx.req.raw, info);
+
+			const body = (await ctx.req.json()) as
+				| { messages: ClientMessage[] }
+				| null
+				| undefined;
+
+			if (!body?.messages) {
+				throw new VerdantError(
+					VerdantError.Code.BodyRequired,
+					undefined,
+					'Invalid request body',
+				);
+			}
+
+			for (const message of body.messages) {
+				await microserver.handleMessage(key, info, message);
+			}
+
+			const res = finish();
+
+			return res;
+		})
+		.post('/files/:fileId', mw, async (ctx) => {
+			const info = ctx.get('tokenInfo');
+
+			const id = ctx.req.param('fileId');
+			if (!id) {
+				throw new VerdantError(
+					VerdantError.Code.NotFound,
+					undefined,
+					'Supply a file ID as a path parameters',
+				);
+			}
+
+			// TODO: remove this once I figure out why request file body parsing is
+			// hanging indefinitely.
+			if (core.__testMode) {
+				const microserver = await core.get(info.libraryId);
+
+				core.log(
+					'warn',
+					'TEST MODE: FILE WILL NOT BE WRITTEN',
+					'\n',
+					'This Verdant server was launched in Test Mode. This is only meant for use',
+					'in automated testing environments. The file just uploaded WILL NOT be',
+					'stored on disk or retrievable.',
+				);
+				// Fake a file upload for testing
+				await microserver.uploadFile(
+					new Readable({
+						read() {
+							this.push('test');
+							this.push(null);
+						},
+					}),
+					{
+						id,
+						libraryId: info.libraryId,
+						fileName: 'test.txt',
+						type: 'text/plain',
+					},
+				);
+				return ctx.json({ success: true }, 200);
+			}
+
+			const form = await ctx.req.parseBody();
+			const file = form.file;
+			if (!file || !(file instanceof File)) {
+				throw new VerdantError(
+					VerdantError.Code.InvalidRequest,
+					undefined,
+					'No file was uploaded to the `file` form key',
+				);
+			}
+
+			const microserver = await core.get(info.libraryId);
+
+			const fileStream = file.stream();
+			await microserver.uploadFile(fileStream, {
+				id,
+				libraryId: info.libraryId,
+				fileName: file.name,
+				type: file.type,
+			});
+
+			return ctx.json({ success: true }, 200);
+		})
+		.get('/files/:fileId', mw, async (ctx) => {
+			const info = ctx.get('tokenInfo');
+
+			const id = ctx.req.param('fileId');
+			if (!id) {
+				throw new VerdantError(
+					VerdantError.Code.NotFound,
+					undefined,
+					'Supply a file ID as a path parameters',
+				);
+			}
+
+			const microserver = await core.get(info.libraryId);
+
+			const file = await microserver.getFileInfo(id);
+			if (!file) {
+				throw new VerdantError(
+					VerdantError.Code.NotFound,
+					undefined,
+					`File with ID ${id} not found`,
+				);
+			}
+
+			return ctx.json(file, 200);
+		});
+	return app;
+}

package/src/adapters/node/index.ts

@@ -0,0 +1,5 @@
+export { errorHandler } from '../node/errorHandler.js';
+export { getRequestToken } from '../node/getRequestToken.js';
+export * from './httpRouter.js';
+export { tokenMiddleware } from './tokenMiddleware.js';
+export * from './websocketHandler.js';

package/src/adapters/node/tokenMiddleware.ts

@@ -0,0 +1,32 @@
+import { generateId } from '@verdant-web/common';
+import { createMiddleware } from 'hono/factory';
+import { TokenInfo, TokenVerifier } from '../../TokenVerifier.js';
+import { getRequestToken } from '../node/getRequestToken.js';
+
+export const tokenMiddleware = (tokenVerifier: TokenVerifier) =>
+	createMiddleware<{
+		Variables: {
+			key: string;
+			tokenInfo: TokenInfo;
+		};
+	}>((ctx, next) => {
+		if (ctx.req.method === 'OPTIONS') {
+			// preflight request, np
+			return next();
+		}
+		const requestToken = getRequestToken(ctx.req.raw)!;
+
+		const key = generateId();
+		const info = tokenVerifier.verifyToken(requestToken);
+		ctx.set('key', key);
+		ctx.set('tokenInfo', info);
+
+		// if a Sec-Websocket-Protocol header was sent, we need to echo it back
+		// so the websocket connection is accepted by the client
+		const protocolHeader = ctx.req.header('Sec-WebSocket-Protocol');
+		if (protocolHeader) {
+			ctx.res.headers.set('Sec-WebSocket-Protocol', requestToken);
+		}
+
+		return next();
+	});

package/src/adapters/node/websocketHandler.ts

@@ -0,0 +1,79 @@
+import {
+	ClientMessage,
+	VerdantError,
+	assert,
+	generateId,
+} from '@verdant-web/common';
+import { IncomingMessage } from 'node:http';
+import internal from 'node:stream';
+import { URL } from 'url';
+import { WebSocket, WebSocketServer } from 'ws';
+import { TokenInfo } from '../../TokenVerifier.js';
+import { SingleNodeLibraryManager } from '../../libraries/singleNode.js';
+
+export function createNodeWebsocketHandler(core: SingleNodeLibraryManager) {
+	const wss = new WebSocketServer({ noServer: true });
+	wss.on(
+		'connection',
+		async (ws: WebSocket, req: IncomingMessage, info: TokenInfo) => {
+			const key = generateId();
+
+			const microserver = await core.get(info.libraryId);
+
+			microserver.clientConnections.addSocket(key, ws, info);
+
+			ws.on('message', async (message: any) => {
+				const data = JSON.parse(message.toString()) as ClientMessage;
+				await microserver.handleMessage(key, info, data);
+			});
+
+			ws.on('close', () => {
+				microserver.clientConnections.remove(key);
+				core.log('debug', 'Connection closed', { key, userId: info.userId });
+			});
+		},
+	);
+
+	function getRequestToken(req: IncomingMessage) {
+		if (req.headers['sec-websocket-protocol']) {
+			// hack: read the token from the websocket protocol header
+			const [type, token] = req.headers['sec-websocket-protocol'].split(',');
+			if (type === 'Bearer') {
+				return token.trim();
+			}
+		}
+
+		assert(req.url, 'Request URL is required');
+		const url = new URL(req.url, 'http://localhost');
+		const token = url.searchParams.get('token');
+		if (!token) {
+			throw new VerdantError(
+				VerdantError.Code.NoToken,
+				undefined,
+				'Token query parameter is required',
+			);
+		}
+
+		return token;
+	}
+
+	return (req: IncomingMessage, socket: internal.Duplex, head: Buffer) => {
+		try {
+			const token = getRequestToken(req);
+			const info = core.tokenVerifier.verifyToken(token);
+			wss.handleUpgrade(req, socket, head, (ws) => {
+				wss.emit('connection', ws, req, info);
+			});
+		} catch (err) {
+			if (err instanceof VerdantError && err.httpStatus === 401) {
+				socket.write(
+					'HTTP/1.1 401 Unauthorized\r\n' +
+						'Connection: close\r\n' +
+						'Content-Length: 0\r\n' +
+						'\r\n',
+				);
+			}
+			socket.destroy();
+		}
+	};
+}

package/src/{ClientConnection.ts → connections/ClientConnection.ts}

@@ -1,7 +1,10 @@
-import { authz, Operation, ServerMessage } from '@verdant-web/common';
+import { authz, ServerMessage } from '@verdant-web/common';
 import { IncomingMessage, ServerResponse } from 'http';
-import { WebSocket } from 'ws';
-import { TokenInfo } from './TokenVerifier.js';
+import { WebSocket as WSWebSocket } from 'ws';
+import { UserProfileLoader } from '../Profiles.js';
+import { TokenInfo } from '../TokenVerifier.js';
+import { MessageSender } from './MessageSender.js';
+import { Presence } from './Presence.js';
 
 abstract class ClientConnection {
 	constructor(
@@ -109,59 +112,79 @@ class FetchClientConnection extends ClientConnection {
 	};
 }
 
+function subscribeToSocketEvent(
+	socket: WSWebSocket | WebSocket,
+	event: string,
+	handler: (data: any) => void,
+) {
+	if ('on' in socket) {
+		(socket as WSWebSocket).on(event as any, handler);
+		return () => (socket as WSWebSocket).off(event as any, handler);
+	} else {
+		(socket as WebSocket).addEventListener(event as any, (evt) =>
+			handler((evt as any).data),
+		);
+		return () =>
+			(socket as WebSocket).removeEventListener(event as any, handler);
+	}
+}
+
 class WebSocketClientConnection extends ClientConnection {
 	readonly type = 'websocket';
 
 	constructor(
 		key: string,
-		readonly ws: WebSocket,
+		// supports either NodeJS+WS mock websocket or native WebSocket
+		// for Cloudflare / Edge environments
+		readonly ws: WebSocket | WSWebSocket,
 		info: TokenInfo,
 	) {
 		super(key, info);
 	}
 
 	handleMessage = (message: ServerMessage) => {
-		this.ws.send(JSON.stringify(message));
+		return this.ws.send(JSON.stringify(message));
 	};
 }
 
-export class ClientConnectionManager {
-	private readonly connections: Record<string, Map<string, ClientConnection>> =
-		{};
+export class ClientConnectionManager implements MessageSender {
+	private readonly connections: Map<string, ClientConnection> = new Map();
+	readonly presence: Presence;
 
-	private getLibraryConnections = (libraryId: string) => {
-		if (!this.connections[libraryId]) {
-			this.connections[libraryId] = new Map();
-		}
-		return this.connections[libraryId]!;
-	};
+	constructor({ profiles }: { profiles: UserProfileLoader<any> }) {
+		this.presence = new Presence(profiles);
+	}
 
 	addSocket = (
-		libraryId: string,
 		key: string,
-		socket: WebSocket,
+		socket: WebSocket | WSWebSocket,
 		info: TokenInfo,
 	) => {
-		const lib = this.getLibraryConnections(libraryId);
-
 		const connection = new WebSocketClientConnection(key, socket, info);
 
-		lib.set(key, connection);
+		this.connections.set(key, connection);
 
-		socket.on('close', () => {
-			lib.delete(key);
-		});
+		const unsubscribes: (() => void)[] = [];
+		unsubscribes.push(
+			subscribeToSocketEvent(socket, 'close', () => {
+				this.connections.delete(key);
+				this.presence.removeConnection(key);
+				unsubscribes.forEach((u) => u());
+			}),
+		);
+		unsubscribes.push(
+			subscribeToSocketEvent(socket, 'messsage', () => {
+				this.presence.keepAlive(key);
+			}),
+		);
 	};
 
 	addRequest = (
-		libraryId: string,
 		key: string,
 		request: IncomingMessage,
 		response: ServerResponse,
 		info: TokenInfo,
 	) => {
-		const lib = this.getLibraryConnections(libraryId);
-
 		const connection = new RequestClientConnection(
 			key,
 			request,
@@ -169,47 +192,37 @@ export class ClientConnectionManager {
 			info,
 		);
 
-		lib.set(key, connection);
+		this.connections.set(key, connection);
 
 		return () => {
 			connection.end();
-			lib.delete(key);
+			this.connections.delete(key);
 		};
 	};
 
-	addFetch = (
-		libraryId: string,
-		key: string,
-		req: Request,
-		info: TokenInfo,
-	): (() => Response) => {
-		const lib = this.getLibraryConnections(libraryId);
-
+	addFetch = (key: string, req: Request, info: TokenInfo): (() => Response) => {
 		const connection = new FetchClientConnection(key, req, info);
 
-		lib.set(key, connection);
+		this.connections.set(key, connection);
 
 		return () => {
 			connection.end();
-			lib.delete(key);
+			this.connections.delete(key);
 			return connection.res;
 		};
 	};
 
-	remove = (libraryId: string, key: string) => {
-		const lib = this.getLibraryConnections(libraryId);
-		lib.delete(key);
+	remove = (key: string) => {
+		this.connections.delete(key);
+		this.presence.removeConnection(key);
 	};
 
-	respond = (libraryId: string, key: string, message: ServerMessage) => {
-		const lib = this.getLibraryConnections(libraryId);
-		const connection = lib.get(key);
+	respond = (key: string, message: ServerMessage) => {
+		const connection = this.connections.get(key);
 		if (connection) {
 			connection.respond(message);
 		} else {
-			throw new Error(
-				`No connection found for library ${libraryId}, key ${key}`,
-			);
+			throw new Error(`No connection found for key ${key}`);
 		}
 	};
 
@@ -217,26 +230,20 @@ export class ClientConnectionManager {
 	 * Broadcasts a message to all live-connected clients in a library.
 	 * This does not reach push/pull clients.
 	 */
-	broadcast = (
-		libraryId: string,
-		message: ServerMessage,
-		omitKeys: string[] = [],
-	) => {
-		const lib = this.getLibraryConnections(libraryId);
-		for (const [key, connection] of lib) {
+	broadcast = (message: ServerMessage, omitKeys: string[] = []) => {
+		for (const [key, connection] of this.connections) {
 			if (!omitKeys.includes(key)) {
 				connection.respond(message);
 			}
 		}
 	};
 
-	disconnectAll = (libraryId: string) => {
-		const lib = this.getLibraryConnections(libraryId);
-		for (const connection of lib.values()) {
+	disconnectAll = () => {
+		for (const connection of this.connections.values()) {
 			if (connection instanceof WebSocketClientConnection) {
 				connection.ws.close();
 			}
 		}
-		lib.clear();
+		this.connections.clear();
 	};
 }

package/src/connections/MessageSender.ts

@@ -0,0 +1,6 @@
+import { ServerMessage } from '@verdant-web/common';
+
+export interface MessageSender {
+	broadcast(message: ServerMessage, omitKeys?: string[]): void;
+	respond(clientKey: string, message: ServerMessage): void;
+}

package/src/connections/Presence.ts

@@ -0,0 +1,95 @@
+import {
+	EventSubscriber,
+	initialInternalPresence,
+	UserInfo,
+	UserInfoUpdate,
+} from '@verdant-web/common';
+import { UserProfiles } from '../Profiles.js';
+
+export type PresenceEvents = {
+	lost: (connectionKey: string, 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>();
+
+	constructor(private profiles: UserProfiles<any>) {
+		super();
+	}
+
+	set = async (
+		connectionKey: string,
+		userId: string,
+		userInfo: UserInfoUpdate,
+	) => {
+		if (!this.presences[userId]) {
+			this.presences[userId] = {
+				...userInfo,
+				profile: await this.profiles.get(userId),
+				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);
+
+		this.keepAlive(connectionKey);
+
+		return this.presences[userId]!;
+	};
+
+	keepAlive = (connectionKey: string) => {
+		const existing = this.keepalives.get(connectionKey);
+		if (existing) {
+			clearTimeout(existing);
+		}
+
+		this.keepalives.set(
+			connectionKey,
+			setTimeout(() => {
+				this.removeConnection(connectionKey);
+				this.keepalives.delete(connectionKey);
+			}, 30 * 1000),
+		);
+	};
+
+	get = (userId: string) => {
+		return this.presences[userId];
+	};
+
+	removeConnection = (connectionKey: string) => {
+		const userId = this.connectionToUser[connectionKey];
+		if (!userId) return;
+
+		this.userToConnection[userId].delete(connectionKey);
+		if (this.userToConnection[userId].size === 0) {
+			delete this.presences[userId];
+			this.emit('lost', connectionKey, userId);
+
+			// memory cleanup
+			if (Object.keys(this.presences).length === 0) {
+				this.clear();
+			}
+		}
+	};
+
+	all = () => {
+		return this.presences;
+	};
+
+	clear = () => {
+		this.presences = {};
+		this.connectionToUser = {};
+		this.userToConnection = {};
+	};
+}

package/src/core.ts

@@ -0,0 +1,36 @@
+import { FileStorage } from './files/FileStorage.js';
+import { SingleNodeLibraryManager } from './libraries/singleNode.js';
+import { Logger } from './logger.js';
+import { UserProfileLoader, UserProfiles } from './Profiles.js';
+import { StorageFactory } from './storage/Storage.js';
+
+export function createVerdant({
+	profiles: profilesSource,
+	storage,
+	tokenSecret,
+	disableRebasing,
+	fileStorage,
+	log,
+	__testMode,
+}: {
+	profiles: UserProfiles<any>;
+	storage: StorageFactory;
+	tokenSecret: string;
+	disableRebasing?: boolean;
+	fileStorage?: FileStorage;
+	log?: Logger;
+	__testMode?: boolean;
+}) {
+	const profiles = new UserProfileLoader(profilesSource);
+	return new SingleNodeLibraryManager({
+		profiles,
+		storage,
+		tokenSecret,
+		disableRebasing,
+		fileStorage,
+		log,
+		__testMode,
+	});
+}
+
+export type VerdantCore = ReturnType<typeof createVerdant>;

package/src/defaults.ts

@@ -0,0 +1,2 @@
+export const defaultFileExpirationDays = 14;
+export const defaultReplicaTruancyMinutes = 7 * 24 * 60; // 7 days

package/src/files/FileStorage.ts

@@ -1,6 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { Readable } from 'stream';
+import type { Readable } from 'stream';
+import { ReadableStream } from 'stream/web';
 
 export interface FileInfo {
 	fileName: string;
@@ -18,7 +19,10 @@ export interface FileInfo {
  * even if the file is not yet uploaded, based on its metadata.
  */
 export interface FileStorage {
-	put(fileStream: Readable, data: FileInfo): Promise<void>;
+	put(
+		fileStream: Readable | ReadableStream | any,
+		data: FileInfo,
+	): Promise<void>;
 	getUrl(data: FileInfo): string | Promise<string>;
 	delete(data: FileInfo): Promise<void>;
 }
@@ -49,7 +53,7 @@ export class LocalFileStorage implements FileStorage {
 		return host;
 	};
 
-	async put(fileStream: Readable, data: FileInfo): Promise<void> {
+	async put(fileStream: any, data: FileInfo): Promise<void> {
 		this.log('debug', 'Saving file', data.id, data.fileName);
 		const filePath = this.getPath(data);
 		const containingDirectory = path.dirname(
@@ -61,6 +65,10 @@ export class LocalFileStorage implements FileStorage {
 		const location = this.getStorageLocation(data);
 		const dest = fs.createWriteStream(location);
 		this.log('info', 'File saving to', location);
+		if (fileStream instanceof ReadableStream) {
+			// @ts-ignore
+			fileStream = Readable.fromWeb(fileStream);
+		}
 		fileStream.pipe(dest);
 	}
 
@@ -100,3 +108,28 @@ export class LocalFileStorage implements FileStorage {
 		return path.join(this.rootDirectory, this.getPath(data));
 	}
 }
+
+export class FileStorageLibraryDelegate {
+	constructor(
+		private libraryId: string,
+		private fileStorage: FileStorage,
+	) {}
+	put = (fileStream: Readable, data: Omit<FileInfo, 'libraryId'>) => {
+		return this.fileStorage.put(fileStream, {
+			...data,
+			libraryId: this.libraryId,
+		});
+	};
+	getUrl = (data: Omit<FileInfo, 'libraryId'>) => {
+		return this.fileStorage.getUrl({
+			...data,
+			libraryId: this.libraryId,
+		});
+	};
+	delete = (data: Omit<FileInfo, 'libraryId'>) => {
+		return this.fileStorage.delete({
+			...data,
+			libraryId: this.libraryId,
+		});
+	};
+}

package/src/index.ts

@@ -1,10 +1,10 @@
-export type { MessageSender } from './MessageSender.js';
-export type { UserProfiles } from './Profiles.js';
-export type { ClientMessage, ServerMessage } from '@verdant-web/common';
 export { ReplicaType } from '@verdant-web/common';
-export { Server } from './Server.js';
-export { TokenProvider } from './TokenProvider.js';
+export type { ClientMessage, ServerMessage } from '@verdant-web/common';
+export { createVerdant, type VerdantCore } from './core.js';
 export { LocalFileStorage } from './files/FileStorage.js';
-export type { FileStorage, FileInfo } from './files/FileStorage.js';
-export type { TokenInfo } from './TokenVerifier.js';
+export type { FileInfo, FileStorage } from './files/FileStorage.js';
+export { type LibraryApi } from './libraries/generic.js';
+export type { UserProfiles } from './Profiles.js';
+export { TokenProvider } from './TokenProvider.js';
+export { type TokenInfo } from './TokenVerifier.js';
 export type { LibraryInfo } from './types.js';