@verdant-web/server 2.1.3 → 3.0.0

package/src/ServerLibrary.ts

@@ -1,34 +1,31 @@
 import {
 	AckMessage,
-	applyOperations,
 	ClientMessage,
 	DocumentBaseline,
+	EventSubscriber,
 	HeartbeatMessage,
-	omit,
 	Operation,
 	OperationMessage,
 	PresenceUpdateMessage,
+	Ref,
 	ReplicaType,
 	SyncMessage,
-	isObjectRef,
-	FileRef,
-	ObjectIdentifier,
-	Ref,
+	applyOperations,
 	isFileRef,
-	SyncAckMessage,
-	EventSubscriber,
+	isObjectRef,
+	omit,
 } from '@verdant-web/common';
-import { Database } from 'better-sqlite3';
-import { ReplicaInfos } from './Replicas.js';
 import { MessageSender } from './MessageSender.js';
-import { OperationHistory } from './OperationHistory.js';
-import { Baselines } from './Baselines.js';
 import { Presence } from './Presence.js';
 import { UserProfileLoader } from './Profiles.js';
 import { TokenInfo } from './TokenVerifier.js';
-import { FileMetadata } from './files/FileMetadata.js';
 import { FileStorage } from './files/FileStorage.js';
-import { LibraryInfo, OperationSpec } from './types.js';
+import { Storage } from './storage/Storage.js';
+import {
+	LibraryInfo,
+	StoredDocumentBaseline,
+	StoredOperation,
+} from './types.js';
 
 export type ServerLibraryEvents = {
 	changes: (
@@ -39,48 +36,36 @@ export type ServerLibraryEvents = {
 };
 
 export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
-	private db;
+	private storage;
 	private sender;
 	private profiles;
-	private replicas;
-	private operations;
-	private baselines;
 	private presences = new Presence();
 	private disableRebasing: boolean;
-	private files;
 	private fileStorage: FileStorage | undefined;
 
 	private log: (...args: any[]) => void;
 	constructor({
-		db,
+		storage,
 		sender,
 		profiles,
-		replicaTruancyMinutes,
 		log = () => {},
 		disableRebasing,
-		fileMetadata,
 		fileStorage,
 	}: {
-		db: Database;
+		storage: Storage;
 		sender: MessageSender;
 		profiles: UserProfileLoader<any>;
-		replicaTruancyMinutes: number;
 		log?: (...args: any[]) => void;
 		disableRebasing?: boolean;
-		fileMetadata: FileMetadata;
 		fileStorage?: FileStorage;
 	}) {
 		super();
 
-		this.db = db;
 		this.log = log;
 		this.disableRebasing = !!disableRebasing;
 		this.sender = sender;
 		this.profiles = profiles;
-		this.replicas = new ReplicaInfos(this.db, replicaTruancyMinutes);
-		this.operations = new OperationHistory(this.db);
-		this.baselines = new Baselines(this.db);
-		this.files = fileMetadata;
+		this.storage = storage;
 		this.fileStorage = fileStorage;
 		this.presences.on('lost', this.onPresenceLost);
 	}
@@ -90,13 +75,19 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 	 * exist, a user may create it. But if it does exist, its user (clientId)
 	 * must match the user making the request.
 	 */
-	private validateReplicaAccess = (replicaId: string, info: TokenInfo) => {
-		const replica = this.replicas.get(info.libraryId, replicaId);
+	private validateReplicaAccess = async (
+		replicaId: string,
+		clientKey: string,
+		info: TokenInfo,
+	) => {
+		const replica = await this.storage.replicas.get(info.libraryId, replicaId);
 		if (replica && replica.clientId !== info.userId) {
-			throw new Error(
-				`Replica ${replicaId} does not belong to client ${info.userId}`,
-			);
+			this.sender.send(info.libraryId, clientKey, {
+				type: 'forbidden',
+			});
+			return false;
 		}
+		return true;
 	};
 
 	private hasWriteAccess = (info: TokenInfo) => {
@@ -111,20 +102,27 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		clientKey: string,
 		info: TokenInfo,
 	) => {
-		this.validateReplicaAccess(message.replicaId, info);
+		await this.storage.ready;
+
+		const allowed = await this.validateReplicaAccess(
+			message.replicaId,
+			clientKey,
+			info,
+		);
+		if (!allowed) return;
 
 		switch (message.type) {
 			case 'op':
-				this.handleOperation(message, clientKey, info);
+				await this.handleOperation(message, clientKey, info);
 				break;
 			case 'sync':
-				this.handleSync(message, clientKey, info);
+				await this.handleSync(message, clientKey, info);
 				break;
 			case 'ack':
-				this.handleAck(message, clientKey, info);
+				await this.handleAck(message, clientKey, info);
 				break;
 			case 'heartbeat':
-				this.handleHeartbeat(message, clientKey, info);
+				await this.handleHeartbeat(message, clientKey, info);
 				break;
 			case 'presence-update':
 				await this.handlePresenceUpdate(message, clientKey, info);
@@ -133,14 +131,17 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 				this.log('Unknown message type', (message as any).type);
 				break;
 		}
-		this.replicas.updateLastSeen(info.libraryId, message.replicaId);
+		await this.storage.replicas.updateLastSeen(
+			info.libraryId,
+			message.replicaId,
+		);
 	};
 
 	remove = (libraryId: string, replicaId: string) => {
 		this.presences.removeReplica(libraryId, replicaId);
 	};
 
-	private handleOperation = (
+	private handleOperation = async (
 		message: OperationMessage,
 		clientKey: string,
 		info: TokenInfo,
@@ -154,35 +155,31 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 			return;
 		}
 
-		const run = this.db.transaction(() => {
-			// insert patches into history
-			this.operations.insertAll(
-				info.libraryId,
-				message.replicaId,
-				message.operations,
-			);
-		});
-
-		run();
-
-		this.enqueueRebase(info.libraryId);
-
 		// rebroadcast to whole library except the sender
 		this.rebroadcastOperations(
 			info.libraryId,
 			clientKey,
 			message.replicaId,
 			message.operations,
-			[],
 		);
 
+		// TODO: can we defer this and rebroadcast in parallel?
+		// insert patches into history
+		await this.storage.operations.insertAll(
+			info.libraryId,
+			message.replicaId,
+			message.operations,
+		);
+
+		this.enqueueRebase(info.libraryId);
+
 		// tell sender we got and processed their operation
 		this.sender.send(info.libraryId, clientKey, {
 			type: 'server-ack',
 			timestamp: message.timestamp,
 		});
 
-		this.updateHighwater(
+		await this.updateHighwater(
 			message.replicaId,
 			message.operations[message.operations.length - 1].timestamp,
 			info,
@@ -191,25 +188,21 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		this.emit(`changes`, info, message.operations, []);
 	};
 
-	private removeExtraOperationData = (operation: OperationSpec): Operation => {
-		return omit(operation, ['replicaId', 'serverOrder']);
-	};
-
-	private rebroadcastOperations = (
+	private rebroadcastOperations = async (
 		libraryId: string,
 		clientKey: string,
 		replicaId: string,
 		ops: Operation[],
-		baselines: DocumentBaseline[],
+		baselines?: DocumentBaseline[],
 	) => {
-		if (ops.length === 0 && baselines.length === 0) return;
+		if (ops.length === 0 && !baselines?.length) return;
 
 		this.log(
 			'info',
 			'Rebroadcasting',
 			ops.length,
-			'operations and',
-			baselines.length,
+			'operations',
+			baselines?.length ?? 0,
 			'baselines',
 		);
 
@@ -220,45 +213,50 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 				operations: ops,
 				baselines,
 				replicaId,
-				globalAckTimestamp: this.replicas.getGlobalAck(libraryId),
+				globalAckTimestamp:
+					(await this.storage.replicas.getGlobalAck(libraryId)) ?? undefined,
 			},
 			[clientKey],
 		);
 	};
 
-	private handleSync = (
+	private handleSync = async (
 		message: SyncMessage,
 		clientKey: string,
 		info: TokenInfo,
 	) => {
 		const replicaId = message.replicaId;
 
-		// TODO: is this right? shouldn't read-only replicas still be able to sync,
-		// just not send ops?
-		if (!this.hasWriteAccess(info)) {
+		// TODO: is this the right way to do this? should it just ignore
+		// read-only changes?
+		if (
+			!this.hasWriteAccess(info) &&
+			(message.operations.length > 0 || message.baselines.length > 0)
+		) {
 			this.sender.send(info.libraryId, clientKey, {
 				type: 'forbidden',
 			});
-			this.log('warning', 'sync from read-only replica', replicaId);
+			this.log('warn', 'sync with changes from read-only replica', replicaId);
 			return;
 		}
 
 		if (message.resyncAll) {
 			// forget our local understanding of the replica and reset it
-			this.replicas.delete(info.libraryId, replicaId);
+			await this.storage.replicas.delete(info.libraryId, replicaId);
 		}
 
 		const { status, replicaInfo: clientReplicaInfo } =
-			this.replicas.getOrCreate(info.libraryId, replicaId, info);
+			await this.storage.replicas.getOrCreate(info.libraryId, replicaId, info);
 
 		const changesSince =
 			status === 'existing' ? clientReplicaInfo.ackedLogicalTime : null;
 		this.log(
+			'info',
 			`Sync from ${replicaId} (user: ${info.userId}) [ackedLogicalTime: ${changesSince}, ackedServerOrder: ${clientReplicaInfo.ackedServerOrder}, status: ${status}}]`,
 		);
 
 		// lookup operations after the last ack the client gave us
-		const ops = this.operations.getFromServerOrder(
+		const ops = await this.storage.operations.getAfterServerOrder(
 			info.libraryId,
 			clientReplicaInfo.ackedServerOrder,
 		);
@@ -268,15 +266,13 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		// truant replicas should also reset their storage.
 		const replicaShouldReset = !!message.resyncAll || status !== 'existing';
 
-		// TODO: assumption: only new replicas need baselines
-		// const baselines = replicaShouldReset
-		// 	? []
-		// 	: this.baselines.getAllAfter(info.libraryId, changesSince);
-		const baselines = this.baselines.getAllAfter(info.libraryId, changesSince);
-		// const baselines = this.baselines.getFromServerOrder(
-		// 	info.libraryId,
-		// 	clientReplicaInfo.ackedServerOrder
-		// );
+		// only new replicas need baselines. by definition, a rebase only
+		// happens when all active replicas agree on history. every client
+		// replica will generate the same baseline locally, so it
+		// doesn't need to receive it from the server.
+		const baselines = replicaShouldReset
+			? await this.storage.baselines.getAll(info.libraryId)
+			: [];
 
 		// We detect that a library is new by checking if it has any history.
 		// If there are no existing operations or baselines (and the requested
@@ -288,6 +284,9 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		// and not rely on seemingly unrelated data.
 		const isEmptyLibrary =
 			changesSince === null && ops.length === 0 && baselines.length === 0;
+		if (isEmptyLibrary) {
+			this.log('info', 'Received sync from new library', replicaId);
+		}
 
 		let overwriteLocalData = replicaShouldReset && !isEmptyLibrary;
 
@@ -297,6 +296,7 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		// this replica should respond with a full history.
 		if (isEmptyLibrary && status === 'new' && message.since !== null) {
 			this.log(
+				'info',
 				'Detected local data is incomplete, requesting full history from replica',
 				replicaId,
 			);
@@ -310,6 +310,7 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 			// but the library already has data. the replica should
 			// reset to the server version
 			this.log(
+				'warn',
 				'Detected replica',
 				replicaId,
 				'is providing a full history but the library already has data. Requesting replica reset.',
@@ -319,6 +320,7 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 
 		if (overwriteLocalData) {
 			this.log(
+				'info',
 				'Overwriting local data for replica',
 				replicaId,
 				'with',
@@ -333,17 +335,22 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		// we are not overwriting the replica's data
 		if (!overwriteLocalData) {
 			// store all incoming operations and baselines
-			this.baselines.insertAll(info.libraryId, message.baselines);
+			await this.storage.baselines.insertAll(info.libraryId, message.baselines);
 
 			this.log(
+				'debug',
 				'Storing',
 				message.baselines.length,
 				'baselines and',
 				message.operations.length,
 				'operations',
 			);
-			this.operations.insertAll(info.libraryId, replicaId, message.operations);
-			this.replicas.updateAcknowledged(
+			await this.storage.operations.insertAll(
+				info.libraryId,
+				replicaId,
+				message.operations,
+			);
+			await this.storage.replicas.updateAcknowledgedLogicalTime(
 				info.libraryId,
 				replicaId,
 				message.timestamp,
@@ -354,7 +361,11 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 				clientKey,
 				message.replicaId,
 				message.operations,
-				message.baselines,
+				// we only need to broadcast baselines if we just initialized
+				// this library, if any other clients (with empty libraries)
+				// are listening for initial data, too. this happens in
+				// rebasing.test.ts, for example.
+				isEmptyLibrary ? message.baselines : undefined,
 			);
 			if (message.operations.length || message.baselines.length) {
 				this.emit(`changes`, info, message.operations, message.baselines);
@@ -362,7 +373,7 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		}
 
 		if (status === 'truant') {
-			this.log('A truant replica has reconnected', replicaId);
+			this.log('info', 'A truant replica has reconnected', replicaId);
 		}
 
 		// create the nonce by encoding the server order of the last operation
@@ -371,21 +382,23 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		// respond to client
 
 		this.log(
+			'info',
 			'Sending sync response with',
 			ops.length,
 			'operations and',
 			baselines.length,
 			'baselines',
 		);
+
+		// mutating baselines/operations to remove extra data -
+		// mutating just to save on allocations here.
+
 		this.sender.send(info.libraryId, clientKey, {
 			type: 'sync-resp',
-			operations: ops.map(this.removeExtraOperationData),
-			baselines: baselines.map((baseline) => ({
-				oid: baseline.oid,
-				snapshot: baseline.snapshot,
-				timestamp: baseline.timestamp,
-			})),
-			globalAckTimestamp: this.replicas.getGlobalAck(info.libraryId),
+			operations: this.removeOperationExtras(ops),
+			baselines: this.removeBaselineExtras(baselines),
+			globalAckTimestamp:
+				(await this.storage.replicas.getGlobalAck(info.libraryId)) ?? undefined,
 			peerPresence: this.presences.all(info.libraryId),
 			// 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
@@ -396,7 +409,7 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		});
 	};
 
-	private createAckNonce = (ops: OperationSpec[]): string | undefined => {
+	private createAckNonce = (ops: StoredOperation[]): string | undefined => {
 		return ops.length
 			? Buffer.from(JSON.stringify(ops[ops.length - 1].serverOrder)).toString(
 					'base64',
@@ -404,7 +417,7 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 			: undefined;
 	};
 
-	private handleAck = (
+	private handleAck = async (
 		message: AckMessage,
 		clientKey: string,
 		info: TokenInfo,
@@ -428,14 +441,20 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 			}
 
 			const replicaId = message.replicaId;
-			this.replicas.updateServerOrder(info.libraryId, replicaId, decodedNonce);
+			await this.storage.replicas.updateAckedServerOrder(
+				info.libraryId,
+				replicaId,
+				decodedNonce,
+			);
 		} else if (message.timestamp) {
-			this.replicas.acknowledgeOperation(
+			await this.storage.replicas.acknowledgeOperation(
 				info.libraryId,
 				message.replicaId,
 				message.timestamp,
 			);
-			const globalAck = this.replicas.getGlobalAck(info.libraryId);
+			const globalAck = await this.storage.replicas.getGlobalAck(
+				info.libraryId,
+			);
 			if (globalAck) {
 				this.sender.broadcast(info.libraryId, {
 					type: 'global-ack',
@@ -445,14 +464,20 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		}
 	};
 
-	private updateHighwater = (
+	private updateHighwater = async (
 		replicaId: string,
 		timestamp: string,
 		info: TokenInfo,
 		ignoreClientKeys: string[] = [],
 	) => {
-		this.replicas.updateAcknowledged(info.libraryId, replicaId, timestamp);
-		const newGlobalAck = this.replicas.getGlobalAck(info.libraryId);
+		await this.storage.replicas.updateAcknowledgedLogicalTime(
+			info.libraryId,
+			replicaId,
+			timestamp,
+		);
+		const newGlobalAck = await this.storage.replicas.getGlobalAck(
+			info.libraryId,
+		);
 		if (newGlobalAck) {
 			this.sender.broadcast(
 				info.libraryId,
@@ -474,10 +499,10 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		}
 	};
 
-	private rebase = (libraryId: string) => {
+	private rebase = async (libraryId: string) => {
 		if (this.disableRebasing) return;
 
-		this.log('Performing rebase check');
+		this.log('debug', 'Performing rebase check');
 
 		// fundamentally a rebase occurs when some conditions are met:
 		// 1. the replica which created an operation has dropped that operation
@@ -498,27 +523,30 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		const activeReplicaIds = Object.values(this.presences.all(libraryId)).map(
 			(p) => p.replicaId,
 		);
-		const globalAck = this.replicas.getGlobalAck(libraryId, activeReplicaIds);
+		const globalAck = await this.storage.replicas.getGlobalAck(
+			libraryId,
+			activeReplicaIds,
+		);
 		const globalServerOrder =
-			this.replicas.getEarliestAckedServerOrder(libraryId);
+			await this.storage.replicas.getEarliestAckedServerOrder(libraryId);
 
 		if (!globalAck) {
-			this.log('No global ack, skipping rebase');
+			this.log('debug', 'No global ack, skipping rebase');
 			return;
 		}
 
 		if (globalServerOrder === null) {
-			this.log('No global server order, skipping rebase');
+			this.log('debug', 'No global server order, skipping rebase');
 			return;
 		}
 
 		// these are in forward chronological order
-		const ops = this.operations.getBeforeServerOrder(
+		const ops = await this.storage.operations.getBeforeServerOrder(
 			libraryId,
 			globalServerOrder,
 		);
 
-		const opsToApply: Record<string, OperationSpec[]> = {};
+		const opsToApply: Record<string, StoredOperation[]> = {};
 		// if we encounter a sequential operation in history which does
 		// not meet our conditions, we must ignore subsequent operations
 		// applied to that document.
@@ -537,8 +565,13 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		const deletedRefs = new Array<Ref>();
 		for (const [documentId, ops] of Object.entries(opsToApply)) {
 			this.log('Rebasing', documentId);
-			this.baselines.applyOperations(libraryId, documentId, ops, deletedRefs),
-				this.operations.dropAll(libraryId, ops);
+			await this.storage.baselines.applyOperations(
+				libraryId,
+				documentId,
+				ops,
+				deletedRefs,
+			);
+			await this.storage.operations.delete(libraryId, ops);
 		}
 
 		// hint to clients they can rebase too
@@ -548,11 +581,13 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		});
 
 		// cleanup deleted files
-		for (const ref of deletedRefs) {
-			if (isFileRef(ref)) {
-				this.files.markPendingDelete(libraryId, ref.id);
-			}
-		}
+		await Promise.all(
+			deletedRefs
+				.filter(isFileRef)
+				.map((ref) =>
+					this.storage.fileMetadata.markPendingDelete(libraryId, ref.id),
+				),
+		);
 	};
 
 	private handleHeartbeat = (
@@ -598,30 +633,32 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		replicaId: string,
 		userId: string,
 	) => {
-		this.log('User disconnected from all replicas:', userId);
+		this.log('info', 'User disconnected from all replicas:', userId);
 		this.sender.broadcast(libraryId, {
 			type: 'presence-offline',
 			replicaId,
 			userId,
 		});
 		if (Object.keys(this.presences.all(libraryId)).length === 0) {
-			this.log(`All users have disconnected from ${libraryId}`);
+			this.log('info', `All users have disconnected from ${libraryId}`);
 			// could happen - if the server is shutting down manually
-			if (!this.db.open) {
+			if (!this.storage.open) {
 				this.log('debug', 'Database not open, skipping cleanup');
 				return;
 			}
-			const pendingDelete = this.files.getPendingDeletes(libraryId);
+			const pendingDelete =
+				await this.storage.fileMetadata.getPendingDelete(libraryId);
 			if (pendingDelete.length > 0) {
 				if (!this.fileStorage) {
 					throw new Error('File storage not configured, cannot delete files');
 				}
 				this.log(
+					'info',
 					'Deleting files:',
 					pendingDelete.map((f) => f.fileId).join(', '),
 				);
 				await Promise.all(
-					pendingDelete.map(async (fileInfo) => {
+					pendingDelete.map(async (fileInfo): Promise<void> => {
 						try {
 							await this.fileStorage?.delete({
 								libraryId: fileInfo.libraryId,
@@ -629,9 +666,10 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 								id: fileInfo.fileId,
 								type: fileInfo.type,
 							});
-							this.files.delete(libraryId, fileInfo.fileId);
+							this.storage.fileMetadata.delete(libraryId, fileInfo.fileId);
 						} catch (e) {
 							this.log(
+								'error',
 								'Failed to delete file',
 								fileInfo.fileId,
 								' the file will remain in a pending delete state',
@@ -645,13 +683,17 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 	};
 
 	destroy = async (libraryId: string) => {
+		this.log('info', 'Destroying library', libraryId);
 		this.presences.clear(libraryId);
-		this.replicas.deleteAll(libraryId);
-		this.operations.deleteAll(libraryId);
-		this.baselines.deleteAll(libraryId);
-		const allFiles = this.files.getAll(libraryId);
+		await Promise.all([
+			this.storage.replicas.deleteAll(libraryId),
+			this.storage.operations.deleteAll(libraryId),
+			this.storage.baselines.deleteAll(libraryId),
+		]);
+		const allFiles = await this.storage.fileMetadata.getAll(libraryId);
 		if (allFiles.length > 0) {
 			this.log(
+				'info',
 				`Deleting ${allFiles.length} files for library ${libraryId}`,
 				allFiles.map((f) => f.fileId).join(', '),
 			);
@@ -663,7 +705,7 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 					type: fileInfo.type,
 				});
 			}
-			this.files.deleteAll(libraryId);
+			await this.storage.fileMetadata.deleteAll(libraryId);
 		}
 	};
 
@@ -672,7 +714,7 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 	};
 
 	getInfo = async (libraryId: string): Promise<LibraryInfo | null> => {
-		const rawReplicas = this.replicas.getAll(libraryId);
+		const rawReplicas = await this.storage.replicas.getAll(libraryId);
 		const profiles = await Promise.all(
 			rawReplicas.map((r) => this.profiles.get(r.clientId)),
 		);
@@ -683,17 +725,18 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 			type: r.type,
 			truant:
 				!!r.lastSeenWallClockTime &&
-				r.lastSeenWallClockTime < this.replicas.truantCutoff,
+				r.lastSeenWallClockTime < this.storage.replicas.truantCutoff,
 			profile: profiles[index],
 		}));
 
 		const data = {
 			id: libraryId,
 			replicas,
-			latestServerOrder: this.operations.getLatestServerOrder(libraryId),
-			operationsCount: this.operations.getCount(libraryId),
-			baselinesCount: this.baselines.getCount(libraryId),
-			globalAck: this.replicas.getGlobalAck(libraryId) ?? null,
+			latestServerOrder:
+				await this.storage.operations.getLatestServerOrder(libraryId),
+			operationsCount: await this.storage.operations.getCount(libraryId),
+			baselinesCount: await this.storage.baselines.getCount(libraryId),
+			globalAck: (await this.storage.replicas.getGlobalAck(libraryId)) ?? null,
 		};
 
 		if (
@@ -707,50 +750,59 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		return data;
 	};
 
-	evictUser = (libraryId: string, userId: string) => {
-		this.replicas.deleteAllForUser(libraryId, userId);
+	evictUser = async (libraryId: string, userId: string) => {
+		await this.storage.replicas.deleteAllForUser(libraryId, userId);
 	};
 
 	getDocumentSnapshot = (libraryId: string, oid: string) => {
 		return this.hydrateObject(libraryId, oid);
 	};
 
-	private getObjectSnapshot = (libraryId: string, oid: string) => {
-		const baseline = this.baselines.get(libraryId, oid);
-		const ops = this.operations.getAllFor(libraryId, oid);
+	private getObjectSnapshot = async (libraryId: string, oid: string) => {
+		const [baseline, ops] = await Promise.all([
+			this.storage.baselines.get(libraryId, oid),
+			this.storage.operations.getAll(libraryId, oid),
+		]);
 		const snapshot = applyOperations(baseline?.snapshot ?? undefined, ops);
 		return snapshot;
 	};
 
-	private hydrateObject = (libraryId: string, oid: string): any => {
-		const snapshot = this.getObjectSnapshot(libraryId, oid);
+	private hydrateObject = async (
+		libraryId: string,
+		oid: string,
+	): Promise<any> => {
+		const snapshot = await this.getObjectSnapshot(libraryId, oid);
 		if (Array.isArray(snapshot)) {
-			return snapshot.map((item, index) => {
-				if (isObjectRef(item)) {
-					return this.hydrateObject(libraryId, item.id);
-				} else if (isFileRef(item)) {
-					return this.hydrateFile(libraryId, item.id);
-				} else {
-					return item;
-				}
-			});
+			return Promise.all(
+				snapshot.map(async (item: any) => {
+					if (isObjectRef(item)) {
+						return this.hydrateObject(libraryId, item.id);
+					} else if (isFileRef(item)) {
+						return this.hydrateFile(libraryId, item.id);
+					} else {
+						return item;
+					}
+				}),
+			);
 		} else if (snapshot && typeof snapshot === 'object') {
 			const hydrated = { ...snapshot };
-			for (const [key, value] of Object.entries(snapshot)) {
-				if (isObjectRef(value)) {
-					hydrated[key] = this.hydrateObject(libraryId, value.id);
-				} else if (isFileRef(value)) {
-					hydrated[key] = this.hydrateFile(libraryId, value.id);
-				}
-			}
+			await Promise.all(
+				Object.entries(snapshot).map(async ([key, value]) => {
+					if (isObjectRef(value)) {
+						hydrated[key] = await this.hydrateObject(libraryId, value.id);
+					} else if (isFileRef(value)) {
+						hydrated[key] = await this.hydrateFile(libraryId, value.id);
+					}
+				}),
+			);
 			return hydrated;
 		} else {
 			return snapshot;
 		}
 	};
 
-	private hydrateFile = (libraryId: string, fileId: string) => {
-		const data = this.files.get(libraryId, fileId);
+	private hydrateFile = async (libraryId: string, fileId: string) => {
+		const data = await this.storage.fileMetadata.get(libraryId, fileId);
 		if (data) {
 			const url =
 				this.fileStorage?.getUrl({
@@ -771,7 +823,31 @@ export class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
 		}
 	};
 
-	close = () => {
-		this.db.close();
+	// MUTATES DATA. ONLY USE WHEN RETURNING DATA TO CLIENT WHICH WILL OTHERWISE
+	// NOT BE REFERENCED.
+	private removeBaselineExtras = (
+		baselines: StoredDocumentBaseline[],
+	): DocumentBaseline[] => {
+		for (const baseline of baselines) {
+			// @ts-expect-error
+			delete baseline.libraryId;
+		}
+		return baselines as unknown as DocumentBaseline[];
+	};
+
+	// MUTATES DATA. ONLY USE WHEN RETURNING DATA TO CLIENT WHICH WILL OTHERWISE
+	// NOT BE REFERENCED.
+	private removeOperationExtras = (
+		operations: StoredOperation[],
+	): Operation[] => {
+		for (const operation of operations) {
+			// @ts-expect-error
+			delete operation.libraryId;
+			// @ts-expect-error
+			delete operation.replicaId;
+			// @ts-expect-error
+			delete operation.serverOrder;
+		}
+		return operations as unknown as Operation[];
 	};
 }