@verdant-web/server 3.3.11 → 4.0.1

package/src/internals.ts

@@ -0,0 +1,14 @@
+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 { FileStorageLibraryDelegate } from './files/FileStorage.js';
+export type * from './libraries/generic.js';
+export { Library, type LibraryEvents } from './libraries/Library.js';
+export { type Logger } from './logger.js';
+export { UserProfileLoader } from './Profiles.js';
+export { SqliteExecutor } from './storage/sqlShard/database.js';
+export { migrateToLatest } from './storage/sqlShard/migrations.js';
+export { SqlShardStorage } from './storage/sqlShard/sqlShardStorage.js';
+export type { Database as DatabaseTypes } from './storage/sqlShard/tables.js';
+export { TokenVerifier } from './TokenVerifier.js';

package/src/{ServerLibrary.test.ts → libraries/Library.test.ts}

@@ -1,17 +1,16 @@
-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';
+import { describe, expect, it, vi } from 'vitest';
+import { MessageSender } from '../connections/MessageSender.js';
+import { Presence } from '../connections/Presence.js';
+import { UserProfileLoader } from '../Profiles.js';
+import { sqlShardStorage } from '../storage/index.js';
+import { TokenInfo } from '../TokenVerifier.js';
+import { Library } from './Library.js';
 
 const profiles = new UserProfileLoader<{ id: string; name: string }>({
 	get: async (userId: string) => {
@@ -22,13 +21,21 @@ const profiles = new UserProfileLoader<{ id: string; name: string }>({
 	},
 });
 
-const baseOptions = () => ({
+const baseOptions = async () => ({
+	id: 'library-1',
 	profiles,
-	storage: sqlStorage({
-		databaseFile: ':memory:',
-	})({
+	storage: await sqlShardStorage({
+		databasesDirectory: ':memory:',
 		fileDeleteExpirationDays: 7,
 		replicaTruancyMinutes: 60 * 24,
+	})('library-1'),
+	presence: new Presence({
+		get: async (userId: string) => {
+			return {
+				id: userId,
+				name: 'Alice',
+			};
+		},
 	}),
 });
 
@@ -70,12 +77,12 @@ function getAllReceivedReplicaOperations(replica: TestReplica) {
 	return operations;
 }
 
-describe('ServerLibrary', () => {
+describe('Library', () => {
 	describe('sync handling', () => {
 		it('should initialize a new library from a replica', async () => {
-			const sender = {
+			const sender: MessageSender = {
 				broadcast: vi.fn(),
-				send: vi.fn(),
+				respond: vi.fn((_: string, message: ServerMessage) => {}),
 			};
 
 			const tokenInfo: TokenInfo = {
@@ -86,8 +93,8 @@ describe('ServerLibrary', () => {
 				userId: 'user-1',
 			};
 
-			const library = new ServerLibrary({
-				...baseOptions(),
+			const library = new Library({
+				...(await baseOptions()),
 				sender,
 			});
 
@@ -135,12 +142,11 @@ describe('ServerLibrary', () => {
 
 			// 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)),
+				messages.map((m) => library.handleMessage(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',
 					baselines: [
@@ -181,7 +187,7 @@ describe('ServerLibrary', () => {
 				['clientKey-1'],
 			);
 
-			expect(sender.send).toHaveBeenCalledWith('library-1', 'clientKey-1', {
+			expect(sender.respond).toHaveBeenCalledWith('clientKey-1', {
 				type: 'sync-resp',
 				operations: [],
 				baselines: [],
@@ -201,22 +207,14 @@ describe('ServerLibrary', () => {
 			const replicas = [replicaA, replicaB];
 
 			const sender: MessageSender = {
-				broadcast: (
-					libraryId: string,
-					message: ServerMessage,
-					omitKeys?: string[],
-				) => {
+				broadcast: (message: ServerMessage, omitKeys?: string[]) => {
 					replicas.forEach((replica) => {
 						if (!omitKeys?.includes(replica.key)) {
 							replica.messages.push(message);
 						}
 					});
 				},
-				send: (
-					libraryId: string,
-					clientKey: string,
-					message: ServerMessage,
-				) => {
+				respond: (clientKey: string, message: ServerMessage) => {
 					const replica = replicas.find((r) => r.key === clientKey);
 					if (replica) {
 						replica.messages.push(message);
@@ -224,8 +222,8 @@ describe('ServerLibrary', () => {
 				},
 			};
 
-			const library = new ServerLibrary({
-				...baseOptions(),
+			const library = new Library({
+				...(await baseOptions()),
 				sender,
 			});
 
@@ -258,7 +256,11 @@ describe('ServerLibrary', () => {
 				since: null,
 				timestamp: now(),
 			};
-			await library.receive(syncMessageA, replicaA.key, replicaA.tokenInfo);
+			await library.handleMessage(
+				syncMessageA,
+				replicaA.key,
+				replicaA.tokenInfo,
+			);
 
 			// concurrently, replica B syncs, and A sends more operations
 			const syncMessageB: ClientMessage = {
@@ -288,8 +290,8 @@ describe('ServerLibrary', () => {
 				timestamp: now(),
 			};
 			await Promise.all([
-				library.receive(syncMessageB, replicaB.key, replicaB.tokenInfo),
-				library.receive(opMessageA, replicaA.key, replicaA.tokenInfo),
+				library.handleMessage(syncMessageB, replicaB.key, replicaB.tokenInfo),
+				library.handleMessage(opMessageA, replicaA.key, replicaA.tokenInfo),
 			]);
 
 			// there are two valid scenario outcomes here:
@@ -323,7 +325,7 @@ describe('ServerLibrary', () => {
 		it('should reject syncs with data from read replicas', async () => {
 			const sender = {
 				broadcast: vi.fn(),
-				send: vi.fn(),
+				respond: vi.fn(),
 			};
 
 			const tokenInfo: TokenInfo = {
@@ -334,8 +336,8 @@ describe('ServerLibrary', () => {
 				userId: 'user-1',
 			};
 
-			const library = new ServerLibrary({
-				...baseOptions(),
+			const library = new Library({
+				...(await baseOptions()),
 				sender,
 			});
 
@@ -383,11 +385,11 @@ describe('ServerLibrary', () => {
 
 			// 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)),
+				messages.map((m) => library.handleMessage(m, 'clientKey-1', tokenInfo)),
 			);
 
-			expect(sender.send).toHaveBeenCalledOnce();
-			expect(sender.send).toHaveBeenCalledWith('library-1', 'clientKey-1', {
+			expect(sender.respond).toHaveBeenCalledOnce();
+			expect(sender.respond).toHaveBeenCalledWith('clientKey-1', {
 				type: 'forbidden',
 			});
 		});
@@ -395,7 +397,7 @@ describe('ServerLibrary', () => {
 		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(),
+				respond: vi.fn((_: string, message: ServerMessage) => {}),
 			};
 
 			const tokenInfo: TokenInfo = {
@@ -406,13 +408,13 @@ describe('ServerLibrary', () => {
 				userId: 'user-1',
 			};
 
-			const library = new ServerLibrary({
-				...baseOptions(),
+			const library = new Library({
+				...(await baseOptions()),
 				sender,
 			});
 
 			// purposefully do not await in order - these all come at the same time
-			await library.receive(
+			await library.handleMessage(
 				{
 					type: 'sync',
 					baselines: [],
@@ -425,7 +427,7 @@ describe('ServerLibrary', () => {
 				'clientKey-1',
 				tokenInfo,
 			);
-			sender.send.mockReset();
+			sender.respond.mockReset();
 
 			// now try to send a message from a different user with the same replica
 			const tokenInfo2: TokenInfo = {
@@ -446,10 +448,10 @@ describe('ServerLibrary', () => {
 				timestamp: now(),
 			};
 
-			await library.receive(message, 'clientKey-1', tokenInfo2);
+			await library.handleMessage(message, 'clientKey-1', tokenInfo2);
 
-			expect(sender.send).toHaveBeenCalledOnce();
-			expect(sender.send).toHaveBeenCalledWith('library-1', 'clientKey-1', {
+			expect(sender.respond).toHaveBeenCalledOnce();
+			expect(sender.respond).toHaveBeenCalledWith('clientKey-1', {
 				type: 'forbidden',
 			});
 		});