@verdant-web/server 2.1.2 → 3.0.0-next.0

package/src/Server.ts

@@ -9,28 +9,21 @@ import {
 	ServerMessage,
 	VerdantError,
 } from '@verdant-web/common';
+import busboy from 'busboy';
 import EventEmitter from 'events';
-import { IncomingMessage, Server as HttpServer, ServerResponse } from 'http';
-import { WebSocketServer, WebSocket } from 'ws';
-import { UserProfileLoader, UserProfiles } from './Profiles.js';
-import create from 'better-sqlite3';
-import { MessageSender } from './MessageSender.js';
+import { Server as HttpServer, IncomingMessage, ServerResponse } from 'http';
+import { TransformStream } from 'node:stream/web';
+import internal, { Readable } from 'stream';
 import { URL } from 'url';
+import { WebSocket, WebSocketServer } from 'ws';
 import { ClientConnectionManager } from './ClientConnection.js';
-import { ReplicaKeepaliveTimers } from './ReplicaKeepaliveTimers.js';
-import { TokenInfo, TokenVerifier } from './TokenVerifier.js';
-import busboy from 'busboy';
 import { FileInfo, FileStorage } from './files/FileStorage.js';
-import internal, { Readable } from 'stream';
-import { FileMetadata, FileMetadataConfig } from './files/FileMetadata.js';
+import { MessageSender } from './MessageSender.js';
+import { UserProfileLoader, UserProfiles } from './Profiles.js';
+import { ReplicaKeepaliveTimers } from './ReplicaKeepaliveTimers.js';
 import { ServerLibrary } from './ServerLibrary.js';
-import { migrations } from './migrations.js';
-import {
-	ReadableStream,
-	ReadableWritablePair,
-	TransformStream,
-	WritableStream,
-} from 'node:stream/web';
+import { TokenInfo, TokenVerifier } from './TokenVerifier.js';
+import { Storage, StorageFactory } from './storage/Storage.js';
 
 export interface ServerOptions {
 	/**
@@ -45,9 +38,10 @@ export interface ServerOptions {
 	 */
 	tokenSecret: string;
 	/**
-	 * The path to your SQLite database.
+	 * Your storage implementation. See the sqlStorage export for a built-in
+	 * option.
 	 */
-	databaseFile: string;
+	storage: StorageFactory;
 	/**
 	 * Optionally provide an implementation of the UserProfiles interface to look up
 	 * static user profile data to use in persistence. This data is considered trusted
@@ -76,7 +70,7 @@ export interface ServerOptions {
 	 * of this library.
 	 */
 	fileStorage?: FileStorage;
-	fileConfig?: FileMetadataConfig;
+	fileConfig?: { deleteExpirationDays?: number };
 }
 
 class DefaultProfiles implements UserProfiles<{ id: string }> {
@@ -117,7 +111,7 @@ export class Server extends EventEmitter implements MessageSender {
 	private httpServer!: HttpServer;
 	private wss: WebSocketServer;
 	private fileStorage?: FileStorage;
-	private fileMetadata;
+	private storage: Storage;
 	private library;
 
 	private clientConnections = new ClientConnectionManager();
@@ -144,23 +138,20 @@ export class Server extends EventEmitter implements MessageSender {
 		});
 
 		this.fileStorage = options.fileStorage;
-
-		const db = create(options.databaseFile);
-		migrations(db);
-
-		this.fileMetadata = new FileMetadata(db, options.fileConfig);
+		this.storage = options.storage({
+			fileDeleteExpirationDays: options.fileConfig?.deleteExpirationDays ?? 14,
+			replicaTruancyMinutes: options.replicaTruancyMinutes || 60 * 24 * 14,
+		});
 
 		this.library = new ServerLibrary({
-			db,
+			storage: this.storage,
 			sender: this,
 			profiles: new UserProfileLoader(
 				options.profiles || new DefaultProfiles(),
 			),
 			log: this.log,
 			disableRebasing: options.disableRebasing,
-			fileMetadata: this.fileMetadata,
 			fileStorage: this.fileStorage,
-			replicaTruancyMinutes: options.replicaTruancyMinutes || 60 * 24 * 14,
 		});
 
 		this.library.subscribe(
@@ -396,7 +387,7 @@ export class Server extends EventEmitter implements MessageSender {
 
 	private writeErrorResponse(e: unknown, res: ServerResponse) {
 		this.emit('error', e);
-		this.log('Error handling request', e);
+		this.log('error', 'Error handling request', e);
 
 		if (e instanceof VerdantError) {
 			// write error data to response
@@ -416,7 +407,7 @@ export class Server extends EventEmitter implements MessageSender {
 	// for fetch-style
 	private getErrorResponse(e: unknown) {
 		this.emit('error', e);
-		this.log('Error handling request', e);
+		this.log('error', 'Error handling request', e);
 
 		if (e instanceof VerdantError) {
 			return new Response(JSON.stringify(e.toResponse()), {
@@ -467,7 +458,7 @@ export class Server extends EventEmitter implements MessageSender {
 					headers: req.headers,
 					id,
 				});
-				this.log('File upload complete');
+				this.log('info', 'File upload complete', id);
 				res.writeHead(200);
 				res.write(JSON.stringify({ success: true }));
 				res.end();
@@ -525,7 +516,7 @@ export class Server extends EventEmitter implements MessageSender {
 					headers: headersAsRecord,
 					id,
 				});
-				this.log('File upload complete');
+				this.log('info', 'File upload complete', id);
 				return new Response(JSON.stringify({ success: true }), {
 					status: 200,
 					headers: {
@@ -571,7 +562,7 @@ export class Server extends EventEmitter implements MessageSender {
 		return new Promise((resolve, reject) => {
 			const bb = busboy({ headers });
 
-			bb.on('file', (fieldName, stream, fileInfo) => {
+			bb.on('file', async (fieldName, stream, fileInfo) => {
 				// too many 'info's....
 				const lofiFileInfo: FileInfo = {
 					id,
@@ -581,7 +572,8 @@ export class Server extends EventEmitter implements MessageSender {
 				};
 				// write metadata to storage
 				try {
-					this.fileMetadata.put(info.libraryId, lofiFileInfo);
+					await this.storage.ready;
+					await this.storage.fileMetadata.put(info.libraryId, lofiFileInfo);
 					fs.put(stream, lofiFileInfo);
 				} catch (e) {
 					reject(e);
@@ -620,7 +612,8 @@ export class Server extends EventEmitter implements MessageSender {
 	): Promise<FileData> => {
 		const fs = this.getFileStorageOrThrow();
 
-		const fileInfo = this.fileMetadata.get(info.libraryId, id);
+		await this.storage.ready;
+		const fileInfo = await this.storage.fileMetadata.get(info.libraryId, id);
 		if (!fileInfo) {
 			throw new VerdantError(
 				VerdantError.Code.NotFound,
@@ -663,6 +656,7 @@ export class Server extends EventEmitter implements MessageSender {
 		message: ClientMessage,
 	) => {
 		this.log(
+			'debug',
 			'Got message from user',
 			info.userId,
 			', library',
@@ -715,26 +709,26 @@ export class Server extends EventEmitter implements MessageSender {
 		await Promise.all([
 			new Promise<void>((resolve) => {
 				setTimeout(() => {
-					console.warn('HTTP server close timed out');
+					this.log('warn', 'HTTP server close timed out');
 					resolve();
 				}, 5 * 1000);
 				this.httpServer.close(() => {
 					resolve();
-					this.log('HTTP server closed');
+					this.log('info', 'HTTP server closed');
 				});
 			}),
 			new Promise<void>((resolve) => {
 				setTimeout(() => {
-					console.warn('Socket server close timed out');
+					this.log('warn', 'Socket server close timed out');
 					resolve();
 				}, 5 * 1000);
 				this.wss.close(() => {
 					resolve();
-					this.log('Socket server closed');
+					this.log('info', 'Socket server closed');
 				});
 			}),
 		]);
-		this.library.close();
+		await this.storage.close();
 	};
 
 	/**
@@ -749,7 +743,7 @@ export class Server extends EventEmitter implements MessageSender {
 		// disconnect all clients
 		this.clientConnections.disconnectAll(libraryId);
 		this.library.destroy(libraryId);
-		this.log('Evicted library', libraryId);
+		this.log('info', 'Evicted library', libraryId);
 	};
 
 	/**
@@ -775,7 +769,7 @@ export class Server extends EventEmitter implements MessageSender {
 	 */
 	evictUser = (libraryId: string, userId: string) => {
 		this.library.evictUser(libraryId, userId);
-		this.log('Evicted user', userId, 'from library', libraryId);
+		this.log('info', 'Evicted user', userId, 'from library', libraryId);
 	};
 
 	/**

package/src/ServerLibrary.test.ts

@@ -0,0 +1,447 @@
+import { describe, expect, it, vi } from 'vitest';
+import { UserProfileLoader } from './Profiles.js';
+import { sqlStorage } from './storage/index.js';
+import { ServerLibrary } from './ServerLibrary.js';
+import {
+	ClientMessage,
+	DocumentBaseline,
+	HybridLogicalClockTimestampProvider,
+	Operation,
+	ReplicaType,
+	ServerMessage,
+} from '@verdant-web/common';
+import { TokenInfo } from './TokenVerifier.js';
+import { MessageSender } from './MessageSender.js';
+
+const profiles = new UserProfileLoader<{ id: string; name: string }>({
+	get: async (userId: string) => {
+		return {
+			id: userId,
+			name: 'Alice',
+		};
+	},
+});
+
+const baseOptions = () => ({
+	profiles,
+	storage: sqlStorage({
+		databaseFile: ':memory:',
+	})({
+		fileDeleteExpirationDays: 7,
+		replicaTruancyMinutes: 60 * 24,
+	}),
+});
+
+let time = 0;
+const now = () => `faketime-${time++}`;
+
+type TestReplica = {
+	key: string;
+	replicaId: string;
+	messages: ServerMessage[];
+	tokenInfo: TokenInfo;
+};
+function createTestReplica(id: string): TestReplica {
+	return {
+		key: `clientKey-${id}`,
+		replicaId: `replica-${id}`,
+		messages: [],
+		tokenInfo: {
+			libraryId: 'library-1',
+			syncEndpoint: 'http://localhost:3000/sync',
+			token: 'fake',
+			type: ReplicaType.Realtime,
+			userId: `user-${id}`,
+		},
+	};
+}
+
+// collects all received operations for a replica
+function getAllReceivedReplicaOperations(replica: TestReplica) {
+	const operations: Operation[] = [];
+	for (const message of replica.messages) {
+		switch (message.type) {
+			case 'op-re':
+			case 'sync-resp':
+				operations.push(...message.operations);
+				break;
+		}
+	}
+	return operations;
+}
+
+describe('ServerLibrary', () => {
+	describe('sync handling', () => {
+		it('should initialize a new library from a replica', async () => {
+			const sender = {
+				broadcast: vi.fn(),
+				send: vi.fn(),
+			};
+
+			const tokenInfo: TokenInfo = {
+				libraryId: 'library-1',
+				syncEndpoint: 'http://localhost:3000/sync',
+				token: 'fake',
+				type: ReplicaType.Realtime,
+				userId: 'user-1',
+			};
+
+			const library = new ServerLibrary({
+				...baseOptions(),
+				sender,
+			});
+
+			const messages: ClientMessage[] = [
+				{
+					type: 'sync',
+					baselines: [
+						{
+							oid: 'notes/1',
+							timestamp: now(),
+							snapshot: {
+								title: 'My Note',
+								content: 'This is my note.',
+							},
+						},
+					],
+					operations: [
+						{
+							oid: 'notes/1',
+							timestamp: now(),
+							data: {
+								op: 'set',
+								name: 'title',
+								value: 'My Note!',
+							},
+						},
+						{
+							oid: 'notes/2',
+							timestamp: now(),
+							data: {
+								op: 'initialize',
+								value: {
+									title: 'Another Note',
+									content: 'This is another note.',
+								},
+							},
+						},
+					],
+					replicaId: 'replica-1',
+					schemaVersion: 1,
+					since: null,
+					timestamp: now(),
+				},
+			];
+
+			// purposefully do not await in order - these all come at the same time
+			await Promise.all(
+				messages.map((m) => library.receive(m, 'clientKey-1', tokenInfo)),
+			);
+
+			// expect sender.broadcast for the operations, and a reply with sync response
+			expect(sender.broadcast).toHaveBeenCalledWith(
+				'library-1',
+				{
+					type: 'op-re',
+					operations: [
+						{
+							oid: 'notes/1',
+							timestamp: `faketime-1`,
+							data: {
+								op: 'set',
+								name: 'title',
+								value: 'My Note!',
+							},
+						},
+						{
+							oid: 'notes/2',
+							timestamp: `faketime-2`,
+							data: {
+								op: 'initialize',
+								value: {
+									title: 'Another Note',
+									content: 'This is another note.',
+								},
+							},
+						},
+					],
+					replicaId: 'replica-1',
+					globalAckTimestamp: undefined,
+				},
+				['clientKey-1'],
+			);
+
+			expect(sender.send).toHaveBeenCalledWith('library-1', '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 () => {
+			// this test setup is more involved - a fake sender will distribute messages to our
+			// fake replicas, and we will verify that the replicas end up with the right data.
+			const replicaA = createTestReplica('a');
+			const replicaB = createTestReplica('b');
+			const replicas = [replicaA, replicaB];
+
+			const sender: MessageSender = {
+				broadcast: (
+					libraryId: string,
+					message: ServerMessage,
+					omitKeys?: string[],
+				) => {
+					replicas.forEach((replica) => {
+						if (!omitKeys?.includes(replica.key)) {
+							replica.messages.push(message);
+						}
+					});
+				},
+				send: (
+					libraryId: string,
+					clientKey: string,
+					message: ServerMessage,
+				) => {
+					const replica = replicas.find((r) => r.key === clientKey);
+					if (replica) {
+						replica.messages.push(message);
+					}
+				},
+			};
+
+			const library = new ServerLibrary({
+				...baseOptions(),
+				sender,
+			});
+
+			// replica A sends a sync message to initialize library
+			const syncMessageA: ClientMessage = {
+				type: 'sync',
+				baselines: [
+					{
+						oid: 'notes/1',
+						timestamp: now(),
+						snapshot: {
+							title: 'My Note',
+							content: 'This is my note.',
+						},
+					},
+				],
+				operations: [
+					{
+						oid: 'notes/1',
+						timestamp: now(),
+						data: {
+							op: 'set',
+							name: 'title',
+							value: 'My Note!',
+						},
+					},
+				],
+				replicaId: 'replica-a',
+				schemaVersion: 1,
+				since: null,
+				timestamp: now(),
+			};
+			await library.receive(syncMessageA, replicaA.key, replicaA.tokenInfo);
+
+			// concurrently, replica B syncs, and A sends more operations
+			const syncMessageB: ClientMessage = {
+				type: 'sync',
+				baselines: [],
+				operations: [],
+				replicaId: 'replica-b',
+				schemaVersion: 1,
+				since: null,
+				timestamp: now(),
+				resyncAll: true,
+			};
+			const opMessageA: ClientMessage = {
+				type: 'op',
+				replicaId: 'replica-a',
+				operations: [
+					{
+						oid: 'notes/1',
+						timestamp: now(),
+						data: {
+							op: 'set',
+							name: 'content',
+							value: 'This is my note!',
+						},
+					},
+				],
+				timestamp: now(),
+			};
+			await Promise.all([
+				library.receive(syncMessageB, replicaB.key, replicaB.tokenInfo),
+				library.receive(opMessageA, replicaA.key, replicaA.tokenInfo),
+			]);
+
+			// there are two valid scenario outcomes here:
+			// 1. A's operation is resolved before B's sync reads operations, and so it's
+			//    included in B's sync response
+			// 2. B's sync reads operations before A's operation is resolved, and so it's
+			//    not included in the sync, but is rebroadcast to B later
+			//
+			// Either way we should end up with that operation on B.
+			const operationsSentToB = getAllReceivedReplicaOperations(replicaB);
+			expect(operationsSentToB).toContainEqual({
+				oid: 'notes/1',
+				timestamp: 'faketime-5',
+				data: {
+					op: 'set',
+					name: 'title',
+					value: 'My Note!',
+				},
+			});
+			expect(operationsSentToB).toContainEqual({
+				oid: 'notes/1',
+				timestamp: 'faketime-8',
+				data: {
+					op: 'set',
+					name: 'content',
+					value: 'This is my note!',
+				},
+			});
+		});
+
+		it('should reject syncs with data from read replicas', async () => {
+			const sender = {
+				broadcast: vi.fn(),
+				send: vi.fn(),
+			};
+
+			const tokenInfo: TokenInfo = {
+				libraryId: 'library-1',
+				syncEndpoint: 'http://localhost:3000/sync',
+				token: 'fake',
+				type: ReplicaType.ReadOnlyPull,
+				userId: 'user-1',
+			};
+
+			const library = new ServerLibrary({
+				...baseOptions(),
+				sender,
+			});
+
+			const messages: ClientMessage[] = [
+				{
+					type: 'sync',
+					baselines: [
+						{
+							oid: 'notes/1',
+							timestamp: now(),
+							snapshot: {
+								title: 'My Note',
+								content: 'This is my note.',
+							},
+						},
+					],
+					operations: [
+						{
+							oid: 'notes/1',
+							timestamp: now(),
+							data: {
+								op: 'set',
+								name: 'title',
+								value: 'My Note!',
+							},
+						},
+						{
+							oid: 'notes/2',
+							timestamp: now(),
+							data: {
+								op: 'initialize',
+								value: {
+									title: 'Another Note',
+									content: 'This is another note.',
+								},
+							},
+						},
+					],
+					replicaId: 'replica-1',
+					schemaVersion: 1,
+					since: null,
+					timestamp: now(),
+				},
+			];
+
+			// purposefully do not await in order - these all come at the same time
+			await Promise.all(
+				messages.map((m) => library.receive(m, 'clientKey-1', tokenInfo)),
+			);
+
+			expect(sender.send).toHaveBeenCalledOnce();
+			expect(sender.send).toHaveBeenCalledWith('library-1', '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(),
+				send: vi.fn(),
+			};
+
+			const tokenInfo: TokenInfo = {
+				libraryId: 'library-1',
+				syncEndpoint: 'http://localhost:3000/sync',
+				token: 'fake',
+				type: ReplicaType.Realtime,
+				userId: 'user-1',
+			};
+
+			const library = new ServerLibrary({
+				...baseOptions(),
+				sender,
+			});
+
+			// purposefully do not await in order - these all come at the same time
+			await library.receive(
+				{
+					type: 'sync',
+					baselines: [],
+					operations: [],
+					replicaId: 'replica-1',
+					schemaVersion: 1,
+					since: null,
+					timestamp: now(),
+				},
+				'clientKey-1',
+				tokenInfo,
+			);
+			sender.send.mockReset();
+
+			// now try to send a message from a different user with the same replica
+			const tokenInfo2: TokenInfo = {
+				libraryId: 'library-1',
+				syncEndpoint: 'http://localhost:3000/sync',
+				token: 'fake',
+				type: ReplicaType.Realtime,
+				userId: 'user-2',
+			};
+
+			const message: ClientMessage = {
+				type: 'sync',
+				baselines: [],
+				operations: [],
+				replicaId: 'replica-1',
+				schemaVersion: 1,
+				since: null,
+				timestamp: now(),
+			};
+
+			await library.receive(message, 'clientKey-1', tokenInfo2);
+
+			expect(sender.send).toHaveBeenCalledOnce();
+			expect(sender.send).toHaveBeenCalledWith('library-1', 'clientKey-1', {
+				type: 'forbidden',
+			});
+		});
+	});
+});